From ee72126a47fc7f5766f99738f2074266e4bc08b6 Mon Sep 17 00:00:00 2001 From: jakobrunge Date: Tue, 2 Mar 2021 17:03:01 +0100 Subject: [PATCH 1/6] added gpdc_torch and some further additions, eg parallelized cython support --- setup.py | 11 +- tests/test_independence_tests.py | 110 +- tests/test_pcmci_calculations.py | 4 +- tigramite/data_processing.py | 7 +- tigramite/independence_tests/__init__.py | 1 + tigramite/independence_tests/gpdc_torch.py | 864 +++ .../oracle_conditional_independence.py | 590 +- tigramite/models.py | 172 +- tigramite/plotting.py | 44 +- tigramite/tigramite_cython_code.c | 5491 +++++++++-------- tigramite/tigramite_cython_code.pyx | 48 +- 11 files changed, 4761 insertions(+), 2581 deletions(-) create mode 100644 tigramite/independence_tests/gpdc_torch.py diff --git a/setup.py b/setup.py index 8e60bb52..76015404 100644 --- a/setup.py +++ b/setup.py @@ -45,13 +45,15 @@ def define_extension(extension_name, source_files=None): from Cython.Build import cythonize # Return the cythonized extension pyx_path = str((pathlib.Path(__file__).parent / extension_name.replace(".", "/")).with_suffix(".pyx")) - return cythonize([pyx_path]) + return cythonize([pyx_path], language_level = "3") except ImportError: print( "Cython cannot be found. Skipping generation of C code from" + " cython and using pre-compiled C code instead" ) - return [Extension(extension_name, source_files)] + return [Extension(extension_name, source_files, + extra_compile_args=['-fopenmp'], + extra_link_args=['-fopenmp'],)] @@ -66,11 +68,12 @@ def define_extension(extension_name, source_files=None): "scikit-learn>=0.21", # Gaussian Process (GP) Regression "matplotlib>=3.0", # plotting "networkx>=2.4", # plotting + "torch>=1.7" ] } # Define the packages needed for testing -TESTS_REQUIRE = ["nose", "pytest", "networkx>=2.4", "scikit-learn>=0.21"] +TESTS_REQUIRE = ["nose", "pytest", "networkx>=2.4", "scikit-learn>=0.21", "torch>=1.7"] EXTRAS_REQUIRE["test"] = TESTS_REQUIRE # Define the extras needed for development EXTRAS_REQUIRE["dev"] = EXTRAS_REQUIRE["all"] + TESTS_REQUIRE + ["cython"] @@ -93,7 +96,7 @@ def define_extension(extension_name, source_files=None): url="https://github.com/jakobrunge/tigramite/", long_description=long_description, long_description_content_type="text/markdown", - keywords="causality, time-series", + keywords="causal inference, causal discovery, prediction, time series", cmdclass=CMDCLASS, ext_modules=EXT_MODULES, install_requires=INSTALL_REQUIRES, diff --git a/tests/test_independence_tests.py b/tests/test_independence_tests.py index fc98a890..9230fda7 100644 --- a/tests/test_independence_tests.py +++ b/tests/test_independence_tests.py @@ -5,7 +5,7 @@ import numpy as np import pytest -from tigramite.independence_tests import ParCorr, GPDC, CMIsymb, CMIknn +from tigramite.independence_tests import ParCorr, GPDC, GPDCtorch, CMIsymb, CMIknn import tigramite.data_processing as pp from test_pcmci_calculations import a_chain, gen_data_frame @@ -356,6 +356,114 @@ def test_trafo2uniform(gpdc, data_sample_a): hist/float(bins), atol=0.01) +# GPDCtorch TESTING ################################################################# +@pytest.fixture() +def gpdc_torch(request): + return GPDCtorch(mask_type=None, + significance='analytic', + fixed_thres=0.1, + sig_samples=1000, + sig_blocklength=1, + confidence='bootstrap', + conf_lev=0.9, + conf_samples=100, + conf_blocklength=None, + recycle_residuals=False, + verbosity=0) + +# RE-USING SETUP FROM GPDC + +# @pytest.fixture(params=[ +# # Generate the sample to be used for confidence interval comparison +# #seed, corr_val, T +# (5, 0.3, 200), # Default +# (6, 0.3, 200), # New Seed +# (1, 0.9, 200)]) # Strong Correlation +# def data_sample_b(request): +# # Unpack the parameters +# seed, corr_val, T = request.param +# # Return the data sample +# return gen_data_sample(seed, corr_val, T) + +# @pytest.fixture(params=[ +# # Generate a test data sample +# # Parameterize the sample by setting the autocorrelation value, coefficient +# # value, total time length, and random seed to different numbers +# # links_coeffs, time, seed_val +# (a_chain(0.1, 0.9), 250, 2), +# (a_chain(0.5, 0.6), 250, 11), +# (a_chain(0.5, 0.6, length=5), 250, 42)]) +# def data_frame_b(request): +# # Set the parameters +# links_coeffs, time, seed_val = request.param +# # Generate the dataframe +# return gen_data_frame(links_coeffs, time, seed_val) + +def test_get_array_gpdc_torch(gpdc_torch, data_frame_b): + # Check the get_array function + check_get_array(gpdc_torch, data_frame_b) + +def test_get_measure_gpdc_torch(gpdc_torch, data_frame_b): + # Check the get_measure function + check_get_measure(gpdc_torch, data_frame_b) + +def test_get_confidence_gpdc_torch(gpdc_torch, data_frame_b): + # Skip if just checking boostrap vs. bootstrap + if not gpdc_torch.confidence == 'bootstrap': + # Check the get_confidence function + check_get_confidence(gpdc_torch, data_frame_b) + +@pytest.mark.parametrize("seed", list(range(10))) +def test_gpdc_torch_residuals(gpdc_torch, seed): + # Set the random seed + np.random.seed(seed) + c_val = .3 + T = 1000 + # Define the function to check against + def func(x_arr, c_val=1.): + return c_val*x_arr*(1. - 4.*np.exp(-x_arr*x_arr/2.)) + # Generate the array + array = np.random.randn(3, T) + # Manipulate the array + array[1] += func(array[2], c_val) + # Set the target value and the target results + target_var = 1 + target_res = np.copy(array[2]) + # Calculate the residuals + (_, pred) = gpdc_torch._get_single_residuals(array, target_var, + standardize=False, + return_means=True) + # Testing that the fit matches in the centre + cntr = np.where(np.abs(target_res) < .7)[0] + np.testing.assert_allclose(pred[cntr], + func(target_res[cntr], c_val), + atol=0.2) + +def test_shuffle_sig_gpdc_torch(gpdc_torch, data_sample_b): + # Get the data sample + array, _, _, xyz, dim, T = data_sample_b + # Trim the data sample down, time goes as T^2 + T = int(T/4.) + array = array[:, :T] + # Get the value of the dependence measurement + val = gpdc_torch.get_dependence_measure(array, xyz) + pval_a = gpdc_torch.get_analytic_significance(value=val, T=T, dim=dim) + pval_s = gpdc_torch.get_shuffle_significance(array, xyz, val) + np.testing.assert_allclose(np.array(pval_a), np.array(pval_s), atol=0.05) + +def test_trafo2uniform_torch(gpdc_torch, data_sample_a): + # Get the data sample + array, _, _, _, _, T = data_sample_a + # Make the transformation + uniform = gpdc_torch._trafo2uniform(array) + # Set the number of bins + bins = 10 + for i in range(array.shape[0]): + hist, _ = np.histogram(uniform[i], bins=bins, density=True) + np.testing.assert_allclose(np.ones(bins)/float(bins), + hist/float(bins), + atol=0.01) + # CMIknn TESTING ############################################################### @pytest.fixture() def cmi_knn(request): diff --git a/tests/test_pcmci_calculations.py b/tests/test_pcmci_calculations.py index b2d2d0be..4a128f6c 100644 --- a/tests/test_pcmci_calculations.py +++ b/tests/test_pcmci_calculations.py @@ -520,7 +520,7 @@ def a_run_pcmciplus(a_pcmciplus, a_pcmciplus_params): ) = a_pcmciplus_params if cond_ind_test_class == 'oracle_ci': - cond_ind_test = OracleCI(links_coeffs) + cond_ind_test = OracleCI(links=links_coeffs) elif cond_ind_test_class == 'par_corr': cond_ind_test = ParCorr() @@ -633,7 +633,7 @@ def test_order_independence_pcmciplus(a_pcmciplus_order_independence, ) = a_pcmciplus_params_order_independence if cond_ind_test_class == 'oracle_ci': - cond_ind_test = OracleCI(links_coeffs) + cond_ind_test = OracleCI(links=links_coeffs) elif cond_ind_test_class == 'par_corr': cond_ind_test = ParCorr() diff --git a/tigramite/data_processing.py b/tigramite/data_processing.py index 82f7bf37..1ae526b7 100644 --- a/tigramite/data_processing.py +++ b/tigramite/data_processing.py @@ -121,10 +121,9 @@ def construct_array(self, X, Y, Z, tau_max, Parameters ---------- X, Y, Z : list of tuples - For a dependence measure I(X;Y|Z), Y is of the form [(varY, 0)], - where var specifies the variable index. X typically is of the form - [(varX, -tau)] with tau denoting the time lag and Z can be - multivariate [(var1, -lag), (var2, -lag), ...] . + For a dependence measure I(X;Y|Z), X, Y, Z can be multivariate of + the form [(var1, -lag), (var2, -lag), ...]. At least one varlag in Y + has to be at lag zero. tau_max : int Maximum time lag. This may be used to make sure that estimates for different lags in X and Z all have the same sample size. diff --git a/tigramite/independence_tests/__init__.py b/tigramite/independence_tests/__init__.py index a0ee2d45..0088c41c 100644 --- a/tigramite/independence_tests/__init__.py +++ b/tigramite/independence_tests/__init__.py @@ -1,6 +1,7 @@ from .independence_tests_base import CondIndTest from .parcorr import ParCorr from .gpdc import GPDC +from .gpdc_torch import GPDCtorch from .cmiknn import CMIknn from .cmisymb import CMIsymb from .oracle_conditional_independence import OracleCI \ No newline at end of file diff --git a/tigramite/independence_tests/gpdc_torch.py b/tigramite/independence_tests/gpdc_torch.py new file mode 100644 index 00000000..74199f4b --- /dev/null +++ b/tigramite/independence_tests/gpdc_torch.py @@ -0,0 +1,864 @@ +"""Tigramite causal discovery for time series.""" + +# Author: Jakob Runge +# +# License: GNU General Public License v3.0 + + + +from __future__ import print_function +import numpy as np +import gpytorch +from gpytorch.kernels import RBFKernel +import torch + +from .independence_tests_base import CondIndTest + +try: + from tigramite import tigramite_cython_code +except: + print("Could not import packages for CMIknn and GPDC estimation") + + +class GaussProcRegTorch(): + r"""Gaussian processes abstract base class. + + GP is estimated with gpytorch. Note that the kernel's hyperparameters are + optimized during fitting. + + When the null distribution is not analytically available, but can be + precomputed with the function generate_and_save_nulldists(...) which saves + a \*.npz file containing the null distribution for different sample sizes. + This file can then be supplied as null_dist_filename. + + Parameters + ---------- + null_samples : int + Number of null samples to use + + cond_ind_test : CondIndTest + Conditional independence test that this Gaussian Proccess Regressor will + calculate the null distribution for. This is used to grab the + get_dependence_measure function. + + null_dist_filename : str, otional (default: None) + Path to file containing null distribution. + + verbosity : int, optional (default: 0) + Level of verbosity. + """ + + def __init__(self, + null_samples, + cond_ind_test, + null_dist_filename=None, + verbosity=0): + # Set the dependence measure function + self.cond_ind_test = cond_ind_test + # Set member variables + self.verbosity = verbosity + # Set the null distribution defaults + self.null_samples = null_samples + self.null_dists = {} + self.null_dist_filename = null_dist_filename + # Check if we are loading a null distrubtion from a cached file + if self.null_dist_filename is not None: + self.null_dists, self.null_samples = \ + self._load_nulldist(self.null_dist_filename) + + def _load_nulldist(self, filename): + r""" + Load a precomputed null distribution from a \*.npz file. This + distribution can be calculated using generate_and_save_nulldists(...). + + Parameters + ---------- + filename : strng + Path to the \*.npz file + + Returns + ------- + null_dists, null_samples : dict, int + The null distirbution as a dictionary of distributions keyed by + sample size, the number of null samples in total. + """ + null_dist_file = np.load(filename) + null_dists = dict(zip(null_dist_file['T'], + null_dist_file['exact_dist'])) + null_samples = len(null_dist_file['exact_dist'][0]) + return null_dists, null_samples + + def _generate_nulldist(self, df, + add_to_null_dists=True): + """Generates null distribution for pairwise independence tests. + + Generates the null distribution for sample size df. Assumes pairwise + samples transformed to uniform marginals. Uses get_dependence_measure + available in class and generates self.sig_samples random samples. Adds + the null distributions to self.null_dists. + + Parameters + ---------- + df : int + Degrees of freedom / sample size to generate null distribution for. + add_to_null_dists : bool, optional (default: True) + Whether to add the null dist to the dictionary of null dists or + just return it. + + Returns + ------- + null_dist : array of shape [df,] + Only returned,if add_to_null_dists is False. + """ + + if self.verbosity > 0: + print("Generating null distribution for df = %d. " % df) + if add_to_null_dists: + print("For faster computations, run function " + "generate_and_save_nulldists(...) to " + "precompute null distribution and load *.npz file with " + "argument null_dist_filename") + + xyz = np.array([0, 1]) + + null_dist = np.zeros(self.null_samples) + for i in range(self.null_samples): + array = np.random.rand(2, df) + null_dist[i] = self.cond_ind_test.get_dependence_measure( + array, xyz) + + null_dist.sort() + if add_to_null_dists: + self.null_dists[df] = null_dist + return null_dist + + def _generate_and_save_nulldists(self, sample_sizes, null_dist_filename): + """Generates and saves null distribution for pairwise independence + tests. + + Generates the null distribution for different sample sizes. Calls + generate_nulldist. Null dists are saved to disk as + self.null_dist_filename.npz. Also adds the null distributions to + self.null_dists. + + Parameters + ---------- + sample_sizes : list + List of sample sizes. + + null_dist_filename : str + Name to save file containing null distributions. + """ + + self.null_dist_filename = null_dist_filename + + null_dists = np.zeros((len(sample_sizes), self.null_samples)) + + for iT, T in enumerate(sample_sizes): + null_dists[iT] = self._generate_nulldist( + T, add_to_null_dists=False) + self.null_dists[T] = null_dists[iT] + + np.savez("%s" % null_dist_filename, + exact_dist=null_dists, + T=np.array(sample_sizes)) + + + def _get_single_residuals(self, array, target_var, + return_means=False, + standardize=True, + return_likelihood=False, + training_iter=25, + lr=0.1): + """Returns residuals of Gaussian process regression. + + Performs a GP regression of the variable indexed by target_var on the + conditions Z. Here array is assumed to contain X and Y as the first two + rows with the remaining rows (if present) containing the conditions Z. + Optionally returns the estimated mean and the likelihood. + + Parameters + ---------- + array : array-like + data array with X, Y, Z in rows and observations in columns + + target_var : {0, 1} + Variable to regress out conditions from. + + standardize : bool, optional (default: True) + Whether to standardize the array beforehand. + + return_means : bool, optional (default: False) + Whether to return the estimated regression line. + + return_likelihood : bool, optional (default: False) + Whether to return the log_marginal_likelihood of the fitted GP + + Returns + ------- + resid [, mean, likelihood] : array-like + The residual of the regression and optionally the estimated mean + and/or the likelihood. + """ + + device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') + + GPU = torch.cuda.is_available() + dim, T = array.shape + + if dim <= 2: + if return_likelihood: + return array[target_var, :], -np.inf + return array[target_var, :] + + # Implement using PyTorch + # Standardize + if standardize: + array -= array.mean(axis=1).reshape(dim, 1) + array /= array.std(axis=1).reshape(dim, 1) + if np.isnan(array).any(): + raise ValueError("Nans after standardizing, " + "possibly constant array!") + + target_series = array[target_var, :] + z = np.fastCopyAndTranspose(array[2:]) + if np.ndim(z) == 1: + z = z.reshape(-1, 1) + + train_x = torch.tensor(z).float() + train_y = torch.tensor(target_series).float() + + if GPU: + train_x = train_x.cuda() + train_y = train_y.cuda() + + # We will use the simplest form of GP model, exact inference + class ExactGPModel(gpytorch.models.ExactGP): + def __init__(self, train_x, train_y, likelihood): + super(ExactGPModel, self).__init__( + train_x, train_y, likelihood) + self.mean_module = gpytorch.means.ConstantMean() + + # We only use the RBF kernel here, the WhiteNoiseKernel is deprecated + # and its featured integrated into the Likelihood-Module. + self.covar_module = gpytorch.kernels.ScaleKernel(RBFKernel()) + + def forward(self, x): + mean_x = self.mean_module(x) + covar_x = self.covar_module(x) + return gpytorch.distributions.MultivariateNormal(mean_x, covar_x) + + # initialize likelihood and model + likelihood = gpytorch.likelihoods.GaussianLikelihood() + model = ExactGPModel(train_x, train_y, likelihood) + + if GPU: + likelihood = likelihood.cuda() + model = model.cuda() + + # Find optimal model hyperparameters + model.train() + likelihood.train() + + # Use the adam optimizer + # Includes GaussianLikelihood parameters + optimizer = torch.optim.Adam(model.parameters(), lr=lr) + + # "Loss" for GPs - the marginal log likelihood + mll = gpytorch.mlls.ExactMarginalLogLikelihood(likelihood, model) + + for i in range(training_iter): + # Zero gradients from previous iteration + optimizer.zero_grad() + # Output from model + output = model(train_x) + + # Calc loss and backprop gradients + loss = -mll(output, train_y) + loss.backward() + optimizer.step() + + # Get into evaluation (predictive posterior) mode + model.eval() + likelihood.eval() + + # Make predictions by feeding model through likelihood + with torch.no_grad(), gpytorch.settings.fast_pred_var(): + mean = model(train_x).loc.detach() + loglik = mll(model(train_x), train_y)*T + + if GPU: + resid = (train_y - mean).detach().cpu().numpy() + mean = mean.detach().cpu().numpy() + else: + resid = (train_y - mean).detach().numpy() + mean = mean.detach().numpy() + + if return_means and not return_likelihood: + return resid, mean + elif return_likelihood and not return_means: + return resid, loglik + elif return_means and return_likelihood: + return resid, mean, loglik + return resid + + def _get_model_selection_criterion(self, j, parents, tau_max=0): + """Returns log marginal likelihood for GP regression. + + Fits a GP model of the parents to variable j and returns the negative + log marginal likelihood as a model selection score. Is used to determine + optimal hyperparameters in PCMCI, in particular the pc_alpha value. + + Parameters + ---------- + j : int + Index of target variable in data array. + + parents : list + List of form [(0, -1), (3, -2), ...] containing parents. + + tau_max : int, optional (default: 0) + Maximum time lag. This may be used to make sure that estimates for + different lags in X, Z, all have the same sample size. + + Returns: + score : float + Model score. + """ + + Y = [(j, 0)] + X = [(j, 0)] # dummy variable here + Z = parents + array, xyz = \ + self.cond_ind_test.dataframe.construct_array( + X=X, Y=Y, Z=Z, + tau_max=tau_max, + mask_type=self.cond_ind_test.mask_type, + return_cleaned_xyz=False, + do_checks=True, + verbosity=self.verbosity) + + dim, T = array.shape + + _, logli = self._get_single_residuals(array, + target_var=1, + return_likelihood=True) + + score = -logli + return score + + +class GPDCtorch(CondIndTest): + r"""GPDC conditional independence test based on Gaussian processes and + distance correlation. Here with gpytorch implementation. + + GPDC is based on a Gaussian process (GP) regression and a distance + correlation test on the residuals [2]_. GP is estimated with gpytorch. + The distance correlation test is implemented with + cython. Here the null distribution is not analytically available, but can be + precomputed with the function generate_and_save_nulldists(...) which saves a + \*.npz file containing the null distribution for different sample sizes. + This file can then be supplied as null_dist_filename. + + Notes + ----- + + GPDC is based on a Gaussian process (GP) regression and a distance + correlation test on the residuals. Distance correlation is described in + [2]_. To test :math:`X \perp Y | Z`, first :math:`Z` is regressed out from + :math:`X` and :math:`Y` assuming the model + + .. math:: X & = f_X(Z) + \epsilon_{X} \\ + Y & = f_Y(Z) + \epsilon_{Y} \\ + \epsilon_{X,Y} &\sim \mathcal{N}(0, \sigma^2) + + using GP regression. Here :math:`\sigma^2` and the kernel bandwidth are + optimzed using ``gpytorch``. Then the residuals are transformed to uniform + marginals yielding :math:`r_X,r_Y` and their dependency is tested with + + .. math:: \mathcal{R}\left(r_X, r_Y\right) + + The null distribution of the distance correlation should be pre-computed. + Otherwise it is computed during runtime. + + The cython-code for distance correlation is Copyright (c) 2012, Florian + Finkernagel (https://gist.github.com/ffinkernagel/2960386). + + References + ---------- + .. [2] Gabor J. Szekely, Maria L. Rizzo, and Nail K. Bakirov: Measuring and + testing dependence by correlation of distances, + https://arxiv.org/abs/0803.4101 + + Parameters + ---------- + null_dist_filename : str, otional (default: None) + Path to file containing null distribution. + + **kwargs : + Arguments passed on to parent class GaussProcRegTorch. + + """ + @property + def measure(self): + """ + Concrete property to return the measure of the independence test + """ + return self._measure + + def __init__(self, + null_dist_filename=None, + **kwargs): + self._measure = 'gp_dc' + self.two_sided = False + self.residual_based = True + # Call the parent constructor + CondIndTest.__init__(self, **kwargs) + # Build the regressor + self.gauss_pr = GaussProcRegTorch(self.sig_samples, + self, + null_dist_filename=null_dist_filename, + verbosity=self.verbosity) + + if self.verbosity > 0: + print("null_dist_filename = %s" % self.gauss_pr.null_dist_filename) + print("") + + def _load_nulldist(self, filename): + r""" + Load a precomputed null distribution from a \*.npz file. This + distribution can be calculated using generate_and_save_nulldists(...). + + Parameters + ---------- + filename : strng + Path to the \*.npz file + + Returns + ------- + null_dists, null_samples : dict, int + The null distirbution as a dictionary of distributions keyed by + sample size, the number of null samples in total. + """ + return self.gauss_pr._load_nulldist(filename) + + def generate_nulldist(self, df, add_to_null_dists=True): + """Generates null distribution for pairwise independence tests. + + Generates the null distribution for sample size df. Assumes pairwise + samples transformed to uniform marginals. Uses get_dependence_measure + available in class and generates self.sig_samples random samples. Adds + the null distributions to self.gauss_pr.null_dists. + + Parameters + ---------- + df : int + Degrees of freedom / sample size to generate null distribution for. + + add_to_null_dists : bool, optional (default: True) + Whether to add the null dist to the dictionary of null dists or + just return it. + + Returns + ------- + null_dist : array of shape [df,] + Only returned,if add_to_null_dists is False. + """ + return self.gauss_pr._generate_nulldist(df, add_to_null_dists) + + def generate_and_save_nulldists(self, sample_sizes, null_dist_filename): + """Generates and saves null distribution for pairwise independence + tests. + + Generates the null distribution for different sample sizes. Calls + generate_nulldist. Null dists are saved to disk as + self.null_dist_filename.npz. Also adds the null distributions to + self.gauss_pr.null_dists. + + Parameters + ---------- + sample_sizes : list + List of sample sizes. + + null_dist_filename : str + Name to save file containing null distributions. + """ + self.gauss_pr._generate_and_save_nulldists(sample_sizes, + null_dist_filename) + + + def _get_single_residuals(self, array, target_var, + return_means=False, + standardize=True, + return_likelihood=False, + training_iter=25, + lr=0.1): + """Returns residuals of Gaussian process regression. + + Performs a GP regression of the variable indexed by target_var on the + conditions Z. Here array is assumed to contain X and Y as the first two + rows with the remaining rows (if present) containing the conditions Z. + Optionally returns the estimated mean and the likelihood. + + Parameters + ---------- + array : array-like + data array with X, Y, Z in rows and observations in columns + + target_var : {0, 1} + Variable to regress out conditions from. + + standardize : bool, optional (default: True) + Whether to standardize the array beforehand. + + return_means : bool, optional (default: False) + Whether to return the estimated regression line. + + return_likelihood : bool, optional (default: False) + Whether to return the log_marginal_likelihood of the fitted GP + + Returns + ------- + resid [, mean, likelihood] : array-like + The residual of the regression and optionally the estimated mean + and/or the likelihood. + """ + return self.gauss_pr._get_single_residuals( + array, target_var, + return_means, + standardize, + return_likelihood, + training_iter, + lr) + + def get_model_selection_criterion(self, j, parents, tau_max=0): + """Returns log marginal likelihood for GP regression. + + Fits a GP model of the parents to variable j and returns the negative + log marginal likelihood as a model selection score. Is used to determine + optimal hyperparameters in PCMCI, in particular the pc_alpha value. + + Parameters + ---------- + j : int + Index of target variable in data array. + + parents : list + List of form [(0, -1), (3, -2), ...] containing parents. + + tau_max : int, optional (default: 0) + Maximum time lag. This may be used to make sure that estimates for + different lags in X, Z, all have the same sample size. + + Returns: + score : float + Model score. + """ + return self.gauss_pr._get_model_selection_criterion(j, parents, tau_max) + + def get_dependence_measure(self, array, xyz): + """Return GPDC measure. + + Estimated as the distance correlation of the residuals of a GP + regression. + + 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,). + + Returns + ------- + val : float + GPDC test statistic. + """ + + x_vals = self._get_single_residuals(array, target_var=0) + y_vals = self._get_single_residuals(array, target_var=1) + val = self._get_dcorr(np.array([x_vals, y_vals])) + return val + + def _get_dcorr(self, array_resid): + """Return distance correlation coefficient. + + The variables are transformed to uniform marginals using the empirical + cumulative distribution function beforehand. Here the null distribution + is not analytically available, but can be precomputed with the function + generate_and_save_nulldists(...) which saves a \*.npz file containing + the null distribution for different sample sizes. This file can then be + supplied as null_dist_filename. + + Parameters + ---------- + array_resid : array-like + data array must be of shape (2, T) + + Returns + ------- + val : float + Distance correlation coefficient. + """ + # Remove ties before applying transformation to uniform marginals + # array_resid = self._remove_ties(array_resid, verbosity=4) + x_vals, y_vals = self._trafo2uniform(array_resid) + + _, val, _, _ = tigramite_cython_code.dcov_all(x_vals, y_vals) + return val + + def get_shuffle_significance(self, array, xyz, value, + return_null_dist=False): + """Returns p-value for shuffle significance test. + + For residual-based test statistics only the residuals are shuffled. + + 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,). + + value : number + Value of test statistic for unshuffled estimate. + + Returns + ------- + pval : float + p-value + """ + + x_vals = self._get_single_residuals(array, target_var=0) + y_vals = self._get_single_residuals(array, target_var=1) + array_resid = np.array([x_vals, y_vals]) + xyz_resid = np.array([0, 1]) + + null_dist = self._get_shuffle_dist(array_resid, xyz_resid, + self.get_dependence_measure, + sig_samples=self.sig_samples, + sig_blocklength=self.sig_blocklength, + verbosity=self.verbosity) + + pval = (null_dist >= value).mean() + + if return_null_dist: + return pval, null_dist + return pval + + def get_analytic_significance(self, value, T, dim): + """Returns p-value for the distance correlation coefficient. + + The null distribution for necessary degrees of freedom (df) is loaded. + If not available, the null distribution is generated with the function + generate_nulldist(). It is recommended to generate the nulldists for a + wide range of sample sizes beforehand with the function + generate_and_save_nulldists(...). The distance correlation coefficient + is one-sided. If the degrees of freedom are less than 1, numpy.nan is + returned. + + Parameters + ---------- + value : float + Test statistic value. + + T : int + Sample length + + dim : int + Dimensionality, ie, number of features. + + Returns + ------- + pval : float or numpy.nan + p-value. + """ + + # GP regression approximately doesn't cost degrees of freedom + df = T + + if df < 1: + pval = np.nan + else: + # idx_near = (np.abs(self.sample_sizes - df)).argmin() + if int(df) not in list(self.gauss_pr.null_dists): + # if np.abs(self.sample_sizes[idx_near] - df) / float(df) > 0.01: + if self.verbosity > 0: + print("Null distribution for GPDC not available " + "for deg. of freed. = %d." % df) + self.generate_nulldist(df) + null_dist_here = self.gauss_pr.null_dists[int(df)] + pval = np.mean(null_dist_here > np.abs(value)) + return pval + +# def dcov_all(x, y): +# """Calculate distance covariance, distance correlation, +# distance variance of x sample and distance variance of y sample""" + +# GPU_FLAG = torch.cuda.is_available() + + +# x = np.reshape(x, (x.shape[0], 1)) +# y = np.reshape(y, (y.shape[0], 1)) + +# x = torch.tensor(x) +# y = torch.tensor(y) + +# mean_x_0 = torch.zeros(x.shape[0],1) +# mean_x_1 = torch.zeros(x.shape[0],1) +# mean_y_0 = torch.zeros(x.shape[0],1) +# mean_y_1 = torch.zeros(x.shape[0],1) +# x_abs_diff = torch.zeros(x.shape[0],1) +# y_abs_diff = torch.zeros(x.shape[0],1) +# x_all_mean = 0 +# y_all_mean = 0 +# SUM_VAL = 0 + +# if GPU_FLAG: +# x = x.cuda() +# y = y.cuda() +# mean_x_0 = mean_x_0.cuda() +# mean_x_1 = mean_x_1.cuda() +# mean_y_0 = mean_y_0.cuda() +# mean_y_1 = mean_y_1.cuda() +# x_abs_diff = x_abs_diff.cuda() +# y_abs_diff = y_abs_diff.cuda() + + +# # Calculate means +# for i in range(x.shape[0]): +# x_abs_diff = torch.abs(x - x[i,:]) +# y_abs_diff = torch.abs(y - y[i,:]) +# mean_x_0 += x_abs_diff +# mean_y_0 += y_abs_diff + +# x_all_mean += torch.sum(mean_x_0) +# y_all_mean += torch.sum(mean_y_0) + +# mean_x_1[i] = torch.mean(x_abs_diff) +# mean_y_1[i] = torch.mean(y_abs_diff) + +# mean_x_0 = mean_x_0/mean_x_0.shape[0] +# mean_y_0 = mean_y_0/mean_y_0.shape[0] + +# x_all_mean = x_all_mean/mean_x_0.shape[0]**2 +# y_all_mean = y_all_mean/mean_y_0.shape[0]**2 + + +# for i in range(x.shape[0]): +# X_i = torch.abs(x - x[i,:]) - mean_x_0 - mean_x_1[i] + x_all_mean +# Y_i = torch.abs(y - y[i,:]) - mean_y_0 - mean_y_1[i] + y_all_mean +# SUM_VAL += torch.sum(torch.mul(X_i, Y_i)) + +# SUM_VAL = SUM_VAL/X_i.shape[0]**2 + +# # Todo: dCor, dVarX, dVarY +# # Todo: Better batching? + +# if GPU_FLAG: +# dCov = 1 # dCov.cpu() + +# return 1 #dCov.numpy() + + +if __name__ == "__main__": + import tigramite.data_processing as pp + import tigramite.plotting as tp + import matplotlib.pyplot as plt + from time import time + import sys + + + # Example process to play around with + # Each key refers to a variable and the incoming links are supplied + # as a list of format [((var, -lag), coeff, function), ...] + + def lin_f(x): + return x + + def nonlin_f(x): + return x + 5.0 * x ** 2 * np.exp(-(x ** 2) / 20.0) + + print(torch.cuda.is_available()) + + for samples in [10000, 20000, 50000, 100000]: + torch.cuda.empty_cache() + test_a = np.random.normal(0,1, samples) + test_b = np.random.normal(0,1, samples) + + start = time() + distance_corr = dcov_all(test_a, test_b) + end_torch = time() - start + + print("###################", flush=True) + print(f"T={samples}.", flush=True) + print(f"PyTorch (GPU) took {end_torch} seconds.\n", flush=True) + + + start = time() + distance_corr = tigramite_cython_code.dcov_all(test_a, test_b) + end_cython = time() - start + + print(f"Cython took {end_cython} seconds.\n", flush=True) + + sys.exit(0) + + N = 50 + + links = {i: [((i, -1), + np.random.uniform(low=0.4, high=0.9, size=None), + np.random.choice([lin_f, nonlin_f], p=[0.7, 0.3]))] + for i in range(N)} + + for i in range(1,N): + links[i].append(((i-1, -1), + np.random.uniform(low=0.4, high=0.9, size=None), + np.random.choice([lin_f, nonlin_f], p=[0.7, 0.3]))) + + torch_time_lst = [] + sklearn_time_lst = [] + + for T in [25000, 40000, 55000]: + + #torch.cuda.empty_cache() + data, nonstat = pp.structural_causal_process(links, T=T) + data = data.T + gpdc = GPDC() + + + #start_sklearn = time() + #get_resid_sklearn = gpdc._get_single_residuals(data, 0, + # return_means=True, + # standardize=True, + # return_likelihood=True) + #end_sklearn = time() - start_sklearn + #sklearn_time_lst.append(end_sklearn) + + start_torch = time() + get_resid_torch = gpdc._get_single_residuals(data, 0, + return_means=True, + standardize=True, + return_likelihood=True) + + end_torch = time() - start_torch + torch_time_lst.append(end_torch) + + print("###################", flush=True) + print(f"Data shape: {data.shape}", flush=True) + #print(f"Sklearn took {end_sklearn} seconds.", flush=True) + print(f"Torch took {end_torch} seconds.", flush=True) + + print("\n") + + try: + #print(f"Sklearn loglik: {get_resid_sklearn[2]}") + print(f"Torch loglik: {get_resid_torch[2]}") + print(f"\n") + except IndexError: + print("The likelihood was not returned.") + + #print(f"Sklearn times: {sklearn_time_lst}") + print(f"Torch times: {torch_time_lst}") + diff --git a/tigramite/independence_tests/oracle_conditional_independence.py b/tigramite/independence_tests/oracle_conditional_independence.py index 42589b7b..4068fdac 100644 --- a/tigramite/independence_tests/oracle_conditional_independence.py +++ b/tigramite/independence_tests/oracle_conditional_independence.py @@ -8,6 +8,7 @@ import numpy as np from collections import defaultdict, OrderedDict +from itertools import combinations, permutations class OracleCI: @@ -21,8 +22,18 @@ class OracleCI: Parameters ---------- - link_coeffs : dict - Dictionary of form {0:[((0, -1), coeff, func), ...], 1:[...], ...}. + graph : array of shape [N, N, tau_max+1] + Causal graph. + links : dict + Dictionary of form {0:[(0, -1), ...], 1:[...], ...}. + Alternatively can also digest {0: [((0, -1), coeff, func)], ...}. + observed_vars : None or list, optional (default: None) + Subset of keys in links definining which variables are + observed. If None, then all variables are observed. + selection_vars : None or list, optional (default: None) + Subset of keys in links definining which variables are + selected (= always conditioned on at every time lag). + If None, then no variables are selected. verbosity : int, optional (default: 0) Level of verbosity. """ @@ -36,14 +47,26 @@ def measure(self): return self._measure def __init__(self, - link_coeffs, + links=None, observed_vars=None, + selection_vars=None, + graph=None, verbosity=0): + + if links is None: + if graph is None: + raise ValueError("Either links or graph must be specified!") + else: + (links, + observed_vars, + selection_vars) = self.get_links_from_graph(graph) + + self.graph = graph self.verbosity = verbosity self._measure = 'oracle_ci' self.confidence = None - self.link_coeffs = link_coeffs - self.N = len(link_coeffs) + self.links = links + self.N = len(links) # Initialize already computed dsepsets of X, Y, Z self.dsepsets = {} @@ -60,6 +83,18 @@ def __init__(self, if len(self.observed_vars) != len(set(self.observed_vars)): raise ValueError("observed_vars must not contain duplicates.") + self.selection_vars = selection_vars + + if self.selection_vars is not None: + if not set(self.selection_vars).issubset(set(range(self.N))): + raise ValueError("selection_vars must be subset of range(N).") + if self.selection_vars != sorted(self.selection_vars): + raise ValueError("selection_vars must ordered.") + if len(self.selection_vars) != len(set(self.selection_vars)): + raise ValueError("selection_vars must not contain duplicates.") + else: + self.selection_vars = [] + def set_dataframe(self, dataframe): """Dummy function.""" pass @@ -129,9 +164,13 @@ def _get_lagged_parents(self, var_lag, exclude_contemp=False): var, lag = var_lag - for link_props in self.link_coeffs[var]: - i, tau = link_props[0] - coeff = link_props[1] + for link_props in self.links[var]: + if len(link_props) == 3: + i, tau = link_props[0] + coeff = link_props[1] + else: + i, tau = link_props + coeff = 1. if coeff != 0.: if not (exclude_contemp and lag == 0): yield (i, lag + tau) @@ -147,15 +186,19 @@ def _get_children(self): Dictionary of form {0:[(0, 1), (3, 0), ...], 1:[], ...}. """ - N = len(self.link_coeffs) + N = len(self.links) children = dict([(j, []) for j in range(N)]) for j in range(N): - for link_props in self.link_coeffs[j]: - i, tau = link_props[0] - coeff = link_props[1] - if coeff != 0.: - children[i].append((j, abs(tau))) + for link_props in self.links[j]: + if len(link_props) == 3: + i, tau = link_props[0] + coeff = link_props[1] + else: + i, tau = link_props + coeff = 1. + if coeff != 0.: + children[i].append((j, abs(tau))) return children @@ -244,7 +287,7 @@ def _repeating(link, seen_links): conds = [] conds = [z for z in conds if z not in Y] - N = len(self.link_coeffs) + N = len(self.links) # Initialize max. ancestral time lag for every N if mode == 'non_repeating': @@ -253,6 +296,12 @@ def _repeating(link, seen_links): if max_lag is None: raise ValueError("max_lag must be set in mode = 'max_lag'") + if self.selection_vars is not None: + for selection_var in self.selection_vars: + # print (selection_var, conds) + # print([(selection_var, -tau_sel) for tau_sel in range(0, max_lag + 1)]) + conds += [(selection_var, -tau_sel) for tau_sel in range(0, max_lag + 1)] + ancestors = dict([(y, []) for y in Y]) for y in Y: @@ -282,7 +331,7 @@ def _repeating(link, seen_links): return ancestors, max_lag - def _has_any_path(self, X, Y, conds, max_lag): + def _has_any_path(self, X, Y, conds, max_lag, backdoor=False): """Returns True if X and Y are d-connected by any open path. Does breadth-first search from both X and Y and meets in the middle. @@ -302,40 +351,51 @@ def _has_any_path(self, X, Y, conds, max_lag): index and tau the time lag. max_lag : int Maximum time lag. - + backdoor : bool + Whether to only consider paths starting with an arrowhead in X. """ def _walk_to_parents(v, fringe, this_path, other_path): """Helper function to update paths when walking to parents.""" - found_path = False + found_connection = False for w in self._get_lagged_parents(v): # Cannot walk into conditioned parents and # cannot walk beyond t or max_lag i, t = w + + if backdoor and w == x: + continue + if (w not in conds and # (w, v) not in seen_links and t <= 0 and abs(t) <= max_lag): - if ((w, 'tail') not in this_path and - (w, None) not in this_path): + # if ((w, 'tail') not in this_path and + # (w, None) not in this_path): + if (w not in this_path or + ('tail' not in this_path[w] and None not in this_path[w])): if self.verbosity > 1: print("Walk parent: %s --> %s " %(v, w)) fringe.append((w, 'tail')) - this_path[(w, 'tail')] = (v, 'arrowhead') + if w not in this_path: + this_path[w] = {'tail' : (v, 'arrowhead')} + else: + this_path[w]['tail'] = (v, 'arrowhead') # seen_links.append((v, w)) # Determine whether X and Y are connected # (w, None) indicates the start or end node X/Y - if ((w, 'tail') in other_path - or (w, 'arrowhead') in other_path - or (w, None) in other_path): + # if ((w, 'tail') in other_path + # or (w, 'arrowhead') in other_path + # or (w, None) in other_path): + if w in other_path: + found_connection = (w, 'tail') if self.verbosity > 1: - print("Found connection: ", w) - found_path = True + print("Found connection: ", found_connection) break - return found_path, fringe, this_path + return found_connection, fringe, this_path def _walk_to_children(v, fringe, this_path, other_path): """Helper function to update paths when walking to children.""" - found_path = False + found_connection = False for w in self._get_lagged_children(v, children): # You can also walk into conditioned children, # but cannot walk beyond t or max_lag @@ -343,87 +403,164 @@ def _walk_to_children(v, fringe, this_path, other_path): if ( # (w, v) not in seen_links and t <= 0 and abs(t) <= max_lag): - if ((w, 'arrowhead') not in this_path and - (w, None) not in this_path): + # if ((w, 'arrowhead') not in this_path and + # (w, None) not in this_path): + if (w not in this_path or + ('arrowhead' not in this_path[w] and None not in this_path[w])): if self.verbosity > 1: print("Walk child: %s --> %s " %(v, w)) fringe.append((w, 'arrowhead')) - this_path[(w, 'arrowhead')] = (v, 'tail') + # this_path[(w, 'arrowhead')] = (v, 'tail') + if w not in this_path: + this_path[w] = {'arrowhead' : (v, 'tail')} + else: + this_path[w]['arrowhead'] = (v, 'tail') # seen_links.append((v, w)) # Determine whether X and Y are connected # If the other_path contains w with a tail, then w must # NOT be conditioned on. Alternatively, if the other_path # contains w with an arrowhead, then w must be # conditioned on. - if (((w, 'tail') in other_path and w not in conds) - or ((w, 'arrowhead') in other_path and w in conds) - or (w, None) in other_path): - if self.verbosity > 1: - print("Found connection: ", w) - found_path = True - break - return found_path, fringe, this_path + # if (((w, 'tail') in other_path and w not in conds) + # or ((w, 'arrowhead') in other_path and w in conds) + # or (w, None) in other_path): + if w in other_path: + if (('tail' in other_path[w] and w not in conds) or + ('arrowhead' in other_path[w] and w in conds) or + (None in other_path[w])): + found_connection = (w, 'arrowhead') + if self.verbosity > 1: + print("Found connection: ", found_connection) + break + return found_connection, fringe, this_path def _walk_fringe(this_level, fringe, this_path, other_path): """Helper function to walk each fringe, i.e., the path from X and Y, respectively.""" - found_path = False + found_connection = False + + if backdoor: + if len(this_level) == 1 and this_level[0] == (x, None): + (found_connection, fringe, + this_path) = _walk_to_parents(x, fringe, + this_path, other_path) + return found_connection, fringe, this_path, other_path + for v, mark in this_level: if v in conds: if (mark == 'arrowhead' or mark == None): # Motif: --> [v] <-- # If standing on a condition and coming from an # arrowhead, you can only walk into parents - (found_path, fringe, + (found_connection, fringe, this_path) = _walk_to_parents(v, fringe, this_path, other_path) - if found_path: break + if found_connection: break else: if (mark == 'tail' or mark == None): # Motif: <-- v <-- or <-- v --> # If NOT standing on a condition and coming from # a tail mark, you can walk into parents or # children - (found_path, fringe, + (found_connection, fringe, this_path) = _walk_to_parents(v, fringe, this_path, other_path) - if found_path: break + if found_connection: break - (found_path, fringe, + (found_connection, fringe, this_path) = _walk_to_children(v, fringe, this_path, other_path) - if found_path: break + if found_connection: break elif mark == 'arrowhead': # Motif: --> v --> # If NOT standing on a condition and coming from # an arrowhead mark, you can only walk into # children - (found_path, fringe, + (found_connection, fringe, this_path) = _walk_to_children(v, fringe, this_path, other_path) - if found_path: break + if found_connection: break + if self.verbosity > 1: print("Updated fringe: ", fringe) - return found_path, fringe, this_path, other_path + return found_connection, fringe, this_path, other_path + + def backtrace_path(): + """Helper function to get path from start point, end point, + and connection found.""" + + path = [found_connection[0]] + node, mark = found_connection + + if 'tail' in pred[node]: + mark = 'tail' + else: + mark = 'arrowhead' + + while path[-1] != x: + prev_node, prev_mark = pred[node][mark] + path.append(prev_node) + if prev_mark == 'arrowhead': + if prev_node not in conds: + mark = 'tail' + elif prev_node in conds: + mark = 'arrowhead' + elif prev_mark == 'tail': + if 'tail' in pred[prev_node] and pred[prev_node]['tail'] != (node, mark): + mark = 'tail' + else: + mark = 'arrowhead' + node = prev_node + + path.reverse() + + node, mark = found_connection + if 'tail' in succ[node]: + mark = 'tail' + else: + mark = 'arrowhead' + + while path[-1] != y: + next_node, next_mark = succ[node][mark] + path.append(next_node) + if next_mark == 'arrowhead': + if next_node not in conds: + mark = 'tail' + elif next_node in conds: + mark = 'arrowhead' + elif next_mark == 'tail': + if 'tail' in succ[next_node] and succ[next_node]['tail'] != (node, mark): + mark = 'tail' + else: + mark = 'arrowhead' + node = next_node + + return path + if conds is None: conds = [] conds = [z for z in conds if z not in Y and z not in X] - N = len(self.link_coeffs) + if self.selection_vars is not None: + for selection_var in self.selection_vars: + conds += [(selection_var, -tau_sel) for tau_sel in range(0, max_lag + 1)] + + + N = len(self.links) children = self._get_children() # Iterate through nodes in X and Y for x in X: for y in Y: - seen_links = [] + # seen_links = [] # predecessor and successors in search # (x, None) where None indicates start/end nodes, later (v, # 'tail') or (w, 'arrowhead') indicate how a link ends at a node - pred = {(x, None): None} - succ = {(y, None): None} + pred = {x : {None: None}} + succ = {y : {None: None}} # initialize fringes, start with forward from X forward_fringe = [(x, None)] @@ -437,11 +574,14 @@ def _walk_fringe(this_level, fringe, this_path, other_path): len(reverse_fringe))) this_level = forward_fringe forward_fringe = [] - (found_path, forward_fringe, pred, + (found_connection, forward_fringe, pred, succ) = _walk_fringe(this_level, forward_fringe, pred, succ) + # print(pred) - if found_path: return True + if found_connection: + path = backtrace_path() + return path else: if self.verbosity > 1: print("Walk from Y since len(X_fringe)=%d " @@ -449,10 +589,13 @@ def _walk_fringe(this_level, fringe, this_path, other_path): len(reverse_fringe))) this_level = reverse_fringe reverse_fringe = [] - (found_path, reverse_fringe, succ, + (found_connection, reverse_fringe, succ, pred) = _walk_fringe(this_level, reverse_fringe, succ, pred) - if found_path: return True + + if found_connection: + path = backtrace_path() + return path if self.verbosity > 1: print("X_fringe = %s \n" % str(forward_fringe) + @@ -460,7 +603,27 @@ def _walk_fringe(this_level, fringe, this_path, other_path): return False - def _is_dsep(self, X, Y, Z, max_lag=None, compute_ancestors=False): + def _get_max_lag_from_XYZ(self, X, Y, Z): + """Get maximum non-repeated ancestral time lag. + """ + + # Get maximum non-repeated ancestral time lag + _, max_lag_X = self._get_non_blocked_ancestors(X, conds=Z, + mode='non_repeating') + _, max_lag_Y = self._get_non_blocked_ancestors(Y, conds=Z, + mode='non_repeating') + _, max_lag_Z = self._get_non_blocked_ancestors(Z, conds=Z, + mode='non_repeating') + + # Get max time lag among the ancestors + max_lag = max(max_lag_X, max_lag_Y, max_lag_Z) + + if self.verbosity > 0: + print("Max. non-repeated ancestral time lag: ", max_lag) + + return max_lag + + def _is_dsep(self, X, Y, Z, max_lag=None): """Returns whether X and Y are d-separated given Z in the graph. X, Y, Z are of the form (var, lag) for lag <= 0. D-separation is @@ -477,9 +640,6 @@ def _is_dsep(self, X, Y, Z, max_lag=None, compute_ancestors=False): d-separation between X and Y conditional on Z using breadth-first search of non-blocked paths according to d-separation rules. - Optionally makes available the ancestors up to max_lag of X, Y, - Z. This may take a very long time, however. - Parameters ---------- X, Y, Z : list of tuples @@ -488,17 +648,14 @@ def _is_dsep(self, X, Y, Z, max_lag=None, compute_ancestors=False): Used here to constrain the _is_dsep function to the graph truncated at max_lag instead of identifying the max_lag from ancestral search. - compute_ancestors : bool - Whether to also make available the ancestors for X, Y, Z as - self.anc_all_x, self.anc_all_y, and self.anc_all_z, respectively. Returns ------- - dseparated : bool + dseparated : bool, or path True if X and Y are d-separated given Z in the graph. """ - N = len(self.link_coeffs) + N = len(self.links) if self.verbosity > 0: print("Testing X=%s d-sep Y=%s given Z=%s in TSG" %(X, Y, Z)) @@ -507,36 +664,104 @@ def _is_dsep(self, X, Y, Z, max_lag=None, compute_ancestors=False): # max_lags = dict([(j, max_lag) for j in range(N)]) if self.verbosity > 0: print("Set max. time lag to: ", max_lag) - else: - # Get maximum non-repeated ancestral time lag - _, max_lag_X = self._get_non_blocked_ancestors(X, conds=Z, - mode='non_repeating') - _, max_lag_Y = self._get_non_blocked_ancestors(Y, conds=Z, - mode='non_repeating') - _, max_lag_Z = self._get_non_blocked_ancestors(Z, conds=Z, - mode='non_repeating') + max_lag = self._get_max_lag_from_XYZ(X, Y, Z) - # Get max time lag among the ancestors - max_lag = max(max_lag_X, max_lag_Y, max_lag_Z) - - if self.verbosity > 0: - print("Max. non-repeated ancestral time lag: ", max_lag) - - # Store overall max. lag + # Store overall max. lag self.max_lag = max_lag - # _has_any_path is the main function that searches open paths any_path = self._has_any_path(X, Y, conds=Z, max_lag=max_lag) - if self.verbosity > 0: - print("_has_any_path = ", any_path) if any_path: dseparated = False else: dseparated = True + return dseparated + + def get_shortest_path(self, X, Y, Z, + max_lag=None, compute_ancestors=False, + backdoor=False): + """Returns path between X and Y given Z in the graph. + + X, Y, Z are of the form (var, lag) for lag <= 0. D-separation is + based on: + + 1. Assessing maximum time lag max_lag of last ancestor of any X, Y, Z + with non-blocked (by Z), non-repeating directed path towards X, Y, Z + in the graph. 'non_repeating' means that an ancestor X^i_{ t-\tau_i} + with link X^i_{t-\tau_i} --> X^j_{ t-\tau_j} is only included if + X^i_{t'-\tau_i} --> X^j_{ t'-\tau_j} for t'!=t is not already part of + the ancestors. + + 2. Using the time series graph truncated at max_lag we then test + d-separation between X and Y conditional on Z using breadth-first + search of non-blocked paths according to d-separation rules including + selection variables. + + Optionally only considers backdoor paths (starting with an arrowhead in X) + and makes available the ancestors up to max_lag of X, Y, Z. This may take + a very long time, however. + + Parameters + ---------- + X, Y, Z : list of tuples + List of variables chosen for testing paths. + max_lag : int, optional (default: None) + Used here to constrain the has_path function to the graph + truncated at max_lag instead of identifying the max_lag from + ancestral search. + compute_ancestors : bool + Whether to also make available the ancestors for X, Y, Z as + self.anc_all_x, self.anc_all_y, and self.anc_all_z, respectively. + backdoor : bool + Whether to only consider paths starting with an arrowhead in X. + + Returns + ------- + path : list or False + Returns path or False if no path exists. + """ + + N = len(self.links) + + # Translate from observed_vars index to full variable set index + X = [(self.observed_vars[x[0]], x[1]) for x in X] + Y = [(self.observed_vars[y[0]], y[1]) for y in Y] + Z = [(self.observed_vars[z[0]], z[1]) for z in Z] + + # Get the array to test on + X, Y, Z = self._check_XYZ(X, Y, Z) + + if self.verbosity > 0: + print("Testing X=%s d-sep Y=%s given Z=%s in TSG" %(X, Y, Z)) + + if max_lag is not None: + # max_lags = dict([(j, max_lag) for j in range(N)]) + if self.verbosity > 0: + print("Set max. time lag to: ", max_lag) + else: + max_lag = self._get_max_lag_from_XYZ(X, Y, Z) + + # Store overall max. lag + self.max_lag = max_lag + + # _has_any_path is the main function that searches open paths + any_path = self._has_any_path(X, Y, conds=Z, max_lag=max_lag, + backdoor=backdoor) + + if any_path: + any_path_observed = [node for node in any_path + if node[0] in self.observed_vars] + else: + any_path_observed = False + + if self.verbosity > 0: + print("_has_any_path = ", any_path) + print("_has_any_path_obs = ", any_path_observed) + + if compute_ancestors: if self.verbosity > 0: print("Compute ancestors.") @@ -550,10 +775,9 @@ def _is_dsep(self, X, Y, Z, max_lag=None, compute_ancestors=False): self.anc_all_z, _ = self._get_non_blocked_ancestors(Z, conds=Z, mode='max_lag', max_lag=max_lag) - return dseparated + return any_path_observed def run_test(self, X, Y, Z=None, tau_max=0, cut_off='2xtau_max', - compute_ancestors=False, verbosity=0): """Perform oracle conditional independence test. @@ -584,9 +808,7 @@ def run_test(self, X, Y, Z=None, tau_max=0, cut_off='2xtau_max', X, Y, Z = self._check_XYZ(X, Y, Z) if not str((X, Y, Z)) in self.dsepsets: - self.dsepsets[str((X, Y, Z))] = self._is_dsep(X, Y, Z, - max_lag=None, - compute_ancestors=compute_ancestors) + self.dsepsets[str((X, Y, Z))] = self._is_dsep(X, Y, Z) if self.dsepsets[str((X, Y, Z))]: val = 0. @@ -632,8 +854,7 @@ def get_measure(self, X, Y, Z=None, tau_max=0): X, Y, Z = _check_XYZ(X, Y, Z) if not str((X, Y, Z)) in self.dsepsets: - self.dsepsets[str((X, Y, Z))] = self._is_dsep(X, Y, Z, - max_lag=None) + self.dsepsets[str((X, Y, Z))] = self._is_dsep(X, Y, Z) if self.dsepsets[str((X, Y, Z))]: return 0. @@ -671,6 +892,95 @@ def get_model_selection_criterion(self, j, parents, tau_max=0): raise NotImplementedError("Model selection not"+\ " implemented for %s" % self.measure) + def _reverse_patt(self, patt): + """Inverts a link pattern""" + + if patt == "": + return "" + + left_mark, middle_mark, right_mark = patt[0], patt[1], patt[2] + if left_mark == "<": + new_right_mark = ">" + else: + new_right_mark = left_mark + if right_mark == ">": + new_left_mark = "<" + else: + new_left_mark = right_mark + + return new_left_mark + middle_mark + new_right_mark + + + def get_links_from_graph(self, graph): + """ + Constructs links_coeffs dictionary, observed_vars, + and selection_vars from graph array (MAG or DAG). + + In the case of MAGs, for every <-> or --- link further + latent and selection variables, respectively, are added. + This corresponds to a canonical DAG (Richardson Spirtes 2002). + + Can be used to evaluate d-separation in MAG/DAGs. + + """ + + if "U3" not in str(graph.dtype): + raise ValueError("graph must be of type '", "<--", "<->", "---"] + + N, N, tau_maxplusone = graph.shape + tau_max = tau_maxplusone - 1 + + observed_vars = list(range(N)) + + selection_vars = [] + + links = {j: [] for j in observed_vars } + + # Add further latent variables to accommodate <-> and --- links + latent_index = N + for i, j, tau in zip(*np.where(graph)): + + if tau == 0: + if graph[i, j, 0] != self._reverse_patt(graph[j, i, 0]): + raise ValueError( + "graph needs to have consistent lag-zero patterns (eg" + " graph[i,j,0]='-->' requires graph[j,i,0]='<--')" + ) + + # Consider contemporaneous links only once + if j > i: + continue + + # Restrict lagged links + else: + if graph[i, j, tau] not in ["-->", "<->", "---"]: + raise ValueError( + "Lagged links can only be in ['-->', '<->', '---']" + ) + + edge_type = graph[i, j, tau] + + if edge_type == "-->": + links[j].append((i, -tau)) + elif edge_type == "<--": + links[i].append((j, -tau)) + elif edge_type == "<->": + links[latent_index] = [] + links[i].append((latent_index, 0)) + links[j].append((latent_index, -tau)) + latent_index += 1 + elif edge_type == "---": + links[latent_index] = [] + selection_vars.append(latent_index) + links[latent_index].append((i, -tau)) + links[latent_index].append((j, 0)) + latent_index += 1 + + return links, observed_vars, selection_vars + + if __name__ == '__main__': import tigramite.plotting as tp @@ -716,13 +1026,13 @@ def lin_f(x): return x # } # def setup_nodes(auto_coeff, N): - # link_coeffs = {} + # links = {} # for j in range(N): - # link_coeffs[j] = [((j, -1), auto_coeff, lin_f)] - # return link_coeffs + # links[j] = [((j, -1), auto_coeff, lin_f)] + # return links # coeff = 0.5 - # link_coeffs = setup_nodes(0.7, N=3) + # links = setup_nodes(0.7, N=3) # for i in [0, 2]: # links[1].append(((i, 0), coeff, lin_f)) @@ -732,31 +1042,93 @@ def lin_f(x): return x # links[1].append(((0, 0), coeff, lin_f)) # links[2].append(((1, 0), coeff, lin_f)) # links[2].append(((0, 0), coeff, lin_f)) - coeff = 0.5 - links ={ - 0: [], - 1: [((0, 0), coeff, lin_f), ((2, 0), coeff, lin_f)], - 2: [], - 3: [((1, 0), coeff, lin_f)], - } - observed_vars = [0, 1, 2, 3] + + # coeff = 0.5 + # links ={ + # 0: [((0, -1), coeff, lin_f)], + # 1: [((0, 0), coeff, lin_f), ((2, 0), coeff, lin_f)], + # 2: [], + # 3: [((1, 0), coeff, lin_f)], + # } + # observed_vars = [0, 1, 2, 3] + + graph = np.zeros((8, 8, 4), dtype=' 0: + # Copy and fit the model + a_model = deepcopy(self.model) + a_model.fit(X=array[2:].T, y=array[1]) + # Cache the results + fit_results[y] = {} + fit_results[y]['model'] = a_model + # Cache the data transform + fit_results[y]['data_transform'] = deepcopy(self.data_transform) + # Cache the data if needed + if return_data: + fit_results[y]['data'] = array + # If there are no parents, skip this variable + else: + fit_results[y] = None + + # Cache and return the fit results + self.fit_results = fit_results + return fit_results + + def get_general_prediction(self, + Y, X, Z=None, + intervention_data=None, + pred_params=None, + cut_off='max_lag_or_tau_max'): + r"""Predict effect of intervention with fitted model. + + Uses the model.predict() function of the sklearn model. + + Parameters + ---------- + X, Y, Z : lists of tuples + List of variables for estimating model Y = f(X,Z) + intervention_data : data object, optional + New Tigramite dataframe object with optional new mask. + pred_params : dict, optional + Optional parameters passed on to sklearn prediction function. + cut_off : {'2xtau_max', 'max_lag', 'max_lag_or_tau_max'} + How many samples to cutoff at the beginning. The default is + '2xtau_max', which guarantees that MCI tests are all conducted on + the same samples. For modeling, 'max_lag_or_tau_max' can be used, + which uses the maximum of tau_max and the conditions, which is + useful to compare multiple models on the same sample. Last, + 'max_lag' uses as much samples as possible. + + Returns + ------- + Results from prediction. + """ + + XZ = X + Z + + return_type = 'list' + + pred_dict = {} + for y in Y: + # Print message + if self.verbosity > 0: + print("\n##\n## Predicting target %s\n##" % str(y)) + if pred_params is not None: + for key in list(pred_params): + print("%s = %s" % (key, pred_params[key])) + # Default value for pred_params + if pred_params is None: + pred_params = {} + # Check this is a valid target + if y not in self.fit_results: + raise ValueError("y = %s not yet fitted" % str(y)) + # Construct the array form of the data + # Check if we've passed a new dataframe object + observation_array, _ = \ + self.dataframe.construct_array(X=[y], Y=[y], Z=XZ, + tau_max=self.tau_max, + # mask=self.test_mask, + mask_type=self.mask_type, + cut_off=cut_off, + verbosity=self.verbosity) + intervention_array = observation_array + if intervention_data is not None: + tmp_array, _ = intervention_data.construct_array(X, Y, Z, + tau_max=self.tau_max, + mask_type=self.mask_type, + cut_off=cut_off, + verbosity=self.verbosity) + + # Only replace X-variables in intervention_array (necessary if lags of + # X are in Z...) + for ix in enumerate(X): + index = ix + 2 + intervention_array[index] = tmp_array[index] + + # Transform the data if needed + a_transform = self.fit_results[y]['data_transform'] + if a_transform is not None: + intervention_array = a_transform.transform(X=intervention_array.T).T + # Cache the test array + self.intervention_array = intervention_array + # Run the predictor + pred_dict[y] = self.fit_results[y]['model'].predict( + X=intervention_array[2:].T, **pred_params) + + return pred_dict + def get_fit(self, all_parents, selected_variables=None, tau_max=None, @@ -190,7 +360,7 @@ def get_coefs(self): return coeffs def get_val_matrix(self): - """Returns the coefficient array for different lags. + """Returns the coefficient array for different lags for linear model. Requires fit_model() before. An entry val_matrix[i,j,tau] gives the coefficient of the link from i to j at lag tau, including tau=0. diff --git a/tigramite/plotting.py b/tigramite/plotting.py index 74fd12b7..b2219377 100644 --- a/tigramite/plotting.py +++ b/tigramite/plotting.py @@ -2952,13 +2952,13 @@ def _links_to_tsg(link_coeffs, max_lag=None): figsize = (3, 3) link_colorbar_label = "MCI" - arrow_linewidth = 20.0 + arrow_linewidth = 8.0 vmin_edges = -1 vmax_edges = 1.0 edge_ticks = 0.4 cmap_edges = "RdBu_r" order = None - node_size = 10 + node_size = .1 arrowhead_size = 20 curved_radius = 0.2 label_fontsize = 10 @@ -3067,15 +3067,12 @@ def _links_to_tsg(link_coeffs, max_lag=None): ax=ax, G=deepcopy(G), pos=pos, - # dictionary of rings: {0:{'sizes':(N,)-array, 'color_array':(N,)-array - # or None, 'cmap':string, node_rings=node_rings, - # 'vmin':float or None, 'vmax':float or None, 'label':string or None}} node_labels=node_labels, - node_label_size=ode_label_size, + node_label_size=node_label_size, node_alpha=alpha, standard_size=node_size, - node_aspect=node_aspect, + node_aspect=None, standard_cmap="OrRd", standard_color="lightgrey", log_sizes=False, @@ -3092,8 +3089,39 @@ def _links_to_tsg(link_coeffs, max_lag=None): inner_edge_curved=True, network_lower_bound=network_lower_bound, inner_edge_style=inner_edge_style, - show_colorbar=False, ) + # _draw_network_with_curved_edges( + # fig=fig, + # ax=ax, + # G=deepcopy(G), + # pos=pos, + # # dictionary of rings: {0:{'sizes':(N,)-array, 'color_array':(N,)-array + # # or None, 'cmap':string, + # node_rings=node_rings, + # # 'vmin':float or None, 'vmax':float or None, 'label':string or None}} + # node_labels=node_labels, + # node_label_size=node_label_size, + # node_alpha=alpha, + # standard_size=node_size, + # node_aspect=None, + # standard_cmap="OrRd", + # standard_color="lightgrey", + # log_sizes=False, + # cmap_links=cmap_edges, + # links_vmin=vmin_edges, + # links_vmax=vmax_edges, + # links_ticks=edge_ticks, + # arrowstyle="simple", + # arrowhead_size=arrowhead_size, + # curved_radius=curved_radius, + # label_fontsize=label_fontsize, + # label_fraction=0.5, + # link_colorbar_label=link_colorbar_label, + # inner_edge_curved=True, + # network_lower_bound=network_lower_bound, + # inner_edge_style=inner_edge_style, + # show_colorbar=False, + # ) for i in range(N): trans = transforms.blended_transform_factory(fig.transFigure, ax.transData) diff --git a/tigramite/tigramite_cython_code.c b/tigramite/tigramite_cython_code.c index b91d5d75..5e504a5a 100644 --- a/tigramite/tigramite_cython_code.c +++ b/tigramite/tigramite_cython_code.c @@ -1,4 +1,4 @@ -/* Generated by Cython 0.29.21 */ +/* Generated by Cython 0.29.12 */ /* BEGIN: Cython Metadata { @@ -6,7 +6,7 @@ "depends": [], "name": "tigramite.tigramite_cython_code", "sources": [ - "tigramite/tigramite_cython_code.pyx" + "/home/rung_ja/work/code/python_code/tigramite/tigramite_v4/tigramite/tigramite/tigramite_cython_code.pyx" ] }, "module_name": "tigramite.tigramite_cython_code" @@ -20,9 +20,9 @@ END: Cython Metadata */ #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.6+ or Python 3.3+. #else -#define CYTHON_ABI "0_29_21" -#define CYTHON_HEX_VERSION 0x001D15F0 -#define CYTHON_FUTURE_DIVISION 0 +#define CYTHON_ABI "0_29_12" +#define CYTHON_HEX_VERSION 0x001D0CF0 +#define CYTHON_FUTURE_DIVISION 1 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) @@ -448,11 +448,7 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) - #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) - #else - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) - #endif #else #define CYTHON_PEP393_ENABLED 0 #define PyUnicode_1BYTE_KIND 1 @@ -501,10 +497,8 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact -#ifndef PyObject_Unicode #define PyObject_Unicode PyObject_Str #endif -#endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) @@ -515,13 +509,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #ifndef PySet_CheckExact #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) #endif -#if PY_VERSION_HEX >= 0x030900A4 - #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) - #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) -#else - #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) - #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) -#endif #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #else @@ -561,7 +548,7 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t #endif #if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : (Py_INCREF(func), func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif @@ -602,10 +589,11 @@ static CYTHON_INLINE float __PYX_NAN() { #define __Pyx_truncl truncl #endif -#define __PYX_MARK_ERR_POS(f_index, lineno) \ - { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } + #define __PYX_ERR(f_index, lineno, Ln_error) \ - { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } +{ \ + __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \ +} #ifndef __PYX_EXTERN_C #ifdef __cplusplus @@ -622,9 +610,6 @@ static CYTHON_INLINE float __PYX_NAN() { #include #include "numpy/arrayobject.h" #include "numpy/ufuncobject.h" - - /* NumPy API declarations from "numpy/__init__.pxd" */ - #include "pythread.h" #include #include "pystate.h" @@ -959,11 +944,6 @@ typedef struct { char is_valid_array; } __Pyx_BufFmt_Context; -/* ForceInitThreads.proto */ -#ifndef __PYX_FORCE_INIT_THREADS - #define __PYX_FORCE_INIT_THREADS 0 -#endif - /* NoFastGil.proto */ #define __Pyx_PyGILState_Ensure PyGILState_Ensure #define __Pyx_PyGILState_Release PyGILState_Release @@ -971,8 +951,13 @@ typedef struct { #define __Pyx_FastGIL_Forget() #define __Pyx_FastGilFuncInit() +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":697 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":776 * # in Cython to enable them only on the right systems. * * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< @@ -981,7 +966,7 @@ typedef struct { */ typedef npy_int8 __pyx_t_5numpy_int8_t; -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":698 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":777 * * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< @@ -990,7 +975,7 @@ typedef npy_int8 __pyx_t_5numpy_int8_t; */ typedef npy_int16 __pyx_t_5numpy_int16_t; -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":699 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":778 * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< @@ -999,7 +984,7 @@ typedef npy_int16 __pyx_t_5numpy_int16_t; */ typedef npy_int32 __pyx_t_5numpy_int32_t; -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":700 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":779 * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< @@ -1008,7 +993,7 @@ typedef npy_int32 __pyx_t_5numpy_int32_t; */ typedef npy_int64 __pyx_t_5numpy_int64_t; -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":704 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":783 * #ctypedef npy_int128 int128_t * * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< @@ -1017,7 +1002,7 @@ typedef npy_int64 __pyx_t_5numpy_int64_t; */ typedef npy_uint8 __pyx_t_5numpy_uint8_t; -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":705 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":784 * * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< @@ -1026,7 +1011,7 @@ typedef npy_uint8 __pyx_t_5numpy_uint8_t; */ typedef npy_uint16 __pyx_t_5numpy_uint16_t; -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":706 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":785 * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< @@ -1035,7 +1020,7 @@ typedef npy_uint16 __pyx_t_5numpy_uint16_t; */ typedef npy_uint32 __pyx_t_5numpy_uint32_t; -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":707 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":786 * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< @@ -1044,7 +1029,7 @@ typedef npy_uint32 __pyx_t_5numpy_uint32_t; */ typedef npy_uint64 __pyx_t_5numpy_uint64_t; -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":711 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":790 * #ctypedef npy_uint128 uint128_t * * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< @@ -1053,7 +1038,7 @@ typedef npy_uint64 __pyx_t_5numpy_uint64_t; */ typedef npy_float32 __pyx_t_5numpy_float32_t; -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":712 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":791 * * ctypedef npy_float32 float32_t * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< @@ -1062,7 +1047,7 @@ typedef npy_float32 __pyx_t_5numpy_float32_t; */ typedef npy_float64 __pyx_t_5numpy_float64_t; -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":721 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":800 * # The int types are mapped a bit surprising -- * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t # <<<<<<<<<<<<<< @@ -1071,7 +1056,7 @@ typedef npy_float64 __pyx_t_5numpy_float64_t; */ typedef npy_long __pyx_t_5numpy_int_t; -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":722 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":801 * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< @@ -1080,7 +1065,7 @@ typedef npy_long __pyx_t_5numpy_int_t; */ typedef npy_longlong __pyx_t_5numpy_long_t; -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":723 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":802 * ctypedef npy_long int_t * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< @@ -1089,7 +1074,7 @@ typedef npy_longlong __pyx_t_5numpy_long_t; */ typedef npy_longlong __pyx_t_5numpy_longlong_t; -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":725 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":804 * ctypedef npy_longlong longlong_t * * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< @@ -1098,7 +1083,7 @@ typedef npy_longlong __pyx_t_5numpy_longlong_t; */ typedef npy_ulong __pyx_t_5numpy_uint_t; -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":726 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":805 * * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< @@ -1107,7 +1092,7 @@ typedef npy_ulong __pyx_t_5numpy_uint_t; */ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":727 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":806 * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< @@ -1116,7 +1101,7 @@ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; */ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":729 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":808 * ctypedef npy_ulonglong ulonglong_t * * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< @@ -1125,7 +1110,7 @@ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; */ typedef npy_intp __pyx_t_5numpy_intp_t; -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":730 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":809 * * ctypedef npy_intp intp_t * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< @@ -1134,7 +1119,7 @@ typedef npy_intp __pyx_t_5numpy_intp_t; */ typedef npy_uintp __pyx_t_5numpy_uintp_t; -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":732 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":811 * ctypedef npy_uintp uintp_t * * ctypedef npy_double float_t # <<<<<<<<<<<<<< @@ -1143,7 +1128,7 @@ typedef npy_uintp __pyx_t_5numpy_uintp_t; */ typedef npy_double __pyx_t_5numpy_float_t; -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":733 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":812 * * ctypedef npy_double float_t * ctypedef npy_double double_t # <<<<<<<<<<<<<< @@ -1152,7 +1137,7 @@ typedef npy_double __pyx_t_5numpy_float_t; */ typedef npy_double __pyx_t_5numpy_double_t; -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":734 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":813 * ctypedef npy_double float_t * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< @@ -1200,7 +1185,7 @@ struct __pyx_MemviewEnum_obj; struct __pyx_memoryview_obj; struct __pyx_memoryviewslice_obj; -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":736 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":815 * ctypedef npy_longdouble longdouble_t * * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< @@ -1209,7 +1194,7 @@ struct __pyx_memoryviewslice_obj; */ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":737 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":816 * * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< @@ -1218,7 +1203,7 @@ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; */ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":738 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":817 * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< @@ -1227,7 +1212,7 @@ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; */ typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":740 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":819 * ctypedef npy_clongdouble clongdouble_t * * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< @@ -1297,7 +1282,7 @@ struct __pyx_memoryview_obj { }; -/* "View.MemoryView":965 +/* "View.MemoryView":961 * * @cname('__pyx_memoryviewslice') * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< @@ -1348,7 +1333,7 @@ struct __pyx_vtabstruct_memoryview { static struct __pyx_vtabstruct_memoryview *__pyx_vtabptr_memoryview; -/* "View.MemoryView":965 +/* "View.MemoryView":961 * * @cname('__pyx_memoryviewslice') * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< @@ -1688,6 +1673,9 @@ static Py_ssize_t __Pyx_minusones[] = { -1, -1, -1, -1, -1, -1, -1, -1 }; static Py_ssize_t __Pyx_zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; #define __Pyx_BufPtrStrided1d(type, buf, i0, s0) (type)((char*)buf + i0 * s0) +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + /* DictGetItem.proto */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); @@ -1708,9 +1696,6 @@ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); /* RaiseNoneIterError.proto */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); -/* RaiseException.proto */ -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); - /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); @@ -1840,7 +1825,7 @@ static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { if (likely(L->allocated > len)) { Py_INCREF(x); PyList_SET_ITEM(list, len, x); - __Pyx_SET_SIZE(list, len + 1); + Py_SIZE(list) = len+1; return 0; } return PyList_Append(list, x); @@ -1878,7 +1863,7 @@ static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { Py_INCREF(x); PyList_SET_ITEM(list, len, x); - __Pyx_SET_SIZE(list, len + 1); + Py_SIZE(list) = len+1; return 0; } return PyList_Append(list, x); @@ -1916,9 +1901,6 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam /* SetVTable.proto */ static int __Pyx_SetVtable(PyObject *dict, void *vtable); -/* PyObjectGetAttrStrNoError.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); - /* SetupReduce.proto */ static int __Pyx_setup_reduce(PyObject* type_obj); @@ -1936,7 +1918,7 @@ static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, /* FetchCommonType.proto */ static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); -/* CythonFunctionShared.proto */ +/* CythonFunction.proto */ #define __Pyx_CyFunction_USED 1 #define __Pyx_CYFUNCTION_STATICMETHOD 0x01 #define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 @@ -1964,7 +1946,6 @@ typedef struct { PyObject *func_classobj; void *defaults; int defaults_pyobjects; - size_t defaults_size; // used by FusedFunction for copying defaults int flags; PyObject *defaults_tuple; PyObject *defaults_kwdict; @@ -1973,7 +1954,9 @@ typedef struct { } __pyx_CyFunctionObject; static PyTypeObject *__pyx_CyFunctionType = 0; #define __Pyx_CyFunction_Check(obj) (__Pyx_TypeCheck(obj, __pyx_CyFunctionType)) -static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, +#define __Pyx_CyFunction_NewEx(ml, flags, qualname, self, module, globals, code)\ + __Pyx_CyFunction_New(__pyx_CyFunctionType, ml, flags, qualname, self, module, globals, code) +static PyObject *__Pyx_CyFunction_New(PyTypeObject *, PyMethodDef *ml, int flags, PyObject* qualname, PyObject *self, PyObject *module, PyObject *globals, @@ -1989,13 +1972,6 @@ static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, PyObject *dict); static int __pyx_CyFunction_init(void); -/* CythonFunction.proto */ -static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, - int flags, PyObject* qualname, - PyObject *closure, - PyObject *module, PyObject *globals, - PyObject* code); - /* SetNameInClass.proto */ #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 #define __Pyx_SetNameInClass(ns, name, value)\ @@ -2346,8 +2322,8 @@ int __pyx_module_is_main_tigramite__tigramite_cython_code = 0; /* Implementation of 'tigramite.tigramite_cython_code' */ static PyObject *__pyx_builtin_range; -static PyObject *__pyx_builtin_RuntimeError; static PyObject *__pyx_builtin_ValueError; +static PyObject *__pyx_builtin_RuntimeError; static PyObject *__pyx_builtin_ImportError; static PyObject *__pyx_builtin_MemoryError; static PyObject *__pyx_builtin_enumerate; @@ -2527,6 +2503,7 @@ static const char __pyx_k_contiguous_and_indirect[] = " static const char __pyx_k_Cannot_index_with_type_s[] = "Cannot index with type '%s'"; static const char __pyx_k_Invalid_shape_in_axis_d_d[] = "Invalid shape in axis %d: %d."; static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cython.array"; +static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous"; static const char __pyx_k_unable_to_allocate_array_data[] = "unable to allocate array data."; static const char __pyx_k_strided_and_direct_or_indirect[] = ""; static const char __pyx_k_get_neighbors_within_eps_cython[] = "_get_neighbors_within_eps_cython"; @@ -2542,12 +2519,13 @@ static const char __pyx_k_Empty_shape_tuple_for_cython_arr[] = "Empty shape tupl static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd"; static const char __pyx_k_Incompatible_checksums_s_vs_0xb0[] = "Incompatible checksums (%s vs 0xb068931 = (name))"; static const char __pyx_k_Indirect_dimensions_not_supporte[] = "Indirect dimensions not supported"; -static const char __pyx_k_Inner_helper_of_dcov_all_Cache_d[] = "Inner helper of dcov_all. Cache different means that are required for calculating \n the matrix members on the fly"; +static const char __pyx_k_Inner_helper_of_dcov_all_Cache_d[] = "Inner helper of dcov_all. Cache different means that are required for calculating\n the matrix members on the fly"; static const char __pyx_k_Invalid_mode_expected_c_or_fortr[] = "Invalid mode, expected 'c' or 'fortran', got %s"; static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported"; static const char __pyx_k_Out_of_bounds_on_buffer_access_a[] = "Out of bounds on buffer access (axis %d)"; static const char __pyx_k_Unable_to_convert_item_to_object[] = "Unable to convert item to object"; static const char __pyx_k_got_differing_extents_in_dimensi[] = "got differing extents in dimension %d (got %d and %d)"; +static const char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous"; static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; static const char __pyx_k_unable_to_allocate_shape_and_str[] = "unable to allocate shape and strides."; @@ -2633,7 +2611,7 @@ static PyObject *__pyx_n_s_epsmax; static PyObject *__pyx_n_s_error; static PyObject *__pyx_n_s_fac; static PyObject *__pyx_n_s_flags; -static PyObject *__pyx_n_s_float; +static PyObject *__pyx_n_u_float; static PyObject *__pyx_n_s_format; static PyObject *__pyx_n_s_fortran; static PyObject *__pyx_n_u_fortran; @@ -2648,7 +2626,7 @@ static PyObject *__pyx_n_s_ii; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_index; static PyObject *__pyx_n_s_init; -static PyObject *__pyx_n_s_int32; +static PyObject *__pyx_n_u_int32; static PyObject *__pyx_n_s_itemsize; static PyObject *__pyx_kp_s_itemsize_0_for_cython_array; static PyObject *__pyx_n_s_j; @@ -2678,14 +2656,16 @@ static PyObject *__pyx_n_s_module; static PyObject *__pyx_n_s_n; static PyObject *__pyx_n_s_name; static PyObject *__pyx_n_s_name_2; +static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous; +static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou; static PyObject *__pyx_n_s_ndim; static PyObject *__pyx_n_s_neighbors; static PyObject *__pyx_n_s_new; static PyObject *__pyx_kp_s_no_default___reduce___due_to_non; static PyObject *__pyx_n_s_np; static PyObject *__pyx_n_s_numpy; -static PyObject *__pyx_kp_s_numpy_core_multiarray_failed_to; -static PyObject *__pyx_kp_s_numpy_core_umath_failed_to_impor; +static PyObject *__pyx_kp_u_numpy_core_multiarray_failed_to; +static PyObject *__pyx_kp_u_numpy_core_umath_failed_to_impor; static PyObject *__pyx_n_s_obj; static PyObject *__pyx_n_s_order; static PyObject *__pyx_n_s_other; @@ -2761,6 +2741,8 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N___init__(CYTHO static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_2calculate_means(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_4squared_sum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_6product_sum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer); /* proto */ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self); /* proto */ @@ -2821,7 +2803,7 @@ static PyObject *__pyx_tuple__6; static PyObject *__pyx_tuple__7; static PyObject *__pyx_tuple__8; static PyObject *__pyx_tuple__9; -static PyObject *__pyx_slice__20; +static PyObject *__pyx_slice__22; static PyObject *__pyx_tuple__10; static PyObject *__pyx_tuple__11; static PyObject *__pyx_tuple__12; @@ -2832,10 +2814,11 @@ static PyObject *__pyx_tuple__16; static PyObject *__pyx_tuple__17; static PyObject *__pyx_tuple__18; static PyObject *__pyx_tuple__19; +static PyObject *__pyx_tuple__20; static PyObject *__pyx_tuple__21; -static PyObject *__pyx_tuple__22; static PyObject *__pyx_tuple__23; static PyObject *__pyx_tuple__24; +static PyObject *__pyx_tuple__25; static PyObject *__pyx_tuple__26; static PyObject *__pyx_tuple__28; static PyObject *__pyx_tuple__30; @@ -2844,12 +2827,12 @@ static PyObject *__pyx_tuple__34; static PyObject *__pyx_tuple__36; static PyObject *__pyx_tuple__38; static PyObject *__pyx_tuple__40; -static PyObject *__pyx_tuple__41; static PyObject *__pyx_tuple__42; static PyObject *__pyx_tuple__43; static PyObject *__pyx_tuple__44; static PyObject *__pyx_tuple__45; -static PyObject *__pyx_codeobj__25; +static PyObject *__pyx_tuple__46; +static PyObject *__pyx_tuple__47; static PyObject *__pyx_codeobj__27; static PyObject *__pyx_codeobj__29; static PyObject *__pyx_codeobj__31; @@ -2857,22 +2840,21 @@ static PyObject *__pyx_codeobj__33; static PyObject *__pyx_codeobj__35; static PyObject *__pyx_codeobj__37; static PyObject *__pyx_codeobj__39; -static PyObject *__pyx_codeobj__46; +static PyObject *__pyx_codeobj__41; +static PyObject *__pyx_codeobj__48; /* Late includes */ /* "tigramite/tigramite_cython_code.pyx":13 + * from cython.parallel import prange, parallel * - * - * cdef inline double max(double a, double b): return a if a >= b else b # <<<<<<<<<<<<<< - * cdef inline double abs(double a) : return a if a >= 0. else -1 * a + * cdef inline double max(double a, double b) nogil: return a if a >= b else b # <<<<<<<<<<<<<< + * cdef inline double abs(double a) nogil: return a if a >= 0. else -1 * a * */ static CYTHON_INLINE double __pyx_f_9tigramite_21tigramite_cython_code_max(double __pyx_v_a, double __pyx_v_b) { double __pyx_r; - __Pyx_RefNannyDeclarations double __pyx_t_1; - __Pyx_RefNannySetupContext("max", 0); if (((__pyx_v_a >= __pyx_v_b) != 0)) { __pyx_t_1 = __pyx_v_a; } else { @@ -2883,23 +2865,20 @@ static CYTHON_INLINE double __pyx_f_9tigramite_21tigramite_cython_code_max(doubl /* function exit code */ __pyx_L0:; - __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "tigramite/tigramite_cython_code.pyx":14 * - * cdef inline double max(double a, double b): return a if a >= b else b - * cdef inline double abs(double a) : return a if a >= 0. else -1 * a # <<<<<<<<<<<<<< + * cdef inline double max(double a, double b) nogil: return a if a >= b else b + * cdef inline double abs(double a) nogil: return a if a >= 0. else -1 * a # <<<<<<<<<<<<<< * * */ static CYTHON_INLINE double __pyx_f_9tigramite_21tigramite_cython_code_abs(double __pyx_v_a) { double __pyx_r; - __Pyx_RefNannyDeclarations double __pyx_t_1; - __Pyx_RefNannySetupContext("abs", 0); if (((__pyx_v_a >= 0.) != 0)) { __pyx_t_1 = __pyx_v_a; } else { @@ -2910,7 +2889,6 @@ static CYTHON_INLINE double __pyx_f_9tigramite_21tigramite_cython_code_abs(doubl /* function exit code */ __pyx_L0:; - __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2933,9 +2911,6 @@ static PyObject *__pyx_pw_9tigramite_21tigramite_cython_code_1_get_neighbors_wit __Pyx_memviewslice __pyx_v_epsarray = { 0, 0, { 0 }, { 0 }, { 0 } }; CYTHON_UNUSED int __pyx_v_k; int __pyx_v_dim; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_get_neighbors_within_eps_cython (wrapper)", 0); @@ -3076,12 +3051,29 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code__get_neighbors_with Py_ssize_t __pyx_t_16; Py_ssize_t __pyx_t_17; Py_ssize_t __pyx_t_18; - int __pyx_t_19; - PyObject *__pyx_t_20 = NULL; - PyObject *__pyx_t_21 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; + Py_ssize_t __pyx_t_19; + int __pyx_t_20; + Py_ssize_t __pyx_t_21; + Py_ssize_t __pyx_t_22; + Py_ssize_t __pyx_t_23; + Py_ssize_t __pyx_t_24; + Py_ssize_t __pyx_t_25; + Py_ssize_t __pyx_t_26; + Py_ssize_t __pyx_t_27; + Py_ssize_t __pyx_t_28; + Py_ssize_t __pyx_t_29; + Py_ssize_t __pyx_t_30; + Py_ssize_t __pyx_t_31; + Py_ssize_t __pyx_t_32; + Py_ssize_t __pyx_t_33; + Py_ssize_t __pyx_t_34; + Py_ssize_t __pyx_t_35; + Py_ssize_t __pyx_t_36; + Py_ssize_t __pyx_t_37; + Py_ssize_t __pyx_t_38; + Py_ssize_t __pyx_t_39; + PyObject *__pyx_t_40 = NULL; + PyObject *__pyx_t_41 = NULL; __Pyx_RefNannySetupContext("_get_neighbors_within_eps_cython", 0); /* "tigramite/tigramite_cython_code.pyx":28 @@ -3105,7 +3097,7 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code__get_neighbors_with __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 28, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_n_s_int32) < 0) __PYX_ERR(0, 28, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_n_u_int32) < 0) __PYX_ERR(0, 28, __pyx_L1_error) __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 28, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -3138,7 +3130,7 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code__get_neighbors_with __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 29, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_n_s_int32) < 0) __PYX_ERR(0, 29, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_n_u_int32) < 0) __PYX_ERR(0, 29, __pyx_L1_error) __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 29, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -3171,7 +3163,7 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code__get_neighbors_with __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 30, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_n_s_int32) < 0) __PYX_ERR(0, 30, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_n_u_int32) < 0) __PYX_ERR(0, 30, __pyx_L1_error) __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 30, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; @@ -3272,11 +3264,11 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code__get_neighbors_with * * # For no conditions, kz is counted up to T */ - __pyx_t_9 = __pyx_v_d; - __pyx_t_16 = __pyx_v_i; - __pyx_t_17 = __pyx_v_d; - __pyx_t_18 = __pyx_v_j; - __pyx_v_dz = __pyx_f_9tigramite_21tigramite_cython_code_max(__pyx_f_9tigramite_21tigramite_cython_code_abs(((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_array.data + __pyx_t_9 * __pyx_v_array.strides[0]) ) + __pyx_t_16 * __pyx_v_array.strides[1]) ))) - (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_array.data + __pyx_t_17 * __pyx_v_array.strides[0]) ) + __pyx_t_18 * __pyx_v_array.strides[1]) ))))), __pyx_v_dz); + __pyx_t_16 = __pyx_v_d; + __pyx_t_17 = __pyx_v_i; + __pyx_t_18 = __pyx_v_d; + __pyx_t_19 = __pyx_v_j; + __pyx_v_dz = __pyx_f_9tigramite_21tigramite_cython_code_max(__pyx_f_9tigramite_21tigramite_cython_code_abs(((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_array.data + __pyx_t_16 * __pyx_v_array.strides[0]) ) + __pyx_t_17 * __pyx_v_array.strides[1]) ))) - (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_array.data + __pyx_t_18 * __pyx_v_array.strides[0]) ) + __pyx_t_19 * __pyx_v_array.strides[1]) ))))), __pyx_v_dz); } /* "tigramite/tigramite_cython_code.pyx":54 @@ -3286,8 +3278,8 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code__get_neighbors_with * kz += 1 * */ - __pyx_t_19 = ((__pyx_v_dz < __pyx_v_epsmax) != 0); - if (__pyx_t_19) { + __pyx_t_20 = ((__pyx_v_dz < __pyx_v_epsmax) != 0); + if (__pyx_t_20) { /* "tigramite/tigramite_cython_code.pyx":55 * # For no conditions, kz is counted up to T @@ -3305,11 +3297,11 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code__get_neighbors_with * for d in range(dim_x+1, dim_x+dim_y): * dy = max( abs(array[d, i] - array[d, j]), dy) */ - __pyx_t_18 = __pyx_v_dim_x; - __pyx_t_17 = __pyx_v_i; - __pyx_t_16 = __pyx_v_dim_x; - __pyx_t_9 = __pyx_v_j; - __pyx_v_dy = __pyx_f_9tigramite_21tigramite_cython_code_abs(((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_array.data + __pyx_t_18 * __pyx_v_array.strides[0]) ) + __pyx_t_17 * __pyx_v_array.strides[1]) ))) - (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_array.data + __pyx_t_16 * __pyx_v_array.strides[0]) ) + __pyx_t_9 * __pyx_v_array.strides[1]) ))))); + __pyx_t_21 = __pyx_v_dim_x; + __pyx_t_22 = __pyx_v_i; + __pyx_t_23 = __pyx_v_dim_x; + __pyx_t_24 = __pyx_v_j; + __pyx_v_dy = __pyx_f_9tigramite_21tigramite_cython_code_abs(((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_array.data + __pyx_t_21 * __pyx_v_array.strides[0]) ) + __pyx_t_22 * __pyx_v_array.strides[1]) ))) - (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_array.data + __pyx_t_23 * __pyx_v_array.strides[0]) ) + __pyx_t_24 * __pyx_v_array.strides[1]) ))))); /* "tigramite/tigramite_cython_code.pyx":61 * # Y-subspace, the loop is only entered for dim_y > 1 @@ -3330,11 +3322,11 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code__get_neighbors_with * * if (dy < epsmax): */ - __pyx_t_9 = __pyx_v_d; - __pyx_t_16 = __pyx_v_i; - __pyx_t_17 = __pyx_v_d; - __pyx_t_18 = __pyx_v_j; - __pyx_v_dy = __pyx_f_9tigramite_21tigramite_cython_code_max(__pyx_f_9tigramite_21tigramite_cython_code_abs(((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_array.data + __pyx_t_9 * __pyx_v_array.strides[0]) ) + __pyx_t_16 * __pyx_v_array.strides[1]) ))) - (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_array.data + __pyx_t_17 * __pyx_v_array.strides[0]) ) + __pyx_t_18 * __pyx_v_array.strides[1]) ))))), __pyx_v_dy); + __pyx_t_25 = __pyx_v_d; + __pyx_t_26 = __pyx_v_i; + __pyx_t_27 = __pyx_v_d; + __pyx_t_28 = __pyx_v_j; + __pyx_v_dy = __pyx_f_9tigramite_21tigramite_cython_code_max(__pyx_f_9tigramite_21tigramite_cython_code_abs(((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_array.data + __pyx_t_25 * __pyx_v_array.strides[0]) ) + __pyx_t_26 * __pyx_v_array.strides[1]) ))) - (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_array.data + __pyx_t_27 * __pyx_v_array.strides[0]) ) + __pyx_t_28 * __pyx_v_array.strides[1]) ))))), __pyx_v_dy); } /* "tigramite/tigramite_cython_code.pyx":64 @@ -3344,8 +3336,8 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code__get_neighbors_with * kyz += 1 * */ - __pyx_t_19 = ((__pyx_v_dy < __pyx_v_epsmax) != 0); - if (__pyx_t_19) { + __pyx_t_20 = ((__pyx_v_dy < __pyx_v_epsmax) != 0); + if (__pyx_t_20) { /* "tigramite/tigramite_cython_code.pyx":65 * @@ -3372,11 +3364,11 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code__get_neighbors_with * for d in range(1, dim_x): * dx = max( abs(array[d, i] - array[d, j]), dx) */ - __pyx_t_18 = 0; - __pyx_t_17 = __pyx_v_i; - __pyx_t_16 = 0; - __pyx_t_9 = __pyx_v_j; - __pyx_v_dx = __pyx_f_9tigramite_21tigramite_cython_code_abs(((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_array.data + __pyx_t_18 * __pyx_v_array.strides[0]) ) + __pyx_t_17 * __pyx_v_array.strides[1]) ))) - (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_array.data + __pyx_t_16 * __pyx_v_array.strides[0]) ) + __pyx_t_9 * __pyx_v_array.strides[1]) ))))); + __pyx_t_29 = 0; + __pyx_t_30 = __pyx_v_i; + __pyx_t_31 = 0; + __pyx_t_32 = __pyx_v_j; + __pyx_v_dx = __pyx_f_9tigramite_21tigramite_cython_code_abs(((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_array.data + __pyx_t_29 * __pyx_v_array.strides[0]) ) + __pyx_t_30 * __pyx_v_array.strides[1]) ))) - (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_array.data + __pyx_t_31 * __pyx_v_array.strides[0]) ) + __pyx_t_32 * __pyx_v_array.strides[1]) ))))); /* "tigramite/tigramite_cython_code.pyx":69 * # X-subspace, the loop is only entered for dim_x > 1 @@ -3397,11 +3389,11 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code__get_neighbors_with * * if (dx < epsmax): */ - __pyx_t_9 = __pyx_v_d; - __pyx_t_16 = __pyx_v_i; - __pyx_t_17 = __pyx_v_d; - __pyx_t_18 = __pyx_v_j; - __pyx_v_dx = __pyx_f_9tigramite_21tigramite_cython_code_max(__pyx_f_9tigramite_21tigramite_cython_code_abs(((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_array.data + __pyx_t_9 * __pyx_v_array.strides[0]) ) + __pyx_t_16 * __pyx_v_array.strides[1]) ))) - (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_array.data + __pyx_t_17 * __pyx_v_array.strides[0]) ) + __pyx_t_18 * __pyx_v_array.strides[1]) ))))), __pyx_v_dx); + __pyx_t_33 = __pyx_v_d; + __pyx_t_34 = __pyx_v_i; + __pyx_t_35 = __pyx_v_d; + __pyx_t_36 = __pyx_v_j; + __pyx_v_dx = __pyx_f_9tigramite_21tigramite_cython_code_max(__pyx_f_9tigramite_21tigramite_cython_code_abs(((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_array.data + __pyx_t_33 * __pyx_v_array.strides[0]) ) + __pyx_t_34 * __pyx_v_array.strides[1]) ))) - (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_array.data + __pyx_t_35 * __pyx_v_array.strides[0]) ) + __pyx_t_36 * __pyx_v_array.strides[1]) ))))), __pyx_v_dx); } /* "tigramite/tigramite_cython_code.pyx":72 @@ -3411,8 +3403,8 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code__get_neighbors_with * kxz += 1 * */ - __pyx_t_19 = ((__pyx_v_dx < __pyx_v_epsmax) != 0); - if (__pyx_t_19) { + __pyx_t_20 = ((__pyx_v_dx < __pyx_v_epsmax) != 0); + if (__pyx_t_20) { /* "tigramite/tigramite_cython_code.pyx":73 * @@ -3449,8 +3441,8 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code__get_neighbors_with * k_yz[i] = kyz * k_z[i] = kz */ - __pyx_t_18 = __pyx_v_i; - *((int *) ( /* dim=0 */ (__pyx_v_k_xz.data + __pyx_t_18 * __pyx_v_k_xz.strides[0]) )) = __pyx_v_kxz; + __pyx_t_37 = __pyx_v_i; + *((int *) ( /* dim=0 */ (__pyx_v_k_xz.data + __pyx_t_37 * __pyx_v_k_xz.strides[0]) )) = __pyx_v_kxz; /* "tigramite/tigramite_cython_code.pyx":77 * # Write to arrays @@ -3459,8 +3451,8 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code__get_neighbors_with * k_z[i] = kz * */ - __pyx_t_18 = __pyx_v_i; - *((int *) ( /* dim=0 */ (__pyx_v_k_yz.data + __pyx_t_18 * __pyx_v_k_yz.strides[0]) )) = __pyx_v_kyz; + __pyx_t_38 = __pyx_v_i; + *((int *) ( /* dim=0 */ (__pyx_v_k_yz.data + __pyx_t_38 * __pyx_v_k_yz.strides[0]) )) = __pyx_v_kyz; /* "tigramite/tigramite_cython_code.pyx":78 * k_xz[i] = kxz @@ -3469,8 +3461,8 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code__get_neighbors_with * * */ - __pyx_t_18 = __pyx_v_i; - *((int *) ( /* dim=0 */ (__pyx_v_k_z.data + __pyx_t_18 * __pyx_v_k_z.strides[0]) )) = __pyx_v_kz; + __pyx_t_39 = __pyx_v_i; + *((int *) ( /* dim=0 */ (__pyx_v_k_z.data + __pyx_t_39 * __pyx_v_k_z.strides[0]) )) = __pyx_v_kz; } /* "tigramite/tigramite_cython_code.pyx":81 @@ -3511,58 +3503,58 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code__get_neighbors_with __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __pyx_memoryview_fromslice(__pyx_v_k_yz, 1, (PyObject *(*)(char *)) __pyx_memview_get_int, (int (*)(char *, PyObject *)) __pyx_memview_set_int, 0);; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_20 = NULL; + __pyx_t_40 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_20)) { + __pyx_t_40 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_40)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_20); + __Pyx_INCREF(__pyx_t_40); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } - __pyx_t_3 = (__pyx_t_20) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_20, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); - __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0; + __pyx_t_3 = (__pyx_t_40) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_40, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); + __Pyx_XDECREF(__pyx_t_40); __pyx_t_40 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 81, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_numpy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_20 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_asarray); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 81, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __pyx_t_40 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_asarray); if (unlikely(!__pyx_t_40)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_40); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __pyx_memoryview_fromslice(__pyx_v_k_z, 1, (PyObject *(*)(char *)) __pyx_memview_get_int, (int (*)(char *, PyObject *)) __pyx_memview_set_int, 0);; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_21 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_20))) { - __pyx_t_21 = PyMethod_GET_SELF(__pyx_t_20); - if (likely(__pyx_t_21)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_20); - __Pyx_INCREF(__pyx_t_21); + __pyx_t_41 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_40))) { + __pyx_t_41 = PyMethod_GET_SELF(__pyx_t_40); + if (likely(__pyx_t_41)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_40); + __Pyx_INCREF(__pyx_t_41); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_20, function); + __Pyx_DECREF_SET(__pyx_t_40, function); } } - __pyx_t_4 = (__pyx_t_21) ? __Pyx_PyObject_Call2Args(__pyx_t_20, __pyx_t_21, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_20, __pyx_t_2); - __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0; + __pyx_t_4 = (__pyx_t_41) ? __Pyx_PyObject_Call2Args(__pyx_t_40, __pyx_t_41, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_40, __pyx_t_2); + __Pyx_XDECREF(__pyx_t_41); __pyx_t_41 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 81, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; - __pyx_t_20 = PyTuple_New(3); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 81, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_20); + __Pyx_DECREF(__pyx_t_40); __pyx_t_40 = 0; + __pyx_t_40 = PyTuple_New(3); if (unlikely(!__pyx_t_40)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_40); __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_20, 0, __pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_40, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_20, 1, __pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_40, 1, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_20, 2, __pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_40, 2, __pyx_t_4); __pyx_t_1 = 0; __pyx_t_3 = 0; __pyx_t_4 = 0; - __pyx_r = __pyx_t_20; - __pyx_t_20 = 0; + __pyx_r = __pyx_t_40; + __pyx_t_40 = 0; goto __pyx_L0; /* "tigramite/tigramite_cython_code.pyx":19 @@ -3580,8 +3572,8 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code__get_neighbors_with __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __PYX_XDEC_MEMVIEW(&__pyx_t_5, 1); - __Pyx_XDECREF(__pyx_t_20); - __Pyx_XDECREF(__pyx_t_21); + __Pyx_XDECREF(__pyx_t_40); + __Pyx_XDECREF(__pyx_t_41); __Pyx_AddTraceback("tigramite.tigramite_cython_code._get_neighbors_within_eps_cython", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -3617,9 +3609,6 @@ static PyObject *__pyx_pw_9tigramite_21tigramite_cython_code_3_get_patterns_cyth __Pyx_memviewslice __pyx_v_fac = { 0, 0, { 0 }, { 0 }, { 0 } }; int __pyx_v_N; int __pyx_v_T; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_get_patterns_cython (wrapper)", 0); @@ -3788,13 +3777,25 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_2_get_patterns_cyth Py_ssize_t __pyx_t_15; Py_ssize_t __pyx_t_16; Py_ssize_t __pyx_t_17; - int __pyx_t_18; - int __pyx_t_19; - int __pyx_t_20; - int __pyx_t_21; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; + Py_ssize_t __pyx_t_18; + Py_ssize_t __pyx_t_19; + Py_ssize_t __pyx_t_20; + Py_ssize_t __pyx_t_21; + Py_ssize_t __pyx_t_22; + Py_ssize_t __pyx_t_23; + Py_ssize_t __pyx_t_24; + Py_ssize_t __pyx_t_25; + int __pyx_t_26; + int __pyx_t_27; + int __pyx_t_28; + int __pyx_t_29; + Py_ssize_t __pyx_t_30; + Py_ssize_t __pyx_t_31; + Py_ssize_t __pyx_t_32; + Py_ssize_t __pyx_t_33; + Py_ssize_t __pyx_t_34; + Py_ssize_t __pyx_t_35; + Py_ssize_t __pyx_t_36; __Pyx_RefNannySetupContext("_get_patterns_cython", 0); /* "tigramite/tigramite_cython_code.pyx":100 @@ -3818,7 +3819,7 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_2_get_patterns_cyth __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 100, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_n_s_float) < 0) __PYX_ERR(0, 100, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_n_u_float) < 0) __PYX_ERR(0, 100, __pyx_L1_error) __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 100, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -3921,8 +3922,8 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_2_get_patterns_cyth * mask *= array_mask[t - tau, n] * ave /= dim */ - __pyx_t_16 = __pyx_v_k; - __pyx_v_ave = (__pyx_v_ave + (*((double *) ( /* dim=0 */ (__pyx_v_v.data + __pyx_t_16 * __pyx_v_v.strides[0]) )))); + __pyx_t_18 = __pyx_v_k; + __pyx_v_ave = (__pyx_v_ave + (*((double *) ( /* dim=0 */ (__pyx_v_v.data + __pyx_t_18 * __pyx_v_v.strides[0]) )))); /* "tigramite/tigramite_cython_code.pyx":111 * v[k] = array[t - tau, n] @@ -3931,9 +3932,9 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_2_get_patterns_cyth * ave /= dim * var = 0. */ - __pyx_t_16 = (__pyx_v_t - __pyx_v_tau); - __pyx_t_15 = __pyx_v_n; - __pyx_v_mask = (__pyx_v_mask * (*((int *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_array_mask.data + __pyx_t_16 * __pyx_v_array_mask.strides[0]) ) + __pyx_t_15 * __pyx_v_array_mask.strides[1]) )))); + __pyx_t_19 = (__pyx_v_t - __pyx_v_tau); + __pyx_t_20 = __pyx_v_n; + __pyx_v_mask = (__pyx_v_mask * (*((int *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_array_mask.data + __pyx_t_19 * __pyx_v_array_mask.strides[0]) ) + __pyx_t_20 * __pyx_v_array_mask.strides[1]) )))); } /* "tigramite/tigramite_cython_code.pyx":112 @@ -3977,8 +3978,8 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_2_get_patterns_cyth * var /= dim * weights[t-start, n] = var */ - __pyx_t_15 = __pyx_v_k; - __pyx_v_var = (__pyx_v_var + pow(((*((double *) ( /* dim=0 */ (__pyx_v_v.data + __pyx_t_15 * __pyx_v_v.strides[0]) ))) - __pyx_v_ave), 2.0)); + __pyx_t_21 = __pyx_v_k; + __pyx_v_var = (__pyx_v_var + pow(((*((double *) ( /* dim=0 */ (__pyx_v_v.data + __pyx_t_21 * __pyx_v_v.strides[0]) ))) - __pyx_v_ave), 2.0)); } /* "tigramite/tigramite_cython_code.pyx":116 @@ -4001,9 +4002,9 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_2_get_patterns_cyth * if( v[0] < v[1]): * p = 1 */ - __pyx_t_15 = (__pyx_v_t - __pyx_v_start); - __pyx_t_16 = __pyx_v_n; - *((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_weights.data + __pyx_t_15 * __pyx_v_weights.strides[0]) ) + __pyx_t_16 * __pyx_v_weights.strides[1]) )) = __pyx_v_var; + __pyx_t_22 = (__pyx_v_t - __pyx_v_start); + __pyx_t_23 = __pyx_v_n; + *((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_weights.data + __pyx_t_22 * __pyx_v_weights.strides[0]) ) + __pyx_t_23 * __pyx_v_weights.strides[1]) )) = __pyx_v_var; /* "tigramite/tigramite_cython_code.pyx":118 * var /= dim @@ -4012,10 +4013,10 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_2_get_patterns_cyth * p = 1 * else: */ - __pyx_t_16 = 0; - __pyx_t_15 = 1; - __pyx_t_18 = (((*((double *) ( /* dim=0 */ (__pyx_v_v.data + __pyx_t_16 * __pyx_v_v.strides[0]) ))) < (*((double *) ( /* dim=0 */ (__pyx_v_v.data + __pyx_t_15 * __pyx_v_v.strides[0]) )))) != 0); - if (__pyx_t_18) { + __pyx_t_24 = 0; + __pyx_t_25 = 1; + __pyx_t_26 = (((*((double *) ( /* dim=0 */ (__pyx_v_v.data + __pyx_t_24 * __pyx_v_v.strides[0]) ))) < (*((double *) ( /* dim=0 */ (__pyx_v_v.data + __pyx_t_25 * __pyx_v_v.strides[0]) )))) != 0); + if (__pyx_t_26) { /* "tigramite/tigramite_cython_code.pyx":119 * weights[t-start, n] = var @@ -4067,10 +4068,10 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_2_get_patterns_cyth * if( v[j] < v[i]): * p += fac[i] */ - __pyx_t_19 = __pyx_v_i; - __pyx_t_20 = __pyx_t_19; - for (__pyx_t_21 = 0; __pyx_t_21 < __pyx_t_20; __pyx_t_21+=1) { - __pyx_v_j = __pyx_t_21; + __pyx_t_27 = __pyx_v_i; + __pyx_t_28 = __pyx_t_27; + for (__pyx_t_29 = 0; __pyx_t_29 < __pyx_t_28; __pyx_t_29+=1) { + __pyx_v_j = __pyx_t_29; /* "tigramite/tigramite_cython_code.pyx":124 * for i in range(2, dim): @@ -4079,10 +4080,10 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_2_get_patterns_cyth * p += fac[i] * patt[t-start, n] = p */ - __pyx_t_15 = __pyx_v_j; - __pyx_t_16 = __pyx_v_i; - __pyx_t_18 = (((*((double *) ( /* dim=0 */ (__pyx_v_v.data + __pyx_t_15 * __pyx_v_v.strides[0]) ))) < (*((double *) ( /* dim=0 */ (__pyx_v_v.data + __pyx_t_16 * __pyx_v_v.strides[0]) )))) != 0); - if (__pyx_t_18) { + __pyx_t_30 = __pyx_v_j; + __pyx_t_31 = __pyx_v_i; + __pyx_t_26 = (((*((double *) ( /* dim=0 */ (__pyx_v_v.data + __pyx_t_30 * __pyx_v_v.strides[0]) ))) < (*((double *) ( /* dim=0 */ (__pyx_v_v.data + __pyx_t_31 * __pyx_v_v.strides[0]) )))) != 0); + if (__pyx_t_26) { /* "tigramite/tigramite_cython_code.pyx":125 * for j in range(0, i): @@ -4091,8 +4092,8 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_2_get_patterns_cyth * patt[t-start, n] = p * patt_mask[t-start, n] = mask */ - __pyx_t_16 = __pyx_v_i; - __pyx_v_p = (__pyx_v_p + (*((int *) ( /* dim=0 */ (__pyx_v_fac.data + __pyx_t_16 * __pyx_v_fac.strides[0]) )))); + __pyx_t_32 = __pyx_v_i; + __pyx_v_p = (__pyx_v_p + (*((int *) ( /* dim=0 */ (__pyx_v_fac.data + __pyx_t_32 * __pyx_v_fac.strides[0]) )))); /* "tigramite/tigramite_cython_code.pyx":124 * for i in range(2, dim): @@ -4112,9 +4113,9 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_2_get_patterns_cyth * patt_mask[t-start, n] = mask * */ - __pyx_t_16 = (__pyx_v_t - __pyx_v_start); - __pyx_t_15 = __pyx_v_n; - *((int *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_patt.data + __pyx_t_16 * __pyx_v_patt.strides[0]) ) + __pyx_t_15 * __pyx_v_patt.strides[1]) )) = __pyx_v_p; + __pyx_t_33 = (__pyx_v_t - __pyx_v_start); + __pyx_t_34 = __pyx_v_n; + *((int *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_patt.data + __pyx_t_33 * __pyx_v_patt.strides[0]) ) + __pyx_t_34 * __pyx_v_patt.strides[1]) )) = __pyx_v_p; /* "tigramite/tigramite_cython_code.pyx":127 * p += fac[i] @@ -4123,9 +4124,9 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_2_get_patterns_cyth * * return (patt, patt_mask, weights) */ - __pyx_t_15 = (__pyx_v_t - __pyx_v_start); - __pyx_t_16 = __pyx_v_n; - *((int *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_patt_mask.data + __pyx_t_15 * __pyx_v_patt_mask.strides[0]) ) + __pyx_t_16 * __pyx_v_patt_mask.strides[1]) )) = __pyx_v_mask; + __pyx_t_35 = (__pyx_v_t - __pyx_v_start); + __pyx_t_36 = __pyx_v_n; + *((int *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_patt_mask.data + __pyx_t_35 * __pyx_v_patt_mask.strides[0]) ) + __pyx_t_36 * __pyx_v_patt_mask.strides[1]) )) = __pyx_v_mask; } } @@ -4206,9 +4207,6 @@ static CYTHON_INLINE int __pyx_f_9tigramite_21tigramite_cython_code_isvalueinarr Py_ssize_t __pyx_t_4; int __pyx_t_5; int __pyx_t_6; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("isvalueinarray", 0); /* "tigramite/tigramite_cython_code.pyx":139 @@ -4306,9 +4304,6 @@ static PyObject *__pyx_pw_9tigramite_21tigramite_cython_code_5_get_restricted_pe int __pyx_v_shuffle_neighbors; __Pyx_memviewslice __pyx_v_neighbors = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_v_order = { 0, 0, { 0 }, { 0 }, { 0 } }; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_get_restricted_permutation_cython (wrapper)", 0); @@ -4404,11 +4399,13 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_4_get_restricted_pe int __pyx_t_8; Py_ssize_t __pyx_t_9; Py_ssize_t __pyx_t_10; - int __pyx_t_11; + Py_ssize_t __pyx_t_11; int __pyx_t_12; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; + int __pyx_t_13; + Py_ssize_t __pyx_t_14; + Py_ssize_t __pyx_t_15; + Py_ssize_t __pyx_t_16; + Py_ssize_t __pyx_t_17; __Pyx_RefNannySetupContext("_get_restricted_permutation_cython", 0); /* "tigramite/tigramite_cython_code.pyx":155 @@ -4432,7 +4429,7 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_4_get_restricted_pe __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 155, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_n_s_int32) < 0) __PYX_ERR(0, 155, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_n_u_int32) < 0) __PYX_ERR(0, 155, __pyx_L1_error) __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 155, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -4465,7 +4462,7 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_4_get_restricted_pe __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 156, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_n_s_int32) < 0) __PYX_ERR(0, 156, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_n_u_int32) < 0) __PYX_ERR(0, 156, __pyx_L1_error) __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 156, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -4510,6 +4507,7 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_4_get_restricted_pe { Py_ssize_t __pyx_tmp_idx = __pyx_v_i; Py_ssize_t __pyx_tmp_stride = __pyx_v_neighbors.strides[0]; + if ((0)) __PYX_ERR(0, 163, __pyx_L1_error) __pyx_t_5.data += __pyx_tmp_idx * __pyx_tmp_stride; } @@ -4579,9 +4577,9 @@ __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_t_5, 1, (PyObject *(*)(char *)) __p * while(isvalueinarray(use, used, i) and (count < shuffle_neighbors - 1)): * count += 1 */ - __pyx_t_9 = __pyx_v_index; - __pyx_t_10 = __pyx_v_count; - __pyx_v_use = (*((int *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_neighbors.data + __pyx_t_9 * __pyx_v_neighbors.strides[0]) ) + __pyx_t_10 * __pyx_v_neighbors.strides[1]) ))); + __pyx_t_10 = __pyx_v_index; + __pyx_t_11 = __pyx_v_count; + __pyx_v_use = (*((int *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_neighbors.data + __pyx_t_10 * __pyx_v_neighbors.strides[0]) ) + __pyx_t_11 * __pyx_v_neighbors.strides[1]) ))); /* "tigramite/tigramite_cython_code.pyx":171 * @@ -4591,16 +4589,16 @@ __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_t_5, 1, (PyObject *(*)(char *)) __p * use = neighbors[index, count] */ while (1) { - __pyx_t_12 = (__pyx_f_9tigramite_21tigramite_cython_code_isvalueinarray(__pyx_v_use, __pyx_v_used, __pyx_v_i) != 0); - if (__pyx_t_12) { + __pyx_t_13 = (__pyx_f_9tigramite_21tigramite_cython_code_isvalueinarray(__pyx_v_use, __pyx_v_used, __pyx_v_i) != 0); + if (__pyx_t_13) { } else { - __pyx_t_11 = __pyx_t_12; + __pyx_t_12 = __pyx_t_13; goto __pyx_L9_bool_binop_done; } - __pyx_t_12 = ((__pyx_v_count < (__pyx_v_shuffle_neighbors - 1)) != 0); - __pyx_t_11 = __pyx_t_12; + __pyx_t_13 = ((__pyx_v_count < (__pyx_v_shuffle_neighbors - 1)) != 0); + __pyx_t_12 = __pyx_t_13; __pyx_L9_bool_binop_done:; - if (!__pyx_t_11) break; + if (!__pyx_t_12) break; /* "tigramite/tigramite_cython_code.pyx":172 * use = neighbors[index, count] @@ -4618,9 +4616,9 @@ __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_t_5, 1, (PyObject *(*)(char *)) __p * * restricted_permutation[index] = use */ - __pyx_t_10 = __pyx_v_index; - __pyx_t_9 = __pyx_v_count; - __pyx_v_use = (*((int *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_neighbors.data + __pyx_t_10 * __pyx_v_neighbors.strides[0]) ) + __pyx_t_9 * __pyx_v_neighbors.strides[1]) ))); + __pyx_t_14 = __pyx_v_index; + __pyx_t_15 = __pyx_v_count; + __pyx_v_use = (*((int *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_neighbors.data + __pyx_t_14 * __pyx_v_neighbors.strides[0]) ) + __pyx_t_15 * __pyx_v_neighbors.strides[1]) ))); } /* "tigramite/tigramite_cython_code.pyx":175 @@ -4630,8 +4628,8 @@ __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_t_5, 1, (PyObject *(*)(char *)) __p * * used[i] = use */ - __pyx_t_9 = __pyx_v_index; - *((int *) ( /* dim=0 */ (__pyx_v_restricted_permutation.data + __pyx_t_9 * __pyx_v_restricted_permutation.strides[0]) )) = __pyx_v_use; + __pyx_t_16 = __pyx_v_index; + *((int *) ( /* dim=0 */ (__pyx_v_restricted_permutation.data + __pyx_t_16 * __pyx_v_restricted_permutation.strides[0]) )) = __pyx_v_use; /* "tigramite/tigramite_cython_code.pyx":177 * restricted_permutation[index] = use @@ -4640,8 +4638,8 @@ __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_t_5, 1, (PyObject *(*)(char *)) __p * * return numpy.asarray(restricted_permutation) */ - __pyx_t_9 = __pyx_v_i; - *((int *) ( /* dim=0 */ (__pyx_v_used.data + __pyx_t_9 * __pyx_v_used.strides[0]) )) = __pyx_v_use; + __pyx_t_17 = __pyx_v_i; + *((int *) ( /* dim=0 */ (__pyx_v_used.data + __pyx_t_17 * __pyx_v_used.strides[0]) )) = __pyx_v_use; } /* "tigramite/tigramite_cython_code.pyx":179 @@ -4721,9 +4719,6 @@ static PyMethodDef __pyx_mdef_9tigramite_21tigramite_cython_code_7dcov_all = {"d static PyObject *__pyx_pw_9tigramite_21tigramite_cython_code_7dcov_all(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_x = 0; PyObject *__pyx_v_y = 0; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("dcov_all (wrapper)", 0); @@ -4796,9 +4791,6 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_6dcov_all(CYTHON_UN PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; double __pyx_t_6; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("dcov_all", 0); __Pyx_INCREF(__pyx_v_x); __Pyx_INCREF(__pyx_v_y); @@ -5171,9 +5163,6 @@ static PyMethodDef __pyx_mdef_9tigramite_21tigramite_cython_code_3D_N_1__init__ static PyObject *__pyx_pw_9tigramite_21tigramite_cython_code_3D_N_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_self = 0; PyObject *__pyx_v_x = 0; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); @@ -5236,9 +5225,6 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N___init__(CYTHO PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "tigramite/tigramite_cython_code.pyx":237 @@ -5335,9 +5321,9 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N___init__(CYTHO return __pyx_r; } -/* "tigramite/tigramite_cython_code.pyx":242 - * +/* "tigramite/tigramite_cython_code.pyx":243 * @cython.boundscheck(False) + * @cython.wraparound(False) * def calculate_means(self): # <<<<<<<<<<<<<< * cdef int dim = self.dim * cdef DTYPE_t value @@ -5390,9 +5376,8 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_2calculate_mea unsigned int __pyx_t_14; size_t __pyx_t_15; size_t __pyx_t_16; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; + size_t __pyx_t_17; + size_t __pyx_t_18; __Pyx_RefNannySetupContext("calculate_means", 0); __pyx_pybuffer_sum_0.pybuffer.buf = NULL; __pyx_pybuffer_sum_0.refcount = 0; @@ -5407,20 +5392,20 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_2calculate_mea __pyx_pybuffernd_x.data = NULL; __pyx_pybuffernd_x.rcbuffer = &__pyx_pybuffer_x; - /* "tigramite/tigramite_cython_code.pyx":243 - * @cython.boundscheck(False) + /* "tigramite/tigramite_cython_code.pyx":244 + * @cython.wraparound(False) * def calculate_means(self): * cdef int dim = self.dim # <<<<<<<<<<<<<< * cdef DTYPE_t value * cdef DTYPE_t sum_total = 0 */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 243, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 244, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 243, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 244, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_dim = __pyx_t_2; - /* "tigramite/tigramite_cython_code.pyx":245 + /* "tigramite/tigramite_cython_code.pyx":246 * cdef int dim = self.dim * cdef DTYPE_t value * cdef DTYPE_t sum_total = 0 # <<<<<<<<<<<<<< @@ -5429,46 +5414,46 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_2calculate_mea */ __pyx_v_sum_total = 0.0; - /* "tigramite/tigramite_cython_code.pyx":246 + /* "tigramite/tigramite_cython_code.pyx":247 * cdef DTYPE_t value * cdef DTYPE_t sum_total = 0 * cdef np.ndarray[DTYPE_t, ndim=1] sum_0 = np.zeros(dim, dtype=np.double) # <<<<<<<<<<<<<< * cdef np.ndarray[DTYPE_t, ndim=1] sum_1 = np.zeros(dim, dtype=np.double) * cdef np.ndarray[DTYPE_t, ndim=1] x = self.x */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 247, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 246, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 247, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 246, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 247, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 246, __pyx_L1_error) + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 247, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 246, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 247, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 247, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_double); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 246, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_double); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 247, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(0, 246, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(0, 247, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 246, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 247, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 246, __pyx_L1_error) + if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 247, __pyx_L1_error) __pyx_t_7 = ((PyArrayObject *)__pyx_t_6); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sum_0.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) { __pyx_v_sum_0 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_sum_0.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 246, __pyx_L1_error) + __PYX_ERR(0, 247, __pyx_L1_error) } else {__pyx_pybuffernd_sum_0.diminfo[0].strides = __pyx_pybuffernd_sum_0.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sum_0.diminfo[0].shape = __pyx_pybuffernd_sum_0.rcbuffer->pybuffer.shape[0]; } } @@ -5476,46 +5461,46 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_2calculate_mea __pyx_v_sum_0 = ((PyArrayObject *)__pyx_t_6); __pyx_t_6 = 0; - /* "tigramite/tigramite_cython_code.pyx":247 + /* "tigramite/tigramite_cython_code.pyx":248 * cdef DTYPE_t sum_total = 0 * cdef np.ndarray[DTYPE_t, ndim=1] sum_0 = np.zeros(dim, dtype=np.double) * cdef np.ndarray[DTYPE_t, ndim=1] sum_1 = np.zeros(dim, dtype=np.double) # <<<<<<<<<<<<<< * cdef np.ndarray[DTYPE_t, ndim=1] x = self.x * cdef unsigned int ii */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 247, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 247, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 247, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 247, __pyx_L1_error) + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 247, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 247, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_double); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 247, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_double); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 247, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 247, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 247, __pyx_L1_error) + if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 248, __pyx_L1_error) __pyx_t_8 = ((PyArrayObject *)__pyx_t_5); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sum_1.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) { __pyx_v_sum_1 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_sum_1.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 247, __pyx_L1_error) + __PYX_ERR(0, 248, __pyx_L1_error) } else {__pyx_pybuffernd_sum_1.diminfo[0].strides = __pyx_pybuffernd_sum_1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sum_1.diminfo[0].shape = __pyx_pybuffernd_sum_1.rcbuffer->pybuffer.shape[0]; } } @@ -5523,22 +5508,22 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_2calculate_mea __pyx_v_sum_1 = ((PyArrayObject *)__pyx_t_5); __pyx_t_5 = 0; - /* "tigramite/tigramite_cython_code.pyx":248 + /* "tigramite/tigramite_cython_code.pyx":249 * cdef np.ndarray[DTYPE_t, ndim=1] sum_0 = np.zeros(dim, dtype=np.double) * cdef np.ndarray[DTYPE_t, ndim=1] sum_1 = np.zeros(dim, dtype=np.double) * cdef np.ndarray[DTYPE_t, ndim=1] x = self.x # <<<<<<<<<<<<<< * cdef unsigned int ii * cdef unsigned int jj */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 248, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 248, __pyx_L1_error) + if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 249, __pyx_L1_error) __pyx_t_9 = ((PyArrayObject *)__pyx_t_5); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_t_9, &__Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { __pyx_v_x = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_x.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 248, __pyx_L1_error) + __PYX_ERR(0, 249, __pyx_L1_error) } else {__pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; } } @@ -5546,9 +5531,9 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_2calculate_mea __pyx_v_x = ((PyArrayObject *)__pyx_t_5); __pyx_t_5 = 0; - /* "tigramite/tigramite_cython_code.pyx":251 - * cdef unsigned int ii - * cdef unsigned int jj + /* "tigramite/tigramite_cython_code.pyx":254 + * + * # Adding prange() here leads to erros. Why? * for ii in range(dim): # <<<<<<<<<<<<<< * for jj in range(dim): * value = abs(x[jj] - x[ii]) @@ -5558,8 +5543,8 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_2calculate_mea for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { __pyx_v_ii = __pyx_t_11; - /* "tigramite/tigramite_cython_code.pyx":252 - * cdef unsigned int jj + /* "tigramite/tigramite_cython_code.pyx":255 + * # Adding prange() here leads to erros. Why? * for ii in range(dim): * for jj in range(dim): # <<<<<<<<<<<<<< * value = abs(x[jj] - x[ii]) @@ -5570,7 +5555,7 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_2calculate_mea for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { __pyx_v_jj = __pyx_t_14; - /* "tigramite/tigramite_cython_code.pyx":253 + /* "tigramite/tigramite_cython_code.pyx":256 * for ii in range(dim): * for jj in range(dim): * value = abs(x[jj] - x[ii]) # <<<<<<<<<<<<<< @@ -5581,7 +5566,7 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_2calculate_mea __pyx_t_16 = __pyx_v_ii; __pyx_v_value = __pyx_f_9tigramite_21tigramite_cython_code_abs(((*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_x.diminfo[0].strides)) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_x.diminfo[0].strides)))); - /* "tigramite/tigramite_cython_code.pyx":254 + /* "tigramite/tigramite_cython_code.pyx":257 * for jj in range(dim): * value = abs(x[jj] - x[ii]) * sum_total += value # <<<<<<<<<<<<<< @@ -5590,82 +5575,82 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_2calculate_mea */ __pyx_v_sum_total = (__pyx_v_sum_total + __pyx_v_value); - /* "tigramite/tigramite_cython_code.pyx":255 + /* "tigramite/tigramite_cython_code.pyx":258 * value = abs(x[jj] - x[ii]) * sum_total += value * sum_1[jj] += value # <<<<<<<<<<<<<< * sum_0[ii] += value * self.mean = sum_total / (self.dim**2) */ - __pyx_t_16 = __pyx_v_jj; - *__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_sum_1.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_sum_1.diminfo[0].strides) += __pyx_v_value; + __pyx_t_17 = __pyx_v_jj; + *__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_sum_1.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_sum_1.diminfo[0].strides) += __pyx_v_value; - /* "tigramite/tigramite_cython_code.pyx":256 + /* "tigramite/tigramite_cython_code.pyx":259 * sum_total += value * sum_1[jj] += value * sum_0[ii] += value # <<<<<<<<<<<<<< * self.mean = sum_total / (self.dim**2) * self.mean_0 = sum_0 / (self.dim) */ - __pyx_t_16 = __pyx_v_ii; - *__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_sum_0.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_sum_0.diminfo[0].strides) += __pyx_v_value; + __pyx_t_18 = __pyx_v_ii; + *__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_sum_0.rcbuffer->pybuffer.buf, __pyx_t_18, __pyx_pybuffernd_sum_0.diminfo[0].strides) += __pyx_v_value; } } - /* "tigramite/tigramite_cython_code.pyx":257 + /* "tigramite/tigramite_cython_code.pyx":260 * sum_1[jj] += value * sum_0[ii] += value * self.mean = sum_total / (self.dim**2) # <<<<<<<<<<<<<< * self.mean_0 = sum_0 / (self.dim) * self.mean_1 = sum_1 / (self.dim) */ - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_sum_total); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 257, __pyx_L1_error) + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_sum_total); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 257, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_4 = PyNumber_Power(__pyx_t_6, __pyx_int_2, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 257, __pyx_L1_error) + __pyx_t_4 = PyNumber_Power(__pyx_t_6, __pyx_int_2, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyNumber_Divide(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 257, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyNumber_Divide(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_mean, __pyx_t_6) < 0) __PYX_ERR(0, 257, __pyx_L1_error) + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_mean, __pyx_t_6) < 0) __PYX_ERR(0, 260, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "tigramite/tigramite_cython_code.pyx":258 + /* "tigramite/tigramite_cython_code.pyx":261 * sum_0[ii] += value * self.mean = sum_total / (self.dim**2) * self.mean_0 = sum_0 / (self.dim) # <<<<<<<<<<<<<< * self.mean_1 = sum_1 / (self.dim) - * return + * */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 258, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 261, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_4 = __Pyx_PyNumber_Divide(((PyObject *)__pyx_v_sum_0), __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 258, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyNumber_Divide(((PyObject *)__pyx_v_sum_0), __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 261, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_mean_0, __pyx_t_4) < 0) __PYX_ERR(0, 258, __pyx_L1_error) + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_mean_0, __pyx_t_4) < 0) __PYX_ERR(0, 261, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "tigramite/tigramite_cython_code.pyx":259 + /* "tigramite/tigramite_cython_code.pyx":262 * self.mean = sum_total / (self.dim**2) * self.mean_0 = sum_0 / (self.dim) * self.mean_1 = sum_1 / (self.dim) # <<<<<<<<<<<<<< - * return * + * return */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dim); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 259, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dim); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 262, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = __Pyx_PyNumber_Divide(((PyObject *)__pyx_v_sum_1), __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 259, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyNumber_Divide(((PyObject *)__pyx_v_sum_1), __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 262, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_mean_1, __pyx_t_6) < 0) __PYX_ERR(0, 259, __pyx_L1_error) + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_mean_1, __pyx_t_6) < 0) __PYX_ERR(0, 262, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "tigramite/tigramite_cython_code.pyx":260 - * self.mean_0 = sum_0 / (self.dim) + /* "tigramite/tigramite_cython_code.pyx":264 * self.mean_1 = sum_1 / (self.dim) + * * return # <<<<<<<<<<<<<< * * @cython.boundscheck(False) @@ -5674,9 +5659,9 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_2calculate_mea __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "tigramite/tigramite_cython_code.pyx":242 - * + /* "tigramite/tigramite_cython_code.pyx":243 * @cython.boundscheck(False) + * @cython.wraparound(False) * def calculate_means(self): # <<<<<<<<<<<<<< * cdef int dim = self.dim * cdef DTYPE_t value @@ -5713,9 +5698,9 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_2calculate_mea return __pyx_r; } -/* "tigramite/tigramite_cython_code.pyx":263 - * +/* "tigramite/tigramite_cython_code.pyx":268 * @cython.boundscheck(False) + * @cython.wraparound(False) * def squared_sum(self): # <<<<<<<<<<<<<< * cdef np.ndarray[DTYPE_t, ndim=1] mean_0 = self.mean_0 * cdef np.ndarray[DTYPE_t, ndim=1] mean_1 = self.mean_1 @@ -5767,9 +5752,8 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_4squared_sum(C unsigned int __pyx_t_11; size_t __pyx_t_12; size_t __pyx_t_13; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; + size_t __pyx_t_14; + size_t __pyx_t_15; __Pyx_RefNannySetupContext("squared_sum", 0); __pyx_pybuffer_mean_0.pybuffer.buf = NULL; __pyx_pybuffer_mean_0.refcount = 0; @@ -5784,22 +5768,22 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_4squared_sum(C __pyx_pybuffernd_x.data = NULL; __pyx_pybuffernd_x.rcbuffer = &__pyx_pybuffer_x; - /* "tigramite/tigramite_cython_code.pyx":264 - * @cython.boundscheck(False) + /* "tigramite/tigramite_cython_code.pyx":269 + * @cython.wraparound(False) * def squared_sum(self): * cdef np.ndarray[DTYPE_t, ndim=1] mean_0 = self.mean_0 # <<<<<<<<<<<<<< * cdef np.ndarray[DTYPE_t, ndim=1] mean_1 = self.mean_1 * cdef DTYPE_t mean = self.mean */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_mean_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 264, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_mean_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 269, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 264, __pyx_L1_error) + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 269, __pyx_L1_error) __pyx_t_2 = ((PyArrayObject *)__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_mean_0.rcbuffer->pybuffer, (PyObject*)__pyx_t_2, &__Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { __pyx_v_mean_0 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_mean_0.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 264, __pyx_L1_error) + __PYX_ERR(0, 269, __pyx_L1_error) } else {__pyx_pybuffernd_mean_0.diminfo[0].strides = __pyx_pybuffernd_mean_0.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_mean_0.diminfo[0].shape = __pyx_pybuffernd_mean_0.rcbuffer->pybuffer.shape[0]; } } @@ -5807,22 +5791,22 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_4squared_sum(C __pyx_v_mean_0 = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - /* "tigramite/tigramite_cython_code.pyx":265 + /* "tigramite/tigramite_cython_code.pyx":270 * def squared_sum(self): * cdef np.ndarray[DTYPE_t, ndim=1] mean_0 = self.mean_0 * cdef np.ndarray[DTYPE_t, ndim=1] mean_1 = self.mean_1 # <<<<<<<<<<<<<< * cdef DTYPE_t mean = self.mean * cdef DTYPE_t squared_sum = 0 */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_mean_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 265, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_mean_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 270, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 265, __pyx_L1_error) + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 270, __pyx_L1_error) __pyx_t_3 = ((PyArrayObject *)__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_mean_1.rcbuffer->pybuffer, (PyObject*)__pyx_t_3, &__Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { __pyx_v_mean_1 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_mean_1.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 265, __pyx_L1_error) + __PYX_ERR(0, 270, __pyx_L1_error) } else {__pyx_pybuffernd_mean_1.diminfo[0].strides = __pyx_pybuffernd_mean_1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_mean_1.diminfo[0].shape = __pyx_pybuffernd_mean_1.rcbuffer->pybuffer.shape[0]; } } @@ -5830,20 +5814,20 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_4squared_sum(C __pyx_v_mean_1 = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - /* "tigramite/tigramite_cython_code.pyx":266 + /* "tigramite/tigramite_cython_code.pyx":271 * cdef np.ndarray[DTYPE_t, ndim=1] mean_0 = self.mean_0 * cdef np.ndarray[DTYPE_t, ndim=1] mean_1 = self.mean_1 * cdef DTYPE_t mean = self.mean # <<<<<<<<<<<<<< * cdef DTYPE_t squared_sum = 0 * cdef DTYPE_t dist */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_mean); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 266, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_mean); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 271, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == ((npy_double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 266, __pyx_L1_error) + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == ((npy_double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 271, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_mean = __pyx_t_4; - /* "tigramite/tigramite_cython_code.pyx":267 + /* "tigramite/tigramite_cython_code.pyx":272 * cdef np.ndarray[DTYPE_t, ndim=1] mean_1 = self.mean_1 * cdef DTYPE_t mean = self.mean * cdef DTYPE_t squared_sum = 0 # <<<<<<<<<<<<<< @@ -5852,22 +5836,22 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_4squared_sum(C */ __pyx_v_squared_sum = 0.0; - /* "tigramite/tigramite_cython_code.pyx":270 + /* "tigramite/tigramite_cython_code.pyx":275 * cdef DTYPE_t dist * cdef DTYPE_t d * cdef np.ndarray[DTYPE_t, ndim=1] x = self.x # <<<<<<<<<<<<<< * cdef unsigned int dim = self.dim * cdef unsigned int ii */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 270, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 270, __pyx_L1_error) + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 275, __pyx_L1_error) __pyx_t_5 = ((PyArrayObject *)__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { __pyx_v_x = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_x.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 270, __pyx_L1_error) + __PYX_ERR(0, 275, __pyx_L1_error) } else {__pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; } } @@ -5875,77 +5859,136 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_4squared_sum(C __pyx_v_x = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - /* "tigramite/tigramite_cython_code.pyx":271 + /* "tigramite/tigramite_cython_code.pyx":276 * cdef DTYPE_t d * cdef np.ndarray[DTYPE_t, ndim=1] x = self.x * cdef unsigned int dim = self.dim # <<<<<<<<<<<<<< * cdef unsigned int ii * cdef unsigned int jj */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 271, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 276, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_6 = __Pyx_PyInt_As_unsigned_int(__pyx_t_1); if (unlikely((__pyx_t_6 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 271, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_As_unsigned_int(__pyx_t_1); if (unlikely((__pyx_t_6 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 276, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_dim = __pyx_t_6; - /* "tigramite/tigramite_cython_code.pyx":274 + /* "tigramite/tigramite_cython_code.pyx":279 * cdef unsigned int ii * cdef unsigned int jj - * for ii in range(dim): # <<<<<<<<<<<<<< + * for ii in prange(dim, nogil=True): # <<<<<<<<<<<<<< * for jj in range(dim): * dist = abs(x[jj] - x[ii]) */ - __pyx_t_6 = __pyx_v_dim; - __pyx_t_7 = __pyx_t_6; - for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { - __pyx_v_ii = __pyx_t_8; - - /* "tigramite/tigramite_cython_code.pyx":275 + { + #ifdef WITH_THREAD + PyThreadState *_save; + Py_UNBLOCK_THREADS + __Pyx_FastGIL_Remember(); + #endif + /*try:*/ { + __pyx_t_6 = __pyx_v_dim; + if (1 == 0) abort(); + { + #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) + #undef likely + #undef unlikely + #define likely(x) (x) + #define unlikely(x) (x) + #endif + __pyx_t_8 = (__pyx_t_6 - 0 + 1 - 1/abs(1)) / 1; + if (__pyx_t_8 > 0) + { + #ifdef _OPENMP + #pragma omp parallel reduction(+:__pyx_v_squared_sum) private(__pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_9) + #endif /* _OPENMP */ + { + #ifdef _OPENMP + #pragma omp for lastprivate(__pyx_v_d) lastprivate(__pyx_v_dist) firstprivate(__pyx_v_ii) lastprivate(__pyx_v_ii) lastprivate(__pyx_v_jj) + #endif /* _OPENMP */ + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_8; __pyx_t_7++){ + { + __pyx_v_ii = (unsigned int)(0 + 1 * __pyx_t_7); + /* Initialize private variables to invalid values */ + __pyx_v_d = ((__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t)__PYX_NAN()); + __pyx_v_dist = ((__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t)__PYX_NAN()); + __pyx_v_jj = ((unsigned int)0xbad0bad0); + + /* "tigramite/tigramite_cython_code.pyx":280 * cdef unsigned int jj - * for ii in range(dim): + * for ii in prange(dim, nogil=True): * for jj in range(dim): # <<<<<<<<<<<<<< * dist = abs(x[jj] - x[ii]) * d = dist - mean_0[ii] - mean_1[jj] + mean */ - __pyx_t_9 = __pyx_v_dim; - __pyx_t_10 = __pyx_t_9; - for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { - __pyx_v_jj = __pyx_t_11; + __pyx_t_9 = __pyx_v_dim; + __pyx_t_10 = __pyx_t_9; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { + __pyx_v_jj = __pyx_t_11; - /* "tigramite/tigramite_cython_code.pyx":276 - * for ii in range(dim): + /* "tigramite/tigramite_cython_code.pyx":281 + * for ii in prange(dim, nogil=True): * for jj in range(dim): * dist = abs(x[jj] - x[ii]) # <<<<<<<<<<<<<< * d = dist - mean_0[ii] - mean_1[jj] + mean * squared_sum += d * d */ - __pyx_t_12 = __pyx_v_jj; - __pyx_t_13 = __pyx_v_ii; - __pyx_v_dist = __pyx_f_9tigramite_21tigramite_cython_code_abs(((*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_12, __pyx_pybuffernd_x.diminfo[0].strides)) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_13, __pyx_pybuffernd_x.diminfo[0].strides)))); + __pyx_t_12 = __pyx_v_jj; + __pyx_t_13 = __pyx_v_ii; + __pyx_v_dist = __pyx_f_9tigramite_21tigramite_cython_code_abs(((*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_12, __pyx_pybuffernd_x.diminfo[0].strides)) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_13, __pyx_pybuffernd_x.diminfo[0].strides)))); - /* "tigramite/tigramite_cython_code.pyx":277 + /* "tigramite/tigramite_cython_code.pyx":282 * for jj in range(dim): * dist = abs(x[jj] - x[ii]) * d = dist - mean_0[ii] - mean_1[jj] + mean # <<<<<<<<<<<<<< * squared_sum += d * d * return squared_sum */ - __pyx_t_13 = __pyx_v_ii; - __pyx_t_12 = __pyx_v_jj; - __pyx_v_d = (((__pyx_v_dist - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_mean_0.rcbuffer->pybuffer.buf, __pyx_t_13, __pyx_pybuffernd_mean_0.diminfo[0].strides))) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_mean_1.rcbuffer->pybuffer.buf, __pyx_t_12, __pyx_pybuffernd_mean_1.diminfo[0].strides))) + __pyx_v_mean); + __pyx_t_14 = __pyx_v_ii; + __pyx_t_15 = __pyx_v_jj; + __pyx_v_d = (((__pyx_v_dist - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_mean_0.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_mean_0.diminfo[0].strides))) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_mean_1.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_mean_1.diminfo[0].strides))) + __pyx_v_mean); - /* "tigramite/tigramite_cython_code.pyx":278 + /* "tigramite/tigramite_cython_code.pyx":283 * dist = abs(x[jj] - x[ii]) * d = dist - mean_0[ii] - mean_1[jj] + mean * squared_sum += d * d # <<<<<<<<<<<<<< * return squared_sum * */ - __pyx_v_squared_sum = (__pyx_v_squared_sum + (__pyx_v_d * __pyx_v_d)); - } + __pyx_v_squared_sum = (__pyx_v_squared_sum + (__pyx_v_d * __pyx_v_d)); + } + } + } + } + } + } + #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) + #undef likely + #undef unlikely + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) + #endif + } + + /* "tigramite/tigramite_cython_code.pyx":279 + * cdef unsigned int ii + * cdef unsigned int jj + * for ii in prange(dim, nogil=True): # <<<<<<<<<<<<<< + * for jj in range(dim): + * dist = abs(x[jj] - x[ii]) + */ + /*finally:*/ { + /*normal exit:*/{ + #ifdef WITH_THREAD + __Pyx_FastGIL_Forget(); + Py_BLOCK_THREADS + #endif + goto __pyx_L5; + } + __pyx_L5:; + } } - /* "tigramite/tigramite_cython_code.pyx":279 + /* "tigramite/tigramite_cython_code.pyx":284 * d = dist - mean_0[ii] - mean_1[jj] + mean * squared_sum += d * d * return squared_sum # <<<<<<<<<<<<<< @@ -5953,15 +5996,15 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_4squared_sum(C * @cython.boundscheck(False) */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_squared_sum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 279, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_squared_sum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 284, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "tigramite/tigramite_cython_code.pyx":263 - * + /* "tigramite/tigramite_cython_code.pyx":268 * @cython.boundscheck(False) + * @cython.wraparound(False) * def squared_sum(self): # <<<<<<<<<<<<<< * cdef np.ndarray[DTYPE_t, ndim=1] mean_0 = self.mean_0 * cdef np.ndarray[DTYPE_t, ndim=1] mean_1 = self.mean_1 @@ -5994,9 +6037,9 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_4squared_sum(C return __pyx_r; } -/* "tigramite/tigramite_cython_code.pyx":282 - * +/* "tigramite/tigramite_cython_code.pyx":288 * @cython.boundscheck(False) + * @cython.wraparound(False) * def product_sum(self, other): # <<<<<<<<<<<<<< * cdef np.ndarray[DTYPE_t, ndim=1] mean_0_here = self.mean_0 * cdef np.ndarray[DTYPE_t, ndim=1] mean_1_here = self.mean_1 @@ -6008,9 +6051,6 @@ static PyMethodDef __pyx_mdef_9tigramite_21tigramite_cython_code_3D_N_7product_s static PyObject *__pyx_pw_9tigramite_21tigramite_cython_code_3D_N_7product_sum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_self = 0; PyObject *__pyx_v_other = 0; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("product_sum (wrapper)", 0); @@ -6037,11 +6077,11 @@ static PyObject *__pyx_pw_9tigramite_21tigramite_cython_code_3D_N_7product_sum(P case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_other)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("product_sum", 1, 2, 2, 1); __PYX_ERR(0, 282, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("product_sum", 1, 2, 2, 1); __PYX_ERR(0, 288, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "product_sum") < 0)) __PYX_ERR(0, 282, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "product_sum") < 0)) __PYX_ERR(0, 288, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -6054,7 +6094,7 @@ static PyObject *__pyx_pw_9tigramite_21tigramite_cython_code_3D_N_7product_sum(P } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("product_sum", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 282, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("product_sum", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 288, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("tigramite.tigramite_cython_code.D_N.product_sum", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -6114,9 +6154,10 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_6product_sum(C size_t __pyx_t_16; size_t __pyx_t_17; size_t __pyx_t_18; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; + size_t __pyx_t_19; + size_t __pyx_t_20; + size_t __pyx_t_21; + size_t __pyx_t_22; __Pyx_RefNannySetupContext("product_sum", 0); __pyx_pybuffer_mean_0_here.pybuffer.buf = NULL; __pyx_pybuffer_mean_0_here.refcount = 0; @@ -6143,22 +6184,22 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_6product_sum(C __pyx_pybuffernd_y.data = NULL; __pyx_pybuffernd_y.rcbuffer = &__pyx_pybuffer_y; - /* "tigramite/tigramite_cython_code.pyx":283 - * @cython.boundscheck(False) + /* "tigramite/tigramite_cython_code.pyx":289 + * @cython.wraparound(False) * def product_sum(self, other): * cdef np.ndarray[DTYPE_t, ndim=1] mean_0_here = self.mean_0 # <<<<<<<<<<<<<< * cdef np.ndarray[DTYPE_t, ndim=1] mean_1_here = self.mean_1 * cdef DTYPE_t mean_here = self.mean */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_mean_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 283, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_mean_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 289, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 283, __pyx_L1_error) + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 289, __pyx_L1_error) __pyx_t_2 = ((PyArrayObject *)__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_mean_0_here.rcbuffer->pybuffer, (PyObject*)__pyx_t_2, &__Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { __pyx_v_mean_0_here = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_mean_0_here.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 283, __pyx_L1_error) + __PYX_ERR(0, 289, __pyx_L1_error) } else {__pyx_pybuffernd_mean_0_here.diminfo[0].strides = __pyx_pybuffernd_mean_0_here.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_mean_0_here.diminfo[0].shape = __pyx_pybuffernd_mean_0_here.rcbuffer->pybuffer.shape[0]; } } @@ -6166,22 +6207,22 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_6product_sum(C __pyx_v_mean_0_here = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - /* "tigramite/tigramite_cython_code.pyx":284 + /* "tigramite/tigramite_cython_code.pyx":290 * def product_sum(self, other): * cdef np.ndarray[DTYPE_t, ndim=1] mean_0_here = self.mean_0 * cdef np.ndarray[DTYPE_t, ndim=1] mean_1_here = self.mean_1 # <<<<<<<<<<<<<< * cdef DTYPE_t mean_here = self.mean * cdef np.ndarray[DTYPE_t, ndim=1] mean_0_there = other.mean_0 */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_mean_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 284, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_mean_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 290, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 284, __pyx_L1_error) + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 290, __pyx_L1_error) __pyx_t_3 = ((PyArrayObject *)__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_mean_1_here.rcbuffer->pybuffer, (PyObject*)__pyx_t_3, &__Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { __pyx_v_mean_1_here = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_mean_1_here.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 284, __pyx_L1_error) + __PYX_ERR(0, 290, __pyx_L1_error) } else {__pyx_pybuffernd_mean_1_here.diminfo[0].strides = __pyx_pybuffernd_mean_1_here.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_mean_1_here.diminfo[0].shape = __pyx_pybuffernd_mean_1_here.rcbuffer->pybuffer.shape[0]; } } @@ -6189,35 +6230,35 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_6product_sum(C __pyx_v_mean_1_here = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - /* "tigramite/tigramite_cython_code.pyx":285 + /* "tigramite/tigramite_cython_code.pyx":291 * cdef np.ndarray[DTYPE_t, ndim=1] mean_0_here = self.mean_0 * cdef np.ndarray[DTYPE_t, ndim=1] mean_1_here = self.mean_1 * cdef DTYPE_t mean_here = self.mean # <<<<<<<<<<<<<< * cdef np.ndarray[DTYPE_t, ndim=1] mean_0_there = other.mean_0 * cdef np.ndarray[DTYPE_t, ndim=1] mean_1_there = other.mean_1 */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_mean); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 285, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_mean); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 291, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == ((npy_double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 285, __pyx_L1_error) + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == ((npy_double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 291, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_mean_here = __pyx_t_4; - /* "tigramite/tigramite_cython_code.pyx":286 + /* "tigramite/tigramite_cython_code.pyx":292 * cdef np.ndarray[DTYPE_t, ndim=1] mean_1_here = self.mean_1 * cdef DTYPE_t mean_here = self.mean * cdef np.ndarray[DTYPE_t, ndim=1] mean_0_there = other.mean_0 # <<<<<<<<<<<<<< * cdef np.ndarray[DTYPE_t, ndim=1] mean_1_there = other.mean_1 * cdef DTYPE_t mean_there = other.mean */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_mean_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 286, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_mean_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 292, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 286, __pyx_L1_error) + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 292, __pyx_L1_error) __pyx_t_5 = ((PyArrayObject *)__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_mean_0_there.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { __pyx_v_mean_0_there = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_mean_0_there.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 286, __pyx_L1_error) + __PYX_ERR(0, 292, __pyx_L1_error) } else {__pyx_pybuffernd_mean_0_there.diminfo[0].strides = __pyx_pybuffernd_mean_0_there.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_mean_0_there.diminfo[0].shape = __pyx_pybuffernd_mean_0_there.rcbuffer->pybuffer.shape[0]; } } @@ -6225,22 +6266,22 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_6product_sum(C __pyx_v_mean_0_there = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - /* "tigramite/tigramite_cython_code.pyx":287 + /* "tigramite/tigramite_cython_code.pyx":293 * cdef DTYPE_t mean_here = self.mean * cdef np.ndarray[DTYPE_t, ndim=1] mean_0_there = other.mean_0 * cdef np.ndarray[DTYPE_t, ndim=1] mean_1_there = other.mean_1 # <<<<<<<<<<<<<< * cdef DTYPE_t mean_there = other.mean * cdef DTYPE_t d_here */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_mean_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 287, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_mean_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 287, __pyx_L1_error) + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 293, __pyx_L1_error) __pyx_t_6 = ((PyArrayObject *)__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_mean_1_there.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { __pyx_v_mean_1_there = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_mean_1_there.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 287, __pyx_L1_error) + __PYX_ERR(0, 293, __pyx_L1_error) } else {__pyx_pybuffernd_mean_1_there.diminfo[0].strides = __pyx_pybuffernd_mean_1_there.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_mean_1_there.diminfo[0].shape = __pyx_pybuffernd_mean_1_there.rcbuffer->pybuffer.shape[0]; } } @@ -6248,20 +6289,20 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_6product_sum(C __pyx_v_mean_1_there = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - /* "tigramite/tigramite_cython_code.pyx":288 + /* "tigramite/tigramite_cython_code.pyx":294 * cdef np.ndarray[DTYPE_t, ndim=1] mean_0_there = other.mean_0 * cdef np.ndarray[DTYPE_t, ndim=1] mean_1_there = other.mean_1 * cdef DTYPE_t mean_there = other.mean # <<<<<<<<<<<<<< * cdef DTYPE_t d_here * cdef DTYPE_t d_there */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_mean); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 288, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_mean); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 294, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == ((npy_double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 288, __pyx_L1_error) + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == ((npy_double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 294, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_mean_there = __pyx_t_4; - /* "tigramite/tigramite_cython_code.pyx":291 + /* "tigramite/tigramite_cython_code.pyx":297 * cdef DTYPE_t d_here * cdef DTYPE_t d_there * cdef DTYPE_t product_sum = 0 # <<<<<<<<<<<<<< @@ -6270,22 +6311,22 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_6product_sum(C */ __pyx_v_product_sum = 0.0; - /* "tigramite/tigramite_cython_code.pyx":292 + /* "tigramite/tigramite_cython_code.pyx":298 * cdef DTYPE_t d_there * cdef DTYPE_t product_sum = 0 * cdef np.ndarray[DTYPE_t, ndim=1] x = self.x # <<<<<<<<<<<<<< * cdef np.ndarray[DTYPE_t, ndim=1] y = other.x * */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 292, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 298, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 292, __pyx_L1_error) + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 298, __pyx_L1_error) __pyx_t_7 = ((PyArrayObject *)__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { __pyx_v_x = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_x.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 292, __pyx_L1_error) + __PYX_ERR(0, 298, __pyx_L1_error) } else {__pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; } } @@ -6293,22 +6334,22 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_6product_sum(C __pyx_v_x = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - /* "tigramite/tigramite_cython_code.pyx":293 + /* "tigramite/tigramite_cython_code.pyx":299 * cdef DTYPE_t product_sum = 0 * cdef np.ndarray[DTYPE_t, ndim=1] x = self.x * cdef np.ndarray[DTYPE_t, ndim=1] y = other.x # <<<<<<<<<<<<<< * * cdef unsigned int dim = self.dim */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 293, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 299, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 293, __pyx_L1_error) + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 299, __pyx_L1_error) __pyx_t_8 = ((PyArrayObject *)__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_y.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { __pyx_v_y = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_y.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 293, __pyx_L1_error) + __PYX_ERR(0, 299, __pyx_L1_error) } else {__pyx_pybuffernd_y.diminfo[0].strides = __pyx_pybuffernd_y.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_y.diminfo[0].shape = __pyx_pybuffernd_y.rcbuffer->pybuffer.shape[0]; } } @@ -6316,94 +6357,153 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_6product_sum(C __pyx_v_y = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - /* "tigramite/tigramite_cython_code.pyx":295 + /* "tigramite/tigramite_cython_code.pyx":301 * cdef np.ndarray[DTYPE_t, ndim=1] y = other.x * * cdef unsigned int dim = self.dim # <<<<<<<<<<<<<< * cdef unsigned int ii * cdef unsigned int jj */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 295, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_9 = __Pyx_PyInt_As_unsigned_int(__pyx_t_1); if (unlikely((__pyx_t_9 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 295, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_As_unsigned_int(__pyx_t_1); if (unlikely((__pyx_t_9 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 301, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_dim = __pyx_t_9; - /* "tigramite/tigramite_cython_code.pyx":298 + /* "tigramite/tigramite_cython_code.pyx":304 * cdef unsigned int ii * cdef unsigned int jj - * for ii in range(dim): # <<<<<<<<<<<<<< + * for ii in prange(dim, nogil=True): # <<<<<<<<<<<<<< * for jj in range(dim): * d_here = abs(x[jj] - x[ii]) - mean_0_here[ii] - mean_1_here[jj] + mean_here */ - __pyx_t_9 = __pyx_v_dim; - __pyx_t_10 = __pyx_t_9; - for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { - __pyx_v_ii = __pyx_t_11; - - /* "tigramite/tigramite_cython_code.pyx":299 + { + #ifdef WITH_THREAD + PyThreadState *_save; + Py_UNBLOCK_THREADS + __Pyx_FastGIL_Remember(); + #endif + /*try:*/ { + __pyx_t_9 = __pyx_v_dim; + if (1 == 0) abort(); + { + #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) + #undef likely + #undef unlikely + #define likely(x) (x) + #define unlikely(x) (x) + #endif + __pyx_t_11 = (__pyx_t_9 - 0 + 1 - 1/abs(1)) / 1; + if (__pyx_t_11 > 0) + { + #ifdef _OPENMP + #pragma omp parallel reduction(+:__pyx_v_product_sum) private(__pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_t_18, __pyx_t_19, __pyx_t_20, __pyx_t_21, __pyx_t_22) + #endif /* _OPENMP */ + { + #ifdef _OPENMP + #pragma omp for lastprivate(__pyx_v_d_here) lastprivate(__pyx_v_d_there) firstprivate(__pyx_v_ii) lastprivate(__pyx_v_ii) lastprivate(__pyx_v_jj) + #endif /* _OPENMP */ + for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_11; __pyx_t_10++){ + { + __pyx_v_ii = (unsigned int)(0 + 1 * __pyx_t_10); + /* Initialize private variables to invalid values */ + __pyx_v_d_here = ((__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t)__PYX_NAN()); + __pyx_v_d_there = ((__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t)__PYX_NAN()); + __pyx_v_jj = ((unsigned int)0xbad0bad0); + + /* "tigramite/tigramite_cython_code.pyx":305 * cdef unsigned int jj - * for ii in range(dim): + * for ii in prange(dim, nogil=True): * for jj in range(dim): # <<<<<<<<<<<<<< * d_here = abs(x[jj] - x[ii]) - mean_0_here[ii] - mean_1_here[jj] + mean_here * d_there = abs(y[jj] - y[ii]) - mean_0_there[ii] - mean_1_there[jj] + mean_there */ - __pyx_t_12 = __pyx_v_dim; - __pyx_t_13 = __pyx_t_12; - for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { - __pyx_v_jj = __pyx_t_14; + __pyx_t_12 = __pyx_v_dim; + __pyx_t_13 = __pyx_t_12; + for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { + __pyx_v_jj = __pyx_t_14; - /* "tigramite/tigramite_cython_code.pyx":300 - * for ii in range(dim): + /* "tigramite/tigramite_cython_code.pyx":306 + * for ii in prange(dim, nogil=True): * for jj in range(dim): * d_here = abs(x[jj] - x[ii]) - mean_0_here[ii] - mean_1_here[jj] + mean_here # <<<<<<<<<<<<<< * d_there = abs(y[jj] - y[ii]) - mean_0_there[ii] - mean_1_there[jj] + mean_there * product_sum += d_here * d_there */ - __pyx_t_15 = __pyx_v_jj; - __pyx_t_16 = __pyx_v_ii; - __pyx_t_17 = __pyx_v_ii; - __pyx_t_18 = __pyx_v_jj; - __pyx_v_d_here = (((__pyx_f_9tigramite_21tigramite_cython_code_abs(((*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_x.diminfo[0].strides)) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_x.diminfo[0].strides)))) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_mean_0_here.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_mean_0_here.diminfo[0].strides))) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_mean_1_here.rcbuffer->pybuffer.buf, __pyx_t_18, __pyx_pybuffernd_mean_1_here.diminfo[0].strides))) + __pyx_v_mean_here); + __pyx_t_15 = __pyx_v_jj; + __pyx_t_16 = __pyx_v_ii; + __pyx_t_17 = __pyx_v_ii; + __pyx_t_18 = __pyx_v_jj; + __pyx_v_d_here = (((__pyx_f_9tigramite_21tigramite_cython_code_abs(((*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_x.diminfo[0].strides)) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_x.diminfo[0].strides)))) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_mean_0_here.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_mean_0_here.diminfo[0].strides))) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_mean_1_here.rcbuffer->pybuffer.buf, __pyx_t_18, __pyx_pybuffernd_mean_1_here.diminfo[0].strides))) + __pyx_v_mean_here); - /* "tigramite/tigramite_cython_code.pyx":301 + /* "tigramite/tigramite_cython_code.pyx":307 * for jj in range(dim): * d_here = abs(x[jj] - x[ii]) - mean_0_here[ii] - mean_1_here[jj] + mean_here * d_there = abs(y[jj] - y[ii]) - mean_0_there[ii] - mean_1_there[jj] + mean_there # <<<<<<<<<<<<<< * product_sum += d_here * d_there * return product_sum */ - __pyx_t_18 = __pyx_v_jj; - __pyx_t_17 = __pyx_v_ii; - __pyx_t_16 = __pyx_v_ii; - __pyx_t_15 = __pyx_v_jj; - __pyx_v_d_there = (((__pyx_f_9tigramite_21tigramite_cython_code_abs(((*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_y.rcbuffer->pybuffer.buf, __pyx_t_18, __pyx_pybuffernd_y.diminfo[0].strides)) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_y.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_y.diminfo[0].strides)))) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_mean_0_there.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_mean_0_there.diminfo[0].strides))) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_mean_1_there.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_mean_1_there.diminfo[0].strides))) + __pyx_v_mean_there); + __pyx_t_19 = __pyx_v_jj; + __pyx_t_20 = __pyx_v_ii; + __pyx_t_21 = __pyx_v_ii; + __pyx_t_22 = __pyx_v_jj; + __pyx_v_d_there = (((__pyx_f_9tigramite_21tigramite_cython_code_abs(((*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_y.rcbuffer->pybuffer.buf, __pyx_t_19, __pyx_pybuffernd_y.diminfo[0].strides)) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_y.rcbuffer->pybuffer.buf, __pyx_t_20, __pyx_pybuffernd_y.diminfo[0].strides)))) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_mean_0_there.rcbuffer->pybuffer.buf, __pyx_t_21, __pyx_pybuffernd_mean_0_there.diminfo[0].strides))) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_mean_1_there.rcbuffer->pybuffer.buf, __pyx_t_22, __pyx_pybuffernd_mean_1_there.diminfo[0].strides))) + __pyx_v_mean_there); - /* "tigramite/tigramite_cython_code.pyx":302 + /* "tigramite/tigramite_cython_code.pyx":308 * d_here = abs(x[jj] - x[ii]) - mean_0_here[ii] - mean_1_here[jj] + mean_here * d_there = abs(y[jj] - y[ii]) - mean_0_there[ii] - mean_1_there[jj] + mean_there * product_sum += d_here * d_there # <<<<<<<<<<<<<< * return product_sum */ - __pyx_v_product_sum = (__pyx_v_product_sum + (__pyx_v_d_here * __pyx_v_d_there)); - } + __pyx_v_product_sum = (__pyx_v_product_sum + (__pyx_v_d_here * __pyx_v_d_there)); + } + } + } + } + } + } + #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) + #undef likely + #undef unlikely + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) + #endif + } + + /* "tigramite/tigramite_cython_code.pyx":304 + * cdef unsigned int ii + * cdef unsigned int jj + * for ii in prange(dim, nogil=True): # <<<<<<<<<<<<<< + * for jj in range(dim): + * d_here = abs(x[jj] - x[ii]) - mean_0_here[ii] - mean_1_here[jj] + mean_here + */ + /*finally:*/ { + /*normal exit:*/{ + #ifdef WITH_THREAD + __Pyx_FastGIL_Forget(); + Py_BLOCK_THREADS + #endif + goto __pyx_L5; + } + __pyx_L5:; + } } - /* "tigramite/tigramite_cython_code.pyx":303 + /* "tigramite/tigramite_cython_code.pyx":309 * d_there = abs(y[jj] - y[ii]) - mean_0_there[ii] - mean_1_there[jj] + mean_there * product_sum += d_here * d_there * return product_sum # <<<<<<<<<<<<<< */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_product_sum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 303, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_product_sum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 309, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "tigramite/tigramite_cython_code.pyx":282 - * + /* "tigramite/tigramite_cython_code.pyx":288 * @cython.boundscheck(False) + * @cython.wraparound(False) * def product_sum(self, other): # <<<<<<<<<<<<<< * cdef np.ndarray[DTYPE_t, ndim=1] mean_0_here = self.mean_0 * cdef np.ndarray[DTYPE_t, ndim=1] mean_1_here = self.mean_1 @@ -6445,57 +6545,910 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_6product_sum(C return __pyx_r; } -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":742 - * ctypedef npy_cdouble complex_t - * - * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(1, a) - * +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":258 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fulfill the PEP. */ -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { - PyObject *__pyx_r = NULL; +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_v_i; + int __pyx_v_ndim; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + int __pyx_v_t; + char *__pyx_v_f; + PyArray_Descr *__pyx_v_descr = 0; + int __pyx_v_offset; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + PyArray_Descr *__pyx_t_7; + PyObject *__pyx_t_8 = NULL; + char *__pyx_t_9; + if (__pyx_v_info == NULL) { + PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); + return -1; + } + __Pyx_RefNannySetupContext("__getbuffer__", 0); + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":743 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":265 * - * cdef inline object PyArray_MultiIterNew1(a): - * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< + * cdef int i, ndim + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) * - * cdef inline object PyArray_MultiIterNew2(a, b): */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 743, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + __pyx_v_endian_detector = 1; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":742 - * ctypedef npy_cdouble complex_t + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":266 + * cdef int i, ndim + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< * - * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(1, a) + * ndim = PyArray_NDIM(self) + */ + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":268 + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * + * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) */ + __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":270 + * ndim = PyArray_NDIM(self) + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":271 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not C contiguous") + * + */ + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_C_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":270 + * ndim = PyArray_NDIM(self) + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + if (unlikely(__pyx_t_1)) { + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":272 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 272, __pyx_L1_error) + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":270 + * ndim = PyArray_NDIM(self) + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + } + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":274 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L7_bool_binop_done; + } + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":275 + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not Fortran contiguous") + * + */ + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_F_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L7_bool_binop_done:; + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":274 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + if (unlikely(__pyx_t_1)) { + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":276 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + * + * info.buf = PyArray_DATA(self) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 276, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 276, __pyx_L1_error) + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":274 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + } + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":278 + * raise ValueError(u"ndarray is not Fortran contiguous") + * + * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< + * info.ndim = ndim + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":279 + * + * info.buf = PyArray_DATA(self) + * info.ndim = ndim # <<<<<<<<<<<<<< + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * # Allocate new buffer for strides and shape info. + */ + __pyx_v_info->ndim = __pyx_v_ndim; + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":280 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + */ + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":283 + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) # <<<<<<<<<<<<<< + * info.shape = info.strides + ndim + * for i in range(ndim): + */ + __pyx_v_info->strides = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * 2) * ((size_t)__pyx_v_ndim)))); + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":284 + * # This is allocated as one block, strides first. + * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) + * info.shape = info.strides + ndim # <<<<<<<<<<<<<< + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] + */ + __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":285 + * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) + * info.shape = info.strides + ndim + * for i in range(ndim): # <<<<<<<<<<<<<< + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] + */ + __pyx_t_4 = __pyx_v_ndim; + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":286 + * info.shape = info.strides + ndim + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + */ + (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":287 + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< + * else: + * info.strides = PyArray_STRIDES(self) + */ + (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); + } + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":280 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + */ + goto __pyx_L9; + } + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":289 + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL + */ + /*else*/ { + __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":290 + * else: + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + */ + __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self)); + } + __pyx_L9:; + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":291 + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) + */ + __pyx_v_info->suboffsets = NULL; + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":292 + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< + * info.readonly = not PyArray_ISWRITEABLE(self) + * + */ + __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":293 + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< + * + * cdef int t + */ + __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":296 + * + * cdef int t + * cdef char* f = NULL # <<<<<<<<<<<<<< + * cdef dtype descr = PyArray_DESCR(self) + * cdef int offset + */ + __pyx_v_f = NULL; + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":297 + * cdef int t + * cdef char* f = NULL + * cdef dtype descr = PyArray_DESCR(self) # <<<<<<<<<<<<<< + * cdef int offset + * + */ + __pyx_t_7 = PyArray_DESCR(__pyx_v_self); + __pyx_t_3 = ((PyObject *)__pyx_t_7); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":300 + * cdef int offset + * + * info.obj = self # <<<<<<<<<<<<<< + * + * if not PyDataType_HASFIELDS(descr): + */ + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":302 + * info.obj = self + * + * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ + __pyx_t_1 = ((!(PyDataType_HASFIELDS(__pyx_v_descr) != 0)) != 0); + if (__pyx_t_1) { + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":303 + * + * if not PyDataType_HASFIELDS(descr): + * t = descr.type_num # <<<<<<<<<<<<<< + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + */ + __pyx_t_4 = __pyx_v_descr->type_num; + __pyx_v_t = __pyx_t_4; + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":304 + * if not PyDataType_HASFIELDS(descr): + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0); + if (!__pyx_t_2) { + goto __pyx_L15_next_or; + } else { + } + __pyx_t_2 = (__pyx_v_little_endian != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L14_bool_binop_done; + } + __pyx_L15_next_or:; + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":305 + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" + */ + __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L14_bool_binop_done; + } + __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L14_bool_binop_done:; + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":304 + * if not PyDataType_HASFIELDS(descr): + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + if (unlikely(__pyx_t_1)) { + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":306 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 306, __pyx_L1_error) + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":304 + * if not PyDataType_HASFIELDS(descr): + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + } + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":307 + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" + */ + switch (__pyx_v_t) { + case NPY_BYTE: + __pyx_v_f = ((char *)"b"); + break; + case NPY_UBYTE: + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":308 + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" + */ + __pyx_v_f = ((char *)"B"); + break; + case NPY_SHORT: + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":309 + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + */ + __pyx_v_f = ((char *)"h"); + break; + case NPY_USHORT: + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":310 + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" + */ + __pyx_v_f = ((char *)"H"); + break; + case NPY_INT: + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":311 + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" + */ + __pyx_v_f = ((char *)"i"); + break; + case NPY_UINT: + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":312 + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + */ + __pyx_v_f = ((char *)"I"); + break; + case NPY_LONG: + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":313 + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" + */ + __pyx_v_f = ((char *)"l"); + break; + case NPY_ULONG: + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":314 + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + */ + __pyx_v_f = ((char *)"L"); + break; + case NPY_LONGLONG: + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":315 + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + */ + __pyx_v_f = ((char *)"q"); + break; + case NPY_ULONGLONG: + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":316 + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + */ + __pyx_v_f = ((char *)"Q"); + break; + case NPY_FLOAT: + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":317 + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" + */ + __pyx_v_f = ((char *)"f"); + break; + case NPY_DOUBLE: + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":318 + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" + */ + __pyx_v_f = ((char *)"d"); + break; + case NPY_LONGDOUBLE: + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":319 + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" + */ + __pyx_v_f = ((char *)"g"); + break; + case NPY_CFLOAT: + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":320 + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" + */ + __pyx_v_f = ((char *)"Zf"); + break; + case NPY_CDOUBLE: + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":321 + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" + */ + __pyx_v_f = ((char *)"Zd"); + break; + case NPY_CLONGDOUBLE: + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":322 + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f = "O" + * else: + */ + __pyx_v_f = ((char *)"Zg"); + break; + case NPY_OBJECT: + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":323 + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + */ + __pyx_v_f = ((char *)"O"); + break; + default: + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":325 + * elif t == NPY_OBJECT: f = "O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * info.format = f + * return + */ + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 325, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 325, __pyx_L1_error) + break; + } + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":326 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f # <<<<<<<<<<<<<< + * return + * else: + */ + __pyx_v_info->format = __pyx_v_f; + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":327 + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f + * return # <<<<<<<<<<<<<< + * else: + * info.format = PyObject_Malloc(_buffer_format_string_len) + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":302 + * info.obj = self + * + * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ + } + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":329 + * return + * else: + * info.format = PyObject_Malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + */ + /*else*/ { + __pyx_v_info->format = ((char *)PyObject_Malloc(0xFF)); + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":330 + * else: + * info.format = PyObject_Malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, + */ + (__pyx_v_info->format[0]) = '^'; + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":331 + * info.format = PyObject_Malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 # <<<<<<<<<<<<<< + * f = _util_dtypestring(descr, info.format + 1, + * info.format + _buffer_format_string_len, + */ + __pyx_v_offset = 0; + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":332 + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< + * info.format + _buffer_format_string_len, + * &offset) + */ + __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 332, __pyx_L1_error) + __pyx_v_f = __pyx_t_9; + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":335 + * info.format + _buffer_format_string_len, + * &offset) + * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + */ + (__pyx_v_f[0]) = '\x00'; + } + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":258 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fulfill the PEP. + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_descr); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":337 + * f[0] = c'\0' # Terminate format string + * + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * PyObject_Free(info.format) + */ + +/* Python wrapper */ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0); + __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__releasebuffer__", 0); + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":338 + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * PyObject_Free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); + if (__pyx_t_1) { + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":339 + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): + * PyObject_Free(info.format) # <<<<<<<<<<<<<< + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * PyObject_Free(info.strides) + */ + PyObject_Free(__pyx_v_info->format); + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":338 + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * PyObject_Free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + } + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":340 + * if PyArray_HASFIELDS(self): + * PyObject_Free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * PyObject_Free(info.strides) + * # info.shape was stored after info.strides in the same block + */ + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":341 + * PyObject_Free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * PyObject_Free(info.strides) # <<<<<<<<<<<<<< + * # info.shape was stored after info.strides in the same block + * + */ + PyObject_Free(__pyx_v_info->strides); + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":340 + * if PyArray_HASFIELDS(self): + * PyObject_Free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * PyObject_Free(info.strides) + * # info.shape was stored after info.strides in the same block + */ + } + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":337 + * f[0] = c'\0' # Terminate format string + * + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * PyObject_Free(info.format) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":821 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":822 + * + * cdef inline object PyArray_MultiIterNew1(a): + * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew2(a, b): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 822, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":821 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":745 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":824 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< @@ -6507,12 +7460,9 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":746 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":825 * * cdef inline object PyArray_MultiIterNew2(a, b): * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< @@ -6520,13 +7470,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ * cdef inline object PyArray_MultiIterNew3(a, b, c): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 746, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 825, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":745 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":824 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< @@ -6545,7 +7495,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ return __pyx_r; } -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":748 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":827 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< @@ -6557,12 +7507,9 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":749 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":828 * * cdef inline object PyArray_MultiIterNew3(a, b, c): * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< @@ -6570,13 +7517,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 749, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 828, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":748 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":827 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< @@ -6595,7 +7542,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ return __pyx_r; } -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":751 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":830 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< @@ -6607,12 +7554,9 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":752 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":831 * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< @@ -6620,13 +7564,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 752, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 831, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":751 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":830 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< @@ -6645,7 +7589,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ return __pyx_r; } -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":754 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":833 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< @@ -6657,12 +7601,9 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":755 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":834 * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< @@ -6670,13 +7611,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ * cdef inline tuple PyDataType_SHAPE(dtype d): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 755, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 834, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":754 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":833 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< @@ -6695,7 +7636,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ return __pyx_r; } -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":757 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":836 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< @@ -6709,7 +7650,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ int __pyx_t_1; __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":758 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":837 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< @@ -6719,7 +7660,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); if (__pyx_t_1) { - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":759 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":838 * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape # <<<<<<<<<<<<<< @@ -6731,7 +7672,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); goto __pyx_L0; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":758 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":837 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< @@ -6740,7 +7681,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ */ } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":761 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":840 * return d.subarray.shape * else: * return () # <<<<<<<<<<<<<< @@ -6754,7 +7695,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ goto __pyx_L0; } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":757 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":836 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< @@ -6769,7 +7710,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ return __pyx_r; } -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":763 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":842 * return () * * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< @@ -6796,12 +7737,9 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx int __pyx_t_7; long __pyx_t_8; char *__pyx_t_9; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_util_dtypestring", 0); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":768 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":847 * * cdef dtype child * cdef int endian_detector = 1 # <<<<<<<<<<<<<< @@ -6810,7 +7748,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx */ __pyx_v_endian_detector = 1; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":769 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":848 * cdef dtype child * cdef int endian_detector = 1 * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< @@ -6819,7 +7757,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx */ __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":772 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":851 * cdef tuple fields * * for childname in descr.names: # <<<<<<<<<<<<<< @@ -6828,21 +7766,21 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx */ if (unlikely(__pyx_v_descr->names == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(1, 772, __pyx_L1_error) + __PYX_ERR(1, 851, __pyx_L1_error) } __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; for (;;) { if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 772, __pyx_L1_error) + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 851, __pyx_L1_error) #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 772, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); __pyx_t_3 = 0; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":773 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":852 * * for childname in descr.names: * fields = descr.fields[childname] # <<<<<<<<<<<<<< @@ -6851,15 +7789,15 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx */ if (unlikely(__pyx_v_descr->fields == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 773, __pyx_L1_error) + __PYX_ERR(1, 852, __pyx_L1_error) } - __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 773, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 852, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 773, __pyx_L1_error) + if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 852, __pyx_L1_error) __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":774 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":853 * for childname in descr.names: * fields = descr.fields[childname] * child, new_offset = fields # <<<<<<<<<<<<<< @@ -6872,7 +7810,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 774, __pyx_L1_error) + __PYX_ERR(1, 853, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); @@ -6880,51 +7818,51 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); #else - __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 774, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 853, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 774, __pyx_L1_error) + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 853, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif } else { - __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 774, __pyx_L1_error) + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 853, __pyx_L1_error) } - if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 774, __pyx_L1_error) + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 853, __pyx_L1_error) __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); __pyx_t_3 = 0; __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); __pyx_t_4 = 0; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":776 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":855 * child, new_offset = fields * * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * */ - __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 776, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 855, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 776, __pyx_L1_error) + __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 855, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 776, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 855, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); if (unlikely(__pyx_t_6)) { - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":777 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":856 * * if (end - f) - (new_offset - offset[0]) < 15: * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< * * if ((child.byteorder == c'>' and little_endian) or */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 777, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 856, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 777, __pyx_L1_error) + __PYX_ERR(1, 856, __pyx_L1_error) - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":776 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":855 * child, new_offset = fields * * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< @@ -6933,7 +7871,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx */ } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":779 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":858 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< @@ -6953,7 +7891,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx } __pyx_L8_next_or:; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":780 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":859 * * if ((child.byteorder == c'>' and little_endian) or * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< @@ -6970,7 +7908,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx __pyx_t_6 = __pyx_t_7; __pyx_L7_bool_binop_done:; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":779 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":858 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< @@ -6979,20 +7917,20 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx */ if (unlikely(__pyx_t_6)) { - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":781 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":860 * if ((child.byteorder == c'>' and little_endian) or * (child.byteorder == c'<' and not little_endian)): * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< * # One could encode it in the format string and have Cython * # complain instead, BUT: < and > in format strings also imply */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 781, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 860, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 781, __pyx_L1_error) + __PYX_ERR(1, 860, __pyx_L1_error) - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":779 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":858 * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< @@ -7001,7 +7939,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx */ } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":791 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":870 * * # Output padding bytes * while offset[0] < new_offset: # <<<<<<<<<<<<<< @@ -7009,15 +7947,15 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx * f += 1 */ while (1) { - __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 791, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 870, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 791, __pyx_L1_error) + __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 870, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 791, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 870, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!__pyx_t_6) break; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":792 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":871 * # Output padding bytes * while offset[0] < new_offset: * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< @@ -7026,7 +7964,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx */ (__pyx_v_f[0]) = 0x78; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":793 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":872 * while offset[0] < new_offset: * f[0] = 120 # "x"; pad byte * f += 1 # <<<<<<<<<<<<<< @@ -7035,7 +7973,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx */ __pyx_v_f = (__pyx_v_f + 1); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":794 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":873 * f[0] = 120 # "x"; pad byte * f += 1 * offset[0] += 1 # <<<<<<<<<<<<<< @@ -7046,7 +7984,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":796 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":875 * offset[0] += 1 * * offset[0] += child.itemsize # <<<<<<<<<<<<<< @@ -7056,7 +7994,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx __pyx_t_8 = 0; (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":798 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":877 * offset[0] += child.itemsize * * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< @@ -7066,19 +8004,19 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); if (__pyx_t_6) { - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":799 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":878 * * if not PyDataType_HASFIELDS(child): * t = child.type_num # <<<<<<<<<<<<<< * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") */ - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 799, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 878, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); __pyx_t_4 = 0; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":800 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":879 * if not PyDataType_HASFIELDS(child): * t = child.type_num * if end - f < 5: # <<<<<<<<<<<<<< @@ -7088,20 +8026,20 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); if (unlikely(__pyx_t_6)) { - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":801 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":880 * t = child.type_num * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< * * # Until ticket #99 is fixed, use integers to avoid warnings */ - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 801, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 880, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(1, 801, __pyx_L1_error) + __PYX_ERR(1, 880, __pyx_L1_error) - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":800 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":879 * if not PyDataType_HASFIELDS(child): * t = child.type_num * if end - f < 5: # <<<<<<<<<<<<<< @@ -7110,252 +8048,252 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx */ } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":804 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":883 * * # Until ticket #99 is fixed, use integers to avoid warnings * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 804, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 804, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 883, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 804, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 883, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 98; goto __pyx_L15; } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":805 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":884 * # Until ticket #99 is fixed, use integers to avoid warnings * if t == NPY_BYTE: f[0] = 98 #"b" * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 805, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 884, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 805, __pyx_L1_error) + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 884, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 805, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 884, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 66; goto __pyx_L15; } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":806 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":885 * if t == NPY_BYTE: f[0] = 98 #"b" * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 806, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 885, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 806, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 885, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 806, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 885, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x68; goto __pyx_L15; } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":807 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":886 * elif t == NPY_UBYTE: f[0] = 66 #"B" * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 807, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 886, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 807, __pyx_L1_error) + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 886, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 807, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 886, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 72; goto __pyx_L15; } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":808 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":887 * elif t == NPY_SHORT: f[0] = 104 #"h" * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 808, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 887, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 808, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 887, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 808, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 887, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x69; goto __pyx_L15; } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":809 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":888 * elif t == NPY_USHORT: f[0] = 72 #"H" * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 809, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 888, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 809, __pyx_L1_error) + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 888, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 809, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 888, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 73; goto __pyx_L15; } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":810 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":889 * elif t == NPY_INT: f[0] = 105 #"i" * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 810, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 889, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 810, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 889, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 810, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 889, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x6C; goto __pyx_L15; } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":811 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":890 * elif t == NPY_UINT: f[0] = 73 #"I" * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 811, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 890, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 811, __pyx_L1_error) + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 890, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 811, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 890, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 76; goto __pyx_L15; } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":812 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":891 * elif t == NPY_LONG: f[0] = 108 #"l" * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 812, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 891, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 812, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 891, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 812, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 891, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x71; goto __pyx_L15; } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":813 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":892 * elif t == NPY_ULONG: f[0] = 76 #"L" * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 813, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 892, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 813, __pyx_L1_error) + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 892, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 813, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 892, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 81; goto __pyx_L15; } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":814 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":893 * elif t == NPY_LONGLONG: f[0] = 113 #"q" * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 814, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 893, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 814, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 893, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 814, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 893, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x66; goto __pyx_L15; } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":815 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":894 * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 815, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 894, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 815, __pyx_L1_error) + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 894, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 815, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 894, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x64; goto __pyx_L15; } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":816 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":895 * elif t == NPY_FLOAT: f[0] = 102 #"f" * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 816, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 895, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 816, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 895, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 816, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 895, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 0x67; goto __pyx_L15; } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":817 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":896 * elif t == NPY_DOUBLE: f[0] = 100 #"d" * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 817, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 817, __pyx_L1_error) + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 896, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 817, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 896, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 90; @@ -7364,18 +8302,18 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx goto __pyx_L15; } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":818 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":897 * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg * elif t == NPY_OBJECT: f[0] = 79 #"O" */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 818, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 897, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 818, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 897, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 818, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 897, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 90; @@ -7384,18 +8322,18 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx goto __pyx_L15; } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":819 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":898 * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< * elif t == NPY_OBJECT: f[0] = 79 #"O" * else: */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 819, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 898, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 819, __pyx_L1_error) + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 898, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 819, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 898, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_6) { (__pyx_v_f[0]) = 90; @@ -7404,25 +8342,25 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx goto __pyx_L15; } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":820 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":899 * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 820, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 899, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 820, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 899, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 820, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 899, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (likely(__pyx_t_6)) { (__pyx_v_f[0]) = 79; goto __pyx_L15; } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":822 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":901 * elif t == NPY_OBJECT: f[0] = 79 #"O" * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< @@ -7430,18 +8368,18 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx * else: */ /*else*/ { - __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 822, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 901, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 822, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 901, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(1, 822, __pyx_L1_error) + __PYX_ERR(1, 901, __pyx_L1_error) } __pyx_L15:; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":823 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":902 * else: * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) * f += 1 # <<<<<<<<<<<<<< @@ -7450,7 +8388,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx */ __pyx_v_f = (__pyx_v_f + 1); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":798 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":877 * offset[0] += child.itemsize * * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< @@ -7460,7 +8398,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx goto __pyx_L13; } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":827 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":906 * # Cython ignores struct boundary information ("T{...}"), * # so don't output it * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< @@ -7468,12 +8406,12 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx * */ /*else*/ { - __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 827, __pyx_L1_error) + __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 906, __pyx_L1_error) __pyx_v_f = __pyx_t_9; } __pyx_L13:; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":772 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":851 * cdef tuple fields * * for childname in descr.names: # <<<<<<<<<<<<<< @@ -7483,7 +8421,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":828 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":907 * # so don't output it * f = _util_dtypestring(child, f, end, offset) * return f # <<<<<<<<<<<<<< @@ -7493,7 +8431,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx __pyx_r = __pyx_v_f; goto __pyx_L0; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":763 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":842 * return () * * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< @@ -7518,7 +8456,7 @@ static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx return __pyx_r; } -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":943 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1022 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< @@ -7530,7 +8468,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_array_base", 0); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":944 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1023 * * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< @@ -7539,7 +8477,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a */ Py_INCREF(__pyx_v_base); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":945 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1024 * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< @@ -7548,7 +8486,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a */ (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":943 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1022 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< @@ -7560,7 +8498,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a __Pyx_RefNannyFinishContext(); } -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":947 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1026 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< @@ -7575,7 +8513,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py int __pyx_t_1; __Pyx_RefNannySetupContext("get_array_base", 0); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":948 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1027 * * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< @@ -7584,7 +8522,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py */ __pyx_v_base = PyArray_BASE(__pyx_v_arr); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":949 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1028 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< @@ -7594,7 +8532,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py __pyx_t_1 = ((__pyx_v_base == NULL) != 0); if (__pyx_t_1) { - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":950 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1029 * base = PyArray_BASE(arr) * if base is NULL: * return None # <<<<<<<<<<<<<< @@ -7605,7 +8543,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":949 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1028 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< @@ -7614,7 +8552,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py */ } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":951 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1030 * if base is NULL: * return None * return base # <<<<<<<<<<<<<< @@ -7626,7 +8564,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py __pyx_r = ((PyObject *)__pyx_v_base); goto __pyx_L0; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":947 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1026 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< @@ -7641,12 +8579,12 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py return __pyx_r; } -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":955 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1034 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< * try: - * __pyx_import_array() + * _import_array() */ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { @@ -7660,16 +8598,13 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_array", 0); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":956 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1035 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< - * __pyx_import_array() + * _import_array() * except Exception: */ { @@ -7681,20 +8616,20 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":957 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1036 * cdef inline int import_array() except -1: * try: - * __pyx_import_array() # <<<<<<<<<<<<<< + * _import_array() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.multiarray failed to import") */ - __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 957, __pyx_L3_error) + __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1036, __pyx_L3_error) - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":956 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1035 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< - * __pyx_import_array() + * _import_array() * except Exception: */ } @@ -7704,9 +8639,9 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { goto __pyx_L8_try_end; __pyx_L3_error:; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":958 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1037 * try: - * __pyx_import_array() + * _import_array() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.multiarray failed to import") * @@ -7714,32 +8649,32 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 958, __pyx_L5_except_error) + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1037, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":959 - * __pyx_import_array() + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1038 + * _import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 959, __pyx_L5_except_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1038, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 959, __pyx_L5_except_error) + __PYX_ERR(1, 1038, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":956 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1035 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< - * __pyx_import_array() + * _import_array() * except Exception: */ __Pyx_XGIVEREF(__pyx_t_1); @@ -7750,12 +8685,12 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __pyx_L8_try_end:; } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":955 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1034 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< * try: - * __pyx_import_array() + * _import_array() */ /* function exit code */ @@ -7773,7 +8708,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { return __pyx_r; } -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":961 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1040 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< @@ -7792,12 +8727,9 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_umath", 0); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":962 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< @@ -7813,16 +8745,16 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":963 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1042 * cdef inline int import_umath() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ - __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 963, __pyx_L3_error) + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1042, __pyx_L3_error) - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":962 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< @@ -7836,7 +8768,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { goto __pyx_L8_try_end; __pyx_L3_error:; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":964 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1043 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< @@ -7846,28 +8778,28 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 964, __pyx_L5_except_error) + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1043, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":965 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1044 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 965, __pyx_L5_except_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1044, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 965, __pyx_L5_except_error) + __PYX_ERR(1, 1044, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":962 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< @@ -7882,7 +8814,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __pyx_L8_try_end:; } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":961 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1040 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< @@ -7905,7 +8837,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { return __pyx_r; } -/* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":967 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< @@ -7924,12 +8856,9 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_ufunc", 0); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":968 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< @@ -7945,16 +8874,16 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":969 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1048 * cdef inline int import_ufunc() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ - __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 969, __pyx_L3_error) + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1048, __pyx_L3_error) - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":968 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< @@ -7968,38 +8897,35 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { goto __pyx_L8_try_end; __pyx_L3_error:; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":970 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1049 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< * raise ImportError("numpy.core.umath failed to import") - * */ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 970, __pyx_L5_except_error) + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1049, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":971 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1050 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< - * - * cdef extern from *: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 971, __pyx_L5_except_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1050, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 971, __pyx_L5_except_error) + __PYX_ERR(1, 1050, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":968 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< @@ -8014,7 +8940,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __pyx_L8_try_end:; } - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":967 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1046 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< @@ -8053,9 +8979,6 @@ static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, P PyObject *__pyx_v_format = 0; PyObject *__pyx_v_mode = 0; int __pyx_v_allocate_buffer; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); @@ -8194,9 +9117,6 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ Py_ssize_t __pyx_t_9; PyObject *__pyx_t_10 = NULL; Py_ssize_t __pyx_t_11; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__cinit__", 0); __Pyx_INCREF(__pyx_v_format); @@ -8240,7 +9160,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ * * if itemsize <= 0: */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 133, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 133, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -8272,7 +9192,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ * * if not isinstance(format, bytes): */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 136, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 136, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -8399,7 +9319,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ * * */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 148, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 148, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -8673,7 +9593,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ * * if self.dtype_is_object: */ - __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 176, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 176, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_Raise(__pyx_t_10, 0, 0, 0); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; @@ -8820,9 +9740,6 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru Py_ssize_t __pyx_t_5; int __pyx_t_6; Py_ssize_t *__pyx_t_7; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; if (__pyx_v_info == NULL) { PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); return -1; @@ -8917,7 +9834,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru * info.buf = self.data * info.len = self.len */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 192, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 192, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -9251,9 +10168,6 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct _ PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "View.MemoryView":223 @@ -9304,9 +10218,6 @@ static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) { PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_memview", 0); /* "View.MemoryView":227 @@ -9445,9 +10356,6 @@ static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__( __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__getattr__", 0); /* "View.MemoryView":234 @@ -9513,9 +10421,6 @@ static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__ __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__getitem__", 0); /* "View.MemoryView":237 @@ -9580,9 +10485,6 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struc int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setitem__", 0); /* "View.MemoryView":240 @@ -9640,9 +10542,6 @@ static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __p PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 @@ -9651,7 +10550,7 @@ static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __p * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -9697,9 +10596,6 @@ static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 @@ -9707,7 +10603,7 @@ static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -9747,9 +10643,6 @@ static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("array_cwrapper", 0); /* "View.MemoryView":248 @@ -9917,9 +10810,6 @@ static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_name = 0; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); @@ -10081,9 +10971,6 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":5 @@ -10309,9 +11196,6 @@ static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_Me PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":17 @@ -10441,9 +11325,6 @@ static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_ar PyObject *__pyx_v_obj = 0; int __pyx_v_flags; int __pyx_v_dtype_is_object; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); @@ -10524,9 +11405,6 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ int __pyx_t_2; int __pyx_t_3; int __pyx_t_4; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__cinit__", 0); /* "View.MemoryView":346 @@ -10842,7 +11720,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal * def __dealloc__(memoryview self): * if self.obj is not None: # <<<<<<<<<<<<<< * __Pyx_ReleaseBuffer(&self.view) - * elif (<__pyx_buffer *> &self.view).obj == Py_None: + * */ __pyx_t_1 = (__pyx_v_self->obj != Py_None); __pyx_t_2 = (__pyx_t_1 != 0); @@ -10852,8 +11730,8 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal * def __dealloc__(memoryview self): * if self.obj is not None: * __Pyx_ReleaseBuffer(&self.view) # <<<<<<<<<<<<<< - * elif (<__pyx_buffer *> &self.view).obj == Py_None: * + * cdef int i */ __Pyx_ReleaseBuffer((&__pyx_v_self->view)); @@ -10862,50 +11740,11 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal * def __dealloc__(memoryview self): * if self.obj is not None: # <<<<<<<<<<<<<< * __Pyx_ReleaseBuffer(&self.view) - * elif (<__pyx_buffer *> &self.view).obj == Py_None: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":375 - * if self.obj is not None: - * __Pyx_ReleaseBuffer(&self.view) - * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<< * - * (<__pyx_buffer *> &self.view).obj = NULL - */ - __pyx_t_2 = ((((Py_buffer *)(&__pyx_v_self->view))->obj == Py_None) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":377 - * elif (<__pyx_buffer *> &self.view).obj == Py_None: - * - * (<__pyx_buffer *> &self.view).obj = NULL # <<<<<<<<<<<<<< - * Py_DECREF(Py_None) - * - */ - ((Py_buffer *)(&__pyx_v_self->view))->obj = NULL; - - /* "View.MemoryView":378 - * - * (<__pyx_buffer *> &self.view).obj = NULL - * Py_DECREF(Py_None) # <<<<<<<<<<<<<< - * - * cdef int i - */ - Py_DECREF(Py_None); - - /* "View.MemoryView":375 - * if self.obj is not None: - * __Pyx_ReleaseBuffer(&self.view) - * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<< - * - * (<__pyx_buffer *> &self.view).obj = NULL */ } - __pyx_L3:; - /* "View.MemoryView":382 + /* "View.MemoryView":378 * cdef int i * global __pyx_memoryview_thread_locks_used * if self.lock != NULL: # <<<<<<<<<<<<<< @@ -10915,7 +11754,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal __pyx_t_2 = ((__pyx_v_self->lock != NULL) != 0); if (__pyx_t_2) { - /* "View.MemoryView":383 + /* "View.MemoryView":379 * global __pyx_memoryview_thread_locks_used * if self.lock != NULL: * for i in range(__pyx_memoryview_thread_locks_used): # <<<<<<<<<<<<<< @@ -10927,7 +11766,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { __pyx_v_i = __pyx_t_5; - /* "View.MemoryView":384 + /* "View.MemoryView":380 * if self.lock != NULL: * for i in range(__pyx_memoryview_thread_locks_used): * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< @@ -10937,7 +11776,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal __pyx_t_2 = (((__pyx_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock) != 0); if (__pyx_t_2) { - /* "View.MemoryView":385 + /* "View.MemoryView":381 * for i in range(__pyx_memoryview_thread_locks_used): * if __pyx_memoryview_thread_locks[i] is self.lock: * __pyx_memoryview_thread_locks_used -= 1 # <<<<<<<<<<<<<< @@ -10946,7 +11785,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal */ __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used - 1); - /* "View.MemoryView":386 + /* "View.MemoryView":382 * if __pyx_memoryview_thread_locks[i] is self.lock: * __pyx_memoryview_thread_locks_used -= 1 * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< @@ -10956,7 +11795,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal __pyx_t_2 = ((__pyx_v_i != __pyx_memoryview_thread_locks_used) != 0); if (__pyx_t_2) { - /* "View.MemoryView":388 + /* "View.MemoryView":384 * if i != __pyx_memoryview_thread_locks_used: * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) # <<<<<<<<<<<<<< @@ -10966,7 +11805,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal __pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); __pyx_t_7 = (__pyx_memoryview_thread_locks[__pyx_v_i]); - /* "View.MemoryView":387 + /* "View.MemoryView":383 * __pyx_memoryview_thread_locks_used -= 1 * if i != __pyx_memoryview_thread_locks_used: * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( # <<<<<<<<<<<<<< @@ -10976,7 +11815,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal (__pyx_memoryview_thread_locks[__pyx_v_i]) = __pyx_t_6; (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_7; - /* "View.MemoryView":386 + /* "View.MemoryView":382 * if __pyx_memoryview_thread_locks[i] is self.lock: * __pyx_memoryview_thread_locks_used -= 1 * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< @@ -10985,7 +11824,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal */ } - /* "View.MemoryView":389 + /* "View.MemoryView":385 * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) * break # <<<<<<<<<<<<<< @@ -10994,7 +11833,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal */ goto __pyx_L6_break; - /* "View.MemoryView":384 + /* "View.MemoryView":380 * if self.lock != NULL: * for i in range(__pyx_memoryview_thread_locks_used): * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< @@ -11005,7 +11844,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal } /*else*/ { - /* "View.MemoryView":391 + /* "View.MemoryView":387 * break * else: * PyThread_free_lock(self.lock) # <<<<<<<<<<<<<< @@ -11016,7 +11855,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal } __pyx_L6_break:; - /* "View.MemoryView":382 + /* "View.MemoryView":378 * cdef int i * global __pyx_memoryview_thread_locks_used * if self.lock != NULL: # <<<<<<<<<<<<<< @@ -11037,7 +11876,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal __Pyx_RefNannyFinishContext(); } -/* "View.MemoryView":393 +/* "View.MemoryView":389 * PyThread_free_lock(self.lock) * * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< @@ -11058,12 +11897,9 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py PyObject *__pyx_t_5 = NULL; Py_ssize_t __pyx_t_6; char *__pyx_t_7; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_item_pointer", 0); - /* "View.MemoryView":395 + /* "View.MemoryView":391 * cdef char *get_item_pointer(memoryview self, object index) except NULL: * cdef Py_ssize_t dim * cdef char *itemp = self.view.buf # <<<<<<<<<<<<<< @@ -11072,7 +11908,7 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py */ __pyx_v_itemp = ((char *)__pyx_v_self->view.buf); - /* "View.MemoryView":397 + /* "View.MemoryView":393 * cdef char *itemp = self.view.buf * * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< @@ -11084,26 +11920,26 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py __pyx_t_2 = __pyx_v_index; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; __pyx_t_4 = NULL; } else { - __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 397, __pyx_L1_error) + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 393, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 397, __pyx_L1_error) + __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 393, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_4)) { if (likely(PyList_CheckExact(__pyx_t_2))) { if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(2, 397, __pyx_L1_error) + __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(2, 393, __pyx_L1_error) #else - __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 397, __pyx_L1_error) + __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 393, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #endif } else { if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(2, 397, __pyx_L1_error) + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(2, 393, __pyx_L1_error) #else - __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 397, __pyx_L1_error) + __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 393, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #endif } @@ -11113,7 +11949,7 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(2, 397, __pyx_L1_error) + else __PYX_ERR(2, 393, __pyx_L1_error) } break; } @@ -11124,18 +11960,18 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py __pyx_v_dim = __pyx_t_1; __pyx_t_1 = (__pyx_t_1 + 1); - /* "View.MemoryView":398 + /* "View.MemoryView":394 * * for dim, idx in enumerate(index): * itemp = pybuffer_index(&self.view, itemp, idx, dim) # <<<<<<<<<<<<<< * * return itemp */ - __pyx_t_6 = __Pyx_PyIndex_AsSsize_t(__pyx_v_idx); if (unlikely((__pyx_t_6 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 398, __pyx_L1_error) - __pyx_t_7 = __pyx_pybuffer_index((&__pyx_v_self->view), __pyx_v_itemp, __pyx_t_6, __pyx_v_dim); if (unlikely(__pyx_t_7 == ((char *)NULL))) __PYX_ERR(2, 398, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyIndex_AsSsize_t(__pyx_v_idx); if (unlikely((__pyx_t_6 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 394, __pyx_L1_error) + __pyx_t_7 = __pyx_pybuffer_index((&__pyx_v_self->view), __pyx_v_itemp, __pyx_t_6, __pyx_v_dim); if (unlikely(__pyx_t_7 == ((char *)NULL))) __PYX_ERR(2, 394, __pyx_L1_error) __pyx_v_itemp = __pyx_t_7; - /* "View.MemoryView":397 + /* "View.MemoryView":393 * cdef char *itemp = self.view.buf * * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< @@ -11145,7 +11981,7 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "View.MemoryView":400 + /* "View.MemoryView":396 * itemp = pybuffer_index(&self.view, itemp, idx, dim) * * return itemp # <<<<<<<<<<<<<< @@ -11155,7 +11991,7 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py __pyx_r = __pyx_v_itemp; goto __pyx_L0; - /* "View.MemoryView":393 + /* "View.MemoryView":389 * PyThread_free_lock(self.lock) * * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< @@ -11175,7 +12011,7 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py return __pyx_r; } -/* "View.MemoryView":403 +/* "View.MemoryView":399 * * * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< @@ -11208,12 +12044,9 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; char *__pyx_t_6; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__getitem__", 0); - /* "View.MemoryView":404 + /* "View.MemoryView":400 * * def __getitem__(memoryview self, object index): * if index is Ellipsis: # <<<<<<<<<<<<<< @@ -11224,7 +12057,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "View.MemoryView":405 + /* "View.MemoryView":401 * def __getitem__(memoryview self, object index): * if index is Ellipsis: * return self # <<<<<<<<<<<<<< @@ -11236,7 +12069,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; - /* "View.MemoryView":404 + /* "View.MemoryView":400 * * def __getitem__(memoryview self, object index): * if index is Ellipsis: # <<<<<<<<<<<<<< @@ -11245,14 +12078,14 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ */ } - /* "View.MemoryView":407 + /* "View.MemoryView":403 * return self * * have_slices, indices = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< * * cdef char *itemp */ - __pyx_t_3 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 407, __pyx_L1_error) + __pyx_t_3 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 403, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (likely(__pyx_t_3 != Py_None)) { PyObject* sequence = __pyx_t_3; @@ -11260,7 +12093,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(2, 407, __pyx_L1_error) + __PYX_ERR(2, 403, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); @@ -11268,31 +12101,31 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); #else - __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 407, __pyx_L1_error) + __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 403, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 407, __pyx_L1_error) + __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 403, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); #endif __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { - __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(2, 407, __pyx_L1_error) + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(2, 403, __pyx_L1_error) } __pyx_v_have_slices = __pyx_t_4; __pyx_t_4 = 0; __pyx_v_indices = __pyx_t_5; __pyx_t_5 = 0; - /* "View.MemoryView":410 + /* "View.MemoryView":406 * * cdef char *itemp * if have_slices: # <<<<<<<<<<<<<< * return memview_slice(self, indices) * else: */ - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(2, 410, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(2, 406, __pyx_L1_error) if (__pyx_t_2) { - /* "View.MemoryView":411 + /* "View.MemoryView":407 * cdef char *itemp * if have_slices: * return memview_slice(self, indices) # <<<<<<<<<<<<<< @@ -11300,13 +12133,13 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ * itemp = self.get_item_pointer(indices) */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 411, __pyx_L1_error) + __pyx_t_3 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 407, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; - /* "View.MemoryView":410 + /* "View.MemoryView":406 * * cdef char *itemp * if have_slices: # <<<<<<<<<<<<<< @@ -11315,7 +12148,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ */ } - /* "View.MemoryView":413 + /* "View.MemoryView":409 * return memview_slice(self, indices) * else: * itemp = self.get_item_pointer(indices) # <<<<<<<<<<<<<< @@ -11323,10 +12156,10 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ * */ /*else*/ { - __pyx_t_6 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_6 == ((char *)NULL))) __PYX_ERR(2, 413, __pyx_L1_error) + __pyx_t_6 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_6 == ((char *)NULL))) __PYX_ERR(2, 409, __pyx_L1_error) __pyx_v_itemp = __pyx_t_6; - /* "View.MemoryView":414 + /* "View.MemoryView":410 * else: * itemp = self.get_item_pointer(indices) * return self.convert_item_to_object(itemp) # <<<<<<<<<<<<<< @@ -11334,14 +12167,14 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ * def __setitem__(memoryview self, object index, object value): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 414, __pyx_L1_error) + __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 410, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; } - /* "View.MemoryView":403 + /* "View.MemoryView":399 * * * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< @@ -11364,7 +12197,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ return __pyx_r; } -/* "View.MemoryView":416 +/* "View.MemoryView":412 * return self.convert_item_to_object(itemp) * * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< @@ -11394,13 +12227,10 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setitem__", 0); __Pyx_INCREF(__pyx_v_index); - /* "View.MemoryView":417 + /* "View.MemoryView":413 * * def __setitem__(memoryview self, object index, object value): * if self.view.readonly: # <<<<<<<<<<<<<< @@ -11410,20 +12240,20 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit __pyx_t_1 = (__pyx_v_self->view.readonly != 0); if (unlikely(__pyx_t_1)) { - /* "View.MemoryView":418 + /* "View.MemoryView":414 * def __setitem__(memoryview self, object index, object value): * if self.view.readonly: * raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<< * * have_slices, index = _unellipsify(index, self.view.ndim) */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 418, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 414, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(2, 418, __pyx_L1_error) + __PYX_ERR(2, 414, __pyx_L1_error) - /* "View.MemoryView":417 + /* "View.MemoryView":413 * * def __setitem__(memoryview self, object index, object value): * if self.view.readonly: # <<<<<<<<<<<<<< @@ -11432,14 +12262,14 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit */ } - /* "View.MemoryView":420 + /* "View.MemoryView":416 * raise TypeError("Cannot assign to read-only memoryview") * * have_slices, index = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< * * if have_slices: */ - __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 420, __pyx_L1_error) + __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 416, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (likely(__pyx_t_2 != Py_None)) { PyObject* sequence = __pyx_t_2; @@ -11447,7 +12277,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(2, 420, __pyx_L1_error) + __PYX_ERR(2, 416, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); @@ -11455,67 +12285,67 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); #else - __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 420, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 416, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 420, __pyx_L1_error) + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 416, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { - __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(2, 420, __pyx_L1_error) + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(2, 416, __pyx_L1_error) } __pyx_v_have_slices = __pyx_t_3; __pyx_t_3 = 0; __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_4); __pyx_t_4 = 0; - /* "View.MemoryView":422 + /* "View.MemoryView":418 * have_slices, index = _unellipsify(index, self.view.ndim) * * if have_slices: # <<<<<<<<<<<<<< * obj = self.is_slice(value) * if obj: */ - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(2, 422, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(2, 418, __pyx_L1_error) if (__pyx_t_1) { - /* "View.MemoryView":423 + /* "View.MemoryView":419 * * if have_slices: * obj = self.is_slice(value) # <<<<<<<<<<<<<< * if obj: * self.setitem_slice_assignment(self[index], obj) */ - __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->is_slice(__pyx_v_self, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 423, __pyx_L1_error) + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->is_slice(__pyx_v_self, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 419, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_obj = __pyx_t_2; __pyx_t_2 = 0; - /* "View.MemoryView":424 + /* "View.MemoryView":420 * if have_slices: * obj = self.is_slice(value) * if obj: # <<<<<<<<<<<<<< * self.setitem_slice_assignment(self[index], obj) * else: */ - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_obj); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(2, 424, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_obj); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(2, 420, __pyx_L1_error) if (__pyx_t_1) { - /* "View.MemoryView":425 + /* "View.MemoryView":421 * obj = self.is_slice(value) * if obj: * self.setitem_slice_assignment(self[index], obj) # <<<<<<<<<<<<<< * else: * self.setitem_slice_assign_scalar(self[index], value) */ - __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 425, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 421, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assignment(__pyx_v_self, __pyx_t_2, __pyx_v_obj); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 425, __pyx_L1_error) + __pyx_t_4 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assignment(__pyx_v_self, __pyx_t_2, __pyx_v_obj); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 421, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "View.MemoryView":424 + /* "View.MemoryView":420 * if have_slices: * obj = self.is_slice(value) * if obj: # <<<<<<<<<<<<<< @@ -11525,7 +12355,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit goto __pyx_L5; } - /* "View.MemoryView":427 + /* "View.MemoryView":423 * self.setitem_slice_assignment(self[index], obj) * else: * self.setitem_slice_assign_scalar(self[index], value) # <<<<<<<<<<<<<< @@ -11533,17 +12363,17 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit * self.setitem_indexed(index, value) */ /*else*/ { - __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 427, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 423, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_memoryview_type))))) __PYX_ERR(2, 427, __pyx_L1_error) - __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_4), __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 427, __pyx_L1_error) + if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_memoryview_type))))) __PYX_ERR(2, 423, __pyx_L1_error) + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_4), __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 423, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_L5:; - /* "View.MemoryView":422 + /* "View.MemoryView":418 * have_slices, index = _unellipsify(index, self.view.ndim) * * if have_slices: # <<<<<<<<<<<<<< @@ -11553,7 +12383,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit goto __pyx_L4; } - /* "View.MemoryView":429 + /* "View.MemoryView":425 * self.setitem_slice_assign_scalar(self[index], value) * else: * self.setitem_indexed(index, value) # <<<<<<<<<<<<<< @@ -11561,13 +12391,13 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit * cdef is_slice(self, obj): */ /*else*/ { - __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 429, __pyx_L1_error) + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_L4:; - /* "View.MemoryView":416 + /* "View.MemoryView":412 * return self.convert_item_to_object(itemp) * * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< @@ -11592,7 +12422,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit return __pyx_r; } -/* "View.MemoryView":431 +/* "View.MemoryView":427 * self.setitem_indexed(index, value) * * cdef is_slice(self, obj): # <<<<<<<<<<<<<< @@ -11612,13 +12442,10 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_t_9; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("is_slice", 0); __Pyx_INCREF(__pyx_v_obj); - /* "View.MemoryView":432 + /* "View.MemoryView":428 * * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< @@ -11629,7 +12456,7 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_2) { - /* "View.MemoryView":433 + /* "View.MemoryView":429 * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): * try: # <<<<<<<<<<<<<< @@ -11645,34 +12472,34 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ __Pyx_XGOTREF(__pyx_t_5); /*try:*/ { - /* "View.MemoryView":434 + /* "View.MemoryView":430 * if not isinstance(obj, memoryview): * try: * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< * self.dtype_is_object) * except TypeError: */ - __pyx_t_6 = __Pyx_PyInt_From_int(((__pyx_v_self->flags & (~PyBUF_WRITABLE)) | PyBUF_ANY_CONTIGUOUS)); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 434, __pyx_L4_error) + __pyx_t_6 = __Pyx_PyInt_From_int(((__pyx_v_self->flags & (~PyBUF_WRITABLE)) | PyBUF_ANY_CONTIGUOUS)); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 430, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); - /* "View.MemoryView":435 + /* "View.MemoryView":431 * try: * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, * self.dtype_is_object) # <<<<<<<<<<<<<< * except TypeError: * return None */ - __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 435, __pyx_L4_error) + __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 431, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); - /* "View.MemoryView":434 + /* "View.MemoryView":430 * if not isinstance(obj, memoryview): * try: * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< * self.dtype_is_object) * except TypeError: */ - __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 434, __pyx_L4_error) + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 430, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_INCREF(__pyx_v_obj); __Pyx_GIVEREF(__pyx_v_obj); @@ -11683,13 +12510,13 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7); __pyx_t_6 = 0; __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 434, __pyx_L4_error) + __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 430, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF_SET(__pyx_v_obj, __pyx_t_7); __pyx_t_7 = 0; - /* "View.MemoryView":433 + /* "View.MemoryView":429 * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): * try: # <<<<<<<<<<<<<< @@ -11706,7 +12533,7 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "View.MemoryView":436 + /* "View.MemoryView":432 * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, * self.dtype_is_object) * except TypeError: # <<<<<<<<<<<<<< @@ -11716,12 +12543,12 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); if (__pyx_t_9) { __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_6) < 0) __PYX_ERR(2, 436, __pyx_L6_except_error) + if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_6) < 0) __PYX_ERR(2, 432, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_8); __Pyx_GOTREF(__pyx_t_6); - /* "View.MemoryView":437 + /* "View.MemoryView":433 * self.dtype_is_object) * except TypeError: * return None # <<<<<<<<<<<<<< @@ -11738,7 +12565,7 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ goto __pyx_L6_except_error; __pyx_L6_except_error:; - /* "View.MemoryView":433 + /* "View.MemoryView":429 * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): * try: # <<<<<<<<<<<<<< @@ -11759,7 +12586,7 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ __pyx_L9_try_end:; } - /* "View.MemoryView":432 + /* "View.MemoryView":428 * * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< @@ -11768,7 +12595,7 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ */ } - /* "View.MemoryView":439 + /* "View.MemoryView":435 * return None * * return obj # <<<<<<<<<<<<<< @@ -11780,7 +12607,7 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ __pyx_r = __pyx_v_obj; goto __pyx_L0; - /* "View.MemoryView":431 + /* "View.MemoryView":427 * self.setitem_indexed(index, value) * * cdef is_slice(self, obj): # <<<<<<<<<<<<<< @@ -11802,7 +12629,7 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ return __pyx_r; } -/* "View.MemoryView":441 +/* "View.MemoryView":437 * return obj * * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< @@ -11815,63 +12642,56 @@ static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryvi __Pyx_memviewslice __pyx_v_src_slice; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - __Pyx_memviewslice *__pyx_t_1; - __Pyx_memviewslice *__pyx_t_2; - PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; int __pyx_t_4; - int __pyx_t_5; - int __pyx_t_6; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("setitem_slice_assignment", 0); - /* "View.MemoryView":445 + /* "View.MemoryView":441 * cdef __Pyx_memviewslice src_slice * * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], # <<<<<<<<<<<<<< * get_slice_from_memview(dst, &dst_slice)[0], * src.ndim, dst.ndim, self.dtype_is_object) */ - if (!(likely(((__pyx_v_src) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_src, __pyx_memoryview_type))))) __PYX_ERR(2, 445, __pyx_L1_error) - __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_src), (&__pyx_v_src_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(2, 445, __pyx_L1_error) + if (!(likely(((__pyx_v_src) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_src, __pyx_memoryview_type))))) __PYX_ERR(2, 441, __pyx_L1_error) - /* "View.MemoryView":446 + /* "View.MemoryView":442 * * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], * get_slice_from_memview(dst, &dst_slice)[0], # <<<<<<<<<<<<<< * src.ndim, dst.ndim, self.dtype_is_object) * */ - if (!(likely(((__pyx_v_dst) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_dst, __pyx_memoryview_type))))) __PYX_ERR(2, 446, __pyx_L1_error) - __pyx_t_2 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice)); if (unlikely(__pyx_t_2 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(2, 446, __pyx_L1_error) + if (!(likely(((__pyx_v_dst) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_dst, __pyx_memoryview_type))))) __PYX_ERR(2, 442, __pyx_L1_error) - /* "View.MemoryView":447 + /* "View.MemoryView":443 * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], * get_slice_from_memview(dst, &dst_slice)[0], * src.ndim, dst.ndim, self.dtype_is_object) # <<<<<<<<<<<<<< * * cdef setitem_slice_assign_scalar(self, memoryview dst, value): */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 447, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 447, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_dst, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 447, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 447, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_n_s_ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 443, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 443, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dst, __pyx_n_s_ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 443, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 443, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "View.MemoryView":445 + /* "View.MemoryView":441 * cdef __Pyx_memviewslice src_slice * * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], # <<<<<<<<<<<<<< * get_slice_from_memview(dst, &dst_slice)[0], * src.ndim, dst.ndim, self.dtype_is_object) */ - __pyx_t_6 = __pyx_memoryview_copy_contents((__pyx_t_1[0]), (__pyx_t_2[0]), __pyx_t_4, __pyx_t_5, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(2, 445, __pyx_L1_error) + __pyx_t_4 = __pyx_memoryview_copy_contents((__pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_src), (&__pyx_v_src_slice))[0]), (__pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice))[0]), __pyx_t_2, __pyx_t_3, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 441, __pyx_L1_error) - /* "View.MemoryView":441 + /* "View.MemoryView":437 * return obj * * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< @@ -11883,7 +12703,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryvi __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assignment", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; @@ -11892,7 +12712,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryvi return __pyx_r; } -/* "View.MemoryView":449 +/* "View.MemoryView":445 * src.ndim, dst.ndim, self.dtype_is_object) * * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< @@ -11908,24 +12728,20 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor __Pyx_memviewslice __pyx_v_tmp_slice; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - __Pyx_memviewslice *__pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; int __pyx_t_4; - int __pyx_t_5; - char const *__pyx_t_6; + char const *__pyx_t_5; + PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; - PyObject *__pyx_t_12 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("setitem_slice_assign_scalar", 0); - /* "View.MemoryView":451 + /* "View.MemoryView":447 * cdef setitem_slice_assign_scalar(self, memoryview dst, value): * cdef int array[128] * cdef void *tmp = NULL # <<<<<<<<<<<<<< @@ -11934,27 +12750,26 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor */ __pyx_v_tmp = NULL; - /* "View.MemoryView":456 + /* "View.MemoryView":452 * cdef __Pyx_memviewslice *dst_slice * cdef __Pyx_memviewslice tmp_slice * dst_slice = get_slice_from_memview(dst, &tmp_slice) # <<<<<<<<<<<<<< * * if self.view.itemsize > sizeof(array): */ - __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_dst, (&__pyx_v_tmp_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(2, 456, __pyx_L1_error) - __pyx_v_dst_slice = __pyx_t_1; + __pyx_v_dst_slice = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_dst, (&__pyx_v_tmp_slice)); - /* "View.MemoryView":458 + /* "View.MemoryView":454 * dst_slice = get_slice_from_memview(dst, &tmp_slice) * * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< * tmp = PyMem_Malloc(self.view.itemsize) * if tmp == NULL: */ - __pyx_t_2 = ((((size_t)__pyx_v_self->view.itemsize) > (sizeof(__pyx_v_array))) != 0); - if (__pyx_t_2) { + __pyx_t_1 = ((((size_t)__pyx_v_self->view.itemsize) > (sizeof(__pyx_v_array))) != 0); + if (__pyx_t_1) { - /* "View.MemoryView":459 + /* "View.MemoryView":455 * * if self.view.itemsize > sizeof(array): * tmp = PyMem_Malloc(self.view.itemsize) # <<<<<<<<<<<<<< @@ -11963,26 +12778,26 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor */ __pyx_v_tmp = PyMem_Malloc(__pyx_v_self->view.itemsize); - /* "View.MemoryView":460 + /* "View.MemoryView":456 * if self.view.itemsize > sizeof(array): * tmp = PyMem_Malloc(self.view.itemsize) * if tmp == NULL: # <<<<<<<<<<<<<< * raise MemoryError * item = tmp */ - __pyx_t_2 = ((__pyx_v_tmp == NULL) != 0); - if (unlikely(__pyx_t_2)) { + __pyx_t_1 = ((__pyx_v_tmp == NULL) != 0); + if (unlikely(__pyx_t_1)) { - /* "View.MemoryView":461 + /* "View.MemoryView":457 * tmp = PyMem_Malloc(self.view.itemsize) * if tmp == NULL: * raise MemoryError # <<<<<<<<<<<<<< * item = tmp * else: */ - PyErr_NoMemory(); __PYX_ERR(2, 461, __pyx_L1_error) + PyErr_NoMemory(); __PYX_ERR(2, 457, __pyx_L1_error) - /* "View.MemoryView":460 + /* "View.MemoryView":456 * if self.view.itemsize > sizeof(array): * tmp = PyMem_Malloc(self.view.itemsize) * if tmp == NULL: # <<<<<<<<<<<<<< @@ -11991,7 +12806,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor */ } - /* "View.MemoryView":462 + /* "View.MemoryView":458 * if tmp == NULL: * raise MemoryError * item = tmp # <<<<<<<<<<<<<< @@ -12000,7 +12815,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor */ __pyx_v_item = __pyx_v_tmp; - /* "View.MemoryView":458 + /* "View.MemoryView":454 * dst_slice = get_slice_from_memview(dst, &tmp_slice) * * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< @@ -12010,7 +12825,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor goto __pyx_L3; } - /* "View.MemoryView":464 + /* "View.MemoryView":460 * item = tmp * else: * item = array # <<<<<<<<<<<<<< @@ -12022,7 +12837,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor } __pyx_L3:; - /* "View.MemoryView":466 + /* "View.MemoryView":462 * item = array * * try: # <<<<<<<<<<<<<< @@ -12031,17 +12846,17 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor */ /*try:*/ { - /* "View.MemoryView":467 + /* "View.MemoryView":463 * * try: * if self.dtype_is_object: # <<<<<<<<<<<<<< * ( item)[0] = value * else: */ - __pyx_t_2 = (__pyx_v_self->dtype_is_object != 0); - if (__pyx_t_2) { + __pyx_t_1 = (__pyx_v_self->dtype_is_object != 0); + if (__pyx_t_1) { - /* "View.MemoryView":468 + /* "View.MemoryView":464 * try: * if self.dtype_is_object: * ( item)[0] = value # <<<<<<<<<<<<<< @@ -12050,7 +12865,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor */ (((PyObject **)__pyx_v_item)[0]) = ((PyObject *)__pyx_v_value); - /* "View.MemoryView":467 + /* "View.MemoryView":463 * * try: * if self.dtype_is_object: # <<<<<<<<<<<<<< @@ -12060,7 +12875,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor goto __pyx_L8; } - /* "View.MemoryView":470 + /* "View.MemoryView":466 * ( item)[0] = value * else: * self.assign_item_from_object( item, value) # <<<<<<<<<<<<<< @@ -12068,34 +12883,34 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor * */ /*else*/ { - __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, ((char *)__pyx_v_item), __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 470, __pyx_L6_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, ((char *)__pyx_v_item), __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 466, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_L8:; - /* "View.MemoryView":474 + /* "View.MemoryView":470 * * * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, */ - __pyx_t_2 = ((__pyx_v_self->view.suboffsets != NULL) != 0); - if (__pyx_t_2) { + __pyx_t_1 = ((__pyx_v_self->view.suboffsets != NULL) != 0); + if (__pyx_t_1) { - /* "View.MemoryView":475 + /* "View.MemoryView":471 * * if self.view.suboffsets != NULL: * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) # <<<<<<<<<<<<<< * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, * item, self.dtype_is_object) */ - __pyx_t_3 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 475, __pyx_L6_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 471, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "View.MemoryView":474 + /* "View.MemoryView":470 * * * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< @@ -12104,7 +12919,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor */ } - /* "View.MemoryView":476 + /* "View.MemoryView":472 * if self.view.suboffsets != NULL: * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, # <<<<<<<<<<<<<< @@ -12114,7 +12929,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor __pyx_memoryview_slice_assign_scalar(__pyx_v_dst_slice, __pyx_v_dst->view.ndim, __pyx_v_self->view.itemsize, __pyx_v_item, __pyx_v_self->dtype_is_object); } - /* "View.MemoryView":479 + /* "View.MemoryView":475 * item, self.dtype_is_object) * finally: * PyMem_Free(tmp) # <<<<<<<<<<<<<< @@ -12130,38 +12945,38 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor /*exception exit:*/{ __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign - __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); - if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); + __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8) < 0)) __Pyx_ErrFetch(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_7); __Pyx_XGOTREF(__pyx_t_8); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); - __Pyx_XGOTREF(__pyx_t_12); - __pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename; + __pyx_t_3 = __pyx_lineno; __pyx_t_4 = __pyx_clineno; __pyx_t_5 = __pyx_filename; { PyMem_Free(__pyx_v_tmp); } if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); - __Pyx_XGIVEREF(__pyx_t_12); - __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); + __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); } + __Pyx_XGIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_8); - __Pyx_XGIVEREF(__pyx_t_9); - __Pyx_ErrRestore(__pyx_t_7, __pyx_t_8, __pyx_t_9); - __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; - __pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_5; __pyx_filename = __pyx_t_6; + __Pyx_ErrRestore(__pyx_t_6, __pyx_t_7, __pyx_t_8); + __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; + __pyx_lineno = __pyx_t_3; __pyx_clineno = __pyx_t_4; __pyx_filename = __pyx_t_5; goto __pyx_L1_error; } __pyx_L7:; } - /* "View.MemoryView":449 + /* "View.MemoryView":445 * src.ndim, dst.ndim, self.dtype_is_object) * * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< @@ -12173,7 +12988,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assign_scalar", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; @@ -12182,7 +12997,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor return __pyx_r; } -/* "View.MemoryView":481 +/* "View.MemoryView":477 * PyMem_Free(tmp) * * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< @@ -12196,33 +13011,30 @@ static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *_ __Pyx_RefNannyDeclarations char *__pyx_t_1; PyObject *__pyx_t_2 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("setitem_indexed", 0); - /* "View.MemoryView":482 + /* "View.MemoryView":478 * * cdef setitem_indexed(self, index, value): * cdef char *itemp = self.get_item_pointer(index) # <<<<<<<<<<<<<< * self.assign_item_from_object(itemp, value) * */ - __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_index); if (unlikely(__pyx_t_1 == ((char *)NULL))) __PYX_ERR(2, 482, __pyx_L1_error) + __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_index); if (unlikely(__pyx_t_1 == ((char *)NULL))) __PYX_ERR(2, 478, __pyx_L1_error) __pyx_v_itemp = __pyx_t_1; - /* "View.MemoryView":483 + /* "View.MemoryView":479 * cdef setitem_indexed(self, index, value): * cdef char *itemp = self.get_item_pointer(index) * self.assign_item_from_object(itemp, value) # <<<<<<<<<<<<<< * * cdef convert_item_to_object(self, char *itemp): */ - __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 483, __pyx_L1_error) + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 479, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "View.MemoryView":481 + /* "View.MemoryView":477 * PyMem_Free(tmp) * * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< @@ -12243,7 +13055,7 @@ static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *_ return __pyx_r; } -/* "View.MemoryView":485 +/* "View.MemoryView":481 * self.assign_item_from_object(itemp, value) * * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< @@ -12268,36 +13080,33 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview PyObject *__pyx_t_9 = NULL; size_t __pyx_t_10; int __pyx_t_11; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("convert_item_to_object", 0); - /* "View.MemoryView":488 + /* "View.MemoryView":484 * """Only used if instantiated manually by the user, or if Cython doesn't * know how to convert the type""" * import struct # <<<<<<<<<<<<<< * cdef bytes bytesitem * */ - __pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 488, __pyx_L1_error) + __pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 484, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_struct = __pyx_t_1; __pyx_t_1 = 0; - /* "View.MemoryView":491 + /* "View.MemoryView":487 * cdef bytes bytesitem * * bytesitem = itemp[:self.view.itemsize] # <<<<<<<<<<<<<< * try: * result = struct.unpack(self.view.format, bytesitem) */ - __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_itemp + 0, __pyx_v_self->view.itemsize - 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 491, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_itemp + 0, __pyx_v_self->view.itemsize - 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 487, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_bytesitem = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "View.MemoryView":492 + /* "View.MemoryView":488 * * bytesitem = itemp[:self.view.itemsize] * try: # <<<<<<<<<<<<<< @@ -12313,16 +13122,16 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { - /* "View.MemoryView":493 + /* "View.MemoryView":489 * bytesitem = itemp[:self.view.itemsize] * try: * result = struct.unpack(self.view.format, bytesitem) # <<<<<<<<<<<<<< * except struct.error: * raise ValueError("Unable to convert item to object") */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_unpack); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 493, __pyx_L3_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_unpack); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 489, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 493, __pyx_L3_error) + __pyx_t_6 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 489, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; @@ -12339,7 +13148,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 493, __pyx_L3_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 489, __pyx_L3_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; @@ -12348,14 +13157,14 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 493, __pyx_L3_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 489, __pyx_L3_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { - __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 493, __pyx_L3_error) + __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 489, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -12366,7 +13175,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview __Pyx_GIVEREF(__pyx_v_bytesitem); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_bytesitem); __pyx_t_6 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 493, __pyx_L3_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 489, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } @@ -12374,7 +13183,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview __pyx_v_result = __pyx_t_1; __pyx_t_1 = 0; - /* "View.MemoryView":492 + /* "View.MemoryView":488 * * bytesitem = itemp[:self.view.itemsize] * try: # <<<<<<<<<<<<<< @@ -12383,7 +13192,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview */ } - /* "View.MemoryView":497 + /* "View.MemoryView":493 * raise ValueError("Unable to convert item to object") * else: * if len(self.view.format) == 1: # <<<<<<<<<<<<<< @@ -12395,7 +13204,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview __pyx_t_11 = ((__pyx_t_10 == 1) != 0); if (__pyx_t_11) { - /* "View.MemoryView":498 + /* "View.MemoryView":494 * else: * if len(self.view.format) == 1: * return result[0] # <<<<<<<<<<<<<< @@ -12403,13 +13212,13 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_result, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 498, __pyx_L5_except_error) + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_result, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 494, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L6_except_return; - /* "View.MemoryView":497 + /* "View.MemoryView":493 * raise ValueError("Unable to convert item to object") * else: * if len(self.view.format) == 1: # <<<<<<<<<<<<<< @@ -12418,7 +13227,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview */ } - /* "View.MemoryView":499 + /* "View.MemoryView":495 * if len(self.view.format) == 1: * return result[0] * return result # <<<<<<<<<<<<<< @@ -12437,7 +13246,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "View.MemoryView":494 + /* "View.MemoryView":490 * try: * result = struct.unpack(self.view.format, bytesitem) * except struct.error: # <<<<<<<<<<<<<< @@ -12445,7 +13254,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview * else: */ __Pyx_ErrFetch(&__pyx_t_1, &__pyx_t_5, &__pyx_t_9); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 494, __pyx_L5_except_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 490, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; @@ -12453,28 +13262,28 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_9 = 0; if (__pyx_t_8) { __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(2, 494, __pyx_L5_except_error) + if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(2, 490, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_1); - /* "View.MemoryView":495 + /* "View.MemoryView":491 * result = struct.unpack(self.view.format, bytesitem) * except struct.error: * raise ValueError("Unable to convert item to object") # <<<<<<<<<<<<<< * else: * if len(self.view.format) == 1: */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 495, __pyx_L5_except_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 491, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(2, 495, __pyx_L5_except_error) + __PYX_ERR(2, 491, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; - /* "View.MemoryView":492 + /* "View.MemoryView":488 * * bytesitem = itemp[:self.view.itemsize] * try: # <<<<<<<<<<<<<< @@ -12494,7 +13303,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview goto __pyx_L0; } - /* "View.MemoryView":485 + /* "View.MemoryView":481 * self.assign_item_from_object(itemp, value) * * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< @@ -12520,7 +13329,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview return __pyx_r; } -/* "View.MemoryView":501 +/* "View.MemoryView":497 * return result * * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< @@ -12549,24 +13358,21 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie char *__pyx_t_12; char *__pyx_t_13; char *__pyx_t_14; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("assign_item_from_object", 0); - /* "View.MemoryView":504 + /* "View.MemoryView":500 * """Only used if instantiated manually by the user, or if Cython doesn't * know how to convert the type""" * import struct # <<<<<<<<<<<<<< * cdef char c * cdef bytes bytesvalue */ - __pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 504, __pyx_L1_error) + __pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 500, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_struct = __pyx_t_1; __pyx_t_1 = 0; - /* "View.MemoryView":509 + /* "View.MemoryView":505 * cdef Py_ssize_t i * * if isinstance(value, tuple): # <<<<<<<<<<<<<< @@ -12577,37 +13383,37 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "View.MemoryView":510 + /* "View.MemoryView":506 * * if isinstance(value, tuple): * bytesvalue = struct.pack(self.view.format, *value) # <<<<<<<<<<<<<< * else: * bytesvalue = struct.pack(self.view.format, value) */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 510, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 506, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 510, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 506, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 510, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 506, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 510, __pyx_L1_error) + __pyx_t_4 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 506, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 510, __pyx_L1_error) + __pyx_t_6 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 506, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 510, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 506, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(2, 510, __pyx_L1_error) + if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(2, 506, __pyx_L1_error) __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; - /* "View.MemoryView":509 + /* "View.MemoryView":505 * cdef Py_ssize_t i * * if isinstance(value, tuple): # <<<<<<<<<<<<<< @@ -12617,7 +13423,7 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie goto __pyx_L3; } - /* "View.MemoryView":512 + /* "View.MemoryView":508 * bytesvalue = struct.pack(self.view.format, *value) * else: * bytesvalue = struct.pack(self.view.format, value) # <<<<<<<<<<<<<< @@ -12625,9 +13431,9 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie * for i, c in enumerate(bytesvalue): */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 512, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 508, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 512, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 508, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = NULL; __pyx_t_7 = 0; @@ -12644,7 +13450,7 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value}; - __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 512, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 508, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -12653,14 +13459,14 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value}; - __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 512, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 508, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif { - __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 512, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 508, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; @@ -12671,18 +13477,18 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie __Pyx_GIVEREF(__pyx_v_value); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_value); __pyx_t_1 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 512, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 508, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(2, 512, __pyx_L1_error) + if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(2, 508, __pyx_L1_error) __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; } __pyx_L3:; - /* "View.MemoryView":514 + /* "View.MemoryView":510 * bytesvalue = struct.pack(self.view.format, value) * * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< @@ -12692,7 +13498,7 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie __pyx_t_9 = 0; if (unlikely(__pyx_v_bytesvalue == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable"); - __PYX_ERR(2, 514, __pyx_L1_error) + __PYX_ERR(2, 510, __pyx_L1_error) } __Pyx_INCREF(__pyx_v_bytesvalue); __pyx_t_10 = __pyx_v_bytesvalue; @@ -12702,7 +13508,7 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie __pyx_t_11 = __pyx_t_14; __pyx_v_c = (__pyx_t_11[0]); - /* "View.MemoryView":515 + /* "View.MemoryView":511 * * for i, c in enumerate(bytesvalue): * itemp[i] = c # <<<<<<<<<<<<<< @@ -12711,7 +13517,7 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie */ __pyx_v_i = __pyx_t_9; - /* "View.MemoryView":514 + /* "View.MemoryView":510 * bytesvalue = struct.pack(self.view.format, value) * * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< @@ -12720,7 +13526,7 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie */ __pyx_t_9 = (__pyx_t_9 + 1); - /* "View.MemoryView":515 + /* "View.MemoryView":511 * * for i, c in enumerate(bytesvalue): * itemp[i] = c # <<<<<<<<<<<<<< @@ -12731,7 +13537,7 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie } __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - /* "View.MemoryView":501 + /* "View.MemoryView":497 * return result * * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< @@ -12759,7 +13565,7 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie return __pyx_r; } -/* "View.MemoryView":518 +/* "View.MemoryView":514 * * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< @@ -12791,9 +13597,6 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu void *__pyx_t_6; int __pyx_t_7; Py_ssize_t __pyx_t_8; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; if (__pyx_v_info == NULL) { PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); return -1; @@ -12802,7 +13605,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); __Pyx_GIVEREF(__pyx_v_info->obj); - /* "View.MemoryView":519 + /* "View.MemoryView":515 * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< @@ -12820,20 +13623,20 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_L4_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "View.MemoryView":520 + /* "View.MemoryView":516 * def __getbuffer__(self, Py_buffer *info, int flags): * if flags & PyBUF_WRITABLE and self.view.readonly: * raise ValueError("Cannot create writable memory view from read-only memoryview") # <<<<<<<<<<<<<< * * if flags & PyBUF_ND: */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 520, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 516, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(2, 520, __pyx_L1_error) + __PYX_ERR(2, 516, __pyx_L1_error) - /* "View.MemoryView":519 + /* "View.MemoryView":515 * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< @@ -12842,7 +13645,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu */ } - /* "View.MemoryView":522 + /* "View.MemoryView":518 * raise ValueError("Cannot create writable memory view from read-only memoryview") * * if flags & PyBUF_ND: # <<<<<<<<<<<<<< @@ -12852,7 +13655,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0); if (__pyx_t_1) { - /* "View.MemoryView":523 + /* "View.MemoryView":519 * * if flags & PyBUF_ND: * info.shape = self.view.shape # <<<<<<<<<<<<<< @@ -12862,7 +13665,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_4 = __pyx_v_self->view.shape; __pyx_v_info->shape = __pyx_t_4; - /* "View.MemoryView":522 + /* "View.MemoryView":518 * raise ValueError("Cannot create writable memory view from read-only memoryview") * * if flags & PyBUF_ND: # <<<<<<<<<<<<<< @@ -12872,7 +13675,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu goto __pyx_L6; } - /* "View.MemoryView":525 + /* "View.MemoryView":521 * info.shape = self.view.shape * else: * info.shape = NULL # <<<<<<<<<<<<<< @@ -12884,7 +13687,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu } __pyx_L6:; - /* "View.MemoryView":527 + /* "View.MemoryView":523 * info.shape = NULL * * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< @@ -12894,7 +13697,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0); if (__pyx_t_1) { - /* "View.MemoryView":528 + /* "View.MemoryView":524 * * if flags & PyBUF_STRIDES: * info.strides = self.view.strides # <<<<<<<<<<<<<< @@ -12904,7 +13707,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_4 = __pyx_v_self->view.strides; __pyx_v_info->strides = __pyx_t_4; - /* "View.MemoryView":527 + /* "View.MemoryView":523 * info.shape = NULL * * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< @@ -12914,7 +13717,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu goto __pyx_L7; } - /* "View.MemoryView":530 + /* "View.MemoryView":526 * info.strides = self.view.strides * else: * info.strides = NULL # <<<<<<<<<<<<<< @@ -12926,7 +13729,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu } __pyx_L7:; - /* "View.MemoryView":532 + /* "View.MemoryView":528 * info.strides = NULL * * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< @@ -12936,7 +13739,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_1 = ((__pyx_v_flags & PyBUF_INDIRECT) != 0); if (__pyx_t_1) { - /* "View.MemoryView":533 + /* "View.MemoryView":529 * * if flags & PyBUF_INDIRECT: * info.suboffsets = self.view.suboffsets # <<<<<<<<<<<<<< @@ -12946,7 +13749,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_4 = __pyx_v_self->view.suboffsets; __pyx_v_info->suboffsets = __pyx_t_4; - /* "View.MemoryView":532 + /* "View.MemoryView":528 * info.strides = NULL * * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< @@ -12956,7 +13759,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu goto __pyx_L8; } - /* "View.MemoryView":535 + /* "View.MemoryView":531 * info.suboffsets = self.view.suboffsets * else: * info.suboffsets = NULL # <<<<<<<<<<<<<< @@ -12968,7 +13771,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu } __pyx_L8:; - /* "View.MemoryView":537 + /* "View.MemoryView":533 * info.suboffsets = NULL * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< @@ -12978,7 +13781,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); if (__pyx_t_1) { - /* "View.MemoryView":538 + /* "View.MemoryView":534 * * if flags & PyBUF_FORMAT: * info.format = self.view.format # <<<<<<<<<<<<<< @@ -12988,7 +13791,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_5 = __pyx_v_self->view.format; __pyx_v_info->format = __pyx_t_5; - /* "View.MemoryView":537 + /* "View.MemoryView":533 * info.suboffsets = NULL * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< @@ -12998,7 +13801,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu goto __pyx_L9; } - /* "View.MemoryView":540 + /* "View.MemoryView":536 * info.format = self.view.format * else: * info.format = NULL # <<<<<<<<<<<<<< @@ -13010,7 +13813,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu } __pyx_L9:; - /* "View.MemoryView":542 + /* "View.MemoryView":538 * info.format = NULL * * info.buf = self.view.buf # <<<<<<<<<<<<<< @@ -13020,7 +13823,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_6 = __pyx_v_self->view.buf; __pyx_v_info->buf = __pyx_t_6; - /* "View.MemoryView":543 + /* "View.MemoryView":539 * * info.buf = self.view.buf * info.ndim = self.view.ndim # <<<<<<<<<<<<<< @@ -13030,7 +13833,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_7 = __pyx_v_self->view.ndim; __pyx_v_info->ndim = __pyx_t_7; - /* "View.MemoryView":544 + /* "View.MemoryView":540 * info.buf = self.view.buf * info.ndim = self.view.ndim * info.itemsize = self.view.itemsize # <<<<<<<<<<<<<< @@ -13040,7 +13843,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_8 = __pyx_v_self->view.itemsize; __pyx_v_info->itemsize = __pyx_t_8; - /* "View.MemoryView":545 + /* "View.MemoryView":541 * info.ndim = self.view.ndim * info.itemsize = self.view.itemsize * info.len = self.view.len # <<<<<<<<<<<<<< @@ -13050,7 +13853,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_8 = __pyx_v_self->view.len; __pyx_v_info->len = __pyx_t_8; - /* "View.MemoryView":546 + /* "View.MemoryView":542 * info.itemsize = self.view.itemsize * info.len = self.view.len * info.readonly = self.view.readonly # <<<<<<<<<<<<<< @@ -13060,7 +13863,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_1 = __pyx_v_self->view.readonly; __pyx_v_info->readonly = __pyx_t_1; - /* "View.MemoryView":547 + /* "View.MemoryView":543 * info.len = self.view.len * info.readonly = self.view.readonly * info.obj = self # <<<<<<<<<<<<<< @@ -13073,7 +13876,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = ((PyObject *)__pyx_v_self); - /* "View.MemoryView":518 + /* "View.MemoryView":514 * * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< @@ -13103,7 +13906,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu return __pyx_r; } -/* "View.MemoryView":553 +/* "View.MemoryView":549 * * @property * def T(self): # <<<<<<<<<<<<<< @@ -13130,34 +13933,31 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct _ __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "View.MemoryView":554 + /* "View.MemoryView":550 * @property * def T(self): * cdef _memoryviewslice result = memoryview_copy(self) # <<<<<<<<<<<<<< * transpose_memslice(&result.from_slice) * return result */ - __pyx_t_1 = __pyx_memoryview_copy_object(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 554, __pyx_L1_error) + __pyx_t_1 = __pyx_memoryview_copy_object(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 550, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_memoryviewslice_type))))) __PYX_ERR(2, 554, __pyx_L1_error) + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_memoryviewslice_type))))) __PYX_ERR(2, 550, __pyx_L1_error) __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_1); __pyx_t_1 = 0; - /* "View.MemoryView":555 + /* "View.MemoryView":551 * def T(self): * cdef _memoryviewslice result = memoryview_copy(self) * transpose_memslice(&result.from_slice) # <<<<<<<<<<<<<< * return result * */ - __pyx_t_2 = __pyx_memslice_transpose((&__pyx_v_result->from_slice)); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(2, 555, __pyx_L1_error) + __pyx_t_2 = __pyx_memslice_transpose((&__pyx_v_result->from_slice)); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(2, 551, __pyx_L1_error) - /* "View.MemoryView":556 + /* "View.MemoryView":552 * cdef _memoryviewslice result = memoryview_copy(self) * transpose_memslice(&result.from_slice) * return result # <<<<<<<<<<<<<< @@ -13169,7 +13969,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct _ __pyx_r = ((PyObject *)__pyx_v_result); goto __pyx_L0; - /* "View.MemoryView":553 + /* "View.MemoryView":549 * * @property * def T(self): # <<<<<<<<<<<<<< @@ -13189,7 +13989,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct _ return __pyx_r; } -/* "View.MemoryView":559 +/* "View.MemoryView":555 * * @property * def base(self): # <<<<<<<<<<<<<< @@ -13215,7 +14015,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struc __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); - /* "View.MemoryView":560 + /* "View.MemoryView":556 * @property * def base(self): * return self.obj # <<<<<<<<<<<<<< @@ -13227,7 +14027,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struc __pyx_r = __pyx_v_self->obj; goto __pyx_L0; - /* "View.MemoryView":559 + /* "View.MemoryView":555 * * @property * def base(self): # <<<<<<<<<<<<<< @@ -13242,7 +14042,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struc return __pyx_r; } -/* "View.MemoryView":563 +/* "View.MemoryView":559 * * @property * def shape(self): # <<<<<<<<<<<<<< @@ -13272,12 +14072,9 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(stru Py_ssize_t *__pyx_t_3; Py_ssize_t *__pyx_t_4; PyObject *__pyx_t_5 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "View.MemoryView":564 + /* "View.MemoryView":560 * @property * def shape(self): * return tuple([length for length in self.view.shape[:self.view.ndim]]) # <<<<<<<<<<<<<< @@ -13285,25 +14082,25 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(stru * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 564, __pyx_L1_error) + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 560, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); for (__pyx_t_4 = __pyx_v_self->view.shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { __pyx_t_2 = __pyx_t_4; __pyx_v_length = (__pyx_t_2[0]); - __pyx_t_5 = PyInt_FromSsize_t(__pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 564, __pyx_L1_error) + __pyx_t_5 = PyInt_FromSsize_t(__pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 560, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 564, __pyx_L1_error) + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 560, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - __pyx_t_5 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 564, __pyx_L1_error) + __pyx_t_5 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 560, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; - /* "View.MemoryView":563 + /* "View.MemoryView":559 * * @property * def shape(self): # <<<<<<<<<<<<<< @@ -13323,7 +14120,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(stru return __pyx_r; } -/* "View.MemoryView":567 +/* "View.MemoryView":563 * * @property * def strides(self): # <<<<<<<<<<<<<< @@ -13354,12 +14151,9 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(st Py_ssize_t *__pyx_t_4; Py_ssize_t *__pyx_t_5; PyObject *__pyx_t_6 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "View.MemoryView":568 + /* "View.MemoryView":564 * @property * def strides(self): * if self.view.strides == NULL: # <<<<<<<<<<<<<< @@ -13369,20 +14163,20 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(st __pyx_t_1 = ((__pyx_v_self->view.strides == NULL) != 0); if (unlikely(__pyx_t_1)) { - /* "View.MemoryView":570 + /* "View.MemoryView":566 * if self.view.strides == NULL: * * raise ValueError("Buffer view does not expose strides") # <<<<<<<<<<<<<< * * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 570, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 566, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(2, 570, __pyx_L1_error) + __PYX_ERR(2, 566, __pyx_L1_error) - /* "View.MemoryView":568 + /* "View.MemoryView":564 * @property * def strides(self): * if self.view.strides == NULL: # <<<<<<<<<<<<<< @@ -13391,7 +14185,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(st */ } - /* "View.MemoryView":572 + /* "View.MemoryView":568 * raise ValueError("Buffer view does not expose strides") * * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) # <<<<<<<<<<<<<< @@ -13399,25 +14193,25 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(st * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 572, __pyx_L1_error) + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 568, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = (__pyx_v_self->view.strides + __pyx_v_self->view.ndim); for (__pyx_t_5 = __pyx_v_self->view.strides; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { __pyx_t_3 = __pyx_t_5; __pyx_v_stride = (__pyx_t_3[0]); - __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_stride); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 572, __pyx_L1_error) + __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_stride); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 568, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(2, 572, __pyx_L1_error) + if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(2, 568, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } - __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 572, __pyx_L1_error) + __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 568, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "View.MemoryView":567 + /* "View.MemoryView":563 * * @property * def strides(self): # <<<<<<<<<<<<<< @@ -13437,7 +14231,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(st return __pyx_r; } -/* "View.MemoryView":575 +/* "View.MemoryView":571 * * @property * def suboffsets(self): # <<<<<<<<<<<<<< @@ -13468,12 +14262,9 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get_ Py_ssize_t *__pyx_t_4; Py_ssize_t *__pyx_t_5; Py_ssize_t *__pyx_t_6; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "View.MemoryView":576 + /* "View.MemoryView":572 * @property * def suboffsets(self): * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< @@ -13483,7 +14274,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get_ __pyx_t_1 = ((__pyx_v_self->view.suboffsets == NULL) != 0); if (__pyx_t_1) { - /* "View.MemoryView":577 + /* "View.MemoryView":573 * def suboffsets(self): * if self.view.suboffsets == NULL: * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< @@ -13491,16 +14282,16 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get_ * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 577, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 573, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyNumber_Multiply(__pyx_tuple__17, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 577, __pyx_L1_error) + __pyx_t_3 = PyNumber_Multiply(__pyx_tuple__19, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 573, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; - /* "View.MemoryView":576 + /* "View.MemoryView":572 * @property * def suboffsets(self): * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< @@ -13509,7 +14300,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get_ */ } - /* "View.MemoryView":579 + /* "View.MemoryView":575 * return (-1,) * self.view.ndim * * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) # <<<<<<<<<<<<<< @@ -13517,25 +14308,25 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get_ * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 579, __pyx_L1_error) + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 575, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = (__pyx_v_self->view.suboffsets + __pyx_v_self->view.ndim); for (__pyx_t_6 = __pyx_v_self->view.suboffsets; __pyx_t_6 < __pyx_t_5; __pyx_t_6++) { __pyx_t_4 = __pyx_t_6; __pyx_v_suboffset = (__pyx_t_4[0]); - __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_suboffset); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 579, __pyx_L1_error) + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_suboffset); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 575, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_2))) __PYX_ERR(2, 579, __pyx_L1_error) + if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_2))) __PYX_ERR(2, 575, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } - __pyx_t_2 = PyList_AsTuple(((PyObject*)__pyx_t_3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 579, __pyx_L1_error) + __pyx_t_2 = PyList_AsTuple(((PyObject*)__pyx_t_3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 575, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "View.MemoryView":575 + /* "View.MemoryView":571 * * @property * def suboffsets(self): # <<<<<<<<<<<<<< @@ -13555,7 +14346,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get_ return __pyx_r; } -/* "View.MemoryView":582 +/* "View.MemoryView":578 * * @property * def ndim(self): # <<<<<<<<<<<<<< @@ -13580,12 +14371,9 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struc PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "View.MemoryView":583 + /* "View.MemoryView":579 * @property * def ndim(self): * return self.view.ndim # <<<<<<<<<<<<<< @@ -13593,13 +14381,13 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struc * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 583, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "View.MemoryView":582 + /* "View.MemoryView":578 * * @property * def ndim(self): # <<<<<<<<<<<<<< @@ -13618,7 +14406,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struc return __pyx_r; } -/* "View.MemoryView":586 +/* "View.MemoryView":582 * * @property * def itemsize(self): # <<<<<<<<<<<<<< @@ -13643,12 +14431,9 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(s PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "View.MemoryView":587 + /* "View.MemoryView":583 * @property * def itemsize(self): * return self.view.itemsize # <<<<<<<<<<<<<< @@ -13656,13 +14441,13 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(s * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 587, __pyx_L1_error) + __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 583, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "View.MemoryView":586 + /* "View.MemoryView":582 * * @property * def itemsize(self): # <<<<<<<<<<<<<< @@ -13681,7 +14466,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(s return __pyx_r; } -/* "View.MemoryView":590 +/* "View.MemoryView":586 * * @property * def nbytes(self): # <<<<<<<<<<<<<< @@ -13708,12 +14493,9 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(str PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "View.MemoryView":591 + /* "View.MemoryView":587 * @property * def nbytes(self): * return self.size * self.view.itemsize # <<<<<<<<<<<<<< @@ -13721,11 +14503,11 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(str * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 591, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 587, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 591, __pyx_L1_error) + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 587, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 591, __pyx_L1_error) + __pyx_t_3 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 587, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -13733,7 +14515,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(str __pyx_t_3 = 0; goto __pyx_L0; - /* "View.MemoryView":590 + /* "View.MemoryView":586 * * @property * def nbytes(self): # <<<<<<<<<<<<<< @@ -13754,7 +14536,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(str return __pyx_r; } -/* "View.MemoryView":594 +/* "View.MemoryView":590 * * @property * def size(self): # <<<<<<<<<<<<<< @@ -13786,12 +14568,9 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc Py_ssize_t *__pyx_t_4; Py_ssize_t *__pyx_t_5; PyObject *__pyx_t_6 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "View.MemoryView":595 + /* "View.MemoryView":591 * @property * def size(self): * if self._size is None: # <<<<<<<<<<<<<< @@ -13802,7 +14581,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "View.MemoryView":596 + /* "View.MemoryView":592 * def size(self): * if self._size is None: * result = 1 # <<<<<<<<<<<<<< @@ -13812,7 +14591,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc __Pyx_INCREF(__pyx_int_1); __pyx_v_result = __pyx_int_1; - /* "View.MemoryView":598 + /* "View.MemoryView":594 * result = 1 * * for length in self.view.shape[:self.view.ndim]: # <<<<<<<<<<<<<< @@ -13822,25 +14601,25 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc __pyx_t_4 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); for (__pyx_t_5 = __pyx_v_self->view.shape; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { __pyx_t_3 = __pyx_t_5; - __pyx_t_6 = PyInt_FromSsize_t((__pyx_t_3[0])); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 598, __pyx_L1_error) + __pyx_t_6 = PyInt_FromSsize_t((__pyx_t_3[0])); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 594, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_6); __pyx_t_6 = 0; - /* "View.MemoryView":599 + /* "View.MemoryView":595 * * for length in self.view.shape[:self.view.ndim]: * result *= length # <<<<<<<<<<<<<< * * self._size = result */ - __pyx_t_6 = PyNumber_InPlaceMultiply(__pyx_v_result, __pyx_v_length); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 599, __pyx_L1_error) + __pyx_t_6 = PyNumber_InPlaceMultiply(__pyx_v_result, __pyx_v_length); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 595, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_6); __pyx_t_6 = 0; } - /* "View.MemoryView":601 + /* "View.MemoryView":597 * result *= length * * self._size = result # <<<<<<<<<<<<<< @@ -13853,7 +14632,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc __Pyx_DECREF(__pyx_v_self->_size); __pyx_v_self->_size = __pyx_v_result; - /* "View.MemoryView":595 + /* "View.MemoryView":591 * @property * def size(self): * if self._size is None: # <<<<<<<<<<<<<< @@ -13862,7 +14641,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc */ } - /* "View.MemoryView":603 + /* "View.MemoryView":599 * self._size = result * * return self._size # <<<<<<<<<<<<<< @@ -13874,7 +14653,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc __pyx_r = __pyx_v_self->_size; goto __pyx_L0; - /* "View.MemoryView":594 + /* "View.MemoryView":590 * * @property * def size(self): # <<<<<<<<<<<<<< @@ -13895,7 +14674,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc return __pyx_r; } -/* "View.MemoryView":605 +/* "View.MemoryView":601 * return self._size * * def __len__(self): # <<<<<<<<<<<<<< @@ -13922,7 +14701,7 @@ static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_1 int __pyx_t_1; __Pyx_RefNannySetupContext("__len__", 0); - /* "View.MemoryView":606 + /* "View.MemoryView":602 * * def __len__(self): * if self.view.ndim >= 1: # <<<<<<<<<<<<<< @@ -13932,7 +14711,7 @@ static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_1 __pyx_t_1 = ((__pyx_v_self->view.ndim >= 1) != 0); if (__pyx_t_1) { - /* "View.MemoryView":607 + /* "View.MemoryView":603 * def __len__(self): * if self.view.ndim >= 1: * return self.view.shape[0] # <<<<<<<<<<<<<< @@ -13942,7 +14721,7 @@ static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_1 __pyx_r = (__pyx_v_self->view.shape[0]); goto __pyx_L0; - /* "View.MemoryView":606 + /* "View.MemoryView":602 * * def __len__(self): * if self.view.ndim >= 1: # <<<<<<<<<<<<<< @@ -13951,7 +14730,7 @@ static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_1 */ } - /* "View.MemoryView":609 + /* "View.MemoryView":605 * return self.view.shape[0] * * return 0 # <<<<<<<<<<<<<< @@ -13961,7 +14740,7 @@ static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_1 __pyx_r = 0; goto __pyx_L0; - /* "View.MemoryView":605 + /* "View.MemoryView":601 * return self._size * * def __len__(self): # <<<<<<<<<<<<<< @@ -13975,7 +14754,7 @@ static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_1 return __pyx_r; } -/* "View.MemoryView":611 +/* "View.MemoryView":607 * return 0 * * def __repr__(self): # <<<<<<<<<<<<<< @@ -14002,12 +14781,9 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12 PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__repr__", 0); - /* "View.MemoryView":612 + /* "View.MemoryView":608 * * def __repr__(self): * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< @@ -14015,33 +14791,33 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12 * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 612, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 608, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 612, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 608, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 612, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 608, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "View.MemoryView":613 + /* "View.MemoryView":609 * def __repr__(self): * return "" % (self.base.__class__.__name__, * id(self)) # <<<<<<<<<<<<<< * * def __str__(self): */ - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 613, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 609, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "View.MemoryView":612 + /* "View.MemoryView":608 * * def __repr__(self): * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< * id(self)) * */ - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 612, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 608, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); @@ -14049,14 +14825,14 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12 PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); __pyx_t_1 = 0; __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 612, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 608, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "View.MemoryView":611 + /* "View.MemoryView":607 * return 0 * * def __repr__(self): # <<<<<<<<<<<<<< @@ -14077,7 +14853,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12 return __pyx_r; } -/* "View.MemoryView":615 +/* "View.MemoryView":611 * id(self)) * * def __str__(self): # <<<<<<<<<<<<<< @@ -14103,12 +14879,9 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14 __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__str__", 0); - /* "View.MemoryView":616 + /* "View.MemoryView":612 * * def __str__(self): * return "" % (self.base.__class__.__name__,) # <<<<<<<<<<<<<< @@ -14116,27 +14889,27 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14 * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 616, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 612, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 616, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 612, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 616, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 612, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 616, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 612, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_object, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 616, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_object, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 612, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "View.MemoryView":615 + /* "View.MemoryView":611 * id(self)) * * def __str__(self): # <<<<<<<<<<<<<< @@ -14156,7 +14929,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14 return __pyx_r; } -/* "View.MemoryView":619 +/* "View.MemoryView":615 * * * def is_c_contig(self): # <<<<<<<<<<<<<< @@ -14182,24 +14955,19 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16 __Pyx_memviewslice __pyx_v_tmp; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - __Pyx_memviewslice *__pyx_t_1; - PyObject *__pyx_t_2 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; + PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("is_c_contig", 0); - /* "View.MemoryView":622 + /* "View.MemoryView":618 * cdef __Pyx_memviewslice *mslice * cdef __Pyx_memviewslice tmp * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<< * return slice_is_contig(mslice[0], 'C', self.view.ndim) * */ - __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(2, 622, __pyx_L1_error) - __pyx_v_mslice = __pyx_t_1; + __pyx_v_mslice = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); - /* "View.MemoryView":623 + /* "View.MemoryView":619 * cdef __Pyx_memviewslice tmp * mslice = get_slice_from_memview(self, &tmp) * return slice_is_contig(mslice[0], 'C', self.view.ndim) # <<<<<<<<<<<<<< @@ -14207,13 +14975,13 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16 * def is_f_contig(self): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'C', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 623, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'C', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 619, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; goto __pyx_L0; - /* "View.MemoryView":619 + /* "View.MemoryView":615 * * * def is_c_contig(self): # <<<<<<<<<<<<<< @@ -14223,7 +14991,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16 /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.memoryview.is_c_contig", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -14232,7 +15000,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16 return __pyx_r; } -/* "View.MemoryView":625 +/* "View.MemoryView":621 * return slice_is_contig(mslice[0], 'C', self.view.ndim) * * def is_f_contig(self): # <<<<<<<<<<<<<< @@ -14258,24 +15026,19 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18 __Pyx_memviewslice __pyx_v_tmp; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - __Pyx_memviewslice *__pyx_t_1; - PyObject *__pyx_t_2 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; + PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("is_f_contig", 0); - /* "View.MemoryView":628 + /* "View.MemoryView":624 * cdef __Pyx_memviewslice *mslice * cdef __Pyx_memviewslice tmp * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<< * return slice_is_contig(mslice[0], 'F', self.view.ndim) * */ - __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(2, 628, __pyx_L1_error) - __pyx_v_mslice = __pyx_t_1; + __pyx_v_mslice = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); - /* "View.MemoryView":629 + /* "View.MemoryView":625 * cdef __Pyx_memviewslice tmp * mslice = get_slice_from_memview(self, &tmp) * return slice_is_contig(mslice[0], 'F', self.view.ndim) # <<<<<<<<<<<<<< @@ -14283,13 +15046,13 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18 * def copy(self): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'F', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 629, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'F', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; goto __pyx_L0; - /* "View.MemoryView":625 + /* "View.MemoryView":621 * return slice_is_contig(mslice[0], 'C', self.view.ndim) * * def is_f_contig(self): # <<<<<<<<<<<<<< @@ -14299,7 +15062,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18 /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("View.MemoryView.memoryview.is_f_contig", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -14308,7 +15071,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18 return __pyx_r; } -/* "View.MemoryView":631 +/* "View.MemoryView":627 * return slice_is_contig(mslice[0], 'F', self.view.ndim) * * def copy(self): # <<<<<<<<<<<<<< @@ -14336,12 +15099,9 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20 __Pyx_RefNannyDeclarations __Pyx_memviewslice __pyx_t_1; PyObject *__pyx_t_2 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("copy", 0); - /* "View.MemoryView":633 + /* "View.MemoryView":629 * def copy(self): * cdef __Pyx_memviewslice mslice * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS # <<<<<<<<<<<<<< @@ -14350,7 +15110,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20 */ __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_F_CONTIGUOUS)); - /* "View.MemoryView":635 + /* "View.MemoryView":631 * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS * * slice_copy(self, &mslice) # <<<<<<<<<<<<<< @@ -14359,17 +15119,17 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20 */ __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_mslice)); - /* "View.MemoryView":636 + /* "View.MemoryView":632 * * slice_copy(self, &mslice) * mslice = slice_copy_contig(&mslice, "c", self.view.ndim, # <<<<<<<<<<<<<< * self.view.itemsize, * flags|PyBUF_C_CONTIGUOUS, */ - __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_mslice), ((char *)"c"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_C_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 636, __pyx_L1_error) + __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_mslice), ((char *)"c"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_C_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 632, __pyx_L1_error) __pyx_v_mslice = __pyx_t_1; - /* "View.MemoryView":641 + /* "View.MemoryView":637 * self.dtype_is_object) * * return memoryview_copy_from_slice(self, &mslice) # <<<<<<<<<<<<<< @@ -14377,13 +15137,13 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20 * def copy_fortran(self): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_mslice)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 641, __pyx_L1_error) + __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_mslice)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 637, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "View.MemoryView":631 + /* "View.MemoryView":627 * return slice_is_contig(mslice[0], 'F', self.view.ndim) * * def copy(self): # <<<<<<<<<<<<<< @@ -14402,7 +15162,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20 return __pyx_r; } -/* "View.MemoryView":643 +/* "View.MemoryView":639 * return memoryview_copy_from_slice(self, &mslice) * * def copy_fortran(self): # <<<<<<<<<<<<<< @@ -14431,12 +15191,9 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22 __Pyx_RefNannyDeclarations __Pyx_memviewslice __pyx_t_1; PyObject *__pyx_t_2 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("copy_fortran", 0); - /* "View.MemoryView":645 + /* "View.MemoryView":641 * def copy_fortran(self): * cdef __Pyx_memviewslice src, dst * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS # <<<<<<<<<<<<<< @@ -14445,7 +15202,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22 */ __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_C_CONTIGUOUS)); - /* "View.MemoryView":647 + /* "View.MemoryView":643 * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS * * slice_copy(self, &src) # <<<<<<<<<<<<<< @@ -14454,17 +15211,17 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22 */ __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_src)); - /* "View.MemoryView":648 + /* "View.MemoryView":644 * * slice_copy(self, &src) * dst = slice_copy_contig(&src, "fortran", self.view.ndim, # <<<<<<<<<<<<<< * self.view.itemsize, * flags|PyBUF_F_CONTIGUOUS, */ - __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_src), ((char *)"fortran"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_F_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 648, __pyx_L1_error) + __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_src), ((char *)"fortran"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_F_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 644, __pyx_L1_error) __pyx_v_dst = __pyx_t_1; - /* "View.MemoryView":653 + /* "View.MemoryView":649 * self.dtype_is_object) * * return memoryview_copy_from_slice(self, &dst) # <<<<<<<<<<<<<< @@ -14472,13 +15229,13 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22 * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_dst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 653, __pyx_L1_error) + __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_dst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 649, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "View.MemoryView":643 + /* "View.MemoryView":639 * return memoryview_copy_from_slice(self, &mslice) * * def copy_fortran(self): # <<<<<<<<<<<<<< @@ -14520,9 +15277,6 @@ static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struc PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 @@ -14531,7 +15285,7 @@ static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struc * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__20, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -14577,9 +15331,6 @@ static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED st PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 @@ -14587,7 +15338,7 @@ static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED st * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__19, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -14610,7 +15361,7 @@ static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED st return __pyx_r; } -/* "View.MemoryView":657 +/* "View.MemoryView":653 * * @cname('__pyx_memoryview_new') * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<< @@ -14625,23 +15376,20 @@ static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, in PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("memoryview_cwrapper", 0); - /* "View.MemoryView":658 + /* "View.MemoryView":654 * @cname('__pyx_memoryview_new') * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): * cdef memoryview result = memoryview(o, flags, dtype_is_object) # <<<<<<<<<<<<<< * result.typeinfo = typeinfo * return result */ - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 658, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 654, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 658, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 654, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 658, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 654, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_o); __Pyx_GIVEREF(__pyx_v_o); @@ -14652,13 +15400,13 @@ static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, in PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); __pyx_t_1 = 0; __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 658, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 654, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_result = ((struct __pyx_memoryview_obj *)__pyx_t_2); __pyx_t_2 = 0; - /* "View.MemoryView":659 + /* "View.MemoryView":655 * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): * cdef memoryview result = memoryview(o, flags, dtype_is_object) * result.typeinfo = typeinfo # <<<<<<<<<<<<<< @@ -14667,7 +15415,7 @@ static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, in */ __pyx_v_result->typeinfo = __pyx_v_typeinfo; - /* "View.MemoryView":660 + /* "View.MemoryView":656 * cdef memoryview result = memoryview(o, flags, dtype_is_object) * result.typeinfo = typeinfo * return result # <<<<<<<<<<<<<< @@ -14679,7 +15427,7 @@ static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, in __pyx_r = ((PyObject *)__pyx_v_result); goto __pyx_L0; - /* "View.MemoryView":657 + /* "View.MemoryView":653 * * @cname('__pyx_memoryview_new') * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<< @@ -14701,7 +15449,7 @@ static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, in return __pyx_r; } -/* "View.MemoryView":663 +/* "View.MemoryView":659 * * @cname('__pyx_memoryview_check') * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< @@ -14715,7 +15463,7 @@ static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) { int __pyx_t_1; __Pyx_RefNannySetupContext("memoryview_check", 0); - /* "View.MemoryView":664 + /* "View.MemoryView":660 * @cname('__pyx_memoryview_check') * cdef inline bint memoryview_check(object o): * return isinstance(o, memoryview) # <<<<<<<<<<<<<< @@ -14726,7 +15474,7 @@ static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) { __pyx_r = __pyx_t_1; goto __pyx_L0; - /* "View.MemoryView":663 + /* "View.MemoryView":659 * * @cname('__pyx_memoryview_check') * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< @@ -14740,7 +15488,7 @@ static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) { return __pyx_r; } -/* "View.MemoryView":666 +/* "View.MemoryView":662 * return isinstance(o, memoryview) * * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< @@ -14769,12 +15517,9 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { int __pyx_t_9; int __pyx_t_10; PyObject *__pyx_t_11 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_unellipsify", 0); - /* "View.MemoryView":671 + /* "View.MemoryView":667 * full slices. * """ * if not isinstance(index, tuple): # <<<<<<<<<<<<<< @@ -14785,14 +15530,14 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_2) { - /* "View.MemoryView":672 + /* "View.MemoryView":668 * """ * if not isinstance(index, tuple): * tup = (index,) # <<<<<<<<<<<<<< * else: * tup = index */ - __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 672, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 668, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_index); __Pyx_GIVEREF(__pyx_v_index); @@ -14800,7 +15545,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __pyx_v_tup = __pyx_t_3; __pyx_t_3 = 0; - /* "View.MemoryView":671 + /* "View.MemoryView":667 * full slices. * """ * if not isinstance(index, tuple): # <<<<<<<<<<<<<< @@ -14810,7 +15555,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { goto __pyx_L3; } - /* "View.MemoryView":674 + /* "View.MemoryView":670 * tup = (index,) * else: * tup = index # <<<<<<<<<<<<<< @@ -14823,19 +15568,19 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { } __pyx_L3:; - /* "View.MemoryView":676 + /* "View.MemoryView":672 * tup = index * * result = [] # <<<<<<<<<<<<<< * have_slices = False * seen_ellipsis = False */ - __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 676, __pyx_L1_error) + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 672, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_result = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; - /* "View.MemoryView":677 + /* "View.MemoryView":673 * * result = [] * have_slices = False # <<<<<<<<<<<<<< @@ -14844,7 +15589,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { */ __pyx_v_have_slices = 0; - /* "View.MemoryView":678 + /* "View.MemoryView":674 * result = [] * have_slices = False * seen_ellipsis = False # <<<<<<<<<<<<<< @@ -14853,7 +15598,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { */ __pyx_v_seen_ellipsis = 0; - /* "View.MemoryView":679 + /* "View.MemoryView":675 * have_slices = False * seen_ellipsis = False * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< @@ -14866,26 +15611,26 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __pyx_t_4 = __pyx_v_tup; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0; __pyx_t_6 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_v_tup); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 679, __pyx_L1_error) + __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_v_tup); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 675, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 679, __pyx_L1_error) + __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 675, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_6)) { if (likely(PyList_CheckExact(__pyx_t_4))) { if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_7 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(2, 679, __pyx_L1_error) + __pyx_t_7 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(2, 675, __pyx_L1_error) #else - __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 679, __pyx_L1_error) + __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 675, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #endif } else { if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_4)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(2, 679, __pyx_L1_error) + __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(2, 675, __pyx_L1_error) #else - __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 679, __pyx_L1_error) + __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 675, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #endif } @@ -14895,7 +15640,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(2, 679, __pyx_L1_error) + else __PYX_ERR(2, 675, __pyx_L1_error) } break; } @@ -14905,13 +15650,13 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __pyx_t_7 = 0; __Pyx_INCREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_3); - __pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 679, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 675, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = __pyx_t_7; __pyx_t_7 = 0; - /* "View.MemoryView":680 + /* "View.MemoryView":676 * seen_ellipsis = False * for idx, item in enumerate(tup): * if item is Ellipsis: # <<<<<<<<<<<<<< @@ -14922,7 +15667,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "View.MemoryView":681 + /* "View.MemoryView":677 * for idx, item in enumerate(tup): * if item is Ellipsis: * if not seen_ellipsis: # <<<<<<<<<<<<<< @@ -14932,27 +15677,27 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __pyx_t_1 = ((!(__pyx_v_seen_ellipsis != 0)) != 0); if (__pyx_t_1) { - /* "View.MemoryView":682 + /* "View.MemoryView":678 * if item is Ellipsis: * if not seen_ellipsis: * result.extend([slice(None)] * (ndim - len(tup) + 1)) # <<<<<<<<<<<<<< * seen_ellipsis = True * else: */ - __pyx_t_8 = PyObject_Length(__pyx_v_tup); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(2, 682, __pyx_L1_error) - __pyx_t_7 = PyList_New(1 * ((((__pyx_v_ndim - __pyx_t_8) + 1)<0) ? 0:((__pyx_v_ndim - __pyx_t_8) + 1))); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 682, __pyx_L1_error) + __pyx_t_8 = PyObject_Length(__pyx_v_tup); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(2, 678, __pyx_L1_error) + __pyx_t_7 = PyList_New(1 * ((((__pyx_v_ndim - __pyx_t_8) + 1)<0) ? 0:((__pyx_v_ndim - __pyx_t_8) + 1))); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 678, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < ((__pyx_v_ndim - __pyx_t_8) + 1); __pyx_temp++) { - __Pyx_INCREF(__pyx_slice__20); - __Pyx_GIVEREF(__pyx_slice__20); - PyList_SET_ITEM(__pyx_t_7, __pyx_temp, __pyx_slice__20); + __Pyx_INCREF(__pyx_slice__22); + __Pyx_GIVEREF(__pyx_slice__22); + PyList_SET_ITEM(__pyx_t_7, __pyx_temp, __pyx_slice__22); } } - __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_7); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 682, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_7); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 678, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - /* "View.MemoryView":683 + /* "View.MemoryView":679 * if not seen_ellipsis: * result.extend([slice(None)] * (ndim - len(tup) + 1)) * seen_ellipsis = True # <<<<<<<<<<<<<< @@ -14961,7 +15706,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { */ __pyx_v_seen_ellipsis = 1; - /* "View.MemoryView":681 + /* "View.MemoryView":677 * for idx, item in enumerate(tup): * if item is Ellipsis: * if not seen_ellipsis: # <<<<<<<<<<<<<< @@ -14971,7 +15716,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { goto __pyx_L7; } - /* "View.MemoryView":685 + /* "View.MemoryView":681 * seen_ellipsis = True * else: * result.append(slice(None)) # <<<<<<<<<<<<<< @@ -14979,11 +15724,11 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { * else: */ /*else*/ { - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_slice__20); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 685, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_slice__22); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 681, __pyx_L1_error) } __pyx_L7:; - /* "View.MemoryView":686 + /* "View.MemoryView":682 * else: * result.append(slice(None)) * have_slices = True # <<<<<<<<<<<<<< @@ -14992,7 +15737,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { */ __pyx_v_have_slices = 1; - /* "View.MemoryView":680 + /* "View.MemoryView":676 * seen_ellipsis = False * for idx, item in enumerate(tup): * if item is Ellipsis: # <<<<<<<<<<<<<< @@ -15002,7 +15747,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { goto __pyx_L6; } - /* "View.MemoryView":688 + /* "View.MemoryView":684 * have_slices = True * else: * if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<< @@ -15022,23 +15767,23 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __pyx_L9_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "View.MemoryView":689 + /* "View.MemoryView":685 * else: * if not isinstance(item, slice) and not PyIndex_Check(item): * raise TypeError("Cannot index with type '%s'" % type(item)) # <<<<<<<<<<<<<< * * have_slices = have_slices or isinstance(item, slice) */ - __pyx_t_7 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Cannot_index_with_type_s, ((PyObject *)Py_TYPE(__pyx_v_item))); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 689, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Cannot_index_with_type_s, ((PyObject *)Py_TYPE(__pyx_v_item))); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_7); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 689, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_7); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_11, 0, 0, 0); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __PYX_ERR(2, 689, __pyx_L1_error) + __PYX_ERR(2, 685, __pyx_L1_error) - /* "View.MemoryView":688 + /* "View.MemoryView":684 * have_slices = True * else: * if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<< @@ -15047,7 +15792,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { */ } - /* "View.MemoryView":691 + /* "View.MemoryView":687 * raise TypeError("Cannot index with type '%s'" % type(item)) * * have_slices = have_slices or isinstance(item, slice) # <<<<<<<<<<<<<< @@ -15066,18 +15811,18 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __pyx_L11_bool_binop_done:; __pyx_v_have_slices = __pyx_t_1; - /* "View.MemoryView":692 + /* "View.MemoryView":688 * * have_slices = have_slices or isinstance(item, slice) * result.append(item) # <<<<<<<<<<<<<< * * nslices = ndim - len(result) */ - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_v_item); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 692, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_v_item); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 688, __pyx_L1_error) } __pyx_L6:; - /* "View.MemoryView":679 + /* "View.MemoryView":675 * have_slices = False * seen_ellipsis = False * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< @@ -15088,17 +15833,17 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "View.MemoryView":694 + /* "View.MemoryView":690 * result.append(item) * * nslices = ndim - len(result) # <<<<<<<<<<<<<< * if nslices: * result.extend([slice(None)] * nslices) */ - __pyx_t_5 = PyList_GET_SIZE(__pyx_v_result); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(2, 694, __pyx_L1_error) + __pyx_t_5 = PyList_GET_SIZE(__pyx_v_result); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(2, 690, __pyx_L1_error) __pyx_v_nslices = (__pyx_v_ndim - __pyx_t_5); - /* "View.MemoryView":695 + /* "View.MemoryView":691 * * nslices = ndim - len(result) * if nslices: # <<<<<<<<<<<<<< @@ -15108,26 +15853,26 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __pyx_t_1 = (__pyx_v_nslices != 0); if (__pyx_t_1) { - /* "View.MemoryView":696 + /* "View.MemoryView":692 * nslices = ndim - len(result) * if nslices: * result.extend([slice(None)] * nslices) # <<<<<<<<<<<<<< * * return have_slices or nslices, tuple(result) */ - __pyx_t_3 = PyList_New(1 * ((__pyx_v_nslices<0) ? 0:__pyx_v_nslices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 696, __pyx_L1_error) + __pyx_t_3 = PyList_New(1 * ((__pyx_v_nslices<0) ? 0:__pyx_v_nslices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 692, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); { Py_ssize_t __pyx_temp; for (__pyx_temp=0; __pyx_temp < __pyx_v_nslices; __pyx_temp++) { - __Pyx_INCREF(__pyx_slice__20); - __Pyx_GIVEREF(__pyx_slice__20); - PyList_SET_ITEM(__pyx_t_3, __pyx_temp, __pyx_slice__20); + __Pyx_INCREF(__pyx_slice__22); + __Pyx_GIVEREF(__pyx_slice__22); + PyList_SET_ITEM(__pyx_t_3, __pyx_temp, __pyx_slice__22); } } - __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 696, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 692, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "View.MemoryView":695 + /* "View.MemoryView":691 * * nslices = ndim - len(result) * if nslices: # <<<<<<<<<<<<<< @@ -15136,7 +15881,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { */ } - /* "View.MemoryView":698 + /* "View.MemoryView":694 * result.extend([slice(None)] * nslices) * * return have_slices or nslices, tuple(result) # <<<<<<<<<<<<<< @@ -15146,20 +15891,20 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __Pyx_XDECREF(__pyx_r); if (!__pyx_v_have_slices) { } else { - __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_have_slices); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 698, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_have_slices); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 694, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L14_bool_binop_done; } - __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_nslices); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 698, __pyx_L1_error) + __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_nslices); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 694, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __pyx_t_4; __pyx_t_4 = 0; __pyx_L14_bool_binop_done:; - __pyx_t_4 = PyList_AsTuple(__pyx_v_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 698, __pyx_L1_error) + __pyx_t_4 = PyList_AsTuple(__pyx_v_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 694, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 698, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 694, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_3); @@ -15171,7 +15916,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __pyx_t_11 = 0; goto __pyx_L0; - /* "View.MemoryView":666 + /* "View.MemoryView":662 * return isinstance(o, memoryview) * * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< @@ -15197,7 +15942,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { return __pyx_r; } -/* "View.MemoryView":700 +/* "View.MemoryView":696 * return have_slices or nslices, tuple(result) * * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< @@ -15214,12 +15959,9 @@ static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __ Py_ssize_t *__pyx_t_3; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("assert_direct_dimensions", 0); - /* "View.MemoryView":701 + /* "View.MemoryView":697 * * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): * for suboffset in suboffsets[:ndim]: # <<<<<<<<<<<<<< @@ -15231,7 +15973,7 @@ static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __ __pyx_t_1 = __pyx_t_3; __pyx_v_suboffset = (__pyx_t_1[0]); - /* "View.MemoryView":702 + /* "View.MemoryView":698 * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: # <<<<<<<<<<<<<< @@ -15241,20 +15983,20 @@ static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __ __pyx_t_4 = ((__pyx_v_suboffset >= 0) != 0); if (unlikely(__pyx_t_4)) { - /* "View.MemoryView":703 + /* "View.MemoryView":699 * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: * raise ValueError("Indirect dimensions not supported") # <<<<<<<<<<<<<< * * */ - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 703, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 699, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __PYX_ERR(2, 703, __pyx_L1_error) + __PYX_ERR(2, 699, __pyx_L1_error) - /* "View.MemoryView":702 + /* "View.MemoryView":698 * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: # <<<<<<<<<<<<<< @@ -15264,7 +16006,7 @@ static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __ } } - /* "View.MemoryView":700 + /* "View.MemoryView":696 * return have_slices or nslices, tuple(result) * * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< @@ -15285,7 +16027,7 @@ static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __ return __pyx_r; } -/* "View.MemoryView":710 +/* "View.MemoryView":706 * * @cname('__pyx_memview_slice') * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< @@ -15324,12 +16066,9 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ Py_ssize_t __pyx_t_10; int __pyx_t_11; Py_ssize_t __pyx_t_12; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("memview_slice", 0); - /* "View.MemoryView":711 + /* "View.MemoryView":707 * @cname('__pyx_memview_slice') * cdef memoryview memview_slice(memoryview memview, object indices): * cdef int new_ndim = 0, suboffset_dim = -1, dim # <<<<<<<<<<<<<< @@ -15339,7 +16078,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_v_new_ndim = 0; __pyx_v_suboffset_dim = -1; - /* "View.MemoryView":718 + /* "View.MemoryView":714 * * * memset(&dst, 0, sizeof(dst)) # <<<<<<<<<<<<<< @@ -15348,7 +16087,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ (void)(memset((&__pyx_v_dst), 0, (sizeof(__pyx_v_dst)))); - /* "View.MemoryView":722 + /* "View.MemoryView":718 * cdef _memoryviewslice memviewsliceobj * * assert memview.view.ndim > 0 # <<<<<<<<<<<<<< @@ -15359,12 +16098,12 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_memview->view.ndim > 0) != 0))) { PyErr_SetNone(PyExc_AssertionError); - __PYX_ERR(2, 722, __pyx_L1_error) + __PYX_ERR(2, 718, __pyx_L1_error) } } #endif - /* "View.MemoryView":724 + /* "View.MemoryView":720 * assert memview.view.ndim > 0 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< @@ -15375,20 +16114,20 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "View.MemoryView":725 + /* "View.MemoryView":721 * * if isinstance(memview, _memoryviewslice): * memviewsliceobj = memview # <<<<<<<<<<<<<< * p_src = &memviewsliceobj.from_slice * else: */ - if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(2, 725, __pyx_L1_error) + if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(2, 721, __pyx_L1_error) __pyx_t_3 = ((PyObject *)__pyx_v_memview); __Pyx_INCREF(__pyx_t_3); __pyx_v_memviewsliceobj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3); __pyx_t_3 = 0; - /* "View.MemoryView":726 + /* "View.MemoryView":722 * if isinstance(memview, _memoryviewslice): * memviewsliceobj = memview * p_src = &memviewsliceobj.from_slice # <<<<<<<<<<<<<< @@ -15397,7 +16136,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ __pyx_v_p_src = (&__pyx_v_memviewsliceobj->from_slice); - /* "View.MemoryView":724 + /* "View.MemoryView":720 * assert memview.view.ndim > 0 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< @@ -15407,7 +16146,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ goto __pyx_L3; } - /* "View.MemoryView":728 + /* "View.MemoryView":724 * p_src = &memviewsliceobj.from_slice * else: * slice_copy(memview, &src) # <<<<<<<<<<<<<< @@ -15417,7 +16156,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ /*else*/ { __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_src)); - /* "View.MemoryView":729 + /* "View.MemoryView":725 * else: * slice_copy(memview, &src) * p_src = &src # <<<<<<<<<<<<<< @@ -15428,7 +16167,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ } __pyx_L3:; - /* "View.MemoryView":735 + /* "View.MemoryView":731 * * * dst.memview = p_src.memview # <<<<<<<<<<<<<< @@ -15438,7 +16177,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_t_4 = __pyx_v_p_src->memview; __pyx_v_dst.memview = __pyx_t_4; - /* "View.MemoryView":736 + /* "View.MemoryView":732 * * dst.memview = p_src.memview * dst.data = p_src.data # <<<<<<<<<<<<<< @@ -15448,7 +16187,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_t_5 = __pyx_v_p_src->data; __pyx_v_dst.data = __pyx_t_5; - /* "View.MemoryView":741 + /* "View.MemoryView":737 * * * cdef __Pyx_memviewslice *p_dst = &dst # <<<<<<<<<<<<<< @@ -15457,7 +16196,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ __pyx_v_p_dst = (&__pyx_v_dst); - /* "View.MemoryView":742 + /* "View.MemoryView":738 * * cdef __Pyx_memviewslice *p_dst = &dst * cdef int *p_suboffset_dim = &suboffset_dim # <<<<<<<<<<<<<< @@ -15466,7 +16205,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ __pyx_v_p_suboffset_dim = (&__pyx_v_suboffset_dim); - /* "View.MemoryView":746 + /* "View.MemoryView":742 * cdef bint have_start, have_stop, have_step * * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< @@ -15478,26 +16217,26 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_t_3 = __pyx_v_indices; __Pyx_INCREF(__pyx_t_3); __pyx_t_7 = 0; __pyx_t_8 = NULL; } else { - __pyx_t_7 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_indices); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 746, __pyx_L1_error) + __pyx_t_7 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_indices); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 742, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 746, __pyx_L1_error) + __pyx_t_8 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 742, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_8)) { if (likely(PyList_CheckExact(__pyx_t_3))) { if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_9 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(2, 746, __pyx_L1_error) + __pyx_t_9 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(2, 742, __pyx_L1_error) #else - __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 746, __pyx_L1_error) + __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 742, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); #endif } else { if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_9 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(2, 746, __pyx_L1_error) + __pyx_t_9 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(2, 742, __pyx_L1_error) #else - __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 746, __pyx_L1_error) + __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 742, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); #endif } @@ -15507,7 +16246,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(2, 746, __pyx_L1_error) + else __PYX_ERR(2, 742, __pyx_L1_error) } break; } @@ -15518,7 +16257,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_v_dim = __pyx_t_6; __pyx_t_6 = (__pyx_t_6 + 1); - /* "View.MemoryView":747 + /* "View.MemoryView":743 * * for dim, index in enumerate(indices): * if PyIndex_Check(index): # <<<<<<<<<<<<<< @@ -15528,25 +16267,25 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_t_2 = (PyIndex_Check(__pyx_v_index) != 0); if (__pyx_t_2) { - /* "View.MemoryView":751 + /* "View.MemoryView":747 * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], * dim, new_ndim, p_suboffset_dim, * index, 0, 0, # start, stop, step # <<<<<<<<<<<<<< * 0, 0, 0, # have_{start,stop,step} * False) */ - __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_index); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 751, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_index); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 747, __pyx_L1_error) - /* "View.MemoryView":748 + /* "View.MemoryView":744 * for dim, index in enumerate(indices): * if PyIndex_Check(index): * slice_memviewslice( # <<<<<<<<<<<<<< * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], * dim, new_ndim, p_suboffset_dim, */ - __pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_t_10, 0, 0, 0, 0, 0, 0); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 748, __pyx_L1_error) + __pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_t_10, 0, 0, 0, 0, 0, 0); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 744, __pyx_L1_error) - /* "View.MemoryView":747 + /* "View.MemoryView":743 * * for dim, index in enumerate(indices): * if PyIndex_Check(index): # <<<<<<<<<<<<<< @@ -15556,7 +16295,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ goto __pyx_L6; } - /* "View.MemoryView":754 + /* "View.MemoryView":750 * 0, 0, 0, # have_{start,stop,step} * False) * elif index is None: # <<<<<<<<<<<<<< @@ -15567,7 +16306,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "View.MemoryView":755 + /* "View.MemoryView":751 * False) * elif index is None: * p_dst.shape[new_ndim] = 1 # <<<<<<<<<<<<<< @@ -15576,7 +16315,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ (__pyx_v_p_dst->shape[__pyx_v_new_ndim]) = 1; - /* "View.MemoryView":756 + /* "View.MemoryView":752 * elif index is None: * p_dst.shape[new_ndim] = 1 * p_dst.strides[new_ndim] = 0 # <<<<<<<<<<<<<< @@ -15585,7 +16324,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ (__pyx_v_p_dst->strides[__pyx_v_new_ndim]) = 0; - /* "View.MemoryView":757 + /* "View.MemoryView":753 * p_dst.shape[new_ndim] = 1 * p_dst.strides[new_ndim] = 0 * p_dst.suboffsets[new_ndim] = -1 # <<<<<<<<<<<<<< @@ -15594,7 +16333,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ (__pyx_v_p_dst->suboffsets[__pyx_v_new_ndim]) = -1L; - /* "View.MemoryView":758 + /* "View.MemoryView":754 * p_dst.strides[new_ndim] = 0 * p_dst.suboffsets[new_ndim] = -1 * new_ndim += 1 # <<<<<<<<<<<<<< @@ -15603,7 +16342,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); - /* "View.MemoryView":754 + /* "View.MemoryView":750 * 0, 0, 0, # have_{start,stop,step} * False) * elif index is None: # <<<<<<<<<<<<<< @@ -15613,7 +16352,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ goto __pyx_L6; } - /* "View.MemoryView":760 + /* "View.MemoryView":756 * new_ndim += 1 * else: * start = index.start or 0 # <<<<<<<<<<<<<< @@ -15621,13 +16360,13 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ * step = index.step or 0 */ /*else*/ { - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 760, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 756, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(2, 760, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(2, 756, __pyx_L1_error) if (!__pyx_t_1) { __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } else { - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 760, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 756, __pyx_L1_error) __pyx_t_10 = __pyx_t_12; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L7_bool_binop_done; @@ -15636,20 +16375,20 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_L7_bool_binop_done:; __pyx_v_start = __pyx_t_10; - /* "View.MemoryView":761 + /* "View.MemoryView":757 * else: * start = index.start or 0 * stop = index.stop or 0 # <<<<<<<<<<<<<< * step = index.step or 0 * */ - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 761, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 757, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(2, 761, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(2, 757, __pyx_L1_error) if (!__pyx_t_1) { __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } else { - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 761, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 757, __pyx_L1_error) __pyx_t_10 = __pyx_t_12; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L9_bool_binop_done; @@ -15658,20 +16397,20 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_L9_bool_binop_done:; __pyx_v_stop = __pyx_t_10; - /* "View.MemoryView":762 + /* "View.MemoryView":758 * start = index.start or 0 * stop = index.stop or 0 * step = index.step or 0 # <<<<<<<<<<<<<< * * have_start = index.start is not None */ - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 762, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 758, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(2, 762, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(2, 758, __pyx_L1_error) if (!__pyx_t_1) { __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } else { - __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 762, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 758, __pyx_L1_error) __pyx_t_10 = __pyx_t_12; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L11_bool_binop_done; @@ -15680,55 +16419,55 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_L11_bool_binop_done:; __pyx_v_step = __pyx_t_10; - /* "View.MemoryView":764 + /* "View.MemoryView":760 * step = index.step or 0 * * have_start = index.start is not None # <<<<<<<<<<<<<< * have_stop = index.stop is not None * have_step = index.step is not None */ - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 764, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 760, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_1 = (__pyx_t_9 != Py_None); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_v_have_start = __pyx_t_1; - /* "View.MemoryView":765 + /* "View.MemoryView":761 * * have_start = index.start is not None * have_stop = index.stop is not None # <<<<<<<<<<<<<< * have_step = index.step is not None * */ - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 765, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 761, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_1 = (__pyx_t_9 != Py_None); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_v_have_stop = __pyx_t_1; - /* "View.MemoryView":766 + /* "View.MemoryView":762 * have_start = index.start is not None * have_stop = index.stop is not None * have_step = index.step is not None # <<<<<<<<<<<<<< * * slice_memviewslice( */ - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 766, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 762, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_1 = (__pyx_t_9 != Py_None); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_v_have_step = __pyx_t_1; - /* "View.MemoryView":768 + /* "View.MemoryView":764 * have_step = index.step is not None * * slice_memviewslice( # <<<<<<<<<<<<<< * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], * dim, new_ndim, p_suboffset_dim, */ - __pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_v_start, __pyx_v_stop, __pyx_v_step, __pyx_v_have_start, __pyx_v_have_stop, __pyx_v_have_step, 1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 768, __pyx_L1_error) + __pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_v_start, __pyx_v_stop, __pyx_v_step, __pyx_v_have_start, __pyx_v_have_stop, __pyx_v_have_step, 1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(2, 764, __pyx_L1_error) - /* "View.MemoryView":774 + /* "View.MemoryView":770 * have_start, have_stop, have_step, * True) * new_ndim += 1 # <<<<<<<<<<<<<< @@ -15739,7 +16478,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ } __pyx_L6:; - /* "View.MemoryView":746 + /* "View.MemoryView":742 * cdef bint have_start, have_stop, have_step * * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< @@ -15749,7 +16488,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "View.MemoryView":776 + /* "View.MemoryView":772 * new_ndim += 1 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< @@ -15760,7 +16499,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "View.MemoryView":777 + /* "View.MemoryView":773 * * if isinstance(memview, _memoryviewslice): * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< @@ -15769,39 +16508,39 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ __Pyx_XDECREF(((PyObject *)__pyx_r)); - /* "View.MemoryView":778 + /* "View.MemoryView":774 * if isinstance(memview, _memoryviewslice): * return memoryview_fromslice(dst, new_ndim, * memviewsliceobj.to_object_func, # <<<<<<<<<<<<<< * memviewsliceobj.to_dtype_func, * memview.dtype_is_object) */ - if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(2, 778, __pyx_L1_error) } + if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(2, 774, __pyx_L1_error) } - /* "View.MemoryView":779 + /* "View.MemoryView":775 * return memoryview_fromslice(dst, new_ndim, * memviewsliceobj.to_object_func, * memviewsliceobj.to_dtype_func, # <<<<<<<<<<<<<< * memview.dtype_is_object) * else: */ - if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(2, 779, __pyx_L1_error) } + if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(2, 775, __pyx_L1_error) } - /* "View.MemoryView":777 + /* "View.MemoryView":773 * * if isinstance(memview, _memoryviewslice): * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< * memviewsliceobj.to_object_func, * memviewsliceobj.to_dtype_func, */ - __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, __pyx_v_memviewsliceobj->to_object_func, __pyx_v_memviewsliceobj->to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 777, __pyx_L1_error) + __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, __pyx_v_memviewsliceobj->to_object_func, __pyx_v_memviewsliceobj->to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 773, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(2, 777, __pyx_L1_error) + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(2, 773, __pyx_L1_error) __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L0; - /* "View.MemoryView":776 + /* "View.MemoryView":772 * new_ndim += 1 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< @@ -15810,7 +16549,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ } - /* "View.MemoryView":782 + /* "View.MemoryView":778 * memview.dtype_is_object) * else: * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< @@ -15820,30 +16559,30 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ /*else*/ { __Pyx_XDECREF(((PyObject *)__pyx_r)); - /* "View.MemoryView":783 + /* "View.MemoryView":779 * else: * return memoryview_fromslice(dst, new_ndim, NULL, NULL, * memview.dtype_is_object) # <<<<<<<<<<<<<< * * */ - __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, NULL, NULL, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 782, __pyx_L1_error) + __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, NULL, NULL, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 778, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - /* "View.MemoryView":782 + /* "View.MemoryView":778 * memview.dtype_is_object) * else: * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< * memview.dtype_is_object) * */ - if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(2, 782, __pyx_L1_error) + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(2, 778, __pyx_L1_error) __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L0; } - /* "View.MemoryView":710 + /* "View.MemoryView":706 * * @cname('__pyx_memview_slice') * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< @@ -15865,7 +16604,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ return __pyx_r; } -/* "View.MemoryView":807 +/* "View.MemoryView":803 * * @cname('__pyx_memoryview_slice_memviewslice') * cdef int slice_memviewslice( # <<<<<<<<<<<<<< @@ -15880,11 +16619,8 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - /* "View.MemoryView":827 + /* "View.MemoryView":823 * cdef bint negative_step * * if not is_slice: # <<<<<<<<<<<<<< @@ -15894,7 +16630,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_1 = ((!(__pyx_v_is_slice != 0)) != 0); if (__pyx_t_1) { - /* "View.MemoryView":829 + /* "View.MemoryView":825 * if not is_slice: * * if start < 0: # <<<<<<<<<<<<<< @@ -15904,7 +16640,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_1 = ((__pyx_v_start < 0) != 0); if (__pyx_t_1) { - /* "View.MemoryView":830 + /* "View.MemoryView":826 * * if start < 0: * start += shape # <<<<<<<<<<<<<< @@ -15913,7 +16649,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_start = (__pyx_v_start + __pyx_v_shape); - /* "View.MemoryView":829 + /* "View.MemoryView":825 * if not is_slice: * * if start < 0: # <<<<<<<<<<<<<< @@ -15922,7 +16658,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ } - /* "View.MemoryView":831 + /* "View.MemoryView":827 * if start < 0: * start += shape * if not 0 <= start < shape: # <<<<<<<<<<<<<< @@ -15936,16 +16672,16 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_2) { - /* "View.MemoryView":832 + /* "View.MemoryView":828 * start += shape * if not 0 <= start < shape: * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) # <<<<<<<<<<<<<< * else: * */ - __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"Index out of bounds (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 832, __pyx_L1_error) + __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"Index out of bounds (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 828, __pyx_L1_error) - /* "View.MemoryView":831 + /* "View.MemoryView":827 * if start < 0: * start += shape * if not 0 <= start < shape: # <<<<<<<<<<<<<< @@ -15954,7 +16690,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ } - /* "View.MemoryView":827 + /* "View.MemoryView":823 * cdef bint negative_step * * if not is_slice: # <<<<<<<<<<<<<< @@ -15964,7 +16700,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, goto __pyx_L3; } - /* "View.MemoryView":835 + /* "View.MemoryView":831 * else: * * negative_step = have_step != 0 and step < 0 # <<<<<<<<<<<<<< @@ -15983,7 +16719,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_L6_bool_binop_done:; __pyx_v_negative_step = __pyx_t_2; - /* "View.MemoryView":837 + /* "View.MemoryView":833 * negative_step = have_step != 0 and step < 0 * * if have_step and step == 0: # <<<<<<<<<<<<<< @@ -16001,16 +16737,16 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_L9_bool_binop_done:; if (__pyx_t_2) { - /* "View.MemoryView":838 + /* "View.MemoryView":834 * * if have_step and step == 0: * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) # <<<<<<<<<<<<<< * * */ - __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Step may not be zero (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 838, __pyx_L1_error) + __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Step may not be zero (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 834, __pyx_L1_error) - /* "View.MemoryView":837 + /* "View.MemoryView":833 * negative_step = have_step != 0 and step < 0 * * if have_step and step == 0: # <<<<<<<<<<<<<< @@ -16019,7 +16755,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ } - /* "View.MemoryView":841 + /* "View.MemoryView":837 * * * if have_start: # <<<<<<<<<<<<<< @@ -16029,7 +16765,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = (__pyx_v_have_start != 0); if (__pyx_t_2) { - /* "View.MemoryView":842 + /* "View.MemoryView":838 * * if have_start: * if start < 0: # <<<<<<<<<<<<<< @@ -16039,7 +16775,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = ((__pyx_v_start < 0) != 0); if (__pyx_t_2) { - /* "View.MemoryView":843 + /* "View.MemoryView":839 * if have_start: * if start < 0: * start += shape # <<<<<<<<<<<<<< @@ -16048,7 +16784,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_start = (__pyx_v_start + __pyx_v_shape); - /* "View.MemoryView":844 + /* "View.MemoryView":840 * if start < 0: * start += shape * if start < 0: # <<<<<<<<<<<<<< @@ -16058,7 +16794,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = ((__pyx_v_start < 0) != 0); if (__pyx_t_2) { - /* "View.MemoryView":845 + /* "View.MemoryView":841 * start += shape * if start < 0: * start = 0 # <<<<<<<<<<<<<< @@ -16067,7 +16803,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_start = 0; - /* "View.MemoryView":844 + /* "View.MemoryView":840 * if start < 0: * start += shape * if start < 0: # <<<<<<<<<<<<<< @@ -16076,7 +16812,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ } - /* "View.MemoryView":842 + /* "View.MemoryView":838 * * if have_start: * if start < 0: # <<<<<<<<<<<<<< @@ -16086,7 +16822,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, goto __pyx_L12; } - /* "View.MemoryView":846 + /* "View.MemoryView":842 * if start < 0: * start = 0 * elif start >= shape: # <<<<<<<<<<<<<< @@ -16096,7 +16832,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = ((__pyx_v_start >= __pyx_v_shape) != 0); if (__pyx_t_2) { - /* "View.MemoryView":847 + /* "View.MemoryView":843 * start = 0 * elif start >= shape: * if negative_step: # <<<<<<<<<<<<<< @@ -16106,7 +16842,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = (__pyx_v_negative_step != 0); if (__pyx_t_2) { - /* "View.MemoryView":848 + /* "View.MemoryView":844 * elif start >= shape: * if negative_step: * start = shape - 1 # <<<<<<<<<<<<<< @@ -16115,7 +16851,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_start = (__pyx_v_shape - 1); - /* "View.MemoryView":847 + /* "View.MemoryView":843 * start = 0 * elif start >= shape: * if negative_step: # <<<<<<<<<<<<<< @@ -16125,7 +16861,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, goto __pyx_L14; } - /* "View.MemoryView":850 + /* "View.MemoryView":846 * start = shape - 1 * else: * start = shape # <<<<<<<<<<<<<< @@ -16137,7 +16873,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, } __pyx_L14:; - /* "View.MemoryView":846 + /* "View.MemoryView":842 * if start < 0: * start = 0 * elif start >= shape: # <<<<<<<<<<<<<< @@ -16147,7 +16883,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, } __pyx_L12:; - /* "View.MemoryView":841 + /* "View.MemoryView":837 * * * if have_start: # <<<<<<<<<<<<<< @@ -16157,7 +16893,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, goto __pyx_L11; } - /* "View.MemoryView":852 + /* "View.MemoryView":848 * start = shape * else: * if negative_step: # <<<<<<<<<<<<<< @@ -16168,7 +16904,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = (__pyx_v_negative_step != 0); if (__pyx_t_2) { - /* "View.MemoryView":853 + /* "View.MemoryView":849 * else: * if negative_step: * start = shape - 1 # <<<<<<<<<<<<<< @@ -16177,7 +16913,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_start = (__pyx_v_shape - 1); - /* "View.MemoryView":852 + /* "View.MemoryView":848 * start = shape * else: * if negative_step: # <<<<<<<<<<<<<< @@ -16187,7 +16923,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, goto __pyx_L15; } - /* "View.MemoryView":855 + /* "View.MemoryView":851 * start = shape - 1 * else: * start = 0 # <<<<<<<<<<<<<< @@ -16201,7 +16937,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, } __pyx_L11:; - /* "View.MemoryView":857 + /* "View.MemoryView":853 * start = 0 * * if have_stop: # <<<<<<<<<<<<<< @@ -16211,7 +16947,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = (__pyx_v_have_stop != 0); if (__pyx_t_2) { - /* "View.MemoryView":858 + /* "View.MemoryView":854 * * if have_stop: * if stop < 0: # <<<<<<<<<<<<<< @@ -16221,7 +16957,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = ((__pyx_v_stop < 0) != 0); if (__pyx_t_2) { - /* "View.MemoryView":859 + /* "View.MemoryView":855 * if have_stop: * if stop < 0: * stop += shape # <<<<<<<<<<<<<< @@ -16230,7 +16966,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_stop = (__pyx_v_stop + __pyx_v_shape); - /* "View.MemoryView":860 + /* "View.MemoryView":856 * if stop < 0: * stop += shape * if stop < 0: # <<<<<<<<<<<<<< @@ -16240,7 +16976,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = ((__pyx_v_stop < 0) != 0); if (__pyx_t_2) { - /* "View.MemoryView":861 + /* "View.MemoryView":857 * stop += shape * if stop < 0: * stop = 0 # <<<<<<<<<<<<<< @@ -16249,7 +16985,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_stop = 0; - /* "View.MemoryView":860 + /* "View.MemoryView":856 * if stop < 0: * stop += shape * if stop < 0: # <<<<<<<<<<<<<< @@ -16258,7 +16994,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ } - /* "View.MemoryView":858 + /* "View.MemoryView":854 * * if have_stop: * if stop < 0: # <<<<<<<<<<<<<< @@ -16268,7 +17004,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, goto __pyx_L17; } - /* "View.MemoryView":862 + /* "View.MemoryView":858 * if stop < 0: * stop = 0 * elif stop > shape: # <<<<<<<<<<<<<< @@ -16278,7 +17014,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = ((__pyx_v_stop > __pyx_v_shape) != 0); if (__pyx_t_2) { - /* "View.MemoryView":863 + /* "View.MemoryView":859 * stop = 0 * elif stop > shape: * stop = shape # <<<<<<<<<<<<<< @@ -16287,7 +17023,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_stop = __pyx_v_shape; - /* "View.MemoryView":862 + /* "View.MemoryView":858 * if stop < 0: * stop = 0 * elif stop > shape: # <<<<<<<<<<<<<< @@ -16297,7 +17033,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, } __pyx_L17:; - /* "View.MemoryView":857 + /* "View.MemoryView":853 * start = 0 * * if have_stop: # <<<<<<<<<<<<<< @@ -16307,7 +17043,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, goto __pyx_L16; } - /* "View.MemoryView":865 + /* "View.MemoryView":861 * stop = shape * else: * if negative_step: # <<<<<<<<<<<<<< @@ -16318,7 +17054,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = (__pyx_v_negative_step != 0); if (__pyx_t_2) { - /* "View.MemoryView":866 + /* "View.MemoryView":862 * else: * if negative_step: * stop = -1 # <<<<<<<<<<<<<< @@ -16327,7 +17063,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_stop = -1L; - /* "View.MemoryView":865 + /* "View.MemoryView":861 * stop = shape * else: * if negative_step: # <<<<<<<<<<<<<< @@ -16337,7 +17073,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, goto __pyx_L19; } - /* "View.MemoryView":868 + /* "View.MemoryView":864 * stop = -1 * else: * stop = shape # <<<<<<<<<<<<<< @@ -16351,7 +17087,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, } __pyx_L16:; - /* "View.MemoryView":870 + /* "View.MemoryView":866 * stop = shape * * if not have_step: # <<<<<<<<<<<<<< @@ -16361,7 +17097,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = ((!(__pyx_v_have_step != 0)) != 0); if (__pyx_t_2) { - /* "View.MemoryView":871 + /* "View.MemoryView":867 * * if not have_step: * step = 1 # <<<<<<<<<<<<<< @@ -16370,7 +17106,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_step = 1; - /* "View.MemoryView":870 + /* "View.MemoryView":866 * stop = shape * * if not have_step: # <<<<<<<<<<<<<< @@ -16379,7 +17115,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ } - /* "View.MemoryView":875 + /* "View.MemoryView":871 * * with cython.cdivision(True): * new_shape = (stop - start) // step # <<<<<<<<<<<<<< @@ -16388,7 +17124,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_new_shape = ((__pyx_v_stop - __pyx_v_start) / __pyx_v_step); - /* "View.MemoryView":877 + /* "View.MemoryView":873 * new_shape = (stop - start) // step * * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< @@ -16398,7 +17134,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = (((__pyx_v_stop - __pyx_v_start) - (__pyx_v_step * __pyx_v_new_shape)) != 0); if (__pyx_t_2) { - /* "View.MemoryView":878 + /* "View.MemoryView":874 * * if (stop - start) - step * new_shape: * new_shape += 1 # <<<<<<<<<<<<<< @@ -16407,7 +17143,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_new_shape = (__pyx_v_new_shape + 1); - /* "View.MemoryView":877 + /* "View.MemoryView":873 * new_shape = (stop - start) // step * * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< @@ -16416,7 +17152,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ } - /* "View.MemoryView":880 + /* "View.MemoryView":876 * new_shape += 1 * * if new_shape < 0: # <<<<<<<<<<<<<< @@ -16426,7 +17162,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = ((__pyx_v_new_shape < 0) != 0); if (__pyx_t_2) { - /* "View.MemoryView":881 + /* "View.MemoryView":877 * * if new_shape < 0: * new_shape = 0 # <<<<<<<<<<<<<< @@ -16435,7 +17171,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_new_shape = 0; - /* "View.MemoryView":880 + /* "View.MemoryView":876 * new_shape += 1 * * if new_shape < 0: # <<<<<<<<<<<<<< @@ -16444,7 +17180,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ } - /* "View.MemoryView":884 + /* "View.MemoryView":880 * * * dst.strides[new_ndim] = stride * step # <<<<<<<<<<<<<< @@ -16453,7 +17189,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ (__pyx_v_dst->strides[__pyx_v_new_ndim]) = (__pyx_v_stride * __pyx_v_step); - /* "View.MemoryView":885 + /* "View.MemoryView":881 * * dst.strides[new_ndim] = stride * step * dst.shape[new_ndim] = new_shape # <<<<<<<<<<<<<< @@ -16462,7 +17198,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ (__pyx_v_dst->shape[__pyx_v_new_ndim]) = __pyx_v_new_shape; - /* "View.MemoryView":886 + /* "View.MemoryView":882 * dst.strides[new_ndim] = stride * step * dst.shape[new_ndim] = new_shape * dst.suboffsets[new_ndim] = suboffset # <<<<<<<<<<<<<< @@ -16473,7 +17209,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, } __pyx_L3:; - /* "View.MemoryView":889 + /* "View.MemoryView":885 * * * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< @@ -16483,7 +17219,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = (((__pyx_v_suboffset_dim[0]) < 0) != 0); if (__pyx_t_2) { - /* "View.MemoryView":890 + /* "View.MemoryView":886 * * if suboffset_dim[0] < 0: * dst.data += start * stride # <<<<<<<<<<<<<< @@ -16492,7 +17228,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_dst->data = (__pyx_v_dst->data + (__pyx_v_start * __pyx_v_stride)); - /* "View.MemoryView":889 + /* "View.MemoryView":885 * * * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< @@ -16502,7 +17238,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, goto __pyx_L23; } - /* "View.MemoryView":892 + /* "View.MemoryView":888 * dst.data += start * stride * else: * dst.suboffsets[suboffset_dim[0]] += start * stride # <<<<<<<<<<<<<< @@ -16515,7 +17251,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, } __pyx_L23:; - /* "View.MemoryView":894 + /* "View.MemoryView":890 * dst.suboffsets[suboffset_dim[0]] += start * stride * * if suboffset >= 0: # <<<<<<<<<<<<<< @@ -16525,7 +17261,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0); if (__pyx_t_2) { - /* "View.MemoryView":895 + /* "View.MemoryView":891 * * if suboffset >= 0: * if not is_slice: # <<<<<<<<<<<<<< @@ -16535,7 +17271,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = ((!(__pyx_v_is_slice != 0)) != 0); if (__pyx_t_2) { - /* "View.MemoryView":896 + /* "View.MemoryView":892 * if suboffset >= 0: * if not is_slice: * if new_ndim == 0: # <<<<<<<<<<<<<< @@ -16545,7 +17281,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = ((__pyx_v_new_ndim == 0) != 0); if (__pyx_t_2) { - /* "View.MemoryView":897 + /* "View.MemoryView":893 * if not is_slice: * if new_ndim == 0: * dst.data = ( dst.data)[0] + suboffset # <<<<<<<<<<<<<< @@ -16554,7 +17290,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_dst->data = ((((char **)__pyx_v_dst->data)[0]) + __pyx_v_suboffset); - /* "View.MemoryView":896 + /* "View.MemoryView":892 * if suboffset >= 0: * if not is_slice: * if new_ndim == 0: # <<<<<<<<<<<<<< @@ -16564,7 +17300,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, goto __pyx_L26; } - /* "View.MemoryView":899 + /* "View.MemoryView":895 * dst.data = ( dst.data)[0] + suboffset * else: * _err_dim(IndexError, "All dimensions preceding dimension %d " # <<<<<<<<<<<<<< @@ -16573,18 +17309,18 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ /*else*/ { - /* "View.MemoryView":900 + /* "View.MemoryView":896 * else: * _err_dim(IndexError, "All dimensions preceding dimension %d " * "must be indexed and not sliced", dim) # <<<<<<<<<<<<<< * else: * suboffset_dim[0] = new_ndim */ - __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"All dimensions preceding dimension %d must be indexed and not sliced"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 899, __pyx_L1_error) + __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"All dimensions preceding dimension %d must be indexed and not sliced"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 895, __pyx_L1_error) } __pyx_L26:; - /* "View.MemoryView":895 + /* "View.MemoryView":891 * * if suboffset >= 0: * if not is_slice: # <<<<<<<<<<<<<< @@ -16594,7 +17330,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, goto __pyx_L25; } - /* "View.MemoryView":902 + /* "View.MemoryView":898 * "must be indexed and not sliced", dim) * else: * suboffset_dim[0] = new_ndim # <<<<<<<<<<<<<< @@ -16606,7 +17342,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, } __pyx_L25:; - /* "View.MemoryView":894 + /* "View.MemoryView":890 * dst.suboffsets[suboffset_dim[0]] += start * stride * * if suboffset >= 0: # <<<<<<<<<<<<<< @@ -16615,7 +17351,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ } - /* "View.MemoryView":904 + /* "View.MemoryView":900 * suboffset_dim[0] = new_ndim * * return 0 # <<<<<<<<<<<<<< @@ -16625,7 +17361,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_r = 0; goto __pyx_L0; - /* "View.MemoryView":807 + /* "View.MemoryView":803 * * @cname('__pyx_memoryview_slice_memviewslice') * cdef int slice_memviewslice( # <<<<<<<<<<<<<< @@ -16649,7 +17385,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, return __pyx_r; } -/* "View.MemoryView":910 +/* "View.MemoryView":906 * * @cname('__pyx_pybuffer_index') * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<< @@ -16669,12 +17405,9 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("pybuffer_index", 0); - /* "View.MemoryView":912 + /* "View.MemoryView":908 * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, * Py_ssize_t dim) except NULL: * cdef Py_ssize_t shape, stride, suboffset = -1 # <<<<<<<<<<<<<< @@ -16683,7 +17416,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ __pyx_v_suboffset = -1L; - /* "View.MemoryView":913 + /* "View.MemoryView":909 * Py_ssize_t dim) except NULL: * cdef Py_ssize_t shape, stride, suboffset = -1 * cdef Py_ssize_t itemsize = view.itemsize # <<<<<<<<<<<<<< @@ -16693,7 +17426,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P __pyx_t_1 = __pyx_v_view->itemsize; __pyx_v_itemsize = __pyx_t_1; - /* "View.MemoryView":916 + /* "View.MemoryView":912 * cdef char *resultp * * if view.ndim == 0: # <<<<<<<<<<<<<< @@ -16703,7 +17436,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P __pyx_t_2 = ((__pyx_v_view->ndim == 0) != 0); if (__pyx_t_2) { - /* "View.MemoryView":917 + /* "View.MemoryView":913 * * if view.ndim == 0: * shape = view.len / itemsize # <<<<<<<<<<<<<< @@ -16712,15 +17445,15 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ if (unlikely(__pyx_v_itemsize == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); - __PYX_ERR(2, 917, __pyx_L1_error) + __PYX_ERR(2, 913, __pyx_L1_error) } else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_view->len))) { PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); - __PYX_ERR(2, 917, __pyx_L1_error) + __PYX_ERR(2, 913, __pyx_L1_error) } __pyx_v_shape = __Pyx_div_Py_ssize_t(__pyx_v_view->len, __pyx_v_itemsize); - /* "View.MemoryView":918 + /* "View.MemoryView":914 * if view.ndim == 0: * shape = view.len / itemsize * stride = itemsize # <<<<<<<<<<<<<< @@ -16729,7 +17462,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ __pyx_v_stride = __pyx_v_itemsize; - /* "View.MemoryView":916 + /* "View.MemoryView":912 * cdef char *resultp * * if view.ndim == 0: # <<<<<<<<<<<<<< @@ -16739,7 +17472,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P goto __pyx_L3; } - /* "View.MemoryView":920 + /* "View.MemoryView":916 * stride = itemsize * else: * shape = view.shape[dim] # <<<<<<<<<<<<<< @@ -16749,7 +17482,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P /*else*/ { __pyx_v_shape = (__pyx_v_view->shape[__pyx_v_dim]); - /* "View.MemoryView":921 + /* "View.MemoryView":917 * else: * shape = view.shape[dim] * stride = view.strides[dim] # <<<<<<<<<<<<<< @@ -16758,7 +17491,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ __pyx_v_stride = (__pyx_v_view->strides[__pyx_v_dim]); - /* "View.MemoryView":922 + /* "View.MemoryView":918 * shape = view.shape[dim] * stride = view.strides[dim] * if view.suboffsets != NULL: # <<<<<<<<<<<<<< @@ -16768,7 +17501,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P __pyx_t_2 = ((__pyx_v_view->suboffsets != NULL) != 0); if (__pyx_t_2) { - /* "View.MemoryView":923 + /* "View.MemoryView":919 * stride = view.strides[dim] * if view.suboffsets != NULL: * suboffset = view.suboffsets[dim] # <<<<<<<<<<<<<< @@ -16777,7 +17510,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ __pyx_v_suboffset = (__pyx_v_view->suboffsets[__pyx_v_dim]); - /* "View.MemoryView":922 + /* "View.MemoryView":918 * shape = view.shape[dim] * stride = view.strides[dim] * if view.suboffsets != NULL: # <<<<<<<<<<<<<< @@ -16788,7 +17521,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P } __pyx_L3:; - /* "View.MemoryView":925 + /* "View.MemoryView":921 * suboffset = view.suboffsets[dim] * * if index < 0: # <<<<<<<<<<<<<< @@ -16798,7 +17531,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P __pyx_t_2 = ((__pyx_v_index < 0) != 0); if (__pyx_t_2) { - /* "View.MemoryView":926 + /* "View.MemoryView":922 * * if index < 0: * index += view.shape[dim] # <<<<<<<<<<<<<< @@ -16807,7 +17540,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ __pyx_v_index = (__pyx_v_index + (__pyx_v_view->shape[__pyx_v_dim])); - /* "View.MemoryView":927 + /* "View.MemoryView":923 * if index < 0: * index += view.shape[dim] * if index < 0: # <<<<<<<<<<<<<< @@ -16817,26 +17550,26 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P __pyx_t_2 = ((__pyx_v_index < 0) != 0); if (unlikely(__pyx_t_2)) { - /* "View.MemoryView":928 + /* "View.MemoryView":924 * index += view.shape[dim] * if index < 0: * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) # <<<<<<<<<<<<<< * * if index >= shape: */ - __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 928, __pyx_L1_error) + __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 924, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 928, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 924, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 928, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 924, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(2, 928, __pyx_L1_error) + __PYX_ERR(2, 924, __pyx_L1_error) - /* "View.MemoryView":927 + /* "View.MemoryView":923 * if index < 0: * index += view.shape[dim] * if index < 0: # <<<<<<<<<<<<<< @@ -16845,7 +17578,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ } - /* "View.MemoryView":925 + /* "View.MemoryView":921 * suboffset = view.suboffsets[dim] * * if index < 0: # <<<<<<<<<<<<<< @@ -16854,7 +17587,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ } - /* "View.MemoryView":930 + /* "View.MemoryView":926 * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) * * if index >= shape: # <<<<<<<<<<<<<< @@ -16864,26 +17597,26 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P __pyx_t_2 = ((__pyx_v_index >= __pyx_v_shape) != 0); if (unlikely(__pyx_t_2)) { - /* "View.MemoryView":931 + /* "View.MemoryView":927 * * if index >= shape: * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) # <<<<<<<<<<<<<< * * resultp = bufp + index * stride */ - __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 931, __pyx_L1_error) + __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 927, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 931, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 927, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 931, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 927, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(2, 931, __pyx_L1_error) + __PYX_ERR(2, 927, __pyx_L1_error) - /* "View.MemoryView":930 + /* "View.MemoryView":926 * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) * * if index >= shape: # <<<<<<<<<<<<<< @@ -16892,7 +17625,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ } - /* "View.MemoryView":933 + /* "View.MemoryView":929 * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) * * resultp = bufp + index * stride # <<<<<<<<<<<<<< @@ -16901,7 +17634,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ __pyx_v_resultp = (__pyx_v_bufp + (__pyx_v_index * __pyx_v_stride)); - /* "View.MemoryView":934 + /* "View.MemoryView":930 * * resultp = bufp + index * stride * if suboffset >= 0: # <<<<<<<<<<<<<< @@ -16911,7 +17644,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0); if (__pyx_t_2) { - /* "View.MemoryView":935 + /* "View.MemoryView":931 * resultp = bufp + index * stride * if suboffset >= 0: * resultp = ( resultp)[0] + suboffset # <<<<<<<<<<<<<< @@ -16920,7 +17653,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ __pyx_v_resultp = ((((char **)__pyx_v_resultp)[0]) + __pyx_v_suboffset); - /* "View.MemoryView":934 + /* "View.MemoryView":930 * * resultp = bufp + index * stride * if suboffset >= 0: # <<<<<<<<<<<<<< @@ -16929,7 +17662,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ } - /* "View.MemoryView":937 + /* "View.MemoryView":933 * resultp = ( resultp)[0] + suboffset * * return resultp # <<<<<<<<<<<<<< @@ -16939,7 +17672,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P __pyx_r = __pyx_v_resultp; goto __pyx_L0; - /* "View.MemoryView":910 + /* "View.MemoryView":906 * * @cname('__pyx_pybuffer_index') * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<< @@ -16958,7 +17691,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P return __pyx_r; } -/* "View.MemoryView":943 +/* "View.MemoryView":939 * * @cname('__pyx_memslice_transpose') * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< @@ -16982,11 +17715,8 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { int __pyx_t_7; int __pyx_t_8; int __pyx_t_9; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - /* "View.MemoryView":944 + /* "View.MemoryView":940 * @cname('__pyx_memslice_transpose') * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: * cdef int ndim = memslice.memview.view.ndim # <<<<<<<<<<<<<< @@ -16996,7 +17726,7 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { __pyx_t_1 = __pyx_v_memslice->memview->view.ndim; __pyx_v_ndim = __pyx_t_1; - /* "View.MemoryView":946 + /* "View.MemoryView":942 * cdef int ndim = memslice.memview.view.ndim * * cdef Py_ssize_t *shape = memslice.shape # <<<<<<<<<<<<<< @@ -17006,7 +17736,7 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { __pyx_t_2 = __pyx_v_memslice->shape; __pyx_v_shape = __pyx_t_2; - /* "View.MemoryView":947 + /* "View.MemoryView":943 * * cdef Py_ssize_t *shape = memslice.shape * cdef Py_ssize_t *strides = memslice.strides # <<<<<<<<<<<<<< @@ -17016,7 +17746,7 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { __pyx_t_2 = __pyx_v_memslice->strides; __pyx_v_strides = __pyx_t_2; - /* "View.MemoryView":951 + /* "View.MemoryView":947 * * cdef int i, j * for i in range(ndim / 2): # <<<<<<<<<<<<<< @@ -17028,7 +17758,7 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { for (__pyx_t_1 = 0; __pyx_t_1 < __pyx_t_4; __pyx_t_1+=1) { __pyx_v_i = __pyx_t_1; - /* "View.MemoryView":952 + /* "View.MemoryView":948 * cdef int i, j * for i in range(ndim / 2): * j = ndim - 1 - i # <<<<<<<<<<<<<< @@ -17037,7 +17767,7 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { */ __pyx_v_j = ((__pyx_v_ndim - 1) - __pyx_v_i); - /* "View.MemoryView":953 + /* "View.MemoryView":949 * for i in range(ndim / 2): * j = ndim - 1 - i * strides[i], strides[j] = strides[j], strides[i] # <<<<<<<<<<<<<< @@ -17049,7 +17779,7 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { (__pyx_v_strides[__pyx_v_i]) = __pyx_t_5; (__pyx_v_strides[__pyx_v_j]) = __pyx_t_6; - /* "View.MemoryView":954 + /* "View.MemoryView":950 * j = ndim - 1 - i * strides[i], strides[j] = strides[j], strides[i] * shape[i], shape[j] = shape[j], shape[i] # <<<<<<<<<<<<<< @@ -17061,7 +17791,7 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { (__pyx_v_shape[__pyx_v_i]) = __pyx_t_6; (__pyx_v_shape[__pyx_v_j]) = __pyx_t_5; - /* "View.MemoryView":956 + /* "View.MemoryView":952 * shape[i], shape[j] = shape[j], shape[i] * * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< @@ -17079,16 +17809,16 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { __pyx_L6_bool_binop_done:; if (__pyx_t_7) { - /* "View.MemoryView":957 + /* "View.MemoryView":953 * * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") # <<<<<<<<<<<<<< * * return 1 */ - __pyx_t_9 = __pyx_memoryview_err(__pyx_builtin_ValueError, ((char *)"Cannot transpose memoryview with indirect dimensions")); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 957, __pyx_L1_error) + __pyx_t_9 = __pyx_memoryview_err(__pyx_builtin_ValueError, ((char *)"Cannot transpose memoryview with indirect dimensions")); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(2, 953, __pyx_L1_error) - /* "View.MemoryView":956 + /* "View.MemoryView":952 * shape[i], shape[j] = shape[j], shape[i] * * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< @@ -17098,7 +17828,7 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { } } - /* "View.MemoryView":959 + /* "View.MemoryView":955 * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") * * return 1 # <<<<<<<<<<<<<< @@ -17108,7 +17838,7 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { __pyx_r = 1; goto __pyx_L0; - /* "View.MemoryView":943 + /* "View.MemoryView":939 * * @cname('__pyx_memslice_transpose') * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< @@ -17132,7 +17862,7 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { return __pyx_r; } -/* "View.MemoryView":976 +/* "View.MemoryView":972 * cdef int (*to_dtype_func)(char *, object) except 0 * * def __dealloc__(self): # <<<<<<<<<<<<<< @@ -17155,7 +17885,7 @@ static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewsl __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__", 0); - /* "View.MemoryView":977 + /* "View.MemoryView":973 * * def __dealloc__(self): * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) # <<<<<<<<<<<<<< @@ -17164,7 +17894,7 @@ static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewsl */ __PYX_XDEC_MEMVIEW((&__pyx_v_self->from_slice), 1); - /* "View.MemoryView":976 + /* "View.MemoryView":972 * cdef int (*to_dtype_func)(char *, object) except 0 * * def __dealloc__(self): # <<<<<<<<<<<<<< @@ -17176,7 +17906,7 @@ static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewsl __Pyx_RefNannyFinishContext(); } -/* "View.MemoryView":979 +/* "View.MemoryView":975 * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) * * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< @@ -17189,12 +17919,9 @@ static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memor __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("convert_item_to_object", 0); - /* "View.MemoryView":980 + /* "View.MemoryView":976 * * cdef convert_item_to_object(self, char *itemp): * if self.to_object_func != NULL: # <<<<<<<<<<<<<< @@ -17204,7 +17931,7 @@ static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memor __pyx_t_1 = ((__pyx_v_self->to_object_func != NULL) != 0); if (__pyx_t_1) { - /* "View.MemoryView":981 + /* "View.MemoryView":977 * cdef convert_item_to_object(self, char *itemp): * if self.to_object_func != NULL: * return self.to_object_func(itemp) # <<<<<<<<<<<<<< @@ -17212,13 +17939,13 @@ static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memor * return memoryview.convert_item_to_object(self, itemp) */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __pyx_v_self->to_object_func(__pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 981, __pyx_L1_error) + __pyx_t_2 = __pyx_v_self->to_object_func(__pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 977, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "View.MemoryView":980 + /* "View.MemoryView":976 * * cdef convert_item_to_object(self, char *itemp): * if self.to_object_func != NULL: # <<<<<<<<<<<<<< @@ -17227,7 +17954,7 @@ static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memor */ } - /* "View.MemoryView":983 + /* "View.MemoryView":979 * return self.to_object_func(itemp) * else: * return memoryview.convert_item_to_object(self, itemp) # <<<<<<<<<<<<<< @@ -17236,14 +17963,14 @@ static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memor */ /*else*/ { __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __pyx_memoryview_convert_item_to_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 983, __pyx_L1_error) + __pyx_t_2 = __pyx_memoryview_convert_item_to_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 979, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; } - /* "View.MemoryView":979 + /* "View.MemoryView":975 * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) * * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< @@ -17262,7 +17989,7 @@ static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memor return __pyx_r; } -/* "View.MemoryView":985 +/* "View.MemoryView":981 * return memoryview.convert_item_to_object(self, itemp) * * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< @@ -17276,12 +18003,9 @@ static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memo int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("assign_item_from_object", 0); - /* "View.MemoryView":986 + /* "View.MemoryView":982 * * cdef assign_item_from_object(self, char *itemp, object value): * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< @@ -17291,16 +18015,16 @@ static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memo __pyx_t_1 = ((__pyx_v_self->to_dtype_func != NULL) != 0); if (__pyx_t_1) { - /* "View.MemoryView":987 + /* "View.MemoryView":983 * cdef assign_item_from_object(self, char *itemp, object value): * if self.to_dtype_func != NULL: * self.to_dtype_func(itemp, value) # <<<<<<<<<<<<<< * else: * memoryview.assign_item_from_object(self, itemp, value) */ - __pyx_t_2 = __pyx_v_self->to_dtype_func(__pyx_v_itemp, __pyx_v_value); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(2, 987, __pyx_L1_error) + __pyx_t_2 = __pyx_v_self->to_dtype_func(__pyx_v_itemp, __pyx_v_value); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(2, 983, __pyx_L1_error) - /* "View.MemoryView":986 + /* "View.MemoryView":982 * * cdef assign_item_from_object(self, char *itemp, object value): * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< @@ -17310,7 +18034,7 @@ static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memo goto __pyx_L3; } - /* "View.MemoryView":989 + /* "View.MemoryView":985 * self.to_dtype_func(itemp, value) * else: * memoryview.assign_item_from_object(self, itemp, value) # <<<<<<<<<<<<<< @@ -17318,13 +18042,13 @@ static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memo * @property */ /*else*/ { - __pyx_t_3 = __pyx_memoryview_assign_item_from_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 989, __pyx_L1_error) + __pyx_t_3 = __pyx_memoryview_assign_item_from_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 985, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_L3:; - /* "View.MemoryView":985 + /* "View.MemoryView":981 * return memoryview.convert_item_to_object(self, itemp) * * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< @@ -17345,7 +18069,7 @@ static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memo return __pyx_r; } -/* "View.MemoryView":992 +/* "View.MemoryView":988 * * @property * def base(self): # <<<<<<<<<<<<<< @@ -17371,7 +18095,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__ __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); - /* "View.MemoryView":993 + /* "View.MemoryView":989 * @property * def base(self): * return self.from_object # <<<<<<<<<<<<<< @@ -17383,7 +18107,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__ __pyx_r = __pyx_v_self->from_object; goto __pyx_L0; - /* "View.MemoryView":992 + /* "View.MemoryView":988 * * @property * def base(self): # <<<<<<<<<<<<<< @@ -17421,9 +18145,6 @@ static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 @@ -17432,7 +18153,7 @@ static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -17478,9 +18199,6 @@ static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUS PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 @@ -17488,7 +18206,7 @@ static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUS * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -17511,7 +18229,7 @@ static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUS return __pyx_r; } -/* "View.MemoryView":999 +/* "View.MemoryView":995 * * @cname('__pyx_memoryview_fromslice') * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< @@ -17534,12 +18252,9 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl Py_ssize_t *__pyx_t_7; Py_ssize_t *__pyx_t_8; Py_ssize_t __pyx_t_9; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("memoryview_fromslice", 0); - /* "View.MemoryView":1007 + /* "View.MemoryView":1003 * cdef _memoryviewslice result * * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< @@ -17549,7 +18264,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __pyx_t_1 = ((((PyObject *)__pyx_v_memviewslice.memview) == Py_None) != 0); if (__pyx_t_1) { - /* "View.MemoryView":1008 + /* "View.MemoryView":1004 * * if memviewslice.memview == Py_None: * return None # <<<<<<<<<<<<<< @@ -17560,7 +18275,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "View.MemoryView":1007 + /* "View.MemoryView":1003 * cdef _memoryviewslice result * * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< @@ -17569,16 +18284,16 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ } - /* "View.MemoryView":1013 + /* "View.MemoryView":1009 * * * result = _memoryviewslice(None, 0, dtype_is_object) # <<<<<<<<<<<<<< * * result.from_slice = memviewslice */ - __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1013, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1009, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1013, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1009, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); @@ -17589,13 +18304,13 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryviewslice_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1013, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryviewslice_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1009, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); __pyx_t_2 = 0; - /* "View.MemoryView":1015 + /* "View.MemoryView":1011 * result = _memoryviewslice(None, 0, dtype_is_object) * * result.from_slice = memviewslice # <<<<<<<<<<<<<< @@ -17604,7 +18319,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ __pyx_v_result->from_slice = __pyx_v_memviewslice; - /* "View.MemoryView":1016 + /* "View.MemoryView":1012 * * result.from_slice = memviewslice * __PYX_INC_MEMVIEW(&memviewslice, 1) # <<<<<<<<<<<<<< @@ -17613,14 +18328,14 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ __PYX_INC_MEMVIEW((&__pyx_v_memviewslice), 1); - /* "View.MemoryView":1018 + /* "View.MemoryView":1014 * __PYX_INC_MEMVIEW(&memviewslice, 1) * * result.from_object = ( memviewslice.memview).base # <<<<<<<<<<<<<< * result.typeinfo = memviewslice.memview.typeinfo * */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_memviewslice.memview), __pyx_n_s_base); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1018, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_memviewslice.memview), __pyx_n_s_base); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1014, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_v_result->from_object); @@ -17628,7 +18343,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __pyx_v_result->from_object = __pyx_t_2; __pyx_t_2 = 0; - /* "View.MemoryView":1019 + /* "View.MemoryView":1015 * * result.from_object = ( memviewslice.memview).base * result.typeinfo = memviewslice.memview.typeinfo # <<<<<<<<<<<<<< @@ -17638,7 +18353,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __pyx_t_4 = __pyx_v_memviewslice.memview->typeinfo; __pyx_v_result->__pyx_base.typeinfo = __pyx_t_4; - /* "View.MemoryView":1021 + /* "View.MemoryView":1017 * result.typeinfo = memviewslice.memview.typeinfo * * result.view = memviewslice.memview.view # <<<<<<<<<<<<<< @@ -17648,7 +18363,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __pyx_t_5 = __pyx_v_memviewslice.memview->view; __pyx_v_result->__pyx_base.view = __pyx_t_5; - /* "View.MemoryView":1022 + /* "View.MemoryView":1018 * * result.view = memviewslice.memview.view * result.view.buf = memviewslice.data # <<<<<<<<<<<<<< @@ -17657,7 +18372,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ __pyx_v_result->__pyx_base.view.buf = ((void *)__pyx_v_memviewslice.data); - /* "View.MemoryView":1023 + /* "View.MemoryView":1019 * result.view = memviewslice.memview.view * result.view.buf = memviewslice.data * result.view.ndim = ndim # <<<<<<<<<<<<<< @@ -17666,7 +18381,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ __pyx_v_result->__pyx_base.view.ndim = __pyx_v_ndim; - /* "View.MemoryView":1024 + /* "View.MemoryView":1020 * result.view.buf = memviewslice.data * result.view.ndim = ndim * (<__pyx_buffer *> &result.view).obj = Py_None # <<<<<<<<<<<<<< @@ -17675,7 +18390,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ ((Py_buffer *)(&__pyx_v_result->__pyx_base.view))->obj = Py_None; - /* "View.MemoryView":1025 + /* "View.MemoryView":1021 * result.view.ndim = ndim * (<__pyx_buffer *> &result.view).obj = Py_None * Py_INCREF(Py_None) # <<<<<<<<<<<<<< @@ -17684,7 +18399,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ Py_INCREF(Py_None); - /* "View.MemoryView":1027 + /* "View.MemoryView":1023 * Py_INCREF(Py_None) * * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< @@ -17694,7 +18409,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __pyx_t_1 = ((((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->flags & PyBUF_WRITABLE) != 0); if (__pyx_t_1) { - /* "View.MemoryView":1028 + /* "View.MemoryView":1024 * * if (memviewslice.memview).flags & PyBUF_WRITABLE: * result.flags = PyBUF_RECORDS # <<<<<<<<<<<<<< @@ -17703,7 +18418,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS; - /* "View.MemoryView":1027 + /* "View.MemoryView":1023 * Py_INCREF(Py_None) * * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< @@ -17713,7 +18428,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl goto __pyx_L4; } - /* "View.MemoryView":1030 + /* "View.MemoryView":1026 * result.flags = PyBUF_RECORDS * else: * result.flags = PyBUF_RECORDS_RO # <<<<<<<<<<<<<< @@ -17725,7 +18440,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl } __pyx_L4:; - /* "View.MemoryView":1032 + /* "View.MemoryView":1028 * result.flags = PyBUF_RECORDS_RO * * result.view.shape = result.from_slice.shape # <<<<<<<<<<<<<< @@ -17734,7 +18449,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ __pyx_v_result->__pyx_base.view.shape = ((Py_ssize_t *)__pyx_v_result->from_slice.shape); - /* "View.MemoryView":1033 + /* "View.MemoryView":1029 * * result.view.shape = result.from_slice.shape * result.view.strides = result.from_slice.strides # <<<<<<<<<<<<<< @@ -17743,7 +18458,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ __pyx_v_result->__pyx_base.view.strides = ((Py_ssize_t *)__pyx_v_result->from_slice.strides); - /* "View.MemoryView":1036 + /* "View.MemoryView":1032 * * * result.view.suboffsets = NULL # <<<<<<<<<<<<<< @@ -17752,7 +18467,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ __pyx_v_result->__pyx_base.view.suboffsets = NULL; - /* "View.MemoryView":1037 + /* "View.MemoryView":1033 * * result.view.suboffsets = NULL * for suboffset in result.from_slice.suboffsets[:ndim]: # <<<<<<<<<<<<<< @@ -17764,7 +18479,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __pyx_t_6 = __pyx_t_8; __pyx_v_suboffset = (__pyx_t_6[0]); - /* "View.MemoryView":1038 + /* "View.MemoryView":1034 * result.view.suboffsets = NULL * for suboffset in result.from_slice.suboffsets[:ndim]: * if suboffset >= 0: # <<<<<<<<<<<<<< @@ -17774,7 +18489,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __pyx_t_1 = ((__pyx_v_suboffset >= 0) != 0); if (__pyx_t_1) { - /* "View.MemoryView":1039 + /* "View.MemoryView":1035 * for suboffset in result.from_slice.suboffsets[:ndim]: * if suboffset >= 0: * result.view.suboffsets = result.from_slice.suboffsets # <<<<<<<<<<<<<< @@ -17783,7 +18498,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ __pyx_v_result->__pyx_base.view.suboffsets = ((Py_ssize_t *)__pyx_v_result->from_slice.suboffsets); - /* "View.MemoryView":1040 + /* "View.MemoryView":1036 * if suboffset >= 0: * result.view.suboffsets = result.from_slice.suboffsets * break # <<<<<<<<<<<<<< @@ -17792,7 +18507,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ goto __pyx_L6_break; - /* "View.MemoryView":1038 + /* "View.MemoryView":1034 * result.view.suboffsets = NULL * for suboffset in result.from_slice.suboffsets[:ndim]: * if suboffset >= 0: # <<<<<<<<<<<<<< @@ -17803,7 +18518,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl } __pyx_L6_break:; - /* "View.MemoryView":1042 + /* "View.MemoryView":1038 * break * * result.view.len = result.view.itemsize # <<<<<<<<<<<<<< @@ -17813,7 +18528,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __pyx_t_9 = __pyx_v_result->__pyx_base.view.itemsize; __pyx_v_result->__pyx_base.view.len = __pyx_t_9; - /* "View.MemoryView":1043 + /* "View.MemoryView":1039 * * result.view.len = result.view.itemsize * for length in result.view.shape[:ndim]: # <<<<<<<<<<<<<< @@ -17823,29 +18538,29 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __pyx_t_7 = (__pyx_v_result->__pyx_base.view.shape + __pyx_v_ndim); for (__pyx_t_8 = __pyx_v_result->__pyx_base.view.shape; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) { __pyx_t_6 = __pyx_t_8; - __pyx_t_2 = PyInt_FromSsize_t((__pyx_t_6[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1043, __pyx_L1_error) + __pyx_t_2 = PyInt_FromSsize_t((__pyx_t_6[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1039, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_2); __pyx_t_2 = 0; - /* "View.MemoryView":1044 + /* "View.MemoryView":1040 * result.view.len = result.view.itemsize * for length in result.view.shape[:ndim]: * result.view.len *= length # <<<<<<<<<<<<<< * * result.to_object_func = to_object_func */ - __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_result->__pyx_base.view.len); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1044, __pyx_L1_error) + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_result->__pyx_base.view.len); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1040, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyNumber_InPlaceMultiply(__pyx_t_2, __pyx_v_length); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1044, __pyx_L1_error) + __pyx_t_3 = PyNumber_InPlaceMultiply(__pyx_t_2, __pyx_v_length); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1040, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 1044, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 1040, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_result->__pyx_base.view.len = __pyx_t_9; } - /* "View.MemoryView":1046 + /* "View.MemoryView":1042 * result.view.len *= length * * result.to_object_func = to_object_func # <<<<<<<<<<<<<< @@ -17854,7 +18569,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ __pyx_v_result->to_object_func = __pyx_v_to_object_func; - /* "View.MemoryView":1047 + /* "View.MemoryView":1043 * * result.to_object_func = to_object_func * result.to_dtype_func = to_dtype_func # <<<<<<<<<<<<<< @@ -17863,7 +18578,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ __pyx_v_result->to_dtype_func = __pyx_v_to_dtype_func; - /* "View.MemoryView":1049 + /* "View.MemoryView":1045 * result.to_dtype_func = to_dtype_func * * return result # <<<<<<<<<<<<<< @@ -17875,7 +18590,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __pyx_r = ((PyObject *)__pyx_v_result); goto __pyx_L0; - /* "View.MemoryView":999 + /* "View.MemoryView":995 * * @cname('__pyx_memoryview_fromslice') * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< @@ -17897,11 +18612,11 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl return __pyx_r; } -/* "View.MemoryView":1052 +/* "View.MemoryView":1048 * * @cname('__pyx_memoryview_get_slice_from_memoryview') * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< - * __Pyx_memviewslice *mslice) except NULL: + * __Pyx_memviewslice *mslice): * cdef _memoryviewslice obj */ @@ -17912,13 +18627,10 @@ static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __p int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_slice_from_memview", 0); - /* "View.MemoryView":1055 - * __Pyx_memviewslice *mslice) except NULL: + /* "View.MemoryView":1051 + * __Pyx_memviewslice *mslice): * cdef _memoryviewslice obj * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< * obj = memview @@ -17928,20 +18640,20 @@ static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __p __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "View.MemoryView":1056 + /* "View.MemoryView":1052 * cdef _memoryviewslice obj * if isinstance(memview, _memoryviewslice): * obj = memview # <<<<<<<<<<<<<< * return &obj.from_slice * else: */ - if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(2, 1056, __pyx_L1_error) + if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(2, 1052, __pyx_L1_error) __pyx_t_3 = ((PyObject *)__pyx_v_memview); __Pyx_INCREF(__pyx_t_3); __pyx_v_obj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3); __pyx_t_3 = 0; - /* "View.MemoryView":1057 + /* "View.MemoryView":1053 * if isinstance(memview, _memoryviewslice): * obj = memview * return &obj.from_slice # <<<<<<<<<<<<<< @@ -17951,8 +18663,8 @@ static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __p __pyx_r = (&__pyx_v_obj->from_slice); goto __pyx_L0; - /* "View.MemoryView":1055 - * __Pyx_memviewslice *mslice) except NULL: + /* "View.MemoryView":1051 + * __Pyx_memviewslice *mslice): * cdef _memoryviewslice obj * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< * obj = memview @@ -17960,7 +18672,7 @@ static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __p */ } - /* "View.MemoryView":1059 + /* "View.MemoryView":1055 * return &obj.from_slice * else: * slice_copy(memview, mslice) # <<<<<<<<<<<<<< @@ -17970,7 +18682,7 @@ static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __p /*else*/ { __pyx_memoryview_slice_copy(__pyx_v_memview, __pyx_v_mslice); - /* "View.MemoryView":1060 + /* "View.MemoryView":1056 * else: * slice_copy(memview, mslice) * return mslice # <<<<<<<<<<<<<< @@ -17981,26 +18693,26 @@ static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __p goto __pyx_L0; } - /* "View.MemoryView":1052 + /* "View.MemoryView":1048 * * @cname('__pyx_memoryview_get_slice_from_memoryview') * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< - * __Pyx_memviewslice *mslice) except NULL: + * __Pyx_memviewslice *mslice): * cdef _memoryviewslice obj */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.get_slice_from_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_WriteUnraisable("View.MemoryView.get_slice_from_memview", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_obj); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "View.MemoryView":1063 +/* "View.MemoryView":1059 * * @cname('__pyx_memoryview_slice_copy') * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< @@ -18021,7 +18733,7 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem Py_ssize_t __pyx_t_5; __Pyx_RefNannySetupContext("slice_copy", 0); - /* "View.MemoryView":1067 + /* "View.MemoryView":1063 * cdef (Py_ssize_t*) shape, strides, suboffsets * * shape = memview.view.shape # <<<<<<<<<<<<<< @@ -18031,7 +18743,7 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem __pyx_t_1 = __pyx_v_memview->view.shape; __pyx_v_shape = __pyx_t_1; - /* "View.MemoryView":1068 + /* "View.MemoryView":1064 * * shape = memview.view.shape * strides = memview.view.strides # <<<<<<<<<<<<<< @@ -18041,7 +18753,7 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem __pyx_t_1 = __pyx_v_memview->view.strides; __pyx_v_strides = __pyx_t_1; - /* "View.MemoryView":1069 + /* "View.MemoryView":1065 * shape = memview.view.shape * strides = memview.view.strides * suboffsets = memview.view.suboffsets # <<<<<<<<<<<<<< @@ -18051,7 +18763,7 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem __pyx_t_1 = __pyx_v_memview->view.suboffsets; __pyx_v_suboffsets = __pyx_t_1; - /* "View.MemoryView":1071 + /* "View.MemoryView":1067 * suboffsets = memview.view.suboffsets * * dst.memview = <__pyx_memoryview *> memview # <<<<<<<<<<<<<< @@ -18060,7 +18772,7 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem */ __pyx_v_dst->memview = ((struct __pyx_memoryview_obj *)__pyx_v_memview); - /* "View.MemoryView":1072 + /* "View.MemoryView":1068 * * dst.memview = <__pyx_memoryview *> memview * dst.data = memview.view.buf # <<<<<<<<<<<<<< @@ -18069,7 +18781,7 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem */ __pyx_v_dst->data = ((char *)__pyx_v_memview->view.buf); - /* "View.MemoryView":1074 + /* "View.MemoryView":1070 * dst.data = memview.view.buf * * for dim in range(memview.view.ndim): # <<<<<<<<<<<<<< @@ -18081,7 +18793,7 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_dim = __pyx_t_4; - /* "View.MemoryView":1075 + /* "View.MemoryView":1071 * * for dim in range(memview.view.ndim): * dst.shape[dim] = shape[dim] # <<<<<<<<<<<<<< @@ -18090,7 +18802,7 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem */ (__pyx_v_dst->shape[__pyx_v_dim]) = (__pyx_v_shape[__pyx_v_dim]); - /* "View.MemoryView":1076 + /* "View.MemoryView":1072 * for dim in range(memview.view.ndim): * dst.shape[dim] = shape[dim] * dst.strides[dim] = strides[dim] # <<<<<<<<<<<<<< @@ -18099,7 +18811,7 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem */ (__pyx_v_dst->strides[__pyx_v_dim]) = (__pyx_v_strides[__pyx_v_dim]); - /* "View.MemoryView":1077 + /* "View.MemoryView":1073 * dst.shape[dim] = shape[dim] * dst.strides[dim] = strides[dim] * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 # <<<<<<<<<<<<<< @@ -18114,7 +18826,7 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem (__pyx_v_dst->suboffsets[__pyx_v_dim]) = __pyx_t_5; } - /* "View.MemoryView":1063 + /* "View.MemoryView":1059 * * @cname('__pyx_memoryview_slice_copy') * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< @@ -18126,7 +18838,7 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem __Pyx_RefNannyFinishContext(); } -/* "View.MemoryView":1080 +/* "View.MemoryView":1076 * * @cname('__pyx_memoryview_copy_object') * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< @@ -18139,12 +18851,9 @@ static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("memoryview_copy", 0); - /* "View.MemoryView":1083 + /* "View.MemoryView":1079 * "Create a new memoryview object" * cdef __Pyx_memviewslice memviewslice * slice_copy(memview, &memviewslice) # <<<<<<<<<<<<<< @@ -18153,7 +18862,7 @@ static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx */ __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_memviewslice)); - /* "View.MemoryView":1084 + /* "View.MemoryView":1080 * cdef __Pyx_memviewslice memviewslice * slice_copy(memview, &memviewslice) * return memoryview_copy_from_slice(memview, &memviewslice) # <<<<<<<<<<<<<< @@ -18161,13 +18870,13 @@ static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx * @cname('__pyx_memoryview_copy_object_from_slice') */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_memoryview_copy_object_from_slice(__pyx_v_memview, (&__pyx_v_memviewslice)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1084, __pyx_L1_error) + __pyx_t_1 = __pyx_memoryview_copy_object_from_slice(__pyx_v_memview, (&__pyx_v_memviewslice)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1080, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "View.MemoryView":1080 + /* "View.MemoryView":1076 * * @cname('__pyx_memoryview_copy_object') * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< @@ -18186,7 +18895,7 @@ static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx return __pyx_r; } -/* "View.MemoryView":1087 +/* "View.MemoryView":1083 * * @cname('__pyx_memoryview_copy_object_from_slice') * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< @@ -18204,12 +18913,9 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview PyObject *(*__pyx_t_3)(char *); int (*__pyx_t_4)(char *, PyObject *); PyObject *__pyx_t_5 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("memoryview_copy_from_slice", 0); - /* "View.MemoryView":1094 + /* "View.MemoryView":1090 * cdef int (*to_dtype_func)(char *, object) except 0 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< @@ -18220,7 +18926,7 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "View.MemoryView":1095 + /* "View.MemoryView":1091 * * if isinstance(memview, _memoryviewslice): * to_object_func = (<_memoryviewslice> memview).to_object_func # <<<<<<<<<<<<<< @@ -18230,7 +18936,7 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview __pyx_t_3 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_object_func; __pyx_v_to_object_func = __pyx_t_3; - /* "View.MemoryView":1096 + /* "View.MemoryView":1092 * if isinstance(memview, _memoryviewslice): * to_object_func = (<_memoryviewslice> memview).to_object_func * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func # <<<<<<<<<<<<<< @@ -18240,7 +18946,7 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview __pyx_t_4 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_dtype_func; __pyx_v_to_dtype_func = __pyx_t_4; - /* "View.MemoryView":1094 + /* "View.MemoryView":1090 * cdef int (*to_dtype_func)(char *, object) except 0 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< @@ -18250,7 +18956,7 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview goto __pyx_L3; } - /* "View.MemoryView":1098 + /* "View.MemoryView":1094 * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func * else: * to_object_func = NULL # <<<<<<<<<<<<<< @@ -18260,7 +18966,7 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview /*else*/ { __pyx_v_to_object_func = NULL; - /* "View.MemoryView":1099 + /* "View.MemoryView":1095 * else: * to_object_func = NULL * to_dtype_func = NULL # <<<<<<<<<<<<<< @@ -18271,7 +18977,7 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview } __pyx_L3:; - /* "View.MemoryView":1101 + /* "View.MemoryView":1097 * to_dtype_func = NULL * * return memoryview_fromslice(memviewslice[0], memview.view.ndim, # <<<<<<<<<<<<<< @@ -18280,20 +18986,20 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview */ __Pyx_XDECREF(__pyx_r); - /* "View.MemoryView":1103 + /* "View.MemoryView":1099 * return memoryview_fromslice(memviewslice[0], memview.view.ndim, * to_object_func, to_dtype_func, * memview.dtype_is_object) # <<<<<<<<<<<<<< * * */ - __pyx_t_5 = __pyx_memoryview_fromslice((__pyx_v_memviewslice[0]), __pyx_v_memview->view.ndim, __pyx_v_to_object_func, __pyx_v_to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1101, __pyx_L1_error) + __pyx_t_5 = __pyx_memoryview_fromslice((__pyx_v_memviewslice[0]), __pyx_v_memview->view.ndim, __pyx_v_to_object_func, __pyx_v_to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 1097, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; - /* "View.MemoryView":1087 + /* "View.MemoryView":1083 * * @cname('__pyx_memoryview_copy_object_from_slice') * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< @@ -18312,7 +19018,7 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview return __pyx_r; } -/* "View.MemoryView":1109 +/* "View.MemoryView":1105 * * * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< @@ -18324,7 +19030,7 @@ static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { Py_ssize_t __pyx_r; int __pyx_t_1; - /* "View.MemoryView":1110 + /* "View.MemoryView":1106 * * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: * if arg < 0: # <<<<<<<<<<<<<< @@ -18334,7 +19040,7 @@ static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { __pyx_t_1 = ((__pyx_v_arg < 0) != 0); if (__pyx_t_1) { - /* "View.MemoryView":1111 + /* "View.MemoryView":1107 * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: * if arg < 0: * return -arg # <<<<<<<<<<<<<< @@ -18344,7 +19050,7 @@ static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { __pyx_r = (-__pyx_v_arg); goto __pyx_L0; - /* "View.MemoryView":1110 + /* "View.MemoryView":1106 * * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: * if arg < 0: # <<<<<<<<<<<<<< @@ -18353,7 +19059,7 @@ static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { */ } - /* "View.MemoryView":1113 + /* "View.MemoryView":1109 * return -arg * else: * return arg # <<<<<<<<<<<<<< @@ -18365,7 +19071,7 @@ static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { goto __pyx_L0; } - /* "View.MemoryView":1109 + /* "View.MemoryView":1105 * * * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< @@ -18378,7 +19084,7 @@ static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { return __pyx_r; } -/* "View.MemoryView":1116 +/* "View.MemoryView":1112 * * @cname('__pyx_get_best_slice_order') * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<< @@ -18396,7 +19102,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ int __pyx_t_3; int __pyx_t_4; - /* "View.MemoryView":1121 + /* "View.MemoryView":1117 * """ * cdef int i * cdef Py_ssize_t c_stride = 0 # <<<<<<<<<<<<<< @@ -18405,7 +19111,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ */ __pyx_v_c_stride = 0; - /* "View.MemoryView":1122 + /* "View.MemoryView":1118 * cdef int i * cdef Py_ssize_t c_stride = 0 * cdef Py_ssize_t f_stride = 0 # <<<<<<<<<<<<<< @@ -18414,7 +19120,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ */ __pyx_v_f_stride = 0; - /* "View.MemoryView":1124 + /* "View.MemoryView":1120 * cdef Py_ssize_t f_stride = 0 * * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< @@ -18424,7 +19130,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { __pyx_v_i = __pyx_t_1; - /* "View.MemoryView":1125 + /* "View.MemoryView":1121 * * for i in range(ndim - 1, -1, -1): * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< @@ -18434,7 +19140,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1126 + /* "View.MemoryView":1122 * for i in range(ndim - 1, -1, -1): * if mslice.shape[i] > 1: * c_stride = mslice.strides[i] # <<<<<<<<<<<<<< @@ -18443,7 +19149,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ */ __pyx_v_c_stride = (__pyx_v_mslice->strides[__pyx_v_i]); - /* "View.MemoryView":1127 + /* "View.MemoryView":1123 * if mslice.shape[i] > 1: * c_stride = mslice.strides[i] * break # <<<<<<<<<<<<<< @@ -18452,7 +19158,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ */ goto __pyx_L4_break; - /* "View.MemoryView":1125 + /* "View.MemoryView":1121 * * for i in range(ndim - 1, -1, -1): * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< @@ -18463,7 +19169,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ } __pyx_L4_break:; - /* "View.MemoryView":1129 + /* "View.MemoryView":1125 * break * * for i in range(ndim): # <<<<<<<<<<<<<< @@ -18475,7 +19181,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - /* "View.MemoryView":1130 + /* "View.MemoryView":1126 * * for i in range(ndim): * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< @@ -18485,7 +19191,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1131 + /* "View.MemoryView":1127 * for i in range(ndim): * if mslice.shape[i] > 1: * f_stride = mslice.strides[i] # <<<<<<<<<<<<<< @@ -18494,7 +19200,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ */ __pyx_v_f_stride = (__pyx_v_mslice->strides[__pyx_v_i]); - /* "View.MemoryView":1132 + /* "View.MemoryView":1128 * if mslice.shape[i] > 1: * f_stride = mslice.strides[i] * break # <<<<<<<<<<<<<< @@ -18503,7 +19209,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ */ goto __pyx_L7_break; - /* "View.MemoryView":1130 + /* "View.MemoryView":1126 * * for i in range(ndim): * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< @@ -18514,7 +19220,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ } __pyx_L7_break:; - /* "View.MemoryView":1134 + /* "View.MemoryView":1130 * break * * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< @@ -18524,7 +19230,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ __pyx_t_2 = ((abs_py_ssize_t(__pyx_v_c_stride) <= abs_py_ssize_t(__pyx_v_f_stride)) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1135 + /* "View.MemoryView":1131 * * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): * return 'C' # <<<<<<<<<<<<<< @@ -18534,7 +19240,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ __pyx_r = 'C'; goto __pyx_L0; - /* "View.MemoryView":1134 + /* "View.MemoryView":1130 * break * * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< @@ -18543,7 +19249,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ */ } - /* "View.MemoryView":1137 + /* "View.MemoryView":1133 * return 'C' * else: * return 'F' # <<<<<<<<<<<<<< @@ -18555,7 +19261,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ goto __pyx_L0; } - /* "View.MemoryView":1116 + /* "View.MemoryView":1112 * * @cname('__pyx_get_best_slice_order') * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<< @@ -18568,7 +19274,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ return __pyx_r; } -/* "View.MemoryView":1140 +/* "View.MemoryView":1136 * * @cython.cdivision(True) * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< @@ -18589,7 +19295,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v Py_ssize_t __pyx_t_5; Py_ssize_t __pyx_t_6; - /* "View.MemoryView":1147 + /* "View.MemoryView":1143 * * cdef Py_ssize_t i * cdef Py_ssize_t src_extent = src_shape[0] # <<<<<<<<<<<<<< @@ -18598,7 +19304,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ __pyx_v_src_extent = (__pyx_v_src_shape[0]); - /* "View.MemoryView":1148 + /* "View.MemoryView":1144 * cdef Py_ssize_t i * cdef Py_ssize_t src_extent = src_shape[0] * cdef Py_ssize_t dst_extent = dst_shape[0] # <<<<<<<<<<<<<< @@ -18607,7 +19313,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ __pyx_v_dst_extent = (__pyx_v_dst_shape[0]); - /* "View.MemoryView":1149 + /* "View.MemoryView":1145 * cdef Py_ssize_t src_extent = src_shape[0] * cdef Py_ssize_t dst_extent = dst_shape[0] * cdef Py_ssize_t src_stride = src_strides[0] # <<<<<<<<<<<<<< @@ -18616,7 +19322,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ __pyx_v_src_stride = (__pyx_v_src_strides[0]); - /* "View.MemoryView":1150 + /* "View.MemoryView":1146 * cdef Py_ssize_t dst_extent = dst_shape[0] * cdef Py_ssize_t src_stride = src_strides[0] * cdef Py_ssize_t dst_stride = dst_strides[0] # <<<<<<<<<<<<<< @@ -18625,7 +19331,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ __pyx_v_dst_stride = (__pyx_v_dst_strides[0]); - /* "View.MemoryView":1152 + /* "View.MemoryView":1148 * cdef Py_ssize_t dst_stride = dst_strides[0] * * if ndim == 1: # <<<<<<<<<<<<<< @@ -18635,7 +19341,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v __pyx_t_1 = ((__pyx_v_ndim == 1) != 0); if (__pyx_t_1) { - /* "View.MemoryView":1153 + /* "View.MemoryView":1149 * * if ndim == 1: * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< @@ -18655,7 +19361,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v goto __pyx_L5_bool_binop_done; } - /* "View.MemoryView":1154 + /* "View.MemoryView":1150 * if ndim == 1: * if (src_stride > 0 and dst_stride > 0 and * src_stride == itemsize == dst_stride): # <<<<<<<<<<<<<< @@ -18670,7 +19376,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v __pyx_t_1 = __pyx_t_3; __pyx_L5_bool_binop_done:; - /* "View.MemoryView":1153 + /* "View.MemoryView":1149 * * if ndim == 1: * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< @@ -18679,7 +19385,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ if (__pyx_t_1) { - /* "View.MemoryView":1155 + /* "View.MemoryView":1151 * if (src_stride > 0 and dst_stride > 0 and * src_stride == itemsize == dst_stride): * memcpy(dst_data, src_data, itemsize * dst_extent) # <<<<<<<<<<<<<< @@ -18688,7 +19394,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, (__pyx_v_itemsize * __pyx_v_dst_extent))); - /* "View.MemoryView":1153 + /* "View.MemoryView":1149 * * if ndim == 1: * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< @@ -18698,7 +19404,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v goto __pyx_L4; } - /* "View.MemoryView":1157 + /* "View.MemoryView":1153 * memcpy(dst_data, src_data, itemsize * dst_extent) * else: * for i in range(dst_extent): # <<<<<<<<<<<<<< @@ -18711,7 +19417,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "View.MemoryView":1158 + /* "View.MemoryView":1154 * else: * for i in range(dst_extent): * memcpy(dst_data, src_data, itemsize) # <<<<<<<<<<<<<< @@ -18720,7 +19426,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, __pyx_v_itemsize)); - /* "View.MemoryView":1159 + /* "View.MemoryView":1155 * for i in range(dst_extent): * memcpy(dst_data, src_data, itemsize) * src_data += src_stride # <<<<<<<<<<<<<< @@ -18729,7 +19435,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); - /* "View.MemoryView":1160 + /* "View.MemoryView":1156 * memcpy(dst_data, src_data, itemsize) * src_data += src_stride * dst_data += dst_stride # <<<<<<<<<<<<<< @@ -18741,7 +19447,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v } __pyx_L4:; - /* "View.MemoryView":1152 + /* "View.MemoryView":1148 * cdef Py_ssize_t dst_stride = dst_strides[0] * * if ndim == 1: # <<<<<<<<<<<<<< @@ -18751,7 +19457,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v goto __pyx_L3; } - /* "View.MemoryView":1162 + /* "View.MemoryView":1158 * dst_data += dst_stride * else: * for i in range(dst_extent): # <<<<<<<<<<<<<< @@ -18764,7 +19470,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "View.MemoryView":1163 + /* "View.MemoryView":1159 * else: * for i in range(dst_extent): * _copy_strided_to_strided(src_data, src_strides + 1, # <<<<<<<<<<<<<< @@ -18773,7 +19479,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ _copy_strided_to_strided(__pyx_v_src_data, (__pyx_v_src_strides + 1), __pyx_v_dst_data, (__pyx_v_dst_strides + 1), (__pyx_v_src_shape + 1), (__pyx_v_dst_shape + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize); - /* "View.MemoryView":1167 + /* "View.MemoryView":1163 * src_shape + 1, dst_shape + 1, * ndim - 1, itemsize) * src_data += src_stride # <<<<<<<<<<<<<< @@ -18782,7 +19488,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); - /* "View.MemoryView":1168 + /* "View.MemoryView":1164 * ndim - 1, itemsize) * src_data += src_stride * dst_data += dst_stride # <<<<<<<<<<<<<< @@ -18794,7 +19500,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v } __pyx_L3:; - /* "View.MemoryView":1140 + /* "View.MemoryView":1136 * * @cython.cdivision(True) * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< @@ -18805,7 +19511,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v /* function exit code */ } -/* "View.MemoryView":1170 +/* "View.MemoryView":1166 * dst_data += dst_stride * * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< @@ -18815,7 +19521,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v static void copy_strided_to_strided(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize) { - /* "View.MemoryView":1173 + /* "View.MemoryView":1169 * __Pyx_memviewslice *dst, * int ndim, size_t itemsize) nogil: * _copy_strided_to_strided(src.data, src.strides, dst.data, dst.strides, # <<<<<<<<<<<<<< @@ -18824,7 +19530,7 @@ static void copy_strided_to_strided(__Pyx_memviewslice *__pyx_v_src, __Pyx_memvi */ _copy_strided_to_strided(__pyx_v_src->data, __pyx_v_src->strides, __pyx_v_dst->data, __pyx_v_dst->strides, __pyx_v_src->shape, __pyx_v_dst->shape, __pyx_v_ndim, __pyx_v_itemsize); - /* "View.MemoryView":1170 + /* "View.MemoryView":1166 * dst_data += dst_stride * * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< @@ -18835,57 +19541,57 @@ static void copy_strided_to_strided(__Pyx_memviewslice *__pyx_v_src, __Pyx_memvi /* function exit code */ } -/* "View.MemoryView":1177 +/* "View.MemoryView":1173 * * @cname('__pyx_memoryview_slice_get_size') * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<< * "Return the size of the memory occupied by the slice in number of bytes" - * cdef Py_ssize_t shape, size = src.memview.view.itemsize + * cdef int i */ static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_src, int __pyx_v_ndim) { - Py_ssize_t __pyx_v_shape; + int __pyx_v_i; Py_ssize_t __pyx_v_size; Py_ssize_t __pyx_r; Py_ssize_t __pyx_t_1; - Py_ssize_t *__pyx_t_2; - Py_ssize_t *__pyx_t_3; - Py_ssize_t *__pyx_t_4; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; - /* "View.MemoryView":1179 - * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: + /* "View.MemoryView":1176 * "Return the size of the memory occupied by the slice in number of bytes" - * cdef Py_ssize_t shape, size = src.memview.view.itemsize # <<<<<<<<<<<<<< + * cdef int i + * cdef Py_ssize_t size = src.memview.view.itemsize # <<<<<<<<<<<<<< * - * for shape in src.shape[:ndim]: + * for i in range(ndim): */ __pyx_t_1 = __pyx_v_src->memview->view.itemsize; __pyx_v_size = __pyx_t_1; - /* "View.MemoryView":1181 - * cdef Py_ssize_t shape, size = src.memview.view.itemsize + /* "View.MemoryView":1178 + * cdef Py_ssize_t size = src.memview.view.itemsize * - * for shape in src.shape[:ndim]: # <<<<<<<<<<<<<< - * size *= shape + * for i in range(ndim): # <<<<<<<<<<<<<< + * size *= src.shape[i] * */ - __pyx_t_3 = (__pyx_v_src->shape + __pyx_v_ndim); - for (__pyx_t_4 = __pyx_v_src->shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { - __pyx_t_2 = __pyx_t_4; - __pyx_v_shape = (__pyx_t_2[0]); + __pyx_t_2 = __pyx_v_ndim; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; - /* "View.MemoryView":1182 + /* "View.MemoryView":1179 * - * for shape in src.shape[:ndim]: - * size *= shape # <<<<<<<<<<<<<< + * for i in range(ndim): + * size *= src.shape[i] # <<<<<<<<<<<<<< * * return size */ - __pyx_v_size = (__pyx_v_size * __pyx_v_shape); + __pyx_v_size = (__pyx_v_size * (__pyx_v_src->shape[__pyx_v_i])); } - /* "View.MemoryView":1184 - * size *= shape + /* "View.MemoryView":1181 + * size *= src.shape[i] * * return size # <<<<<<<<<<<<<< * @@ -18894,12 +19600,12 @@ static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_sr __pyx_r = __pyx_v_size; goto __pyx_L0; - /* "View.MemoryView":1177 + /* "View.MemoryView":1173 * * @cname('__pyx_memoryview_slice_get_size') * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<< * "Return the size of the memory occupied by the slice in number of bytes" - * cdef Py_ssize_t shape, size = src.memview.view.itemsize + * cdef int i */ /* function exit code */ @@ -18907,7 +19613,7 @@ static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_sr return __pyx_r; } -/* "View.MemoryView":1187 +/* "View.MemoryView":1184 * * @cname('__pyx_fill_contig_strides_array') * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< @@ -18923,7 +19629,7 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ int __pyx_t_3; int __pyx_t_4; - /* "View.MemoryView":1196 + /* "View.MemoryView":1193 * cdef int idx * * if order == 'F': # <<<<<<<<<<<<<< @@ -18933,38 +19639,38 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ __pyx_t_1 = ((__pyx_v_order == 'F') != 0); if (__pyx_t_1) { - /* "View.MemoryView":1197 + /* "View.MemoryView":1194 * * if order == 'F': * for idx in range(ndim): # <<<<<<<<<<<<<< * strides[idx] = stride - * stride *= shape[idx] + * stride = stride * shape[idx] */ __pyx_t_2 = __pyx_v_ndim; __pyx_t_3 = __pyx_t_2; for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_idx = __pyx_t_4; - /* "View.MemoryView":1198 + /* "View.MemoryView":1195 * if order == 'F': * for idx in range(ndim): * strides[idx] = stride # <<<<<<<<<<<<<< - * stride *= shape[idx] + * stride = stride * shape[idx] * else: */ (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; - /* "View.MemoryView":1199 + /* "View.MemoryView":1196 * for idx in range(ndim): * strides[idx] = stride - * stride *= shape[idx] # <<<<<<<<<<<<<< + * stride = stride * shape[idx] # <<<<<<<<<<<<<< * else: * for idx in range(ndim - 1, -1, -1): */ __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx])); } - /* "View.MemoryView":1196 + /* "View.MemoryView":1193 * cdef int idx * * if order == 'F': # <<<<<<<<<<<<<< @@ -18974,30 +19680,30 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ goto __pyx_L3; } - /* "View.MemoryView":1201 - * stride *= shape[idx] + /* "View.MemoryView":1198 + * stride = stride * shape[idx] * else: * for idx in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< * strides[idx] = stride - * stride *= shape[idx] + * stride = stride * shape[idx] */ /*else*/ { for (__pyx_t_2 = (__pyx_v_ndim - 1); __pyx_t_2 > -1; __pyx_t_2-=1) { __pyx_v_idx = __pyx_t_2; - /* "View.MemoryView":1202 + /* "View.MemoryView":1199 * else: * for idx in range(ndim - 1, -1, -1): * strides[idx] = stride # <<<<<<<<<<<<<< - * stride *= shape[idx] + * stride = stride * shape[idx] * */ (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; - /* "View.MemoryView":1203 + /* "View.MemoryView":1200 * for idx in range(ndim - 1, -1, -1): * strides[idx] = stride - * stride *= shape[idx] # <<<<<<<<<<<<<< + * stride = stride * shape[idx] # <<<<<<<<<<<<<< * * return stride */ @@ -19006,8 +19712,8 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ } __pyx_L3:; - /* "View.MemoryView":1205 - * stride *= shape[idx] + /* "View.MemoryView":1202 + * stride = stride * shape[idx] * * return stride # <<<<<<<<<<<<<< * @@ -19016,7 +19722,7 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ __pyx_r = __pyx_v_stride; goto __pyx_L0; - /* "View.MemoryView":1187 + /* "View.MemoryView":1184 * * @cname('__pyx_fill_contig_strides_array') * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< @@ -19029,7 +19735,7 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ return __pyx_r; } -/* "View.MemoryView":1208 +/* "View.MemoryView":1205 * * @cname('__pyx_memoryview_copy_data_to_temp') * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< @@ -19049,11 +19755,8 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, struct __pyx_memoryview_obj *__pyx_t_4; int __pyx_t_5; int __pyx_t_6; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - /* "View.MemoryView":1219 + /* "View.MemoryView":1216 * cdef void *result * * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< @@ -19063,7 +19766,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __pyx_t_1 = __pyx_v_src->memview->view.itemsize; __pyx_v_itemsize = __pyx_t_1; - /* "View.MemoryView":1220 + /* "View.MemoryView":1217 * * cdef size_t itemsize = src.memview.view.itemsize * cdef size_t size = slice_get_size(src, ndim) # <<<<<<<<<<<<<< @@ -19072,7 +19775,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, */ __pyx_v_size = __pyx_memoryview_slice_get_size(__pyx_v_src, __pyx_v_ndim); - /* "View.MemoryView":1222 + /* "View.MemoryView":1219 * cdef size_t size = slice_get_size(src, ndim) * * result = malloc(size) # <<<<<<<<<<<<<< @@ -19081,7 +19784,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, */ __pyx_v_result = malloc(__pyx_v_size); - /* "View.MemoryView":1223 + /* "View.MemoryView":1220 * * result = malloc(size) * if not result: # <<<<<<<<<<<<<< @@ -19091,16 +19794,16 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __pyx_t_2 = ((!(__pyx_v_result != 0)) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1224 + /* "View.MemoryView":1221 * result = malloc(size) * if not result: * _err(MemoryError, NULL) # <<<<<<<<<<<<<< * * */ - __pyx_t_3 = __pyx_memoryview_err(__pyx_builtin_MemoryError, NULL); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 1224, __pyx_L1_error) + __pyx_t_3 = __pyx_memoryview_err(__pyx_builtin_MemoryError, NULL); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(2, 1221, __pyx_L1_error) - /* "View.MemoryView":1223 + /* "View.MemoryView":1220 * * result = malloc(size) * if not result: # <<<<<<<<<<<<<< @@ -19109,7 +19812,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, */ } - /* "View.MemoryView":1227 + /* "View.MemoryView":1224 * * * tmpslice.data = result # <<<<<<<<<<<<<< @@ -19118,7 +19821,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, */ __pyx_v_tmpslice->data = ((char *)__pyx_v_result); - /* "View.MemoryView":1228 + /* "View.MemoryView":1225 * * tmpslice.data = result * tmpslice.memview = src.memview # <<<<<<<<<<<<<< @@ -19128,7 +19831,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __pyx_t_4 = __pyx_v_src->memview; __pyx_v_tmpslice->memview = __pyx_t_4; - /* "View.MemoryView":1229 + /* "View.MemoryView":1226 * tmpslice.data = result * tmpslice.memview = src.memview * for i in range(ndim): # <<<<<<<<<<<<<< @@ -19140,7 +19843,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "View.MemoryView":1230 + /* "View.MemoryView":1227 * tmpslice.memview = src.memview * for i in range(ndim): * tmpslice.shape[i] = src.shape[i] # <<<<<<<<<<<<<< @@ -19149,7 +19852,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, */ (__pyx_v_tmpslice->shape[__pyx_v_i]) = (__pyx_v_src->shape[__pyx_v_i]); - /* "View.MemoryView":1231 + /* "View.MemoryView":1228 * for i in range(ndim): * tmpslice.shape[i] = src.shape[i] * tmpslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< @@ -19159,7 +19862,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, (__pyx_v_tmpslice->suboffsets[__pyx_v_i]) = -1L; } - /* "View.MemoryView":1233 + /* "View.MemoryView":1230 * tmpslice.suboffsets[i] = -1 * * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, # <<<<<<<<<<<<<< @@ -19168,7 +19871,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, */ (void)(__pyx_fill_contig_strides_array((&(__pyx_v_tmpslice->shape[0])), (&(__pyx_v_tmpslice->strides[0])), __pyx_v_itemsize, __pyx_v_ndim, __pyx_v_order)); - /* "View.MemoryView":1237 + /* "View.MemoryView":1234 * * * for i in range(ndim): # <<<<<<<<<<<<<< @@ -19180,7 +19883,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "View.MemoryView":1238 + /* "View.MemoryView":1235 * * for i in range(ndim): * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< @@ -19190,7 +19893,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __pyx_t_2 = (((__pyx_v_tmpslice->shape[__pyx_v_i]) == 1) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1239 + /* "View.MemoryView":1236 * for i in range(ndim): * if tmpslice.shape[i] == 1: * tmpslice.strides[i] = 0 # <<<<<<<<<<<<<< @@ -19199,7 +19902,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, */ (__pyx_v_tmpslice->strides[__pyx_v_i]) = 0; - /* "View.MemoryView":1238 + /* "View.MemoryView":1235 * * for i in range(ndim): * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< @@ -19209,7 +19912,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, } } - /* "View.MemoryView":1241 + /* "View.MemoryView":1238 * tmpslice.strides[i] = 0 * * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< @@ -19219,7 +19922,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __pyx_t_2 = (__pyx_memviewslice_is_contig((__pyx_v_src[0]), __pyx_v_order, __pyx_v_ndim) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1242 + /* "View.MemoryView":1239 * * if slice_is_contig(src[0], order, ndim): * memcpy(result, src.data, size) # <<<<<<<<<<<<<< @@ -19228,7 +19931,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, */ (void)(memcpy(__pyx_v_result, __pyx_v_src->data, __pyx_v_size)); - /* "View.MemoryView":1241 + /* "View.MemoryView":1238 * tmpslice.strides[i] = 0 * * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< @@ -19238,7 +19941,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, goto __pyx_L9; } - /* "View.MemoryView":1244 + /* "View.MemoryView":1241 * memcpy(result, src.data, size) * else: * copy_strided_to_strided(src, tmpslice, ndim, itemsize) # <<<<<<<<<<<<<< @@ -19250,7 +19953,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, } __pyx_L9:; - /* "View.MemoryView":1246 + /* "View.MemoryView":1243 * copy_strided_to_strided(src, tmpslice, ndim, itemsize) * * return result # <<<<<<<<<<<<<< @@ -19260,7 +19963,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __pyx_r = __pyx_v_result; goto __pyx_L0; - /* "View.MemoryView":1208 + /* "View.MemoryView":1205 * * @cname('__pyx_memoryview_copy_data_to_temp') * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< @@ -19284,7 +19987,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, return __pyx_r; } -/* "View.MemoryView":1251 +/* "View.MemoryView":1248 * * @cname('__pyx_memoryview_err_extents') * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< @@ -19299,28 +20002,25 @@ static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("_err_extents", 0); - /* "View.MemoryView":1254 + /* "View.MemoryView":1251 * Py_ssize_t extent2) except -1 with gil: * raise ValueError("got differing extents in dimension %d (got %d and %d)" % * (i, extent1, extent2)) # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_err_dim') */ - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1254, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1251, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_extent1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1254, __pyx_L1_error) + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_extent1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1251, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_extent2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1254, __pyx_L1_error) + __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_extent2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1251, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1254, __pyx_L1_error) + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1251, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); @@ -19332,24 +20032,24 @@ static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent __pyx_t_2 = 0; __pyx_t_3 = 0; - /* "View.MemoryView":1253 + /* "View.MemoryView":1250 * cdef int _err_extents(int i, Py_ssize_t extent1, * Py_ssize_t extent2) except -1 with gil: * raise ValueError("got differing extents in dimension %d (got %d and %d)" % # <<<<<<<<<<<<<< * (i, extent1, extent2)) * */ - __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1253, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1250, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1253, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1250, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(2, 1253, __pyx_L1_error) + __PYX_ERR(2, 1250, __pyx_L1_error) - /* "View.MemoryView":1251 + /* "View.MemoryView":1248 * * @cname('__pyx_memoryview_err_extents') * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< @@ -19372,7 +20072,7 @@ static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent return __pyx_r; } -/* "View.MemoryView":1257 +/* "View.MemoryView":1254 * * @cname('__pyx_memoryview_err_dim') * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< @@ -19387,27 +20087,24 @@ static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg, PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("_err_dim", 0); __Pyx_INCREF(__pyx_v_error); - /* "View.MemoryView":1258 + /* "View.MemoryView":1255 * @cname('__pyx_memoryview_err_dim') * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: * raise error(msg.decode('ascii') % dim) # <<<<<<<<<<<<<< * * @cname('__pyx_memoryview_err') */ - __pyx_t_2 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1258, __pyx_L1_error) + __pyx_t_2 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1258, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyUnicode_Format(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1258, __pyx_L1_error) + __pyx_t_4 = PyUnicode_Format(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 1255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -19425,14 +20122,14 @@ static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg, __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1258, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 1255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(2, 1258, __pyx_L1_error) + __PYX_ERR(2, 1255, __pyx_L1_error) - /* "View.MemoryView":1257 + /* "View.MemoryView":1254 * * @cname('__pyx_memoryview_err_dim') * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< @@ -19456,7 +20153,7 @@ static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg, return __pyx_r; } -/* "View.MemoryView":1261 +/* "View.MemoryView":1258 * * @cname('__pyx_memoryview_err') * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< @@ -19472,16 +20169,13 @@ static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("_err", 0); __Pyx_INCREF(__pyx_v_error); - /* "View.MemoryView":1262 + /* "View.MemoryView":1259 * @cname('__pyx_memoryview_err') * cdef int _err(object error, char *msg) except -1 with gil: * if msg != NULL: # <<<<<<<<<<<<<< @@ -19491,14 +20185,14 @@ static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { __pyx_t_1 = ((__pyx_v_msg != NULL) != 0); if (unlikely(__pyx_t_1)) { - /* "View.MemoryView":1263 + /* "View.MemoryView":1260 * cdef int _err(object error, char *msg) except -1 with gil: * if msg != NULL: * raise error(msg.decode('ascii')) # <<<<<<<<<<<<<< * else: * raise error */ - __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1263, __pyx_L1_error) + __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 1260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_error); __pyx_t_4 = __pyx_v_error; __pyx_t_5 = NULL; @@ -19514,14 +20208,14 @@ static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1263, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 1260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(2, 1263, __pyx_L1_error) + __PYX_ERR(2, 1260, __pyx_L1_error) - /* "View.MemoryView":1262 + /* "View.MemoryView":1259 * @cname('__pyx_memoryview_err') * cdef int _err(object error, char *msg) except -1 with gil: * if msg != NULL: # <<<<<<<<<<<<<< @@ -19530,7 +20224,7 @@ static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { */ } - /* "View.MemoryView":1265 + /* "View.MemoryView":1262 * raise error(msg.decode('ascii')) * else: * raise error # <<<<<<<<<<<<<< @@ -19539,10 +20233,10 @@ static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { */ /*else*/ { __Pyx_Raise(__pyx_v_error, 0, 0, 0); - __PYX_ERR(2, 1265, __pyx_L1_error) + __PYX_ERR(2, 1262, __pyx_L1_error) } - /* "View.MemoryView":1261 + /* "View.MemoryView":1258 * * @cname('__pyx_memoryview_err') * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< @@ -19566,7 +20260,7 @@ static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { return __pyx_r; } -/* "View.MemoryView":1268 +/* "View.MemoryView":1265 * * @cname('__pyx_memoryview_copy_contents') * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< @@ -19592,11 +20286,8 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ int __pyx_t_6; void *__pyx_t_7; int __pyx_t_8; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - /* "View.MemoryView":1276 + /* "View.MemoryView":1273 * Check for overlapping memory and verify the shapes. * """ * cdef void *tmpdata = NULL # <<<<<<<<<<<<<< @@ -19605,7 +20296,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_tmpdata = NULL; - /* "View.MemoryView":1277 + /* "View.MemoryView":1274 * """ * cdef void *tmpdata = NULL * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< @@ -19615,7 +20306,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_1 = __pyx_v_src.memview->view.itemsize; __pyx_v_itemsize = __pyx_t_1; - /* "View.MemoryView":1279 + /* "View.MemoryView":1276 * cdef size_t itemsize = src.memview.view.itemsize * cdef int i * cdef char order = get_best_order(&src, src_ndim) # <<<<<<<<<<<<<< @@ -19624,7 +20315,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_src), __pyx_v_src_ndim); - /* "View.MemoryView":1280 + /* "View.MemoryView":1277 * cdef int i * cdef char order = get_best_order(&src, src_ndim) * cdef bint broadcasting = False # <<<<<<<<<<<<<< @@ -19633,7 +20324,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_broadcasting = 0; - /* "View.MemoryView":1281 + /* "View.MemoryView":1278 * cdef char order = get_best_order(&src, src_ndim) * cdef bint broadcasting = False * cdef bint direct_copy = False # <<<<<<<<<<<<<< @@ -19642,7 +20333,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_direct_copy = 0; - /* "View.MemoryView":1284 + /* "View.MemoryView":1281 * cdef __Pyx_memviewslice tmp * * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< @@ -19652,7 +20343,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_2 = ((__pyx_v_src_ndim < __pyx_v_dst_ndim) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1285 + /* "View.MemoryView":1282 * * if src_ndim < dst_ndim: * broadcast_leading(&src, src_ndim, dst_ndim) # <<<<<<<<<<<<<< @@ -19661,7 +20352,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_memoryview_broadcast_leading((&__pyx_v_src), __pyx_v_src_ndim, __pyx_v_dst_ndim); - /* "View.MemoryView":1284 + /* "View.MemoryView":1281 * cdef __Pyx_memviewslice tmp * * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< @@ -19671,7 +20362,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ goto __pyx_L3; } - /* "View.MemoryView":1286 + /* "View.MemoryView":1283 * if src_ndim < dst_ndim: * broadcast_leading(&src, src_ndim, dst_ndim) * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< @@ -19681,7 +20372,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_2 = ((__pyx_v_dst_ndim < __pyx_v_src_ndim) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1287 + /* "View.MemoryView":1284 * broadcast_leading(&src, src_ndim, dst_ndim) * elif dst_ndim < src_ndim: * broadcast_leading(&dst, dst_ndim, src_ndim) # <<<<<<<<<<<<<< @@ -19690,7 +20381,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_memoryview_broadcast_leading((&__pyx_v_dst), __pyx_v_dst_ndim, __pyx_v_src_ndim); - /* "View.MemoryView":1286 + /* "View.MemoryView":1283 * if src_ndim < dst_ndim: * broadcast_leading(&src, src_ndim, dst_ndim) * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< @@ -19700,7 +20391,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ } __pyx_L3:; - /* "View.MemoryView":1289 + /* "View.MemoryView":1286 * broadcast_leading(&dst, dst_ndim, src_ndim) * * cdef int ndim = max(src_ndim, dst_ndim) # <<<<<<<<<<<<<< @@ -19716,7 +20407,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ } __pyx_v_ndim = __pyx_t_5; - /* "View.MemoryView":1291 + /* "View.MemoryView":1288 * cdef int ndim = max(src_ndim, dst_ndim) * * for i in range(ndim): # <<<<<<<<<<<<<< @@ -19728,7 +20419,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - /* "View.MemoryView":1292 + /* "View.MemoryView":1289 * * for i in range(ndim): * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< @@ -19738,7 +20429,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) != (__pyx_v_dst.shape[__pyx_v_i])) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1293 + /* "View.MemoryView":1290 * for i in range(ndim): * if src.shape[i] != dst.shape[i]: * if src.shape[i] == 1: # <<<<<<<<<<<<<< @@ -19748,7 +20439,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) == 1) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1294 + /* "View.MemoryView":1291 * if src.shape[i] != dst.shape[i]: * if src.shape[i] == 1: * broadcasting = True # <<<<<<<<<<<<<< @@ -19757,7 +20448,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_broadcasting = 1; - /* "View.MemoryView":1295 + /* "View.MemoryView":1292 * if src.shape[i] == 1: * broadcasting = True * src.strides[i] = 0 # <<<<<<<<<<<<<< @@ -19766,7 +20457,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ (__pyx_v_src.strides[__pyx_v_i]) = 0; - /* "View.MemoryView":1293 + /* "View.MemoryView":1290 * for i in range(ndim): * if src.shape[i] != dst.shape[i]: * if src.shape[i] == 1: # <<<<<<<<<<<<<< @@ -19776,7 +20467,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ goto __pyx_L7; } - /* "View.MemoryView":1297 + /* "View.MemoryView":1294 * src.strides[i] = 0 * else: * _err_extents(i, dst.shape[i], src.shape[i]) # <<<<<<<<<<<<<< @@ -19784,11 +20475,11 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ * if src.suboffsets[i] >= 0: */ /*else*/ { - __pyx_t_6 = __pyx_memoryview_err_extents(__pyx_v_i, (__pyx_v_dst.shape[__pyx_v_i]), (__pyx_v_src.shape[__pyx_v_i])); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(2, 1297, __pyx_L1_error) + __pyx_t_6 = __pyx_memoryview_err_extents(__pyx_v_i, (__pyx_v_dst.shape[__pyx_v_i]), (__pyx_v_src.shape[__pyx_v_i])); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(2, 1294, __pyx_L1_error) } __pyx_L7:; - /* "View.MemoryView":1292 + /* "View.MemoryView":1289 * * for i in range(ndim): * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< @@ -19797,7 +20488,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ } - /* "View.MemoryView":1299 + /* "View.MemoryView":1296 * _err_extents(i, dst.shape[i], src.shape[i]) * * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< @@ -19807,16 +20498,16 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_2 = (((__pyx_v_src.suboffsets[__pyx_v_i]) >= 0) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1300 + /* "View.MemoryView":1297 * * if src.suboffsets[i] >= 0: * _err_dim(ValueError, "Dimension %d is not direct", i) # <<<<<<<<<<<<<< * * if slices_overlap(&src, &dst, ndim, itemsize): */ - __pyx_t_6 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Dimension %d is not direct"), __pyx_v_i); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(2, 1300, __pyx_L1_error) + __pyx_t_6 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Dimension %d is not direct"), __pyx_v_i); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(2, 1297, __pyx_L1_error) - /* "View.MemoryView":1299 + /* "View.MemoryView":1296 * _err_extents(i, dst.shape[i], src.shape[i]) * * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< @@ -19826,7 +20517,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ } } - /* "View.MemoryView":1302 + /* "View.MemoryView":1299 * _err_dim(ValueError, "Dimension %d is not direct", i) * * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< @@ -19836,7 +20527,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_2 = (__pyx_slices_overlap((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1304 + /* "View.MemoryView":1301 * if slices_overlap(&src, &dst, ndim, itemsize): * * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< @@ -19846,7 +20537,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_2 = ((!(__pyx_memviewslice_is_contig(__pyx_v_src, __pyx_v_order, __pyx_v_ndim) != 0)) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1305 + /* "View.MemoryView":1302 * * if not slice_is_contig(src, order, ndim): * order = get_best_order(&dst, ndim) # <<<<<<<<<<<<<< @@ -19855,7 +20546,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim); - /* "View.MemoryView":1304 + /* "View.MemoryView":1301 * if slices_overlap(&src, &dst, ndim, itemsize): * * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< @@ -19864,17 +20555,17 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ } - /* "View.MemoryView":1307 + /* "View.MemoryView":1304 * order = get_best_order(&dst, ndim) * * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) # <<<<<<<<<<<<<< * src = tmp * */ - __pyx_t_7 = __pyx_memoryview_copy_data_to_temp((&__pyx_v_src), (&__pyx_v_tmp), __pyx_v_order, __pyx_v_ndim); if (unlikely(__pyx_t_7 == ((void *)NULL))) __PYX_ERR(2, 1307, __pyx_L1_error) + __pyx_t_7 = __pyx_memoryview_copy_data_to_temp((&__pyx_v_src), (&__pyx_v_tmp), __pyx_v_order, __pyx_v_ndim); if (unlikely(__pyx_t_7 == ((void *)NULL))) __PYX_ERR(2, 1304, __pyx_L1_error) __pyx_v_tmpdata = __pyx_t_7; - /* "View.MemoryView":1308 + /* "View.MemoryView":1305 * * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) * src = tmp # <<<<<<<<<<<<<< @@ -19883,7 +20574,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_src = __pyx_v_tmp; - /* "View.MemoryView":1302 + /* "View.MemoryView":1299 * _err_dim(ValueError, "Dimension %d is not direct", i) * * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< @@ -19892,7 +20583,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ } - /* "View.MemoryView":1310 + /* "View.MemoryView":1307 * src = tmp * * if not broadcasting: # <<<<<<<<<<<<<< @@ -19902,7 +20593,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_2 = ((!(__pyx_v_broadcasting != 0)) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1313 + /* "View.MemoryView":1310 * * * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< @@ -19912,7 +20603,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'C', __pyx_v_ndim) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1314 + /* "View.MemoryView":1311 * * if slice_is_contig(src, 'C', ndim): * direct_copy = slice_is_contig(dst, 'C', ndim) # <<<<<<<<<<<<<< @@ -19921,7 +20612,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'C', __pyx_v_ndim); - /* "View.MemoryView":1313 + /* "View.MemoryView":1310 * * * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< @@ -19931,7 +20622,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ goto __pyx_L12; } - /* "View.MemoryView":1315 + /* "View.MemoryView":1312 * if slice_is_contig(src, 'C', ndim): * direct_copy = slice_is_contig(dst, 'C', ndim) * elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<< @@ -19941,7 +20632,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'F', __pyx_v_ndim) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1316 + /* "View.MemoryView":1313 * direct_copy = slice_is_contig(dst, 'C', ndim) * elif slice_is_contig(src, 'F', ndim): * direct_copy = slice_is_contig(dst, 'F', ndim) # <<<<<<<<<<<<<< @@ -19950,7 +20641,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'F', __pyx_v_ndim); - /* "View.MemoryView":1315 + /* "View.MemoryView":1312 * if slice_is_contig(src, 'C', ndim): * direct_copy = slice_is_contig(dst, 'C', ndim) * elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<< @@ -19960,7 +20651,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ } __pyx_L12:; - /* "View.MemoryView":1318 + /* "View.MemoryView":1315 * direct_copy = slice_is_contig(dst, 'F', ndim) * * if direct_copy: # <<<<<<<<<<<<<< @@ -19970,7 +20661,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_2 = (__pyx_v_direct_copy != 0); if (__pyx_t_2) { - /* "View.MemoryView":1320 + /* "View.MemoryView":1317 * if direct_copy: * * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< @@ -19979,7 +20670,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); - /* "View.MemoryView":1321 + /* "View.MemoryView":1318 * * refcount_copying(&dst, dtype_is_object, ndim, False) * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) # <<<<<<<<<<<<<< @@ -19988,7 +20679,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ (void)(memcpy(__pyx_v_dst.data, __pyx_v_src.data, __pyx_memoryview_slice_get_size((&__pyx_v_src), __pyx_v_ndim))); - /* "View.MemoryView":1322 + /* "View.MemoryView":1319 * refcount_copying(&dst, dtype_is_object, ndim, False) * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) * refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< @@ -19997,7 +20688,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); - /* "View.MemoryView":1323 + /* "View.MemoryView":1320 * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) * refcount_copying(&dst, dtype_is_object, ndim, True) * free(tmpdata) # <<<<<<<<<<<<<< @@ -20006,7 +20697,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ free(__pyx_v_tmpdata); - /* "View.MemoryView":1324 + /* "View.MemoryView":1321 * refcount_copying(&dst, dtype_is_object, ndim, True) * free(tmpdata) * return 0 # <<<<<<<<<<<<<< @@ -20016,7 +20707,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_r = 0; goto __pyx_L0; - /* "View.MemoryView":1318 + /* "View.MemoryView":1315 * direct_copy = slice_is_contig(dst, 'F', ndim) * * if direct_copy: # <<<<<<<<<<<<<< @@ -20025,7 +20716,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ } - /* "View.MemoryView":1310 + /* "View.MemoryView":1307 * src = tmp * * if not broadcasting: # <<<<<<<<<<<<<< @@ -20034,7 +20725,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ } - /* "View.MemoryView":1326 + /* "View.MemoryView":1323 * return 0 * * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< @@ -20048,25 +20739,25 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_8 = (__pyx_t_2 != 0); if (__pyx_t_8) { - /* "View.MemoryView":1329 + /* "View.MemoryView":1326 * * * transpose_memslice(&src) # <<<<<<<<<<<<<< * transpose_memslice(&dst) * */ - __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_src)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(2, 1329, __pyx_L1_error) + __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_src)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(2, 1326, __pyx_L1_error) - /* "View.MemoryView":1330 + /* "View.MemoryView":1327 * * transpose_memslice(&src) * transpose_memslice(&dst) # <<<<<<<<<<<<<< * * refcount_copying(&dst, dtype_is_object, ndim, False) */ - __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_dst)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(2, 1330, __pyx_L1_error) + __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_dst)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(2, 1327, __pyx_L1_error) - /* "View.MemoryView":1326 + /* "View.MemoryView":1323 * return 0 * * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< @@ -20075,7 +20766,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ } - /* "View.MemoryView":1332 + /* "View.MemoryView":1329 * transpose_memslice(&dst) * * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< @@ -20084,7 +20775,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); - /* "View.MemoryView":1333 + /* "View.MemoryView":1330 * * refcount_copying(&dst, dtype_is_object, ndim, False) * copy_strided_to_strided(&src, &dst, ndim, itemsize) # <<<<<<<<<<<<<< @@ -20093,7 +20784,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ copy_strided_to_strided((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize); - /* "View.MemoryView":1334 + /* "View.MemoryView":1331 * refcount_copying(&dst, dtype_is_object, ndim, False) * copy_strided_to_strided(&src, &dst, ndim, itemsize) * refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< @@ -20102,7 +20793,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); - /* "View.MemoryView":1336 + /* "View.MemoryView":1333 * refcount_copying(&dst, dtype_is_object, ndim, True) * * free(tmpdata) # <<<<<<<<<<<<<< @@ -20111,7 +20802,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ free(__pyx_v_tmpdata); - /* "View.MemoryView":1337 + /* "View.MemoryView":1334 * * free(tmpdata) * return 0 # <<<<<<<<<<<<<< @@ -20121,7 +20812,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_r = 0; goto __pyx_L0; - /* "View.MemoryView":1268 + /* "View.MemoryView":1265 * * @cname('__pyx_memoryview_copy_contents') * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< @@ -20145,7 +20836,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ return __pyx_r; } -/* "View.MemoryView":1340 +/* "View.MemoryView":1337 * * @cname('__pyx_memoryview_broadcast_leading') * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< @@ -20160,7 +20851,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic int __pyx_t_2; int __pyx_t_3; - /* "View.MemoryView":1344 + /* "View.MemoryView":1341 * int ndim_other) nogil: * cdef int i * cdef int offset = ndim_other - ndim # <<<<<<<<<<<<<< @@ -20169,7 +20860,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic */ __pyx_v_offset = (__pyx_v_ndim_other - __pyx_v_ndim); - /* "View.MemoryView":1346 + /* "View.MemoryView":1343 * cdef int offset = ndim_other - ndim * * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< @@ -20179,7 +20870,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { __pyx_v_i = __pyx_t_1; - /* "View.MemoryView":1347 + /* "View.MemoryView":1344 * * for i in range(ndim - 1, -1, -1): * mslice.shape[i + offset] = mslice.shape[i] # <<<<<<<<<<<<<< @@ -20188,7 +20879,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic */ (__pyx_v_mslice->shape[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->shape[__pyx_v_i]); - /* "View.MemoryView":1348 + /* "View.MemoryView":1345 * for i in range(ndim - 1, -1, -1): * mslice.shape[i + offset] = mslice.shape[i] * mslice.strides[i + offset] = mslice.strides[i] # <<<<<<<<<<<<<< @@ -20197,7 +20888,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic */ (__pyx_v_mslice->strides[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->strides[__pyx_v_i]); - /* "View.MemoryView":1349 + /* "View.MemoryView":1346 * mslice.shape[i + offset] = mslice.shape[i] * mslice.strides[i + offset] = mslice.strides[i] * mslice.suboffsets[i + offset] = mslice.suboffsets[i] # <<<<<<<<<<<<<< @@ -20207,7 +20898,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic (__pyx_v_mslice->suboffsets[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->suboffsets[__pyx_v_i]); } - /* "View.MemoryView":1351 + /* "View.MemoryView":1348 * mslice.suboffsets[i + offset] = mslice.suboffsets[i] * * for i in range(offset): # <<<<<<<<<<<<<< @@ -20219,7 +20910,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { __pyx_v_i = __pyx_t_3; - /* "View.MemoryView":1352 + /* "View.MemoryView":1349 * * for i in range(offset): * mslice.shape[i] = 1 # <<<<<<<<<<<<<< @@ -20228,7 +20919,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic */ (__pyx_v_mslice->shape[__pyx_v_i]) = 1; - /* "View.MemoryView":1353 + /* "View.MemoryView":1350 * for i in range(offset): * mslice.shape[i] = 1 * mslice.strides[i] = mslice.strides[0] # <<<<<<<<<<<<<< @@ -20237,7 +20928,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic */ (__pyx_v_mslice->strides[__pyx_v_i]) = (__pyx_v_mslice->strides[0]); - /* "View.MemoryView":1354 + /* "View.MemoryView":1351 * mslice.shape[i] = 1 * mslice.strides[i] = mslice.strides[0] * mslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< @@ -20247,7 +20938,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic (__pyx_v_mslice->suboffsets[__pyx_v_i]) = -1L; } - /* "View.MemoryView":1340 + /* "View.MemoryView":1337 * * @cname('__pyx_memoryview_broadcast_leading') * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< @@ -20258,7 +20949,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic /* function exit code */ } -/* "View.MemoryView":1362 +/* "View.MemoryView":1359 * * @cname('__pyx_memoryview_refcount_copying') * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< @@ -20269,7 +20960,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_dtype_is_object, int __pyx_v_ndim, int __pyx_v_inc) { int __pyx_t_1; - /* "View.MemoryView":1366 + /* "View.MemoryView":1363 * * * if dtype_is_object: # <<<<<<<<<<<<<< @@ -20279,7 +20970,7 @@ static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *__pyx_v_dst, i __pyx_t_1 = (__pyx_v_dtype_is_object != 0); if (__pyx_t_1) { - /* "View.MemoryView":1367 + /* "View.MemoryView":1364 * * if dtype_is_object: * refcount_objects_in_slice_with_gil(dst.data, dst.shape, # <<<<<<<<<<<<<< @@ -20288,7 +20979,7 @@ static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *__pyx_v_dst, i */ __pyx_memoryview_refcount_objects_in_slice_with_gil(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_inc); - /* "View.MemoryView":1366 + /* "View.MemoryView":1363 * * * if dtype_is_object: # <<<<<<<<<<<<<< @@ -20297,7 +20988,7 @@ static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *__pyx_v_dst, i */ } - /* "View.MemoryView":1362 + /* "View.MemoryView":1359 * * @cname('__pyx_memoryview_refcount_copying') * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< @@ -20308,7 +20999,7 @@ static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *__pyx_v_dst, i /* function exit code */ } -/* "View.MemoryView":1371 +/* "View.MemoryView":1368 * * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< @@ -20323,7 +21014,7 @@ static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *__pyx_v_da #endif __Pyx_RefNannySetupContext("refcount_objects_in_slice_with_gil", 0); - /* "View.MemoryView":1374 + /* "View.MemoryView":1371 * Py_ssize_t *strides, int ndim, * bint inc) with gil: * refcount_objects_in_slice(data, shape, strides, ndim, inc) # <<<<<<<<<<<<<< @@ -20332,7 +21023,7 @@ static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *__pyx_v_da */ __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, __pyx_v_shape, __pyx_v_strides, __pyx_v_ndim, __pyx_v_inc); - /* "View.MemoryView":1371 + /* "View.MemoryView":1368 * * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< @@ -20347,7 +21038,7 @@ static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *__pyx_v_da #endif } -/* "View.MemoryView":1377 +/* "View.MemoryView":1374 * * @cname('__pyx_memoryview_refcount_objects_in_slice') * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< @@ -20364,7 +21055,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss int __pyx_t_4; __Pyx_RefNannySetupContext("refcount_objects_in_slice", 0); - /* "View.MemoryView":1381 + /* "View.MemoryView":1378 * cdef Py_ssize_t i * * for i in range(shape[0]): # <<<<<<<<<<<<<< @@ -20376,7 +21067,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { __pyx_v_i = __pyx_t_3; - /* "View.MemoryView":1382 + /* "View.MemoryView":1379 * * for i in range(shape[0]): * if ndim == 1: # <<<<<<<<<<<<<< @@ -20386,7 +21077,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss __pyx_t_4 = ((__pyx_v_ndim == 1) != 0); if (__pyx_t_4) { - /* "View.MemoryView":1383 + /* "View.MemoryView":1380 * for i in range(shape[0]): * if ndim == 1: * if inc: # <<<<<<<<<<<<<< @@ -20396,7 +21087,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss __pyx_t_4 = (__pyx_v_inc != 0); if (__pyx_t_4) { - /* "View.MemoryView":1384 + /* "View.MemoryView":1381 * if ndim == 1: * if inc: * Py_INCREF(( data)[0]) # <<<<<<<<<<<<<< @@ -20405,7 +21096,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss */ Py_INCREF((((PyObject **)__pyx_v_data)[0])); - /* "View.MemoryView":1383 + /* "View.MemoryView":1380 * for i in range(shape[0]): * if ndim == 1: * if inc: # <<<<<<<<<<<<<< @@ -20415,7 +21106,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss goto __pyx_L6; } - /* "View.MemoryView":1386 + /* "View.MemoryView":1383 * Py_INCREF(( data)[0]) * else: * Py_DECREF(( data)[0]) # <<<<<<<<<<<<<< @@ -20427,7 +21118,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss } __pyx_L6:; - /* "View.MemoryView":1382 + /* "View.MemoryView":1379 * * for i in range(shape[0]): * if ndim == 1: # <<<<<<<<<<<<<< @@ -20437,7 +21128,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss goto __pyx_L5; } - /* "View.MemoryView":1388 + /* "View.MemoryView":1385 * Py_DECREF(( data)[0]) * else: * refcount_objects_in_slice(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< @@ -20446,7 +21137,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss */ /*else*/ { - /* "View.MemoryView":1389 + /* "View.MemoryView":1386 * else: * refcount_objects_in_slice(data, shape + 1, strides + 1, * ndim - 1, inc) # <<<<<<<<<<<<<< @@ -20457,7 +21148,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss } __pyx_L5:; - /* "View.MemoryView":1391 + /* "View.MemoryView":1388 * ndim - 1, inc) * * data += strides[0] # <<<<<<<<<<<<<< @@ -20467,7 +21158,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss __pyx_v_data = (__pyx_v_data + (__pyx_v_strides[0])); } - /* "View.MemoryView":1377 + /* "View.MemoryView":1374 * * @cname('__pyx_memoryview_refcount_objects_in_slice') * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< @@ -20479,7 +21170,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss __Pyx_RefNannyFinishContext(); } -/* "View.MemoryView":1397 +/* "View.MemoryView":1394 * * @cname('__pyx_memoryview_slice_assign_scalar') * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< @@ -20489,7 +21180,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item, int __pyx_v_dtype_is_object) { - /* "View.MemoryView":1400 + /* "View.MemoryView":1397 * size_t itemsize, void *item, * bint dtype_is_object) nogil: * refcount_copying(dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< @@ -20498,7 +21189,7 @@ static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *__pyx_v_dst */ __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 0); - /* "View.MemoryView":1401 + /* "View.MemoryView":1398 * bint dtype_is_object) nogil: * refcount_copying(dst, dtype_is_object, ndim, False) * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, # <<<<<<<<<<<<<< @@ -20507,7 +21198,7 @@ static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *__pyx_v_dst */ __pyx_memoryview__slice_assign_scalar(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_itemsize, __pyx_v_item); - /* "View.MemoryView":1403 + /* "View.MemoryView":1400 * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, * itemsize, item) * refcount_copying(dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< @@ -20516,7 +21207,7 @@ static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *__pyx_v_dst */ __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 1); - /* "View.MemoryView":1397 + /* "View.MemoryView":1394 * * @cname('__pyx_memoryview_slice_assign_scalar') * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< @@ -20527,7 +21218,7 @@ static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *__pyx_v_dst /* function exit code */ } -/* "View.MemoryView":1407 +/* "View.MemoryView":1404 * * @cname('__pyx_memoryview__slice_assign_scalar') * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< @@ -20544,7 +21235,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t Py_ssize_t __pyx_t_3; Py_ssize_t __pyx_t_4; - /* "View.MemoryView":1411 + /* "View.MemoryView":1408 * size_t itemsize, void *item) nogil: * cdef Py_ssize_t i * cdef Py_ssize_t stride = strides[0] # <<<<<<<<<<<<<< @@ -20553,7 +21244,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t */ __pyx_v_stride = (__pyx_v_strides[0]); - /* "View.MemoryView":1412 + /* "View.MemoryView":1409 * cdef Py_ssize_t i * cdef Py_ssize_t stride = strides[0] * cdef Py_ssize_t extent = shape[0] # <<<<<<<<<<<<<< @@ -20562,7 +21253,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t */ __pyx_v_extent = (__pyx_v_shape[0]); - /* "View.MemoryView":1414 + /* "View.MemoryView":1411 * cdef Py_ssize_t extent = shape[0] * * if ndim == 1: # <<<<<<<<<<<<<< @@ -20572,7 +21263,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t __pyx_t_1 = ((__pyx_v_ndim == 1) != 0); if (__pyx_t_1) { - /* "View.MemoryView":1415 + /* "View.MemoryView":1412 * * if ndim == 1: * for i in range(extent): # <<<<<<<<<<<<<< @@ -20584,7 +21275,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - /* "View.MemoryView":1416 + /* "View.MemoryView":1413 * if ndim == 1: * for i in range(extent): * memcpy(data, item, itemsize) # <<<<<<<<<<<<<< @@ -20593,7 +21284,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t */ (void)(memcpy(__pyx_v_data, __pyx_v_item, __pyx_v_itemsize)); - /* "View.MemoryView":1417 + /* "View.MemoryView":1414 * for i in range(extent): * memcpy(data, item, itemsize) * data += stride # <<<<<<<<<<<<<< @@ -20603,7 +21294,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t __pyx_v_data = (__pyx_v_data + __pyx_v_stride); } - /* "View.MemoryView":1414 + /* "View.MemoryView":1411 * cdef Py_ssize_t extent = shape[0] * * if ndim == 1: # <<<<<<<<<<<<<< @@ -20613,7 +21304,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t goto __pyx_L3; } - /* "View.MemoryView":1419 + /* "View.MemoryView":1416 * data += stride * else: * for i in range(extent): # <<<<<<<<<<<<<< @@ -20626,7 +21317,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - /* "View.MemoryView":1420 + /* "View.MemoryView":1417 * else: * for i in range(extent): * _slice_assign_scalar(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< @@ -20635,7 +21326,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t */ __pyx_memoryview__slice_assign_scalar(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize, __pyx_v_item); - /* "View.MemoryView":1422 + /* "View.MemoryView":1419 * _slice_assign_scalar(data, shape + 1, strides + 1, * ndim - 1, itemsize, item) * data += stride # <<<<<<<<<<<<<< @@ -20647,7 +21338,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t } __pyx_L3:; - /* "View.MemoryView":1407 + /* "View.MemoryView":1404 * * @cname('__pyx_memoryview__slice_assign_scalar') * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< @@ -20671,9 +21362,6 @@ static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *_ PyObject *__pyx_v___pyx_type = 0; long __pyx_v___pyx_checksum; PyObject *__pyx_v___pyx_state = 0; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_unpickle_Enum (wrapper)", 0); @@ -20751,9 +21439,6 @@ static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSE PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_t_6; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle_Enum", 0); /* "(tree fragment)":4 @@ -20942,9 +21627,6 @@ static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__ PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle_Enum__set_state", 0); /* "(tree fragment)":12 @@ -21086,9 +21768,9 @@ static void __pyx_tp_dealloc_array(PyObject *o) { { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + ++Py_REFCNT(o); __pyx_array___dealloc__(o); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + --Py_REFCNT(o); PyErr_Restore(etype, eval, etb); } Py_CLEAR(p->mode); @@ -21181,12 +21863,7 @@ static PyTypeObject __pyx_type___pyx_array = { sizeof(struct __pyx_array_obj), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_array, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 @@ -21239,9 +21916,6 @@ static PyTypeObject __pyx_type___pyx_array = { #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif }; static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { @@ -21300,12 +21974,7 @@ static PyTypeObject __pyx_type___pyx_MemviewEnum = { sizeof(struct __pyx_MemviewEnum_obj), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_Enum, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 @@ -21358,9 +22027,6 @@ static PyTypeObject __pyx_type___pyx_MemviewEnum = { #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif }; static struct __pyx_vtabstruct_memoryview __pyx_vtable_memoryview; @@ -21397,9 +22063,9 @@ static void __pyx_tp_dealloc_memoryview(PyObject *o) { { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + ++Py_REFCNT(o); __pyx_memoryview___dealloc__(o); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + --Py_REFCNT(o); PyErr_Restore(etype, eval, etb); } Py_CLEAR(p->obj); @@ -21561,12 +22227,7 @@ static PyTypeObject __pyx_type___pyx_memoryview = { sizeof(struct __pyx_memoryview_obj), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_memoryview, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 @@ -21619,9 +22280,6 @@ static PyTypeObject __pyx_type___pyx_memoryview = { #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif }; static struct __pyx_vtabstruct__memoryviewslice __pyx_vtable__memoryviewslice; @@ -21647,9 +22305,9 @@ static void __pyx_tp_dealloc__memoryviewslice(PyObject *o) { { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + ++Py_REFCNT(o); __pyx_memoryviewslice___dealloc__(o); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + --Py_REFCNT(o); PyErr_Restore(etype, eval, etb); } Py_CLEAR(p->from_object); @@ -21699,12 +22357,7 @@ static PyTypeObject __pyx_type___pyx_memoryviewslice = { sizeof(struct __pyx_memoryviewslice_obj), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc__memoryviewslice, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 @@ -21765,9 +22418,6 @@ static PyTypeObject __pyx_type___pyx_memoryviewslice = { #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif }; static PyMethodDef __pyx_methods[] = { @@ -21896,7 +22546,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1}, {&__pyx_n_s_fac, __pyx_k_fac, sizeof(__pyx_k_fac), 0, 0, 1, 1}, {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1}, - {&__pyx_n_s_float, __pyx_k_float, sizeof(__pyx_k_float), 0, 0, 1, 1}, + {&__pyx_n_u_float, __pyx_k_float, sizeof(__pyx_k_float), 0, 1, 0, 1}, {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1}, {&__pyx_n_s_fortran, __pyx_k_fortran, sizeof(__pyx_k_fortran), 0, 0, 1, 1}, {&__pyx_n_u_fortran, __pyx_k_fortran, sizeof(__pyx_k_fortran), 0, 1, 0, 1}, @@ -21911,7 +22561,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_index, __pyx_k_index, sizeof(__pyx_k_index), 0, 0, 1, 1}, {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1}, - {&__pyx_n_s_int32, __pyx_k_int32, sizeof(__pyx_k_int32), 0, 0, 1, 1}, + {&__pyx_n_u_int32, __pyx_k_int32, sizeof(__pyx_k_int32), 0, 1, 0, 1}, {&__pyx_n_s_itemsize, __pyx_k_itemsize, sizeof(__pyx_k_itemsize), 0, 0, 1, 1}, {&__pyx_kp_s_itemsize_0_for_cython_array, __pyx_k_itemsize_0_for_cython_array, sizeof(__pyx_k_itemsize_0_for_cython_array), 0, 0, 1, 0}, {&__pyx_n_s_j, __pyx_k_j, sizeof(__pyx_k_j), 0, 0, 1, 1}, @@ -21941,14 +22591,16 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, + {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0}, + {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0}, {&__pyx_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 0, 0, 1, 1}, {&__pyx_n_s_neighbors, __pyx_k_neighbors, sizeof(__pyx_k_neighbors), 0, 0, 1, 1}, {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, - {&__pyx_kp_s_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 0, 1, 0}, - {&__pyx_kp_s_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 0, 1, 0}, + {&__pyx_kp_u_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 1, 0, 0}, + {&__pyx_kp_u_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 1, 0, 0}, {&__pyx_n_s_obj, __pyx_k_obj, sizeof(__pyx_k_obj), 0, 0, 1, 1}, {&__pyx_n_s_order, __pyx_k_order, sizeof(__pyx_k_order), 0, 0, 1, 1}, {&__pyx_n_s_other, __pyx_k_other, sizeof(__pyx_k_other), 0, 0, 1, 1}, @@ -22020,15 +22672,15 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { }; static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 36, __pyx_L1_error) - __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 777, __pyx_L1_error) - __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 781, __pyx_L1_error) - __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 959, __pyx_L1_error) + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 272, __pyx_L1_error) + __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 856, __pyx_L1_error) + __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 1038, __pyx_L1_error) __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(2, 148, __pyx_L1_error) __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(2, 151, __pyx_L1_error) __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(2, 2, __pyx_L1_error) - __pyx_builtin_Ellipsis = __Pyx_GetBuiltinName(__pyx_n_s_Ellipsis); if (!__pyx_builtin_Ellipsis) __PYX_ERR(2, 404, __pyx_L1_error) - __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(2, 613, __pyx_L1_error) - __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(2, 832, __pyx_L1_error) + __pyx_builtin_Ellipsis = __Pyx_GetBuiltinName(__pyx_n_s_Ellipsis); if (!__pyx_builtin_Ellipsis) __PYX_ERR(2, 400, __pyx_L1_error) + __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(2, 609, __pyx_L1_error) + __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(2, 828, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; @@ -22038,60 +22690,82 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":777 - * - * if (end - f) - (new_offset - offset[0]) < 15: - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":272 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< * - * if ((child.byteorder == c'>' and little_endian) or + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) */ - __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 777, __pyx_L1_error) + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":781 - * if ((child.byteorder == c'>' and little_endian) or - * (child.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< - * # One could encode it in the format string and have Cython - * # complain instead, BUT: < and > in format strings also imply + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":276 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + * + * info.buf = PyArray_DATA(self) */ - __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 781, __pyx_L1_error) + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 276, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":801 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":306 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + */ + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":856 + * + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + * + * if ((child.byteorder == c'>' and little_endian) or + */ + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 856, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":880 * t = child.type_num * if end - f < 5: * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< * * # Until ticket #99 is fixed, use integers to avoid warnings */ - __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 801, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__3); - __Pyx_GIVEREF(__pyx_tuple__3); + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 880, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":959 - * __pyx_import_array() + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1038 + * _import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ - __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 959, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__4); - __Pyx_GIVEREF(__pyx_tuple__4); + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 1038, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); - /* "../../../../../../anaconda3/envs/tigramitepipdistribute/lib/python3.6/site-packages/numpy/__init__.pxd":965 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1044 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ - __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 965, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__5); - __Pyx_GIVEREF(__pyx_tuple__5); + __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 1044, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); /* "View.MemoryView":133 * @@ -22100,9 +22774,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * * if itemsize <= 0: */ - __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_Empty_shape_tuple_for_cython_arr); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(2, 133, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__6); - __Pyx_GIVEREF(__pyx_tuple__6); + __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_Empty_shape_tuple_for_cython_arr); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(2, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); /* "View.MemoryView":136 * @@ -22111,9 +22785,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * * if not isinstance(format, bytes): */ - __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_itemsize_0_for_cython_array); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(2, 136, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__7); - __Pyx_GIVEREF(__pyx_tuple__7); + __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_itemsize_0_for_cython_array); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(2, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); /* "View.MemoryView":148 * @@ -22122,9 +22796,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * * */ - __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_shape_and_str); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(2, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__8); - __Pyx_GIVEREF(__pyx_tuple__8); + __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_shape_and_str); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(2, 148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); /* "View.MemoryView":176 * self.data = malloc(self.len) @@ -22133,9 +22807,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * * if self.dtype_is_object: */ - __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_array_data); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(2, 176, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__9); - __Pyx_GIVEREF(__pyx_tuple__9); + __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_array_data); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(2, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); /* "View.MemoryView":192 * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS @@ -22144,9 +22818,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * info.buf = self.data * info.len = self.len */ - __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_Can_only_create_a_buffer_that_is); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(2, 192, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__10); - __Pyx_GIVEREF(__pyx_tuple__10); + __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_s_Can_only_create_a_buffer_that_is); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(2, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); /* "(tree fragment)":2 * def __reduce_cython__(self): @@ -22154,76 +22828,76 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ - __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(2, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__11); - __Pyx_GIVEREF(__pyx_tuple__11); + __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(2, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(2, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__12); - __Pyx_GIVEREF(__pyx_tuple__12); + __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(2, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__14); + __Pyx_GIVEREF(__pyx_tuple__14); - /* "View.MemoryView":418 + /* "View.MemoryView":414 * def __setitem__(memoryview self, object index, object value): * if self.view.readonly: * raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<< * * have_slices, index = _unellipsify(index, self.view.ndim) */ - __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_s_Cannot_assign_to_read_only_memor); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(2, 418, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__13); - __Pyx_GIVEREF(__pyx_tuple__13); + __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_s_Cannot_assign_to_read_only_memor); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(2, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__15); + __Pyx_GIVEREF(__pyx_tuple__15); - /* "View.MemoryView":495 + /* "View.MemoryView":491 * result = struct.unpack(self.view.format, bytesitem) * except struct.error: * raise ValueError("Unable to convert item to object") # <<<<<<<<<<<<<< * else: * if len(self.view.format) == 1: */ - __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_Unable_to_convert_item_to_object); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(2, 495, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__14); - __Pyx_GIVEREF(__pyx_tuple__14); + __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_s_Unable_to_convert_item_to_object); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(2, 491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__16); + __Pyx_GIVEREF(__pyx_tuple__16); - /* "View.MemoryView":520 + /* "View.MemoryView":516 * def __getbuffer__(self, Py_buffer *info, int flags): * if flags & PyBUF_WRITABLE and self.view.readonly: * raise ValueError("Cannot create writable memory view from read-only memoryview") # <<<<<<<<<<<<<< * * if flags & PyBUF_ND: */ - __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_s_Cannot_create_writable_memory_vi); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(2, 520, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__15); - __Pyx_GIVEREF(__pyx_tuple__15); + __pyx_tuple__17 = PyTuple_Pack(1, __pyx_kp_s_Cannot_create_writable_memory_vi); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(2, 516, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__17); + __Pyx_GIVEREF(__pyx_tuple__17); - /* "View.MemoryView":570 + /* "View.MemoryView":566 * if self.view.strides == NULL: * * raise ValueError("Buffer view does not expose strides") # <<<<<<<<<<<<<< * * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) */ - __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_s_Buffer_view_does_not_expose_stri); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(2, 570, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__16); - __Pyx_GIVEREF(__pyx_tuple__16); + __pyx_tuple__18 = PyTuple_Pack(1, __pyx_kp_s_Buffer_view_does_not_expose_stri); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(2, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__18); + __Pyx_GIVEREF(__pyx_tuple__18); - /* "View.MemoryView":577 + /* "View.MemoryView":573 * def suboffsets(self): * if self.view.suboffsets == NULL: * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< * * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) */ - __pyx_tuple__17 = PyTuple_New(1); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(2, 577, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__17); + __pyx_tuple__19 = PyTuple_New(1); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(2, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__19); __Pyx_INCREF(__pyx_int_neg_1); __Pyx_GIVEREF(__pyx_int_neg_1); - PyTuple_SET_ITEM(__pyx_tuple__17, 0, __pyx_int_neg_1); - __Pyx_GIVEREF(__pyx_tuple__17); + PyTuple_SET_ITEM(__pyx_tuple__19, 0, __pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_tuple__19); /* "(tree fragment)":2 * def __reduce_cython__(self): @@ -22231,40 +22905,40 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ - __pyx_tuple__18 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(2, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__18); - __Pyx_GIVEREF(__pyx_tuple__18); + __pyx_tuple__20 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(2, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__20); + __Pyx_GIVEREF(__pyx_tuple__20); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__19 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(2, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__19); - __Pyx_GIVEREF(__pyx_tuple__19); + __pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(2, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__21); + __Pyx_GIVEREF(__pyx_tuple__21); - /* "View.MemoryView":682 + /* "View.MemoryView":678 * if item is Ellipsis: * if not seen_ellipsis: * result.extend([slice(None)] * (ndim - len(tup) + 1)) # <<<<<<<<<<<<<< * seen_ellipsis = True * else: */ - __pyx_slice__20 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__20)) __PYX_ERR(2, 682, __pyx_L1_error) - __Pyx_GOTREF(__pyx_slice__20); - __Pyx_GIVEREF(__pyx_slice__20); + __pyx_slice__22 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__22)) __PYX_ERR(2, 678, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice__22); + __Pyx_GIVEREF(__pyx_slice__22); - /* "View.MemoryView":703 + /* "View.MemoryView":699 * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: * raise ValueError("Indirect dimensions not supported") # <<<<<<<<<<<<<< * * */ - __pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_s_Indirect_dimensions_not_supporte); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(2, 703, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__21); - __Pyx_GIVEREF(__pyx_tuple__21); + __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_s_Indirect_dimensions_not_supporte); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(2, 699, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__23); + __Pyx_GIVEREF(__pyx_tuple__23); /* "(tree fragment)":2 * def __reduce_cython__(self): @@ -22272,18 +22946,18 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ - __pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(2, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__22); - __Pyx_GIVEREF(__pyx_tuple__22); + __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(2, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__24); + __Pyx_GIVEREF(__pyx_tuple__24); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(2, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__23); - __Pyx_GIVEREF(__pyx_tuple__23); + __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(2, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__25); + __Pyx_GIVEREF(__pyx_tuple__25); /* "tigramite/tigramite_cython_code.pyx":19 * @cython.boundscheck(False) @@ -22292,10 +22966,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * double[:,:] array, * int T, */ - __pyx_tuple__24 = PyTuple_Pack(20, __pyx_n_s_array, __pyx_n_s_T, __pyx_n_s_dim_x, __pyx_n_s_dim_y, __pyx_n_s_epsarray, __pyx_n_s_k, __pyx_n_s_dim, __pyx_n_s_k_xz, __pyx_n_s_k_yz, __pyx_n_s_k_z, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_d, __pyx_n_s_kz, __pyx_n_s_kxz, __pyx_n_s_kyz, __pyx_n_s_dz, __pyx_n_s_dy, __pyx_n_s_dx, __pyx_n_s_epsmax); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(0, 19, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__24); - __Pyx_GIVEREF(__pyx_tuple__24); - __pyx_codeobj__25 = (PyObject*)__Pyx_PyCode_New(7, 0, 20, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__24, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_tigramite_tigramite_cython_code, __pyx_n_s_get_neighbors_within_eps_cython, 19, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__25)) __PYX_ERR(0, 19, __pyx_L1_error) + __pyx_tuple__26 = PyTuple_Pack(20, __pyx_n_s_array, __pyx_n_s_T, __pyx_n_s_dim_x, __pyx_n_s_dim_y, __pyx_n_s_epsarray, __pyx_n_s_k, __pyx_n_s_dim, __pyx_n_s_k_xz, __pyx_n_s_k_yz, __pyx_n_s_k_z, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_d, __pyx_n_s_kz, __pyx_n_s_kxz, __pyx_n_s_kyz, __pyx_n_s_dz, __pyx_n_s_dy, __pyx_n_s_dx, __pyx_n_s_epsmax); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__26); + __Pyx_GIVEREF(__pyx_tuple__26); + __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(7, 0, 20, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_tigramite_tigramite_cython_code, __pyx_n_s_get_neighbors_within_eps_cython, 19, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) __PYX_ERR(0, 19, __pyx_L1_error) /* "tigramite/tigramite_cython_code.pyx":86 * @cython.boundscheck(False) @@ -22304,10 +22978,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * double[:,:] array, * int[:,:] array_mask, */ - __pyx_tuple__26 = PyTuple_Pack(22, __pyx_n_s_array, __pyx_n_s_array_mask, __pyx_n_s_patt, __pyx_n_s_patt_mask, __pyx_n_s_weights, __pyx_n_s_dim, __pyx_n_s_step, __pyx_n_s_fac, __pyx_n_s_N, __pyx_n_s_T, __pyx_n_s_n, __pyx_n_s_t, __pyx_n_s_k, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_p, __pyx_n_s_tau, __pyx_n_s_start, __pyx_n_s_mask, __pyx_n_s_ave, __pyx_n_s_var, __pyx_n_s_v); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__26); - __Pyx_GIVEREF(__pyx_tuple__26); - __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(10, 0, 22, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_tigramite_tigramite_cython_code, __pyx_n_s_get_patterns_cython, 86, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) __PYX_ERR(0, 86, __pyx_L1_error) + __pyx_tuple__28 = PyTuple_Pack(22, __pyx_n_s_array, __pyx_n_s_array_mask, __pyx_n_s_patt, __pyx_n_s_patt_mask, __pyx_n_s_weights, __pyx_n_s_dim, __pyx_n_s_step, __pyx_n_s_fac, __pyx_n_s_N, __pyx_n_s_T, __pyx_n_s_n, __pyx_n_s_t, __pyx_n_s_k, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_p, __pyx_n_s_tau, __pyx_n_s_start, __pyx_n_s_mask, __pyx_n_s_ave, __pyx_n_s_var, __pyx_n_s_v); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__28); + __Pyx_GIVEREF(__pyx_tuple__28); + __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(10, 0, 22, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__28, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_tigramite_tigramite_cython_code, __pyx_n_s_get_patterns_cython, 86, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(0, 86, __pyx_L1_error) /* "tigramite/tigramite_cython_code.pyx":148 * @cython.boundscheck(False) @@ -22316,10 +22990,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * int T, * int shuffle_neighbors, */ - __pyx_tuple__28 = PyTuple_Pack(10, __pyx_n_s_T, __pyx_n_s_shuffle_neighbors, __pyx_n_s_neighbors, __pyx_n_s_order, __pyx_n_s_restricted_permutation, __pyx_n_s_used, __pyx_n_s_i, __pyx_n_s_index, __pyx_n_s_count, __pyx_n_s_use); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__28); - __Pyx_GIVEREF(__pyx_tuple__28); - __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(4, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__28, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_tigramite_tigramite_cython_code, __pyx_n_s_get_restricted_permutation_cyth, 148, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(0, 148, __pyx_L1_error) + __pyx_tuple__30 = PyTuple_Pack(10, __pyx_n_s_T, __pyx_n_s_shuffle_neighbors, __pyx_n_s_neighbors, __pyx_n_s_order, __pyx_n_s_restricted_permutation, __pyx_n_s_used, __pyx_n_s_i, __pyx_n_s_index, __pyx_n_s_count, __pyx_n_s_use); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__30); + __Pyx_GIVEREF(__pyx_tuple__30); + __pyx_codeobj__31 = (PyObject*)__Pyx_PyCode_New(4, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__30, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_tigramite_tigramite_cython_code, __pyx_n_s_get_restricted_permutation_cyth, 148, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__31)) __PYX_ERR(0, 148, __pyx_L1_error) /* "tigramite/tigramite_cython_code.pyx":217 * ctypedef np.double_t DTYPE_t @@ -22328,10 +23002,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * 'Calculate distance covariance, distance correlation, distance variance of x sample and distance variance of y sample' * x = np.array(x, dtype=np.double) */ - __pyx_tuple__30 = PyTuple_Pack(9, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_dnx, __pyx_n_s_dny, __pyx_n_s_denom, __pyx_n_s_dc, __pyx_n_s_dvx, __pyx_n_s_dvy, __pyx_n_s_dr); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 217, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__30); - __Pyx_GIVEREF(__pyx_tuple__30); - __pyx_codeobj__31 = (PyObject*)__Pyx_PyCode_New(2, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__30, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_tigramite_tigramite_cython_code, __pyx_n_s_dcov_all, 217, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__31)) __PYX_ERR(0, 217, __pyx_L1_error) + __pyx_tuple__32 = PyTuple_Pack(9, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_dnx, __pyx_n_s_dny, __pyx_n_s_denom, __pyx_n_s_dc, __pyx_n_s_dvx, __pyx_n_s_dvy, __pyx_n_s_dr); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__32); + __Pyx_GIVEREF(__pyx_tuple__32); + __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(2, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__32, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_tigramite_tigramite_cython_code, __pyx_n_s_dcov_all, 217, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(0, 217, __pyx_L1_error) /* "tigramite/tigramite_cython_code.pyx":236 * the matrix members on the fly""" @@ -22340,46 +23014,46 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * self.x = np.array(x) * self.dim = x.shape[0] */ - __pyx_tuple__32 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_x); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 236, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__32); - __Pyx_GIVEREF(__pyx_tuple__32); - __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__32, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_tigramite_tigramite_cython_code, __pyx_n_s_init, 236, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(0, 236, __pyx_L1_error) + __pyx_tuple__34 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_x); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__34); + __Pyx_GIVEREF(__pyx_tuple__34); + __pyx_codeobj__35 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__34, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_tigramite_tigramite_cython_code, __pyx_n_s_init, 236, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__35)) __PYX_ERR(0, 236, __pyx_L1_error) - /* "tigramite/tigramite_cython_code.pyx":242 - * + /* "tigramite/tigramite_cython_code.pyx":243 * @cython.boundscheck(False) + * @cython.wraparound(False) * def calculate_means(self): # <<<<<<<<<<<<<< * cdef int dim = self.dim * cdef DTYPE_t value */ - __pyx_tuple__34 = PyTuple_Pack(9, __pyx_n_s_self, __pyx_n_s_dim, __pyx_n_s_value, __pyx_n_s_sum_total, __pyx_n_s_sum_0, __pyx_n_s_sum_1, __pyx_n_s_x, __pyx_n_s_ii, __pyx_n_s_jj); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 242, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__34); - __Pyx_GIVEREF(__pyx_tuple__34); - __pyx_codeobj__35 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__34, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_tigramite_tigramite_cython_code, __pyx_n_s_calculate_means, 242, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__35)) __PYX_ERR(0, 242, __pyx_L1_error) + __pyx_tuple__36 = PyTuple_Pack(9, __pyx_n_s_self, __pyx_n_s_dim, __pyx_n_s_value, __pyx_n_s_sum_total, __pyx_n_s_sum_0, __pyx_n_s_sum_1, __pyx_n_s_x, __pyx_n_s_ii, __pyx_n_s_jj); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(0, 243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__36); + __Pyx_GIVEREF(__pyx_tuple__36); + __pyx_codeobj__37 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__36, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_tigramite_tigramite_cython_code, __pyx_n_s_calculate_means, 243, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__37)) __PYX_ERR(0, 243, __pyx_L1_error) - /* "tigramite/tigramite_cython_code.pyx":263 - * + /* "tigramite/tigramite_cython_code.pyx":268 * @cython.boundscheck(False) + * @cython.wraparound(False) * def squared_sum(self): # <<<<<<<<<<<<<< * cdef np.ndarray[DTYPE_t, ndim=1] mean_0 = self.mean_0 * cdef np.ndarray[DTYPE_t, ndim=1] mean_1 = self.mean_1 */ - __pyx_tuple__36 = PyTuple_Pack(11, __pyx_n_s_self, __pyx_n_s_mean_0, __pyx_n_s_mean_1, __pyx_n_s_mean, __pyx_n_s_squared_sum, __pyx_n_s_dist, __pyx_n_s_d, __pyx_n_s_x, __pyx_n_s_dim, __pyx_n_s_ii, __pyx_n_s_jj); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(0, 263, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__36); - __Pyx_GIVEREF(__pyx_tuple__36); - __pyx_codeobj__37 = (PyObject*)__Pyx_PyCode_New(1, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__36, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_tigramite_tigramite_cython_code, __pyx_n_s_squared_sum, 263, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__37)) __PYX_ERR(0, 263, __pyx_L1_error) + __pyx_tuple__38 = PyTuple_Pack(11, __pyx_n_s_self, __pyx_n_s_mean_0, __pyx_n_s_mean_1, __pyx_n_s_mean, __pyx_n_s_squared_sum, __pyx_n_s_dist, __pyx_n_s_d, __pyx_n_s_x, __pyx_n_s_dim, __pyx_n_s_ii, __pyx_n_s_jj); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(0, 268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__38); + __Pyx_GIVEREF(__pyx_tuple__38); + __pyx_codeobj__39 = (PyObject*)__Pyx_PyCode_New(1, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__38, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_tigramite_tigramite_cython_code, __pyx_n_s_squared_sum, 268, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__39)) __PYX_ERR(0, 268, __pyx_L1_error) - /* "tigramite/tigramite_cython_code.pyx":282 - * + /* "tigramite/tigramite_cython_code.pyx":288 * @cython.boundscheck(False) + * @cython.wraparound(False) * def product_sum(self, other): # <<<<<<<<<<<<<< * cdef np.ndarray[DTYPE_t, ndim=1] mean_0_here = self.mean_0 * cdef np.ndarray[DTYPE_t, ndim=1] mean_1_here = self.mean_1 */ - __pyx_tuple__38 = PyTuple_Pack(16, __pyx_n_s_self, __pyx_n_s_other, __pyx_n_s_mean_0_here, __pyx_n_s_mean_1_here, __pyx_n_s_mean_here, __pyx_n_s_mean_0_there, __pyx_n_s_mean_1_there, __pyx_n_s_mean_there, __pyx_n_s_d_here, __pyx_n_s_d_there, __pyx_n_s_product_sum, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_dim, __pyx_n_s_ii, __pyx_n_s_jj); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(0, 282, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__38); - __Pyx_GIVEREF(__pyx_tuple__38); - __pyx_codeobj__39 = (PyObject*)__Pyx_PyCode_New(2, 0, 16, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__38, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_tigramite_tigramite_cython_code, __pyx_n_s_product_sum, 282, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__39)) __PYX_ERR(0, 282, __pyx_L1_error) + __pyx_tuple__40 = PyTuple_Pack(16, __pyx_n_s_self, __pyx_n_s_other, __pyx_n_s_mean_0_here, __pyx_n_s_mean_1_here, __pyx_n_s_mean_here, __pyx_n_s_mean_0_there, __pyx_n_s_mean_1_there, __pyx_n_s_mean_there, __pyx_n_s_d_here, __pyx_n_s_d_there, __pyx_n_s_product_sum, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_dim, __pyx_n_s_ii, __pyx_n_s_jj); if (unlikely(!__pyx_tuple__40)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__40); + __Pyx_GIVEREF(__pyx_tuple__40); + __pyx_codeobj__41 = (PyObject*)__Pyx_PyCode_New(2, 0, 16, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__40, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_tigramite_tigramite_cython_code, __pyx_n_s_product_sum, 288, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__41)) __PYX_ERR(0, 288, __pyx_L1_error) /* "View.MemoryView":286 * return self.name @@ -22388,9 +23062,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * cdef strided = Enum("") # default * cdef indirect = Enum("") */ - __pyx_tuple__40 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__40)) __PYX_ERR(2, 286, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__40); - __Pyx_GIVEREF(__pyx_tuple__40); + __pyx_tuple__42 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__42)) __PYX_ERR(2, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__42); + __Pyx_GIVEREF(__pyx_tuple__42); /* "View.MemoryView":287 * @@ -22399,9 +23073,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * cdef indirect = Enum("") * */ - __pyx_tuple__41 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); if (unlikely(!__pyx_tuple__41)) __PYX_ERR(2, 287, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__41); - __Pyx_GIVEREF(__pyx_tuple__41); + __pyx_tuple__43 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(2, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__43); + __Pyx_GIVEREF(__pyx_tuple__43); /* "View.MemoryView":288 * cdef generic = Enum("") @@ -22410,9 +23084,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * * */ - __pyx_tuple__42 = PyTuple_Pack(1, __pyx_kp_s_strided_and_indirect); if (unlikely(!__pyx_tuple__42)) __PYX_ERR(2, 288, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__42); - __Pyx_GIVEREF(__pyx_tuple__42); + __pyx_tuple__44 = PyTuple_Pack(1, __pyx_kp_s_strided_and_indirect); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(2, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__44); + __Pyx_GIVEREF(__pyx_tuple__44); /* "View.MemoryView":291 * @@ -22421,9 +23095,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * cdef indirect_contiguous = Enum("") * */ - __pyx_tuple__43 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(2, 291, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__43); - __Pyx_GIVEREF(__pyx_tuple__43); + __pyx_tuple__45 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(2, 291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__45); + __Pyx_GIVEREF(__pyx_tuple__45); /* "View.MemoryView":292 * @@ -22432,19 +23106,19 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * * */ - __pyx_tuple__44 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_indirect); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(2, 292, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__44); - __Pyx_GIVEREF(__pyx_tuple__44); + __pyx_tuple__46 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_indirect); if (unlikely(!__pyx_tuple__46)) __PYX_ERR(2, 292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__46); + __Pyx_GIVEREF(__pyx_tuple__46); /* "(tree fragment)":1 * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ - __pyx_tuple__45 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(2, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__45); - __Pyx_GIVEREF(__pyx_tuple__45); - __pyx_codeobj__46 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__45, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__46)) __PYX_ERR(2, 1, __pyx_L1_error) + __pyx_tuple__47 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__47)) __PYX_ERR(2, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__47); + __Pyx_GIVEREF(__pyx_tuple__47); + __pyx_codeobj__48 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__47, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__48)) __PYX_ERR(2, 1, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -22453,6 +23127,13 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { } static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + /* InitThreads.init */ + #ifdef WITH_THREAD +PyEval_InitThreads(); +#endif + +if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) @@ -22503,9 +23184,6 @@ static int __Pyx_modinit_function_export_code(void) { static int __Pyx_modinit_type_init_code(void) { __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- Type init code ---*/ __pyx_vtabptr_array = &__pyx_vtable_array; @@ -22549,15 +23227,15 @@ static int __Pyx_modinit_type_init_code(void) { __pyx_vtable__memoryviewslice.__pyx_base.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryviewslice_convert_item_to_object; __pyx_vtable__memoryviewslice.__pyx_base.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryviewslice_assign_item_from_object; __pyx_type___pyx_memoryviewslice.tp_base = __pyx_memoryview_type; - if (PyType_Ready(&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(2, 965, __pyx_L1_error) + if (PyType_Ready(&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(2, 961, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type___pyx_memoryviewslice.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryviewslice.tp_dictoffset && __pyx_type___pyx_memoryviewslice.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type___pyx_memoryviewslice.tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (__Pyx_SetVtable(__pyx_type___pyx_memoryviewslice.tp_dict, __pyx_vtabptr__memoryviewslice) < 0) __PYX_ERR(2, 965, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(2, 965, __pyx_L1_error) + if (__Pyx_SetVtable(__pyx_type___pyx_memoryviewslice.tp_dict, __pyx_vtabptr__memoryviewslice) < 0) __PYX_ERR(2, 961, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(2, 961, __pyx_L1_error) __pyx_memoryviewslice_type = &__pyx_type___pyx_memoryviewslice; __Pyx_RefNannyFinishContext(); return 0; @@ -22569,9 +23247,6 @@ static int __Pyx_modinit_type_init_code(void) { static int __Pyx_modinit_type_import_code(void) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 9, __pyx_L1_error) @@ -22585,18 +23260,18 @@ static int __Pyx_modinit_type_import_code(void) { __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(3, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 207, __pyx_L1_error) + __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 206, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 207, __pyx_L1_error) - __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 230, __pyx_L1_error) - __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 234, __pyx_L1_error) + if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 206, __pyx_L1_error) + __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 229, __pyx_L1_error) + __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 233, __pyx_L1_error) __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 246, __pyx_L1_error) - __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 839, __pyx_L1_error) + if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 242, __pyx_L1_error) + __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 918, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; @@ -22623,19 +23298,17 @@ static int __Pyx_modinit_function_import_code(void) { } -#ifndef CYTHON_NO_PYINIT_EXPORT -#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC -#elif PY_MAJOR_VERSION < 3 -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" void -#else +#if PY_MAJOR_VERSION < 3 +#ifdef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC void -#endif #else -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#endif #else +#ifdef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyObject * +#else +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #endif #endif @@ -22719,9 +23392,6 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_tigramite_cython_code(PyObject *__ PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; static PyThread_type_lock __pyx_t_3[8]; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT if (__pyx_m) { @@ -22810,15 +23480,15 @@ if (!__Pyx_RefNanny) { } #endif /*--- Builtin init code ---*/ - if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_InitCachedBuiltins() < 0) goto __pyx_L1_error; /*--- Constants init code ---*/ - if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_InitCachedConstants() < 0) goto __pyx_L1_error; /*--- Global type/function init code ---*/ (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); (void)__Pyx_modinit_function_export_code(); - if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) - if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely(__Pyx_modinit_type_init_code() != 0)) goto __pyx_L1_error; + if (unlikely(__Pyx_modinit_type_import_code() != 0)) goto __pyx_L1_error; (void)__Pyx_modinit_variable_import_code(); (void)__Pyx_modinit_function_import_code(); /*--- Execution code ---*/ @@ -22831,7 +23501,7 @@ if (!__Pyx_RefNanny) { * cimport numpy * import cython */ - __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_numpy, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -22843,7 +23513,7 @@ if (!__Pyx_RefNanny) { * import timeit * import sys */ - __pyx_t_1 = __Pyx_Import(__pyx_n_s_unittest, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __pyx_t_1 = __Pyx_Import(__pyx_n_s_unittest, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_unittest, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -22855,7 +23525,7 @@ if (!__Pyx_RefNanny) { * import sys * import random */ - __pyx_t_1 = __Pyx_Import(__pyx_n_s_timeit, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) + __pyx_t_1 = __Pyx_Import(__pyx_n_s_timeit, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_timeit, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -22867,7 +23537,7 @@ if (!__Pyx_RefNanny) { * import random * import numpy as np */ - __pyx_t_1 = __Pyx_Import(__pyx_n_s_sys, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) + __pyx_t_1 = __Pyx_Import(__pyx_n_s_sys, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_1) < 0) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -22879,7 +23549,7 @@ if (!__Pyx_RefNanny) { * import numpy as np * cimport numpy as np */ - __pyx_t_1 = __Pyx_Import(__pyx_n_s_random, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) + __pyx_t_1 = __Pyx_Import(__pyx_n_s_random, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_random, __pyx_t_1) < 0) __PYX_ERR(0, 7, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -22891,7 +23561,7 @@ if (!__Pyx_RefNanny) { * cimport numpy as np * import cython */ - __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -22961,45 +23631,45 @@ if (!__Pyx_RefNanny) { * self.x = np.array(x) * self.dim = x.shape[0] */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9tigramite_21tigramite_cython_code_3D_N_1__init__, 0, __pyx_n_s_D_N___init, NULL, __pyx_n_s_tigramite_tigramite_cython_code_2, __pyx_d, ((PyObject *)__pyx_codeobj__33)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 236, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_9tigramite_21tigramite_cython_code_3D_N_1__init__, 0, __pyx_n_s_D_N___init, NULL, __pyx_n_s_tigramite_tigramite_cython_code_2, __pyx_d, ((PyObject *)__pyx_codeobj__35)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 236, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_init, __pyx_t_2) < 0) __PYX_ERR(0, 236, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "tigramite/tigramite_cython_code.pyx":242 - * + /* "tigramite/tigramite_cython_code.pyx":243 * @cython.boundscheck(False) + * @cython.wraparound(False) * def calculate_means(self): # <<<<<<<<<<<<<< * cdef int dim = self.dim * cdef DTYPE_t value */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9tigramite_21tigramite_cython_code_3D_N_3calculate_means, 0, __pyx_n_s_D_N_calculate_means, NULL, __pyx_n_s_tigramite_tigramite_cython_code_2, __pyx_d, ((PyObject *)__pyx_codeobj__35)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 242, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_9tigramite_21tigramite_cython_code_3D_N_3calculate_means, 0, __pyx_n_s_D_N_calculate_means, NULL, __pyx_n_s_tigramite_tigramite_cython_code_2, __pyx_d, ((PyObject *)__pyx_codeobj__37)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 243, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_calculate_means, __pyx_t_2) < 0) __PYX_ERR(0, 242, __pyx_L1_error) + if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_calculate_means, __pyx_t_2) < 0) __PYX_ERR(0, 243, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "tigramite/tigramite_cython_code.pyx":263 - * + /* "tigramite/tigramite_cython_code.pyx":268 * @cython.boundscheck(False) + * @cython.wraparound(False) * def squared_sum(self): # <<<<<<<<<<<<<< * cdef np.ndarray[DTYPE_t, ndim=1] mean_0 = self.mean_0 * cdef np.ndarray[DTYPE_t, ndim=1] mean_1 = self.mean_1 */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9tigramite_21tigramite_cython_code_3D_N_5squared_sum, 0, __pyx_n_s_D_N_squared_sum, NULL, __pyx_n_s_tigramite_tigramite_cython_code_2, __pyx_d, ((PyObject *)__pyx_codeobj__37)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 263, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_9tigramite_21tigramite_cython_code_3D_N_5squared_sum, 0, __pyx_n_s_D_N_squared_sum, NULL, __pyx_n_s_tigramite_tigramite_cython_code_2, __pyx_d, ((PyObject *)__pyx_codeobj__39)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 268, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_squared_sum, __pyx_t_2) < 0) __PYX_ERR(0, 263, __pyx_L1_error) + if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_squared_sum, __pyx_t_2) < 0) __PYX_ERR(0, 268, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "tigramite/tigramite_cython_code.pyx":282 - * + /* "tigramite/tigramite_cython_code.pyx":288 * @cython.boundscheck(False) + * @cython.wraparound(False) * def product_sum(self, other): # <<<<<<<<<<<<<< * cdef np.ndarray[DTYPE_t, ndim=1] mean_0_here = self.mean_0 * cdef np.ndarray[DTYPE_t, ndim=1] mean_1_here = self.mean_1 */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9tigramite_21tigramite_cython_code_3D_N_7product_sum, 0, __pyx_n_s_D_N_product_sum, NULL, __pyx_n_s_tigramite_tigramite_cython_code_2, __pyx_d, ((PyObject *)__pyx_codeobj__39)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 282, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_9tigramite_21tigramite_cython_code_3D_N_7product_sum, 0, __pyx_n_s_D_N_product_sum, NULL, __pyx_n_s_tigramite_tigramite_cython_code_2, __pyx_d, ((PyObject *)__pyx_codeobj__41)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 288, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_product_sum, __pyx_t_2) < 0) __PYX_ERR(0, 282, __pyx_L1_error) + if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_product_sum, __pyx_t_2) < 0) __PYX_ERR(0, 288, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "tigramite/tigramite_cython_code.pyx":232 @@ -23009,7 +23679,7 @@ if (!__Pyx_RefNanny) { * """Inner helper of dcov_all. Cache different means that are required for calculating * the matrix members on the fly""" */ - __pyx_t_2 = __Pyx_Py3ClassCreate(((PyObject*)&__Pyx_DefaultClassType), __pyx_n_s_D_N, __pyx_empty_tuple, __pyx_t_1, NULL, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 232, __pyx_L1_error) + __pyx_t_2 = __Pyx_Py3ClassCreate(((PyObject*)&__Pyx_DefaultClassType), __pyx_n_s_D_N, __pyx_empty_tuple, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 232, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_D_N, __pyx_t_2) < 0) __PYX_ERR(0, 232, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -23045,7 +23715,7 @@ if (!__Pyx_RefNanny) { * cdef strided = Enum("") # default * cdef indirect = Enum("") */ - __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__40, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 286, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__42, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 286, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XGOTREF(generic); __Pyx_DECREF_SET(generic, __pyx_t_1); @@ -23059,7 +23729,7 @@ if (!__Pyx_RefNanny) { * cdef indirect = Enum("") * */ - __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__41, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 287, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__43, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 287, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XGOTREF(strided); __Pyx_DECREF_SET(strided, __pyx_t_1); @@ -23073,7 +23743,7 @@ if (!__Pyx_RefNanny) { * * */ - __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__42, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 288, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__44, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 288, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XGOTREF(indirect); __Pyx_DECREF_SET(indirect, __pyx_t_1); @@ -23087,7 +23757,7 @@ if (!__Pyx_RefNanny) { * cdef indirect_contiguous = Enum("") * */ - __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__43, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 291, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__45, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 291, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XGOTREF(contiguous); __Pyx_DECREF_SET(contiguous, __pyx_t_1); @@ -23101,7 +23771,7 @@ if (!__Pyx_RefNanny) { * * */ - __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__44, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 292, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__46, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 292, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XGOTREF(indirect_contiguous); __Pyx_DECREF_SET(indirect_contiguous, __pyx_t_1); @@ -23134,29 +23804,29 @@ if (!__Pyx_RefNanny) { __pyx_t_3[7] = PyThread_allocate_lock(); memcpy(&(__pyx_memoryview_thread_locks[0]), __pyx_t_3, sizeof(__pyx_memoryview_thread_locks[0]) * (8)); - /* "View.MemoryView":549 + /* "View.MemoryView":545 * info.obj = self * * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< * * */ - __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 549, __pyx_L1_error) + __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 545, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem((PyObject *)__pyx_memoryview_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(2, 549, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_memoryview_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(2, 545, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_memoryview_type); - /* "View.MemoryView":995 + /* "View.MemoryView":991 * return self.from_object * * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< * * */ - __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 995, __pyx_L1_error) + __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 991, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem((PyObject *)__pyx_memoryviewslice_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(2, 995, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_memoryviewslice_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(2, 991, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_memoryviewslice_type); @@ -23311,7 +23981,7 @@ static int __Pyx_ParseOptionalKeywords( } name = first_kw_arg; #if PY_MAJOR_VERSION < 3 - if (likely(PyString_Check(key))) { + if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { while (*name) { if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { @@ -23338,7 +24008,7 @@ static int __Pyx_ParseOptionalKeywords( while (*name) { int cmp = (**name == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**name, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; @@ -23354,7 +24024,7 @@ static int __Pyx_ParseOptionalKeywords( while (argname != first_kw_arg) { int cmp = (**argname == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**argname, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; @@ -23714,7 +24384,7 @@ __Pyx_init_memviewslice(struct __pyx_memoryview_obj *memview, int i, retval=-1; Py_buffer *buf = &memview->view; __Pyx_RefNannySetupContext("init_memviewslice", 0); - if (unlikely(memviewslice->memview || memviewslice->data)) { + if (memviewslice->memview || memviewslice->data) { PyErr_SetString(PyExc_ValueError, "memviewslice is already initialized!"); goto fail; @@ -23793,13 +24463,13 @@ __Pyx_INC_MEMVIEW(__Pyx_memviewslice *memslice, int have_gil, int lineno) { int first_time; struct __pyx_memoryview_obj *memview = memslice->memview; - if (unlikely(!memview || (PyObject *) memview == Py_None)) + if (!memview || (PyObject *) memview == Py_None) return; - if (unlikely(__pyx_get_slice_count(memview) < 0)) + if (__pyx_get_slice_count(memview) < 0) __pyx_fatalerror("Acquisition count is %d (line %d)", __pyx_get_slice_count(memview), lineno); first_time = __pyx_add_acquisition_count(memview) == 0; - if (unlikely(first_time)) { + if (first_time) { if (have_gil) { Py_INCREF((PyObject *) memview); } else { @@ -23813,16 +24483,18 @@ static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW(__Pyx_memviewslice *memslice, int have_gil, int lineno) { int last_time; struct __pyx_memoryview_obj *memview = memslice->memview; - if (unlikely(!memview || (PyObject *) memview == Py_None)) { + if (!memview ) { + return; + } else if ((PyObject *) memview == Py_None) { memslice->memview = NULL; return; } - if (unlikely(__pyx_get_slice_count(memview) <= 0)) + if (__pyx_get_slice_count(memview) <= 0) __pyx_fatalerror("Acquisition count is %d (line %d)", __pyx_get_slice_count(memview), lineno); last_time = __pyx_sub_acquisition_count(memview) == 1; memslice->data = NULL; - if (unlikely(last_time)) { + if (last_time) { if (have_gil) { Py_CLEAR(memslice->memview); } else { @@ -24150,7 +24822,6 @@ static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { } static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { switch (ch) { - case '?': return "'bool'"; case 'c': return "'char'"; case 'b': return "'signed char'"; case 'B': return "'unsigned char'"; @@ -24193,7 +24864,7 @@ static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { } static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { switch (ch) { - case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'c': case 'b': case 'B': case 's': case 'p': return 1; case 'h': case 'H': return sizeof(short); case 'i': case 'I': return sizeof(int); case 'l': case 'L': return sizeof(long); @@ -24277,7 +24948,7 @@ static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { case 'b': case 'h': case 'i': case 'l': case 'q': case 's': case 'p': return 'I'; - case '?': case 'B': case 'H': case 'I': case 'L': case 'Q': + case 'B': case 'H': case 'I': case 'L': case 'Q': return 'U'; case 'f': case 'd': case 'g': return (is_complex ? 'C' : 'R'); @@ -24421,7 +25092,9 @@ static PyObject * __pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) { const char *ts = *tsp; - int i = 0, number, ndim; + int i = 0, number; + int ndim = ctx->head->field->type->ndim; +; ++ts; if (ctx->new_count != 1) { PyErr_SetString(PyExc_ValueError, @@ -24429,7 +25102,6 @@ __pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) return NULL; } if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; - ndim = ctx->head->field->type->ndim; while (*ts && *ts != ')') { switch (*ts) { case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; @@ -24555,12 +25227,12 @@ static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const cha return NULL; } CYTHON_FALLTHROUGH; - case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': + case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': case 'l': case 'L': case 'q': case 'Q': case 'f': case 'd': case 'g': case 'O': case 'p': - if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) && - (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) { + if (ctx->enc_type == *ts && got_Z == ctx->is_complex && + ctx->enc_packmode == ctx->new_packmode) { ctx->enc_count += ctx->new_count; ctx->new_count = 1; got_Z = 0; @@ -24643,48 +25315,6 @@ fail:; return -1; } -/* DictGetItem */ - #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY -static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { - PyObject *value; - value = PyDict_GetItemWithError(d, key); - if (unlikely(!value)) { - if (!PyErr_Occurred()) { - if (unlikely(PyTuple_Check(key))) { - PyObject* args = PyTuple_Pack(1, key); - if (likely(args)) { - PyErr_SetObject(PyExc_KeyError, args); - Py_DECREF(args); - } - } else { - PyErr_SetObject(PyExc_KeyError, key); - } - } - return NULL; - } - Py_INCREF(value); - return value; -} -#endif - -/* RaiseTooManyValuesToUnpack */ - static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { - PyErr_Format(PyExc_ValueError, - "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); -} - -/* RaiseNeedMoreValuesToUnpack */ - static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { - PyErr_Format(PyExc_ValueError, - "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", - index, (index == 1) ? "" : "s"); -} - -/* RaiseNoneIterError */ - static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); -} - /* RaiseException */ #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, @@ -24844,6 +25474,48 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject } #endif +/* DictGetItem */ + #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (!PyErr_Occurred()) { + if (unlikely(PyTuple_Check(key))) { + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) { + PyErr_SetObject(PyExc_KeyError, args); + Py_DECREF(args); + } + } else { + PyErr_SetObject(PyExc_KeyError, key); + } + } + return NULL; + } + Py_INCREF(value); + return value; +} +#endif + +/* RaiseTooManyValuesToUnpack */ + static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +/* RaiseNeedMoreValuesToUnpack */ + static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +/* RaiseNoneIterError */ + static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +} + /* GetTopmostException */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * @@ -25241,9 +25913,9 @@ static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) { if (stop < 0) stop += length; } - if (unlikely(stop <= start)) - return __Pyx_NewRef(__pyx_empty_unicode); length = stop - start; + if (unlikely(length <= 0)) + return PyUnicode_FromUnicode(NULL, 0); cstring += start; if (decode_func) { return decode_func(cstring, length, errors); @@ -25332,7 +26004,7 @@ static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, { #if PY_MAJOR_VERSION >= 3 if (level == -1) { - if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { + if (strchr(__Pyx_MODULE_NAME, '.')) { module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, 1); if (!module) { @@ -25704,28 +26376,6 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam return -1; } -/* PyObjectGetAttrStrNoError */ - static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) - __Pyx_PyErr_Clear(); -} -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { - PyObject *result; -#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 - PyTypeObject* tp = Py_TYPE(obj); - if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { - return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); - } -#endif - result = __Pyx_PyObject_GetAttrStr(obj, attr_name); - if (unlikely(!result)) { - __Pyx_PyObject_GetAttrStr_ClearAttributeError(); - } - return result; -} - /* SetupReduce */ static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { int ret; @@ -25753,51 +26403,43 @@ static int __Pyx_setup_reduce(PyObject* type_obj) { PyObject *setstate = NULL; PyObject *setstate_cython = NULL; #if CYTHON_USE_PYTYPE_LOOKUP - if (_PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD; + if (_PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate)) goto GOOD; #else - if (PyObject_HasAttr(type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD; + if (PyObject_HasAttr(type_obj, __pyx_n_s_getstate)) goto GOOD; #endif #if CYTHON_USE_PYTYPE_LOOKUP - object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; + object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto BAD; #else - object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; + object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto BAD; #endif - reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; + reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto BAD; if (reduce_ex == object_reduce_ex) { #if CYTHON_USE_PYTYPE_LOOKUP - object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; + object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto BAD; #else - object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; + object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto BAD; #endif - reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; + reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto BAD; if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { - reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); - if (likely(reduce_cython)) { - ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - } else if (reduce == object_reduce || PyErr_Occurred()) { - goto __PYX_BAD; - } + reduce_cython = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_cython); if (unlikely(!reduce_cython)) goto BAD; + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto BAD; setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); if (!setstate) PyErr_Clear(); if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { - setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); - if (likely(setstate_cython)) { - ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - } else if (!setstate || PyErr_Occurred()) { - goto __PYX_BAD; - } + setstate_cython = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate_cython); if (unlikely(!setstate_cython)) goto BAD; + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto BAD; } PyType_Modified((PyTypeObject*)type_obj); } } - goto __PYX_GOOD; -__PYX_BAD: + goto GOOD; +BAD: if (!PyErr_Occurred()) PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); ret = -1; -__PYX_GOOD: +GOOD: #if !CYTHON_USE_PYTYPE_LOOKUP Py_XDECREF(object_reduce); Py_XDECREF(object_reduce_ex); @@ -25910,7 +26552,7 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, goto done; } -/* CythonFunctionShared */ +/* CythonFunction */ #include static PyObject * __Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure) @@ -26217,9 +26859,10 @@ static PyMethodDef __pyx_CyFunction_methods[] = { #else #define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist) #endif -static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, - PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { - if (unlikely(op == NULL)) +static PyObject *__Pyx_CyFunction_New(PyTypeObject *type, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + __pyx_CyFunctionObject *op = PyObject_GC_New(__pyx_CyFunctionObject, type); + if (op == NULL) return NULL; op->flags = flags; __Pyx_CyFunction_weakreflist(op) = NULL; @@ -26240,12 +26883,12 @@ static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef * Py_XINCREF(code); op->func_code = code; op->defaults_pyobjects = 0; - op->defaults_size = 0; op->defaults = NULL; op->defaults_tuple = NULL; op->defaults_kwdict = NULL; op->defaults_getter = NULL; op->func_annotations = NULL; + PyObject_GC_Track(op); return (PyObject *) op; } static int @@ -26308,7 +26951,6 @@ static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, } static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type) { -#if PY_MAJOR_VERSION < 3 __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) { Py_INCREF(func); @@ -26321,7 +26963,6 @@ static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObj } if (obj == Py_None) obj = NULL; -#endif return __Pyx_PyMethod_New(func, obj, type); } static PyObject* @@ -26477,9 +27118,6 @@ static PyTypeObject __pyx_CyFunctionType_type = { #if PY_VERSION_HEX >= 0x030800b1 0, #endif -#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, -#endif }; static int __pyx_CyFunction_init(void) { __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); @@ -26495,7 +27133,6 @@ static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t return PyErr_NoMemory(); memset(m->defaults, 0, size); m->defaults_pyobjects = pyobjects; - m->defaults_size = size; return m->defaults; } static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { @@ -26514,19 +27151,6 @@ static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, Py Py_INCREF(dict); } -/* CythonFunction */ - static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, - PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { - PyObject *op = __Pyx_CyFunction_Init( - PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType), - ml, flags, qualname, closure, module, globals, code - ); - if (likely(op)) { - PyObject_GC_Track(op); - } - return op; -} - /* CalculateMetaclass */ static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) { Py_ssize_t i, nbases = PyTuple_GET_SIZE(bases); @@ -26635,7 +27259,7 @@ static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObj /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK -static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON @@ -26739,7 +27363,7 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( - __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); + __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } @@ -26843,6 +27467,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, #if PY_MAJOR_VERSION < 3 static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); + if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags); if (__Pyx_TypeCheck(obj, __pyx_array_type)) return __pyx_array_getbuffer(obj, view, flags); if (__Pyx_TypeCheck(obj, __pyx_memoryview_type)) return __pyx_memoryview_getbuffer(obj, view, flags); PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); @@ -26856,6 +27481,7 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { return; } if ((0)) {} + else if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); view->obj = NULL; Py_DECREF(obj); } @@ -26983,13 +27609,13 @@ __pyx_check_strides(Py_buffer *buf, int dim, int ndim, int spec) if (buf->strides) { if (spec & __Pyx_MEMVIEW_CONTIG) { if (spec & (__Pyx_MEMVIEW_PTR|__Pyx_MEMVIEW_FULL)) { - if (unlikely(buf->strides[dim] != sizeof(void *))) { + if (buf->strides[dim] != sizeof(void *)) { PyErr_Format(PyExc_ValueError, "Buffer is not indirectly contiguous " "in dimension %d.", dim); goto fail; } - } else if (unlikely(buf->strides[dim] != buf->itemsize)) { + } else if (buf->strides[dim] != buf->itemsize) { PyErr_SetString(PyExc_ValueError, "Buffer and memoryview are not contiguous " "in the same dimension."); @@ -27000,7 +27626,7 @@ __pyx_check_strides(Py_buffer *buf, int dim, int ndim, int spec) Py_ssize_t stride = buf->strides[dim]; if (stride < 0) stride = -stride; - if (unlikely(stride < buf->itemsize)) { + if (stride < buf->itemsize) { PyErr_SetString(PyExc_ValueError, "Buffer and memoryview are not contiguous " "in the same dimension."); @@ -27008,17 +27634,17 @@ __pyx_check_strides(Py_buffer *buf, int dim, int ndim, int spec) } } } else { - if (unlikely(spec & __Pyx_MEMVIEW_CONTIG && dim != ndim - 1)) { + if (spec & __Pyx_MEMVIEW_CONTIG && dim != ndim - 1) { PyErr_Format(PyExc_ValueError, "C-contiguous buffer is not contiguous in " "dimension %d", dim); goto fail; - } else if (unlikely(spec & (__Pyx_MEMVIEW_PTR))) { + } else if (spec & (__Pyx_MEMVIEW_PTR)) { PyErr_Format(PyExc_ValueError, "C-contiguous buffer is not indirect in " "dimension %d", dim); goto fail; - } else if (unlikely(buf->suboffsets)) { + } else if (buf->suboffsets) { PyErr_SetString(PyExc_ValueError, "Buffer exposes suboffsets but no strides"); goto fail; @@ -27032,7 +27658,7 @@ static int __pyx_check_suboffsets(Py_buffer *buf, int dim, CYTHON_UNUSED int ndim, int spec) { if (spec & __Pyx_MEMVIEW_DIRECT) { - if (unlikely(buf->suboffsets && buf->suboffsets[dim] >= 0)) { + if (buf->suboffsets && buf->suboffsets[dim] >= 0) { PyErr_Format(PyExc_ValueError, "Buffer not compatible with direct access " "in dimension %d.", dim); @@ -27040,7 +27666,7 @@ __pyx_check_suboffsets(Py_buffer *buf, int dim, CYTHON_UNUSED int ndim, int spec } } if (spec & __Pyx_MEMVIEW_PTR) { - if (unlikely(!buf->suboffsets || (buf->suboffsets[dim] < 0))) { + if (!buf->suboffsets || (buf->suboffsets[dim] < 0)) { PyErr_Format(PyExc_ValueError, "Buffer is not indirectly accessible " "in dimension %d.", dim); @@ -27058,7 +27684,9 @@ __pyx_verify_contig(Py_buffer *buf, int ndim, int c_or_f_flag) if (c_or_f_flag & __Pyx_IS_F_CONTIG) { Py_ssize_t stride = 1; for (i = 0; i < ndim; i++) { - if (unlikely(stride * buf->itemsize != buf->strides[i] && buf->shape[i] > 1)) { + if (stride * buf->itemsize != buf->strides[i] && + buf->shape[i] > 1) + { PyErr_SetString(PyExc_ValueError, "Buffer not fortran contiguous."); goto fail; @@ -27068,7 +27696,8 @@ __pyx_verify_contig(Py_buffer *buf, int ndim, int c_or_f_flag) } else if (c_or_f_flag & __Pyx_IS_C_CONTIG) { Py_ssize_t stride = 1; for (i = ndim - 1; i >- 1; i--) { - if (unlikely(stride * buf->itemsize != buf->strides[i] && buf->shape[i] > 1)) { + if (stride * buf->itemsize != buf->strides[i] && + buf->shape[i] > 1) { PyErr_SetString(PyExc_ValueError, "Buffer not C contiguous."); goto fail; @@ -27109,7 +27738,7 @@ static int __Pyx_ValidateAndInit_memviewslice( goto fail; } buf = &memview->view; - if (unlikely(buf->ndim != ndim)) { + if (buf->ndim != ndim) { PyErr_Format(PyExc_ValueError, "Buffer has wrong number of dimensions (expected %d, got %d)", ndim, buf->ndim); @@ -27117,9 +27746,9 @@ static int __Pyx_ValidateAndInit_memviewslice( } if (new_memview) { __Pyx_BufFmt_Init(&ctx, stack, dtype); - if (unlikely(!__Pyx_BufFmt_CheckString(&ctx, buf->format))) goto fail; + if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; } - if (unlikely((unsigned) buf->itemsize != dtype->size)) { + if ((unsigned) buf->itemsize != dtype->size) { PyErr_Format(PyExc_ValueError, "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "u byte%s) " "does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "u byte%s)", @@ -27130,17 +27759,15 @@ static int __Pyx_ValidateAndInit_memviewslice( (dtype->size > 1) ? "s" : ""); goto fail; } - if (buf->len > 0) { - for (i = 0; i < ndim; i++) { - spec = axes_specs[i]; - if (unlikely(!__pyx_check_strides(buf, i, ndim, spec))) - goto fail; - if (unlikely(!__pyx_check_suboffsets(buf, i, ndim, spec))) - goto fail; - } - if (unlikely(buf->strides && !__pyx_verify_contig(buf, ndim, c_or_f_flag))) + for (i = 0; i < ndim; i++) { + spec = axes_specs[i]; + if (!__pyx_check_strides(buf, i, ndim, spec)) + goto fail; + if (!__pyx_check_suboffsets(buf, i, ndim, spec)) goto fail; } + if (buf->strides && !__pyx_verify_contig(buf, ndim, c_or_f_flag)) + goto fail; if (unlikely(__Pyx_init_memviewslice(memview, ndim, memviewslice, new_memview != NULL) == -1)) { goto fail; @@ -27503,6 +28130,7 @@ static CYTHON_INLINE int __pyx_memview_set_double(const char *itemp, PyObject *o case 1: return a; case 2: + z = __Pyx_c_prod_float(a, a); return __Pyx_c_prod_float(a, a); case 3: z = __Pyx_c_prod_float(a, a); @@ -27657,6 +28285,7 @@ static CYTHON_INLINE int __pyx_memview_set_double(const char *itemp, PyObject *o case 1: return a; case 2: + z = __Pyx_c_prod_double(a, a); return __Pyx_c_prod_double(a, a); case 3: z = __Pyx_c_prod_double(a, a); @@ -27743,7 +28372,7 @@ __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, struct __pyx_memoryview_obj *memview_obj = NULL; __Pyx_RefNannySetupContext("__pyx_memoryview_copy_new_contig", 0); for (i = 0; i < ndim; i++) { - if (unlikely(from_mvs->suboffsets[i] >= 0)) { + if (from_mvs->suboffsets[i] >= 0) { PyErr_Format(PyExc_ValueError, "Cannot copy memoryview slice with " "indirect dimensions (axis %d)", i); goto fail; diff --git a/tigramite/tigramite_cython_code.pyx b/tigramite/tigramite_cython_code.pyx index f13081b3..8797c689 100644 --- a/tigramite/tigramite_cython_code.pyx +++ b/tigramite/tigramite_cython_code.pyx @@ -8,19 +8,19 @@ import random import numpy as np cimport numpy as np import cython +from cython.parallel import prange, parallel - -cdef inline double max(double a, double b): return a if a >= b else b -cdef inline double abs(double a) : return a if a >= 0. else -1 * a +cdef inline double max(double a, double b) nogil: return a if a >= b else b +cdef inline double abs(double a) nogil: return a if a >= 0. else -1 * a @cython.boundscheck(False) @cython.wraparound(False) def _get_neighbors_within_eps_cython( - double[:,:] array, - int T, - int dim_x, - int dim_y, + double[:,:] array, + int T, + int dim_x, + int dim_y, double[:] epsarray, int k, int dim): @@ -49,7 +49,7 @@ def _get_neighbors_within_eps_cython( dz = 0. for d in range(dim_x+dim_y, dim): dz = max( abs(array[d, i] - array[d, j]), dz) - + # For no conditions, kz is counted up to T if (dz < epsmax): kz += 1 @@ -60,7 +60,7 @@ def _get_neighbors_within_eps_cython( dy = abs(array[dim_x, i] - array[dim_x, j]) for d in range(dim_x+1, dim_x+dim_y): dy = max( abs(array[d, i] - array[d, j]), dy) - + if (dy < epsmax): kyz += 1 @@ -68,10 +68,10 @@ def _get_neighbors_within_eps_cython( dx = abs(array[0, i] - array[0, j]) for d in range(1, dim_x): dx = max( abs(array[d, i] - array[d, j]), dx) - + if (dx < epsmax): kxz += 1 - + # Write to arrays k_xz[i] = kxz k_yz[i] = kyz @@ -92,7 +92,7 @@ def _get_patterns_cython( int dim, int step, int[:] fac, - int N, + int N, int T): cdef int n, t, k, i, j, p, tau, start, mask @@ -173,7 +173,7 @@ def _get_restricted_permutation_cython( use = neighbors[index, count] restricted_permutation[index] = use - + used[i] = use return numpy.asarray(restricted_permutation) @@ -207,7 +207,7 @@ def _get_restricted_permutation_cython( ## THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ## (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ## OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - + """An implementation of Distance Correlation (see http://en.wikipedia.org/wiki/Distance_correlation ) that is not quadratic in space requirements (only in runtime).""" @@ -229,8 +229,8 @@ def dcov_all(x, y): return dc, dr, dvx, dvy -class D_N: - """Inner helper of dcov_all. Cache different means that are required for calculating +class D_N: + """Inner helper of dcov_all. Cache different means that are required for calculating the matrix members on the fly""" def __init__(self, x): @@ -239,6 +239,7 @@ class D_N: self.calculate_means() @cython.boundscheck(False) + @cython.wraparound(False) def calculate_means(self): cdef int dim = self.dim cdef DTYPE_t value @@ -248,6 +249,8 @@ class D_N: cdef np.ndarray[DTYPE_t, ndim=1] x = self.x cdef unsigned int ii cdef unsigned int jj + + # Adding prange() here leads to erros. Why? for ii in range(dim): for jj in range(dim): value = abs(x[jj] - x[ii]) @@ -257,9 +260,11 @@ class D_N: self.mean = sum_total / (self.dim**2) self.mean_0 = sum_0 / (self.dim) self.mean_1 = sum_1 / (self.dim) + return @cython.boundscheck(False) + @cython.wraparound(False) def squared_sum(self): cdef np.ndarray[DTYPE_t, ndim=1] mean_0 = self.mean_0 cdef np.ndarray[DTYPE_t, ndim=1] mean_1 = self.mean_1 @@ -271,14 +276,15 @@ class D_N: cdef unsigned int dim = self.dim cdef unsigned int ii cdef unsigned int jj - for ii in range(dim): - for jj in range(dim): + for ii in prange(dim, nogil=True): + for jj in range(dim): dist = abs(x[jj] - x[ii]) d = dist - mean_0[ii] - mean_1[jj] + mean squared_sum += d * d return squared_sum - + @cython.boundscheck(False) + @cython.wraparound(False) def product_sum(self, other): cdef np.ndarray[DTYPE_t, ndim=1] mean_0_here = self.mean_0 cdef np.ndarray[DTYPE_t, ndim=1] mean_1_here = self.mean_1 @@ -295,8 +301,8 @@ class D_N: cdef unsigned int dim = self.dim cdef unsigned int ii cdef unsigned int jj - for ii in range(dim): - for jj in range(dim): + for ii in prange(dim, nogil=True): + for jj in range(dim): d_here = abs(x[jj] - x[ii]) - mean_0_here[ii] - mean_1_here[jj] + mean_here d_there = abs(y[jj] - y[ii]) - mean_0_there[ii] - mean_1_there[jj] + mean_there product_sum += d_here * d_there From 4b05800d851781fe9b2f22350d0e2fccd2d97d5e Mon Sep 17 00:00:00 2001 From: jakobrunge Date: Tue, 2 Mar 2021 17:08:54 +0100 Subject: [PATCH 2/6] added gpdc_torch and some further additions, eg parallelized cython support --- environment_py3.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/environment_py3.yml b/environment_py3.yml index c2c72326..f0d717ee 100644 --- a/environment_py3.yml +++ b/environment_py3.yml @@ -6,4 +6,5 @@ dependencies: - scikit-learn>=0.21.2 - matplotlib>=3.1.1 - networkx>=2.4 - - cython>=0.26 \ No newline at end of file + - cython>=0.26 + - torch>=1.7 \ No newline at end of file From e20475d309ae8735f6f95372ffe8bdba133e34de Mon Sep 17 00:00:00 2001 From: jakobrunge Date: Tue, 2 Mar 2021 17:17:39 +0100 Subject: [PATCH 3/6] added gpdc_torch and some further additions, eg parallelized cython support --- environment_py3.yml | 3 ++- setup.py | 5 +++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/environment_py3.yml b/environment_py3.yml index f0d717ee..1727b932 100644 --- a/environment_py3.yml +++ b/environment_py3.yml @@ -7,4 +7,5 @@ dependencies: - matplotlib>=3.1.1 - networkx>=2.4 - cython>=0.26 - - torch>=1.7 \ No newline at end of file + - torch>=1.7 + - gpytorch>=1.4 \ No newline at end of file diff --git a/setup.py b/setup.py index 76015404..a695f060 100644 --- a/setup.py +++ b/setup.py @@ -68,12 +68,13 @@ def define_extension(extension_name, source_files=None): "scikit-learn>=0.21", # Gaussian Process (GP) Regression "matplotlib>=3.0", # plotting "networkx>=2.4", # plotting - "torch>=1.7" + "torch>=1.7", + "gpytorch>=1.4" ] } # Define the packages needed for testing -TESTS_REQUIRE = ["nose", "pytest", "networkx>=2.4", "scikit-learn>=0.21", "torch>=1.7"] +TESTS_REQUIRE = ["nose", "pytest", "networkx>=2.4", "scikit-learn>=0.21", "torch>=1.7", "gpytorch>=1.4"] EXTRAS_REQUIRE["test"] = TESTS_REQUIRE # Define the extras needed for development EXTRAS_REQUIRE["dev"] = EXTRAS_REQUIRE["all"] + TESTS_REQUIRE + ["cython"] From c214c7527e79f8a253f8b22664285465067de9a5 Mon Sep 17 00:00:00 2001 From: jakobrunge Date: Fri, 14 May 2021 17:50:24 +0200 Subject: [PATCH 4/6] fixes on consistency of selected_links, random seed handling, distance correlation fixed GPDCtorch memory issue fixed --- README.md | 19 + environment_py3.yml | 3 +- setup.py | 12 +- tests/test_independence_tests.py | 2 +- tigramite/independence_tests/LBFGS.py | 1090 +++++++++++++++++ tigramite/independence_tests/cmiknn.py | 89 +- tigramite/independence_tests/gpdc.py | 95 +- tigramite/independence_tests/gpdc_torch.py | 445 +++---- .../independence_tests_base.py | 13 +- .../oracle_conditional_independence.py | 771 ++++++++++-- tigramite/independence_tests/parcorr.py | 7 +- tigramite/models.py | 87 +- tigramite/pcmci.py | 67 +- tigramite/plotting.py | 68 +- tigramite/tigramite_cython_code.pyx | 134 -- .../tigramite_tutorial_assumptions.ipynb | 58 +- tutorials/tigramite_tutorial_basics.ipynb | 126 +- ...te_tutorial_causal_effects_mediation.ipynb | 4 +- .../tigramite_tutorial_missing_masking.ipynb | 52 +- .../tigramite_tutorial_pcmci_fullci.ipynb | 8 +- tutorials/tigramite_tutorial_pcmciplus.ipynb | 280 +++-- tutorials/tigramite_tutorial_prediction.ipynb | 75 +- 22 files changed, 2588 insertions(+), 917 deletions(-) create mode 100644 tigramite/independence_tests/LBFGS.py diff --git a/README.md b/README.md index a02575d4..8f4aac0d 100644 --- a/README.md +++ b/README.md @@ -8,6 +8,25 @@ Version 4.2 [Documentation](https://jakobrunge.github.io/tigramite/) +## Overview + +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. PCMCI 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 | + + +| Conditional independence test | Assumptions | +|--------|---------------------------------------------------------------------------| +| ParCorr | univariate, continuous, linear Gaussian dependencies | +| GPDC / GPDCtorch | univariate, continuous, additive dependencies | +| CMIknn | multivariate, continuous, general dependencies | +| CMIsymb | univariate, discrete/categorical dependencies | + ## General Notes Tigramite is a causal time series analysis python package. It allows to diff --git a/environment_py3.yml b/environment_py3.yml index 1727b932..7b75c2de 100644 --- a/environment_py3.yml +++ b/environment_py3.yml @@ -8,4 +8,5 @@ dependencies: - networkx>=2.4 - cython>=0.26 - torch>=1.7 - - gpytorch>=1.4 \ No newline at end of file + - gpytorch>=1.4 + - dcor>=0.5.3 \ No newline at end of file diff --git a/setup.py b/setup.py index a695f060..9a414772 100644 --- a/setup.py +++ b/setup.py @@ -66,15 +66,17 @@ def define_extension(extension_name, source_files=None): EXTRAS_REQUIRE = { "all": [ "scikit-learn>=0.21", # Gaussian Process (GP) Regression - "matplotlib>=3.0", # plotting - "networkx>=2.4", # plotting - "torch>=1.7", - "gpytorch>=1.4" + "matplotlib>=3.0", # plotting + "networkx>=2.4", # plotting + "torch>=1.7", # GPDC torch version + "gpytorch>=1.4", # GPDC torch version + "dcor>=0.5.3", # GPDC ] } # Define the packages needed for testing -TESTS_REQUIRE = ["nose", "pytest", "networkx>=2.4", "scikit-learn>=0.21", "torch>=1.7", "gpytorch>=1.4"] +TESTS_REQUIRE = ["nose", "pytest", "networkx>=2.4", "scikit-learn>=0.21", + "torch>=1.7", "gpytorch>=1.4", "dcor>=0.5.3"] EXTRAS_REQUIRE["test"] = TESTS_REQUIRE # Define the extras needed for development EXTRAS_REQUIRE["dev"] = EXTRAS_REQUIRE["all"] + TESTS_REQUIRE + ["cython"] diff --git a/tests/test_independence_tests.py b/tests/test_independence_tests.py index 9230fda7..61992c6d 100644 --- a/tests/test_independence_tests.py +++ b/tests/test_independence_tests.py @@ -437,7 +437,7 @@ def func(x_arr, c_val=1.): cntr = np.where(np.abs(target_res) < .7)[0] np.testing.assert_allclose(pred[cntr], func(target_res[cntr], c_val), - atol=0.2) + atol=0.2, rtol=1e-01) def test_shuffle_sig_gpdc_torch(gpdc_torch, data_sample_b): # Get the data sample diff --git a/tigramite/independence_tests/LBFGS.py b/tigramite/independence_tests/LBFGS.py new file mode 100644 index 00000000..3f344c22 --- /dev/null +++ b/tigramite/independence_tests/LBFGS.py @@ -0,0 +1,1090 @@ +import torch +import numpy as np +import matplotlib.pyplot as plt +from functools import reduce +from copy import deepcopy +from torch.optim import Optimizer + + +def is_legal(v): + """ + Checks that tensor is not NaN or Inf. + Inputs: + v (tensor): tensor to be checked + """ + legal = not torch.isnan(v).any() and not torch.isinf(v) + + return legal + + +def polyinterp(points, x_min_bound=None, x_max_bound=None, plot=False): + """ + Gives the minimizer and minimum of the interpolating polynomial over given points + based on function and derivative information. Defaults to bisection if no critical + points are valid. + Based on polyinterp.m Matlab function in minFunc by Mark Schmidt with some slight + modifications. + Implemented by: Hao-Jun Michael Shi and Dheevatsa Mudigere + Last edited 12/6/18. + Inputs: + points (nparray): two-dimensional array with each point of form [x f g] + x_min_bound (float): minimum value that brackets minimum (default: minimum of points) + x_max_bound (float): maximum value that brackets minimum (default: maximum of points) + plot (bool): plot interpolating polynomial + Outputs: + x_sol (float): minimizer of interpolating polynomial + F_min (float): minimum of interpolating polynomial + Note: + . Set f or g to np.nan if they are unknown + """ + no_points = points.shape[0] + order = np.sum(1 - np.isnan(points[:, 1:3]).astype("int")) - 1 + + x_min = np.min(points[:, 0]) + x_max = np.max(points[:, 0]) + + # compute bounds of interpolation area + if x_min_bound is None: + x_min_bound = x_min + if x_max_bound is None: + x_max_bound = x_max + + # explicit formula for quadratic interpolation + if no_points == 2 and order == 2 and plot is False: + # Solution to quadratic interpolation is given by: + # a = -(f1 - f2 - g1(x1 - x2))/(x1 - x2)^2 + # x_min = x1 - g1/(2a) + # if x1 = 0, then is given by: + # x_min = - (g1*x2^2)/(2(f2 - f1 - g1*x2)) + + if points[0, 0] == 0: + x_sol = ( + -points[0, 2] * points[1, 0] ** 2 / (2 * (points[1, 1] - points[0, 1] - points[0, 2] * points[1, 0])) + ) + else: + a = ( + -(points[0, 1] - points[1, 1] - points[0, 2] * (points[0, 0] - points[1, 0])) + / (points[0, 0] - points[1, 0]) ** 2 + ) + x_sol = points[0, 0] - points[0, 2] / (2 * a) + + x_sol = np.minimum(np.maximum(x_min_bound, x_sol), x_max_bound) + + # explicit formula for cubic interpolation + elif no_points == 2 and order == 3 and plot is False: + # Solution to cubic interpolation is given by: + # d1 = g1 + g2 - 3((f1 - f2)/(x1 - x2)) + # d2 = sqrt(d1^2 - g1*g2) + # x_min = x2 - (x2 - x1)*((g2 + d2 - d1)/(g2 - g1 + 2*d2)) + d1 = points[0, 2] + points[1, 2] - 3 * ((points[0, 1] - points[1, 1]) / (points[0, 0] - points[1, 0])) + d2 = np.sqrt(d1 ** 2 - points[0, 2] * points[1, 2]) + if np.isreal(d2): + x_sol = points[1, 0] - (points[1, 0] - points[0, 0]) * ( + (points[1, 2] + d2 - d1) / (points[1, 2] - points[0, 2] + 2 * d2) + ) + x_sol = np.minimum(np.maximum(x_min_bound, x_sol), x_max_bound) + else: + x_sol = (x_max_bound + x_min_bound) / 2 + + # solve linear system + else: + # define linear constraints + A = np.zeros((0, order + 1)) + b = np.zeros((0, 1)) + + # add linear constraints on function values + for i in range(no_points): + if not np.isnan(points[i, 1]): + constraint = np.zeros((1, order + 1)) + for j in range(order, -1, -1): + constraint[0, order - j] = points[i, 0] ** j + A = np.append(A, constraint, 0) + b = np.append(b, points[i, 1]) + + # add linear constraints on gradient values + for i in range(no_points): + if not np.isnan(points[i, 2]): + constraint = np.zeros((1, order + 1)) + for j in range(order): + constraint[0, j] = (order - j) * points[i, 0] ** (order - j - 1) + A = np.append(A, constraint, 0) + b = np.append(b, points[i, 2]) + + # check if system is solvable + if A.shape[0] != A.shape[1] or np.linalg.matrix_rank(A) != A.shape[0]: + x_sol = (x_min_bound + x_max_bound) / 2 + f_min = np.Inf + else: + # solve linear system for interpolating polynomial + coeff = np.linalg.solve(A, b) + + # compute critical points + dcoeff = np.zeros(order) + for i in range(len(coeff) - 1): + dcoeff[i] = coeff[i] * (order - i) + + crit_pts = np.array([x_min_bound, x_max_bound]) + crit_pts = np.append(crit_pts, points[:, 0]) + + if not np.isinf(dcoeff).any(): + roots = np.roots(dcoeff) + crit_pts = np.append(crit_pts, roots) + + # test critical points + f_min = np.Inf + x_sol = (x_min_bound + x_max_bound) / 2 # defaults to bisection + for crit_pt in crit_pts: + if np.isreal(crit_pt) and crit_pt >= x_min_bound and crit_pt <= x_max_bound: + F_cp = np.polyval(coeff, crit_pt) + if np.isreal(F_cp) and F_cp < f_min: + x_sol = np.real(crit_pt) + f_min = np.real(F_cp) + + if plot: + plt.figure() + x = np.arange(x_min_bound, x_max_bound, (x_max_bound - x_min_bound) / 10000) + f = np.polyval(coeff, x) + plt.plot(x, f) + plt.plot(x_sol, f_min, "x") + + return x_sol + + +class LBFGS(Optimizer): + """ + Implements the L-BFGS algorithm. Compatible with multi-batch and full-overlap + L-BFGS implementations and (stochastic) Powell damping. Partly based on the + original L-BFGS implementation in PyTorch, Mark Schmidt's minFunc MATLAB code, + and Michael Overton's weak Wolfe line search MATLAB code. + Implemented by: Hao-Jun Michael Shi and Dheevatsa Mudigere + Last edited 12/6/18. + Warnings: + . Does not support per-parameter options and parameter groups. + . All parameters have to be on a single device. + Inputs: + lr (float): steplength or learning rate (default: 1) + history_size (int): update history size (default: 10) + line_search (str): designates line search to use (default: 'Wolfe') + Options: + 'None': uses steplength designated in algorithm + 'Armijo': uses Armijo backtracking line search + 'Wolfe': uses Armijo-Wolfe bracketing line search + dtype: data type (default: torch.float) + debug (bool): debugging mode + References: + [1] Berahas, Albert S., Jorge Nocedal, and Martin Takác. "A Multi-Batch L-BFGS + Method for Machine Learning." Advances in Neural Information Processing + Systems. 2016. + [2] Bollapragada, Raghu, et al. "A Progressive Batching L-BFGS Method for Machine + Learning." International Conference on Machine Learning. 2018. + [3] Lewis, Adrian S., and Michael L. Overton. "Nonsmooth Optimization via Quasi-Newton + Methods." Mathematical Programming 141.1-2 (2013): 135-163. + [4] Liu, Dong C., and Jorge Nocedal. "On the Limited Memory BFGS Method for + Large Scale Optimization." Mathematical Programming 45.1-3 (1989): 503-528. + [5] Nocedal, Jorge. "Updating Quasi-Newton Matrices With Limited Storage." + Mathematics of Computation 35.151 (1980): 773-782. + [6] Nocedal, Jorge, and Stephen J. Wright. "Numerical Optimization." Springer New York, + 2006. + [7] Schmidt, Mark. "minFunc: Unconstrained Differentiable Multivariate Optimization + in Matlab." Software available at http://www.cs.ubc.ca/~schmidtm/Software/minFunc.html + (2005). + [8] Schraudolph, Nicol N., Jin Yu, and Simon Günter. "A Stochastic Quasi-Newton + Method for Online Convex Optimization." Artificial Intelligence and Statistics. + 2007. + [9] Wang, Xiao, et al. "Stochastic Quasi-Newton Methods for Nonconvex Stochastic + Optimization." SIAM Journal on Optimization 27.2 (2017): 927-956. + """ + + def __init__(self, params, lr=1, history_size=10, line_search="Wolfe", dtype=torch.float, debug=False): + + # ensure inputs are valid + if not 0.0 <= lr: + raise ValueError("Invalid learning rate: {}".format(lr)) + if not 0 <= history_size: + raise ValueError("Invalid history size: {}".format(history_size)) + if line_search not in ["Armijo", "Wolfe", "None"]: + raise ValueError("Invalid line search: {}".format(line_search)) + + defaults = dict(lr=lr, history_size=history_size, line_search=line_search, dtype=dtype, debug=debug) + super(LBFGS, self).__init__(params, defaults) + + if len(self.param_groups) != 1: + raise ValueError("L-BFGS doesn't support per-parameter options " "(parameter groups)") + + self._params = self.param_groups[0]["params"] + self._numel_cache = None + + state = self.state["global_state"] + state.setdefault("n_iter", 0) + state.setdefault("curv_skips", 0) + state.setdefault("fail_skips", 0) + state.setdefault("H_diag", 1) + state.setdefault("fail", True) + + state["old_dirs"] = [] + state["old_stps"] = [] + + def _numel(self): + if self._numel_cache is None: + self._numel_cache = reduce(lambda total, p: total + p.numel(), self._params, 0) + return self._numel_cache + + def _gather_flat_grad(self): + views = [] + for p in self._params: + if p.grad is None: + view = p.data.new(p.data.numel()).zero_() + elif p.grad.data.is_sparse: + view = p.grad.data.to_dense().view(-1) + else: + view = p.grad.data.view(-1) + views.append(view) + return torch.cat(views, 0) + + def _add_update(self, step_size, update): + offset = 0 + for p in self._params: + numel = p.numel() + # view as to avoid deprecated pointwise semantics + p.data.add_(update[offset : offset + numel].view_as(p.data), alpha=step_size) + offset += numel + assert offset == self._numel() + + def _copy_params(self): + current_params = [] + for param in self._params: + current_params.append(deepcopy(param.data)) + return current_params + + def _load_params(self, current_params): + i = 0 + for param in self._params: + param.data[:] = current_params[i] + i += 1 + + def line_search(self, line_search): + """ + Switches line search option. + Inputs: + line_search (str): designates line search to use + Options: + 'None': uses steplength designated in algorithm + 'Armijo': uses Armijo backtracking line search + 'Wolfe': uses Armijo-Wolfe bracketing line search + """ + + group = self.param_groups[0] + group["line_search"] = line_search + + return + + def two_loop_recursion(self, vec): + """ + Performs two-loop recursion on given vector to obtain Hv. + Inputs: + vec (tensor): 1-D tensor to apply two-loop recursion to + Output: + r (tensor): matrix-vector product Hv + """ + + group = self.param_groups[0] + history_size = group["history_size"] + + state = self.state["global_state"] + old_dirs = state.get("old_dirs") # change in gradients + old_stps = state.get("old_stps") # change in iterates + H_diag = state.get("H_diag") + + # compute the product of the inverse Hessian approximation and the gradient + num_old = len(old_dirs) + + if "rho" not in state: + state["rho"] = [None] * history_size + state["alpha"] = [None] * history_size + rho = state["rho"] + alpha = state["alpha"] + + for i in range(num_old): + rho[i] = 1.0 / old_stps[i].dot(old_dirs[i]) + + q = vec + for i in range(num_old - 1, -1, -1): + alpha[i] = old_dirs[i].dot(q) * rho[i] + q.add_(old_stps[i], alpha=-alpha[i]) + + # multiply by initial Hessian + # r/d is the final direction + r = torch.mul(q, H_diag) + for i in range(num_old): + beta = old_stps[i].dot(r) * rho[i] + r.add_(old_dirs[i], alpha=(alpha[i] - beta)) + + return r + + def curvature_update(self, flat_grad, eps=1e-2, damping=False): + """ + Performs curvature update. + Inputs: + flat_grad (tensor): 1-D tensor of flattened gradient for computing + gradient difference with previously stored gradient + eps (float): constant for curvature pair rejection or damping (default: 1e-2) + damping (bool): flag for using Powell damping (default: False) + """ + + assert len(self.param_groups) == 1 + + # load parameters + if eps <= 0: + raise (ValueError("Invalid eps; must be positive.")) + + group = self.param_groups[0] + history_size = group["history_size"] + debug = group["debug"] + + # variables cached in state (for tracing) + state = self.state["global_state"] + fail = state.get("fail") + + # check if line search failed + if not fail: + + d = state.get("d") + t = state.get("t") + old_dirs = state.get("old_dirs") + old_stps = state.get("old_stps") + H_diag = state.get("H_diag") + prev_flat_grad = state.get("prev_flat_grad") + Bs = state.get("Bs") + + # compute y's + y = flat_grad.sub(prev_flat_grad) + s = d.mul(t) + sBs = s.dot(Bs) + ys = y.dot(s) # y*s + + # update L-BFGS matrix + if ys > eps * sBs or damping == True: + + # perform Powell damping + if damping == True and ys < eps * sBs: + if debug: + print("Applying Powell damping...") + theta = ((1 - eps) * sBs) / (sBs - ys) + y = theta * y + (1 - theta) * Bs + + # updating memory + if len(old_dirs) == history_size: + # shift history by one (limited-memory) + old_dirs.pop(0) + old_stps.pop(0) + + # store new direction/step + old_dirs.append(s) + old_stps.append(y) + + # update scale of initial Hessian approximation + H_diag = ys / y.dot(y) # (y*y) + + state["old_dirs"] = old_dirs + state["old_stps"] = old_stps + state["H_diag"] = H_diag + + else: + # save skip + state["curv_skips"] += 1 + if debug: + print("Curvature pair skipped due to failed criterion") + + else: + # save skip + state["fail_skips"] += 1 + if debug: + print("Line search failed; curvature pair update skipped") + + return + + def _step(self, p_k, g_Ok, g_Sk=None, options={}): + """ + Performs a single optimization step. + Inputs: + p_k (tensor): 1-D tensor specifying search direction + g_Ok (tensor): 1-D tensor of flattened gradient over overlap O_k used + for gradient differencing in curvature pair update + g_Sk (tensor): 1-D tensor of flattened gradient over full sample S_k + used for curvature pair damping or rejection criterion, + if None, will use g_Ok (default: None) + options (dict): contains options for performing line search + Options for Armijo backtracking line search: + 'closure' (callable): reevaluates model and returns function value + 'current_loss' (tensor): objective value at current iterate (default: F(x_k)) + 'gtd' (tensor): inner product g_Ok'd in line search (default: g_Ok'd) + 'eta' (tensor): factor for decreasing steplength > 0 (default: 2) + 'c1' (tensor): sufficient decrease constant in (0, 1) (default: 1e-4) + 'max_ls' (int): maximum number of line search steps permitted (default: 10) + 'interpolate' (bool): flag for using interpolation (default: True) + 'inplace' (bool): flag for inplace operations (default: True) + 'ls_debug' (bool): debugging mode for line search + Options for Wolfe line search: + 'closure' (callable): reevaluates model and returns function value + 'current_loss' (tensor): objective value at current iterate (default: F(x_k)) + 'gtd' (tensor): inner product g_Ok'd in line search (default: g_Ok'd) + 'eta' (float): factor for extrapolation (default: 2) + 'c1' (float): sufficient decrease constant in (0, 1) (default: 1e-4) + 'c2' (float): curvature condition constant in (0, 1) (default: 0.9) + 'max_ls' (int): maximum number of line search steps permitted (default: 10) + 'interpolate' (bool): flag for using interpolation (default: True) + 'inplace' (bool): flag for inplace operations (default: True) + 'ls_debug' (bool): debugging mode for line search + Outputs (depends on line search): + . No line search: + t (float): steplength + . Armijo backtracking line search: + F_new (tensor): loss function at new iterate + t (tensor): final steplength + ls_step (int): number of backtracks + closure_eval (int): number of closure evaluations + desc_dir (bool): descent direction flag + True: p_k is descent direction with respect to the line search + function + False: p_k is not a descent direction with respect to the line + search function + fail (bool): failure flag + True: line search reached maximum number of iterations, failed + False: line search succeeded + . Wolfe line search: + F_new (tensor): loss function at new iterate + g_new (tensor): gradient at new iterate + t (float): final steplength + ls_step (int): number of backtracks + closure_eval (int): number of closure evaluations + grad_eval (int): number of gradient evaluations + desc_dir (bool): descent direction flag + True: p_k is descent direction with respect to the line search + function + False: p_k is not a descent direction with respect to the line + search function + fail (bool): failure flag + True: line search reached maximum number of iterations, failed + False: line search succeeded + Notes: + . If encountering line search failure in the deterministic setting, one + should try increasing the maximum number of line search steps max_ls. + """ + + assert len(self.param_groups) == 1 + + # load parameter options + group = self.param_groups[0] + lr = group["lr"] + line_search = group["line_search"] + dtype = group["dtype"] + debug = group["debug"] + + # variables cached in state (for tracing) + state = self.state["global_state"] + d = state.get("d") + t = state.get("t") + prev_flat_grad = state.get("prev_flat_grad") + Bs = state.get("Bs") + + # keep track of nb of iterations + state["n_iter"] += 1 + + # set search direction + d = p_k + + # modify previous gradient + if prev_flat_grad is None: + prev_flat_grad = g_Ok.clone() + else: + prev_flat_grad.copy_(g_Ok) + + # set initial step size + t = lr + + # closure evaluation counter + closure_eval = 0 + + if g_Sk is None: + g_Sk = g_Ok.clone() + + # perform Armijo backtracking line search + if line_search == "Armijo": + + # load options + if options: + if "closure" not in options.keys(): + raise (ValueError("closure option not specified.")) + else: + closure = options["closure"] + + if "gtd" not in options.keys(): + gtd = g_Ok.dot(d) + else: + gtd = options["gtd"] + + if "current_loss" not in options.keys(): + F_k = closure() + closure_eval += 1 + else: + F_k = options["current_loss"] + + if "eta" not in options.keys(): + eta = 2 + elif options["eta"] <= 0: + raise (ValueError("Invalid eta; must be positive.")) + else: + eta = options["eta"] + + if "c1" not in options.keys(): + c1 = 1e-4 + elif options["c1"] >= 1 or options["c1"] <= 0: + raise (ValueError("Invalid c1; must be strictly between 0 and 1.")) + else: + c1 = options["c1"] + + if "max_ls" not in options.keys(): + max_ls = 10 + elif options["max_ls"] <= 0: + raise (ValueError("Invalid max_ls; must be positive.")) + else: + max_ls = options["max_ls"] + + if "interpolate" not in options.keys(): + interpolate = True + else: + interpolate = options["interpolate"] + + if "inplace" not in options.keys(): + inplace = True + else: + inplace = options["inplace"] + + if "ls_debug" not in options.keys(): + ls_debug = False + else: + ls_debug = options["ls_debug"] + + else: + raise (ValueError("Options are not specified; need closure evaluating function.")) + + # initialize values + if interpolate: + if torch.cuda.is_available(): + F_prev = torch.tensor(np.nan, dtype=dtype).cuda() + else: + F_prev = torch.tensor(np.nan, dtype=dtype) + + ls_step = 0 + t_prev = 0 # old steplength + fail = False # failure flag + + # begin print for debug mode + if ls_debug: + print( + "==================================== Begin Armijo line search ===================================" + ) + print("F(x): %.8e g*d: %.8e" % (F_k, gtd)) + + # check if search direction is descent direction + if gtd >= 0: + desc_dir = False + if debug: + print("Not a descent direction!") + else: + desc_dir = True + + # store values if not in-place + if not inplace: + current_params = self._copy_params() + + # update and evaluate at new point + self._add_update(t, d) + F_new = closure() + closure_eval += 1 + + # print info if debugging + if ls_debug: + print( + "LS Step: %d t: %.8e F(x+td): %.8e F-c1*t*g*d: %.8e F(x): %.8e" + % (ls_step, t, F_new, F_k + c1 * t * gtd, F_k) + ) + + # check Armijo condition + while F_new > F_k + c1 * t * gtd or not is_legal(F_new): + + # check if maximum number of iterations reached + if ls_step >= max_ls: + if inplace: + self._add_update(-t, d) + else: + self._load_params(current_params) + + t = 0 + F_new = closure() + closure_eval += 1 + fail = True + break + + else: + # store current steplength + t_new = t + + # compute new steplength + + # if first step or not interpolating, then multiply by factor + if ls_step == 0 or not interpolate or not is_legal(F_new): + t = t / eta + + # if second step, use function value at new point along with + # gradient and function at current iterate + elif ls_step == 1 or not is_legal(F_prev): + t = polyinterp(np.array([[0, F_k.item(), gtd.item()], [t_new, F_new.item(), np.nan]])) + + # otherwise, use function values at new point, previous point, + # and gradient and function at current iterate + else: + t = polyinterp( + np.array( + [ + [0, F_k.item(), gtd.item()], + [t_new, F_new.item(), np.nan], + [t_prev, F_prev.item(), np.nan], + ] + ) + ) + + # if values are too extreme, adjust t + if interpolate: + if t < 1e-3 * t_new: + t = 1e-3 * t_new + elif t > 0.6 * t_new: + t = 0.6 * t_new + + # store old point + F_prev = F_new + t_prev = t_new + + # update iterate and reevaluate + if inplace: + self._add_update(t - t_new, d) + else: + self._load_params(current_params) + self._add_update(t, d) + + F_new = closure() + closure_eval += 1 + ls_step += 1 # iterate + + # print info if debugging + if ls_debug: + print( + "LS Step: %d t: %.8e F(x+td): %.8e F-c1*t*g*d: %.8e F(x): %.8e" + % (ls_step, t, F_new, F_k + c1 * t * gtd, F_k) + ) + + # store Bs + if Bs is None: + Bs = (g_Sk.mul(-t)).clone() + else: + Bs.copy_(g_Sk.mul(-t)) + + # print final steplength + if ls_debug: + print("Final Steplength:", t) + print( + "===================================== End Armijo line search ====================================" + ) + + state["d"] = d + state["prev_flat_grad"] = prev_flat_grad + state["t"] = t + state["Bs"] = Bs + state["fail"] = fail + + return F_new, t, ls_step, closure_eval, desc_dir, fail + + # perform weak Wolfe line search + elif line_search == "Wolfe": + + # load options + if options: + if "closure" not in options.keys(): + raise (ValueError("closure option not specified.")) + else: + closure = options["closure"] + + if "current_loss" not in options.keys(): + F_k = closure() + closure_eval += 1 + else: + F_k = options["current_loss"] + + if "gtd" not in options.keys(): + gtd = g_Ok.dot(d) + else: + gtd = options["gtd"] + + if "eta" not in options.keys(): + eta = 2 + elif options["eta"] <= 1: + raise (ValueError("Invalid eta; must be greater than 1.")) + else: + eta = options["eta"] + + if "c1" not in options.keys(): + c1 = 1e-4 + elif options["c1"] >= 1 or options["c1"] <= 0: + raise (ValueError("Invalid c1; must be strictly between 0 and 1.")) + else: + c1 = options["c1"] + + if "c2" not in options.keys(): + c2 = 0.9 + elif options["c2"] >= 1 or options["c2"] <= 0: + raise (ValueError("Invalid c2; must be strictly between 0 and 1.")) + elif options["c2"] <= c1: + raise (ValueError("Invalid c2; must be strictly larger than c1.")) + else: + c2 = options["c2"] + + if "max_ls" not in options.keys(): + max_ls = 10 + elif options["max_ls"] <= 0: + raise (ValueError("Invalid max_ls; must be positive.")) + else: + max_ls = options["max_ls"] + + if "interpolate" not in options.keys(): + interpolate = True + else: + interpolate = options["interpolate"] + + if "inplace" not in options.keys(): + inplace = True + else: + inplace = options["inplace"] + + if "ls_debug" not in options.keys(): + ls_debug = False + else: + ls_debug = options["ls_debug"] + + else: + raise (ValueError("Options are not specified; need closure evaluating function.")) + + # initialize counters + ls_step = 0 + grad_eval = 0 # tracks gradient evaluations + t_prev = 0 # old steplength + + # initialize bracketing variables and flag + alpha = 0 + beta = float("Inf") + fail = False + + # initialize values for line search + if interpolate: + F_a = F_k + g_a = gtd + + if torch.cuda.is_available(): + F_b = torch.tensor(np.nan, dtype=dtype).cuda() + g_b = torch.tensor(np.nan, dtype=dtype).cuda() + else: + F_b = torch.tensor(np.nan, dtype=dtype) + g_b = torch.tensor(np.nan, dtype=dtype) + + # begin print for debug mode + if ls_debug: + print( + "==================================== Begin Wolfe line search ====================================" + ) + print("F(x): %.8e g*d: %.8e" % (F_k, gtd)) + + # check if search direction is descent direction + if gtd >= 0: + desc_dir = False + if debug: + print("Not a descent direction!") + else: + desc_dir = True + + # store values if not in-place + if not inplace: + current_params = self._copy_params() + + # update and evaluate at new point + self._add_update(t, d) + F_new = closure() + closure_eval += 1 + + # main loop + while True: + + # check if maximum number of line search steps have been reached + if ls_step >= max_ls: + if inplace: + self._add_update(-t, d) + else: + self._load_params(current_params) + + t = 0 + F_new = closure() + F_new.backward() + g_new = self._gather_flat_grad() + closure_eval += 1 + grad_eval += 1 + fail = True + break + + # print info if debugging + if ls_debug: + print("LS Step: %d t: %.8e alpha: %.8e beta: %.8e" % (ls_step, t, alpha, beta)) + print("Armijo: F(x+td): %.8e F-c1*t*g*d: %.8e F(x): %.8e" % (F_new, F_k + c1 * t * gtd, F_k)) + + # check Armijo condition + if F_new > F_k + c1 * t * gtd: + + # set upper bound + beta = t + t_prev = t + + # update interpolation quantities + if interpolate: + F_b = F_new + if torch.cuda.is_available(): + g_b = torch.tensor(np.nan, dtype=dtype).cuda() + else: + g_b = torch.tensor(np.nan, dtype=dtype) + + else: + + # compute gradient + F_new.backward() + g_new = self._gather_flat_grad() + grad_eval += 1 + gtd_new = g_new.dot(d) + + # print info if debugging + if ls_debug: + print("Wolfe: g(x+td)*d: %.8e c2*g*d: %.8e gtd: %.8e" % (gtd_new, c2 * gtd, gtd)) + + # check curvature condition + if gtd_new < c2 * gtd: + + # set lower bound + alpha = t + t_prev = t + + # update interpolation quantities + if interpolate: + F_a = F_new + g_a = gtd_new + + else: + break + + # compute new steplength + + # if first step or not interpolating, then bisect or multiply by factor + if not interpolate or not is_legal(F_b): + if beta == float("Inf"): + t = eta * t + else: + t = (alpha + beta) / 2.0 + + # otherwise interpolate between a and b + else: + t = polyinterp(np.array([[alpha, F_a.item(), g_a.item()], [beta, F_b.item(), g_b.item()]])) + + # if values are too extreme, adjust t + if beta == float("Inf"): + if t > 2 * eta * t_prev: + t = 2 * eta * t_prev + elif t < eta * t_prev: + t = eta * t_prev + else: + if t < alpha + 0.2 * (beta - alpha): + t = alpha + 0.2 * (beta - alpha) + elif t > (beta - alpha) / 2.0: + t = (beta - alpha) / 2.0 + + # if we obtain nonsensical value from interpolation + if t <= 0: + t = (beta - alpha) / 2.0 + + # update parameters + if inplace: + self._add_update(t - t_prev, d) + else: + self._load_params(current_params) + self._add_update(t, d) + + # evaluate closure + F_new = closure() + closure_eval += 1 + ls_step += 1 + + # store Bs + if Bs is None: + Bs = (g_Sk.mul(-t)).clone() + else: + Bs.copy_(g_Sk.mul(-t)) + + # print final steplength + if ls_debug: + print("Final Steplength:", t) + print( + "===================================== End Wolfe line search =====================================" + ) + + state["d"] = d + state["prev_flat_grad"] = prev_flat_grad + state["t"] = t + state["Bs"] = Bs + state["fail"] = fail + + return F_new, g_new, t, ls_step, closure_eval, grad_eval, desc_dir, fail + + else: + + # perform update + self._add_update(t, d) + + # store Bs + if Bs is None: + Bs = (g_Sk.mul(-t)).clone() + else: + Bs.copy_(g_Sk.mul(-t)) + + state["d"] = d + state["prev_flat_grad"] = prev_flat_grad + state["t"] = t + state["Bs"] = Bs + state["fail"] = False + + return t + + def step(self, p_k, g_Ok, g_Sk=None, options={}): + return self._step(p_k, g_Ok, g_Sk, options) + + +#%% Full-Batch (Deterministic) L-BFGS Optimizer (Wrapper) + + +class FullBatchLBFGS(LBFGS): + """ + Implements full-batch or deterministic L-BFGS algorithm. Compatible with + Powell damping. Can be used when evaluating a deterministic function and + gradient. Wraps the LBFGS optimizer. Performs the two-loop recursion, + updating, and curvature updating in a single step. + Implemented by: Hao-Jun Michael Shi and Dheevatsa Mudigere + Last edited 11/15/18. + Warnings: + . Does not support per-parameter options and parameter groups. + . All parameters have to be on a single device. + Inputs: + lr (float): steplength or learning rate (default: 1) + history_size (int): update history size (default: 10) + line_search (str): designates line search to use (default: 'Wolfe') + Options: + 'None': uses steplength designated in algorithm + 'Armijo': uses Armijo backtracking line search + 'Wolfe': uses Armijo-Wolfe bracketing line search + dtype: data type (default: torch.float) + debug (bool): debugging mode + """ + + def __init__(self, params, lr=1, history_size=10, line_search="Wolfe", dtype=torch.float, debug=False): + super(FullBatchLBFGS, self).__init__(params, lr, history_size, line_search, dtype, debug) + + def step(self, options={}): + """ + Performs a single optimization step. + Inputs: + options (dict): contains options for performing line search + General Options: + 'eps' (float): constant for curvature pair rejection or damping (default: 1e-2) + 'damping' (bool): flag for using Powell damping (default: False) + Options for Armijo backtracking line search: + 'closure' (callable): reevaluates model and returns function value + 'current_loss' (tensor): objective value at current iterate (default: F(x_k)) + 'gtd' (tensor): inner product g_Ok'd in line search (default: g_Ok'd) + 'eta' (tensor): factor for decreasing steplength > 0 (default: 2) + 'c1' (tensor): sufficient decrease constant in (0, 1) (default: 1e-4) + 'max_ls' (int): maximum number of line search steps permitted (default: 10) + 'interpolate' (bool): flag for using interpolation (default: True) + 'inplace' (bool): flag for inplace operations (default: True) + 'ls_debug' (bool): debugging mode for line search + Options for Wolfe line search: + 'closure' (callable): reevaluates model and returns function value + 'current_loss' (tensor): objective value at current iterate (default: F(x_k)) + 'gtd' (tensor): inner product g_Ok'd in line search (default: g_Ok'd) + 'eta' (float): factor for extrapolation (default: 2) + 'c1' (float): sufficient decrease constant in (0, 1) (default: 1e-4) + 'c2' (float): curvature condition constant in (0, 1) (default: 0.9) + 'max_ls' (int): maximum number of line search steps permitted (default: 10) + 'interpolate' (bool): flag for using interpolation (default: True) + 'inplace' (bool): flag for inplace operations (default: True) + 'ls_debug' (bool): debugging mode for line search + Outputs (depends on line search): + . No line search: + t (float): steplength + . Armijo backtracking line search: + F_new (tensor): loss function at new iterate + t (tensor): final steplength + ls_step (int): number of backtracks + closure_eval (int): number of closure evaluations + desc_dir (bool): descent direction flag + True: p_k is descent direction with respect to the line search + function + False: p_k is not a descent direction with respect to the line + search function + fail (bool): failure flag + True: line search reached maximum number of iterations, failed + False: line search succeeded + . Wolfe line search: + F_new (tensor): loss function at new iterate + g_new (tensor): gradient at new iterate + t (float): final steplength + ls_step (int): number of backtracks + closure_eval (int): number of closure evaluations + grad_eval (int): number of gradient evaluations + desc_dir (bool): descent direction flag + True: p_k is descent direction with respect to the line search + function + False: p_k is not a descent direction with respect to the line + search function + fail (bool): failure flag + True: line search reached maximum number of iterations, failed + False: line search succeeded + Notes: + . If encountering line search failure in the deterministic setting, one + should try increasing the maximum number of line search steps max_ls. + """ + + # load options for damping and eps + if "damping" not in options.keys(): + damping = False + else: + damping = options["damping"] + + if "eps" not in options.keys(): + eps = 1e-2 + else: + eps = options["eps"] + + # gather gradient + grad = self._gather_flat_grad() + + # update curvature if after 1st iteration + state = self.state["global_state"] + if state["n_iter"] > 0: + self.curvature_update(grad, eps, damping) + + # compute search direction + p = self.two_loop_recursion(-grad) + + # take step + return self._step(p, grad, options=options) diff --git a/tigramite/independence_tests/cmiknn.py b/tigramite/independence_tests/cmiknn.py index dc015e08..ca8cb6cc 100644 --- a/tigramite/independence_tests/cmiknn.py +++ b/tigramite/independence_tests/cmiknn.py @@ -159,7 +159,7 @@ def _get_nearest_neighbors(self, array, xyz, knn): # Add noise to destroy ties... array += (1E-6 * array.std(axis=1).reshape(dim, 1) - * np.random.rand(array.shape[0], array.shape[1])) + * self.random_state.random((array.shape[0], array.shape[1]))) if self.transform == 'standardize': # Standardize @@ -291,8 +291,11 @@ class which is a block shuffle test, which does not preserve # Generate random order in which to go through indices loop in # next step - order = np.random.permutation(T).astype('int32') + order = self.random_state.permutation(T).astype('int32') # print(order[:5]) + # Shuffle neighbor indices for each sample index + for i in range(T): + self.random_state.shuffle(neighbors[i]) # Select a series of neighbor indices that contains as few as # possible duplicates restricted_permutation = \ @@ -325,3 +328,85 @@ class which is a block shuffle test, which does not preserve return pval, null_dist return pval + + def get_conditional_entropy(self, array, xyz): + """Returns the nearest-neighbor conditional entropy estimate of H(X|Y). + + Parameters + ---------- + array : array-like + data array with X, Y in rows and observations in columns + + xyz : array of ints + XYZ identifier array of shape (dim,). Here only uses 0 for X and + 1 for Y. + + Returns + ------- + val : float + Entropy estimate. + """ + + + dim, T = array.shape + + if self.knn < 1: + knn_here = max(1, int(self.knn*T)) + else: + knn_here = max(1, int(self.knn)) + + + array = array.astype('float') + + # Add noise to destroy ties... + array += (1E-6 * array.std(axis=1).reshape(dim, 1) + * np.random.rand(array.shape[0], array.shape[1])) + + if self.transform == 'standardize': + # Standardize + array = array.astype('float') + array -= array.mean(axis=1).reshape(dim, 1) + array /= array.std(axis=1).reshape(dim, 1) + # FIXME: If the time series is constant, return nan rather than + # raising Exception + if np.isnan(array).sum() != 0: + raise ValueError("nans after standardizing, " + "possibly constant array!") + elif self.transform == 'uniform': + array = self._trafo2uniform(array) + elif self.transform == 'ranks': + array = array.argsort(axis=1).argsort(axis=1).astype('float') + + # Compute conditional entropy as H(X|Y) = H(X) - I(X;Y) + + # First compute H(X) + # Use cKDTree to get distances eps to the k-th nearest neighbors for + # every sample in joint space X with maximum norm + x_indices = np.where(xyz == 0)[0] + y_indices = np.where(xyz == 1)[0] + + dim_x = int(np.where(xyz == 0)[0][-1] + 1) + if 1 in xyz: + dim_y = int(np.where(xyz == 1)[0][-1] + 1 - dim_x) + else: + dim_y = 0 + + + x_array = np.fastCopyAndTranspose(array[x_indices, :]) + tree_xyz = spatial.cKDTree(x_array) + epsarray = tree_xyz.query(x_array, k=knn_here+1, p=np.inf, + eps=0., n_jobs=self.n_jobs)[0][:, knn_here].astype('float') + + h_x = - special.digamma(knn_here) + special.digamma(T) + dim_x * np.log(2.*epsarray).mean() + + # Then compute MI(X;Y) + if dim_y > 0: + xyz_here = np.array([index for index in xyz if index == 0 or index == 1]) + array_xy = array[list(x_indices) + list(y_indices), :] + i_xy = self.get_dependence_measure(array_xy, xyz_here) + else: + i_xy = 0. + + h_x_y = h_x - i_xy + + return h_x_y diff --git a/tigramite/independence_tests/gpdc.py b/tigramite/independence_tests/gpdc.py index f8b77abf..7fb3d1b0 100644 --- a/tigramite/independence_tests/gpdc.py +++ b/tigramite/independence_tests/gpdc.py @@ -6,6 +6,7 @@ from __future__ import print_function import numpy as np +import dcor from .independence_tests_base import CondIndTest @@ -14,12 +15,6 @@ except: print("Could not import sklearn for Gaussian process tests") -try: - from tigramite import tigramite_cython_code -except: - print("Could not import packages for CMIknn and GPDC estimation") - - class GaussProcReg(): r"""Gaussian processes abstract base class. @@ -46,11 +41,6 @@ class GaussProcReg(): calculate the null distribution for. This is used to grab the get_dependence_measure function. - gp_version : {'new', 'old'}, optional (default: 'new') - The older GP version from scikit-learn 0.17 was used for the numerical - simulations in [1]_. The newer version from scikit-learn 0.19 is faster - and allows more flexibility regarding kernels etc. - gp_params : dictionary, optional (default: None) Dictionary with parameters for ``GaussianProcessRegressor``. @@ -63,14 +53,12 @@ class GaussProcReg(): def __init__(self, null_samples, cond_ind_test, - gp_version='new', gp_params=None, null_dist_filename=None, verbosity=0): # Set the dependence measure function self.cond_ind_test = cond_ind_test # Set member variables - self.gp_version = gp_version self.gp_params = gp_params self.verbosity = verbosity # Set the null distribution defaults @@ -139,7 +127,7 @@ def _generate_nulldist(self, df, null_dist = np.zeros(self.null_samples) for i in range(self.null_samples): - array = np.random.rand(2, df) + array = self.cond_ind_test.random_state.random((2, df)) null_dist[i] = self.cond_ind_test.get_dependence_measure(array, xyz) null_dist.sort() @@ -234,59 +222,31 @@ def _get_single_residuals(self, array, target_var, if np.ndim(z) == 1: z = z.reshape(-1, 1) - if self.gp_version == 'old': - # Old GP failed for ties in the data - def remove_ties(series, verbosity=0): - # Test whether ties exist and add noise to destroy ties... - cnt = 0 - while len(np.unique(series)) < np.size(series): - series += 1E-6 * np.random.rand(*series.shape) - cnt += 1 - if cnt > 100: - break - return series - - z = remove_ties(z) - target_series = remove_ties(target_series) - - gp = gaussian_process.GaussianProcess( - nugget=1E-1, - thetaL=1E-16, - thetaU=np.inf, - corr='squared_exponential', - optimizer='fmin_cobyla', - regr='constant', - normalize=False, - storage_mode='light') - - elif self.gp_version == 'new': - # Overwrite default kernel and alpha values - params = self.gp_params.copy() - if 'kernel' not in list(self.gp_params): - kernel = gaussian_process.kernels.RBF() +\ - gaussian_process.kernels.WhiteKernel() - else: - kernel = self.gp_params['kernel'] - del params['kernel'] - - if 'alpha' not in list(self.gp_params): - alpha = 0. - else: - alpha = self.gp_params['alpha'] - del params['alpha'] - - gp = gaussian_process.GaussianProcessRegressor(kernel=kernel, - alpha=alpha, - **params) + + # Overwrite default kernel and alpha values + params = self.gp_params.copy() + if 'kernel' not in list(self.gp_params): + kernel = gaussian_process.kernels.RBF() +\ + gaussian_process.kernels.WhiteKernel() + else: + kernel = self.gp_params['kernel'] + del params['kernel'] + + if 'alpha' not in list(self.gp_params): + alpha = 0. + else: + alpha = self.gp_params['alpha'] + del params['alpha'] + + gp = gaussian_process.GaussianProcessRegressor(kernel=kernel, + alpha=alpha, + **params) gp.fit(z, target_series.reshape(-1, 1)) - if self.verbosity > 3 and self.gp_version == 'new': + if self.verbosity > 3: print(kernel, alpha, gp.kernel_, gp.alpha) - if self.verbosity > 3 and self.gp_version == 'old': - print(gp.get_params) - if return_likelihood: likelihood = gp.log_marginal_likelihood() @@ -395,11 +355,6 @@ class GPDC(CondIndTest): null_dist_filename : str, otional (default: None) Path to file containing null distribution. - gp_version : {'new', 'old'}, optional (default: 'new') - The older GP version from scikit-learn 0.17 was used for the numerical - simulations in [1]_. The newer version from scikit-learn 0.19 is faster - and allows more flexibility regarding kernels etc. - gp_params : dictionary, optional (default: None) Dictionary with parameters for ``GaussianProcessRegressor``. @@ -416,7 +371,6 @@ def measure(self): def __init__(self, null_dist_filename=None, - gp_version='new', gp_params=None, **kwargs): self._measure = 'gp_dc' @@ -427,14 +381,12 @@ def __init__(self, # Build the regressor self.gauss_pr = GaussProcReg(self.sig_samples, self, - gp_version=gp_version, gp_params=gp_params, null_dist_filename=null_dist_filename, verbosity=self.verbosity) if self.verbosity > 0: print("null_dist_filename = %s" % self.gauss_pr.null_dist_filename) - print("gp_version = %s" % self.gauss_pr.gp_version) if self.gauss_pr.gp_params is not None: for key in list(self.gauss_pr.gp_params): print("%s = %s" % (key, self.gauss_pr.gp_params[key])) @@ -616,8 +568,7 @@ def _get_dcorr(self, array_resid): # Remove ties before applying transformation to uniform marginals # array_resid = self._remove_ties(array_resid, verbosity=4) x_vals, y_vals = self._trafo2uniform(array_resid) - - _, val, _, _ = tigramite_cython_code.dcov_all(x_vals, y_vals) + val = dcor.distance_correlation(x_vals, y_vals, method='AVL') return val def get_shuffle_significance(self, array, xyz, value, diff --git a/tigramite/independence_tests/gpdc_torch.py b/tigramite/independence_tests/gpdc_torch.py index 74199f4b..4e2bc22a 100644 --- a/tigramite/independence_tests/gpdc_torch.py +++ b/tigramite/independence_tests/gpdc_torch.py @@ -9,21 +9,17 @@ from __future__ import print_function import numpy as np import gpytorch -from gpytorch.kernels import RBFKernel import torch +import dcor +import gc from .independence_tests_base import CondIndTest - -try: - from tigramite import tigramite_cython_code -except: - print("Could not import packages for CMIknn and GPDC estimation") - +from .LBFGS import FullBatchLBFGS class GaussProcRegTorch(): r"""Gaussian processes abstract base class. - GP is estimated with gpytorch. Note that the kernel's hyperparameters are + GP is estimated with gpytorch. Note that the kernel's hyperparameters are optimized during fitting. When the null distribution is not analytically available, but can be @@ -65,6 +61,8 @@ def __init__(self, if self.null_dist_filename is not None: self.null_dists, self.null_samples = \ self._load_nulldist(self.null_dist_filename) + # Size for batching + self.checkpoint_size = None def _load_nulldist(self, filename): r""" @@ -123,7 +121,7 @@ def _generate_nulldist(self, df, null_dist = np.zeros(self.null_samples) for i in range(self.null_samples): - array = np.random.rand(2, df) + array = self.cond_ind_test.random_state.random((2, df)) null_dist[i] = self.cond_ind_test.get_dependence_measure( array, xyz) @@ -168,7 +166,7 @@ def _get_single_residuals(self, array, target_var, return_means=False, standardize=True, return_likelihood=False, - training_iter=25, + training_iter=50, lr=0.1): """Returns residuals of Gaussian process regression. @@ -192,7 +190,13 @@ def _get_single_residuals(self, array, target_var, Whether to return the estimated regression line. return_likelihood : bool, optional (default: False) - Whether to return the log_marginal_likelihood of the fitted GP + Whether to return the log_marginal_likelihood of the fitted GP. + + training_iter : int, optional (default: 50) + Number of training iterations. + + lr : float, optional (default: 0.1) + Learning rate (default: 0.1). Returns ------- @@ -201,9 +205,6 @@ def _get_single_residuals(self, array, target_var, and/or the likelihood. """ - device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') - - GPU = torch.cuda.is_available() dim, T = array.shape if dim <= 2: @@ -228,69 +229,185 @@ def _get_single_residuals(self, array, target_var, train_x = torch.tensor(z).float() train_y = torch.tensor(target_series).float() - if GPU: - train_x = train_x.cuda() - train_y = train_y.cuda() - - # We will use the simplest form of GP model, exact inference - class ExactGPModel(gpytorch.models.ExactGP): - def __init__(self, train_x, train_y, likelihood): - super(ExactGPModel, self).__init__( - train_x, train_y, likelihood) - self.mean_module = gpytorch.means.ConstantMean() - - # We only use the RBF kernel here, the WhiteNoiseKernel is deprecated - # and its featured integrated into the Likelihood-Module. - self.covar_module = gpytorch.kernels.ScaleKernel(RBFKernel()) - - def forward(self, x): - mean_x = self.mean_module(x) - covar_x = self.covar_module(x) - return gpytorch.distributions.MultivariateNormal(mean_x, covar_x) - - # initialize likelihood and model - likelihood = gpytorch.likelihoods.GaussianLikelihood() - model = ExactGPModel(train_x, train_y, likelihood) - - if GPU: - likelihood = likelihood.cuda() - model = model.cuda() - - # Find optimal model hyperparameters - model.train() - likelihood.train() - - # Use the adam optimizer - # Includes GaussianLikelihood parameters - optimizer = torch.optim.Adam(model.parameters(), lr=lr) - - # "Loss" for GPs - the marginal log likelihood - mll = gpytorch.mlls.ExactMarginalLogLikelihood(likelihood, model) - - for i in range(training_iter): - # Zero gradients from previous iteration - optimizer.zero_grad() - # Output from model - output = model(train_x) - - # Calc loss and backprop gradients - loss = -mll(output, train_y) - loss.backward() - optimizer.step() - - # Get into evaluation (predictive posterior) mode - model.eval() - likelihood.eval() - - # Make predictions by feeding model through likelihood - with torch.no_grad(), gpytorch.settings.fast_pred_var(): - mean = model(train_x).loc.detach() - loglik = mll(model(train_x), train_y)*T - - if GPU: + device_type = 'cuda' if torch.cuda.is_available() else 'cpu' + output_device = torch.device(device_type) + train_x, train_y = train_x.to(output_device), train_y.to(output_device) + + if device_type == 'cuda': + # If GPU is available, use MultiGPU with Kernel Partitioning + n_devices = torch.cuda.device_count() + class mExactGPModel(gpytorch.models.ExactGP): + def __init__(self, train_x, train_y, likelihood, n_devices): + super(mExactGPModel, self).__init__(train_x, train_y, likelihood) + self.mean_module = gpytorch.means.ConstantMean() + base_covar_module = gpytorch.kernels.ScaleKernel(gpytorch.kernels.RBFKernel()) + + self.covar_module = gpytorch.kernels.MultiDeviceKernel( + base_covar_module, device_ids=range(n_devices), + output_device=output_device + ) + + def forward(self, x): + mean_x = self.mean_module(x) + covar_x = self.covar_module(x) + return gpytorch.distributions.MultivariateNormal(mean_x, covar_x) + + def mtrain(train_x, + train_y, + n_devices, + output_device, + checkpoint_size, + preconditioner_size, + n_training_iter, + ): + likelihood = gpytorch.likelihoods.GaussianLikelihood().to(output_device) + model = mExactGPModel(train_x, train_y, likelihood, n_devices).to(output_device) + model.train() + likelihood.train() + + optimizer = FullBatchLBFGS(model.parameters(), lr=lr) + # "Loss" for GPs - the marginal log likelihood + mll = gpytorch.mlls.ExactMarginalLogLikelihood(likelihood, model) + + with gpytorch.beta_features.checkpoint_kernel(checkpoint_size), \ + gpytorch.settings.max_preconditioner_size(preconditioner_size): + + def closure(): + optimizer.zero_grad() + output = model(train_x) + loss = -mll(output, train_y) + return loss + + loss = closure() + loss.backward() + + for i in range(n_training_iter): + options = {'closure': closure, 'current_loss': loss, 'max_ls': 10} + loss, _, _, _, _, _, _, fail = optimizer.step(options) + + '''print('Iter %d/%d - Loss: %.3f lengthscale: %.3f noise: %.3f' % ( + i + 1, n_training_iter, loss.item(), + model.covar_module.module.base_kernel.lengthscale.item(), + model.likelihood.noise.item() + ))''' + + if fail: + # print('Convergence reached!') + break + + return model, likelihood, mll + + def find_best_gpu_setting(train_x, + train_y, + n_devices, + output_device, + preconditioner_size + ): + N = train_x.size(0) + + # Find the optimum partition/checkpoint size by decreasing in powers of 2 + # Start with no partitioning (size = 0) + settings = [0] + [int(n) for n in np.ceil(N / 2 ** np.arange(1, np.floor(np.log2(N))))] + + for checkpoint_size in settings: + print('Number of devices: {} -- Kernel partition size: {}'.format(n_devices, checkpoint_size)) + try: + # Try a full forward and backward pass with this setting to check memory usage + _, _, _ = mtrain(train_x, train_y, + n_devices=n_devices, output_device=output_device, + checkpoint_size=checkpoint_size, + preconditioner_size=preconditioner_size, n_training_iter=1) + + # when successful, break out of for-loop and jump to finally block + break + except RuntimeError as e: + pass + except AttributeError as e: + pass + finally: + # handle CUDA OOM error + gc.collect() + torch.cuda.empty_cache() + return checkpoint_size + + # Set a large enough preconditioner size to reduce the number of CG iterations run + preconditioner_size = 100 + if self.checkpoint_size is None: + self.checkpoint_size = find_best_gpu_setting(train_x, train_y, + n_devices=n_devices, + output_device=output_device, + preconditioner_size=preconditioner_size) + + model, likelihood, mll = mtrain(train_x, train_y, + n_devices=n_devices, output_device=output_device, + checkpoint_size=self.checkpoint_size, + preconditioner_size=100, + n_training_iter=training_iter) + + # Get into evaluation (predictive posterior) mode + model.eval() + likelihood.eval() + + # Make predictions by feeding model through likelihood + with torch.no_grad(), gpytorch.settings.fast_pred_var(), gpytorch.beta_features.checkpoint_kernel(1000): + mean = model(train_x).loc.detach() + loglik = mll(model(train_x), train_y)*T + resid = (train_y - mean).detach().cpu().numpy() mean = mean.detach().cpu().numpy() + else: + # If only CPU is available, we will use the simplest form of GP model, exact inference + class ExactGPModel(gpytorch.models.ExactGP): + def __init__(self, train_x, train_y, likelihood): + super(ExactGPModel, self).__init__( + train_x, train_y, likelihood) + self.mean_module = gpytorch.means.ConstantMean() + + # We only use the RBF kernel here, the WhiteNoiseKernel is deprecated + # and its featured integrated into the Likelihood-Module. + self.covar_module = gpytorch.kernels.ScaleKernel(gpytorch.kernels.RBFKernel()) + + def forward(self, x): + mean_x = self.mean_module(x) + covar_x = self.covar_module(x) + return gpytorch.distributions.MultivariateNormal(mean_x, covar_x) + + # initialize likelihood and model + likelihood = gpytorch.likelihoods.GaussianLikelihood() + model = ExactGPModel(train_x, train_y, likelihood) + + # Find optimal model hyperparameters + model.train() + likelihood.train() + + # Use the adam optimizer + # Includes GaussianLikelihood parameters + optimizer = torch.optim.Adam(model.parameters(), lr=lr) + + # "Loss" for GPs - the marginal log likelihood + mll = gpytorch.mlls.ExactMarginalLogLikelihood(likelihood, model) + + for i in range(training_iter): + # Zero gradients from previous iteration + optimizer.zero_grad() + # Output from model + output = model(train_x) + + # Calc loss and backprop gradients + loss = -mll(output, train_y) + loss.backward() + optimizer.step() + + # Get into evaluation (predictive posterior) mode + model.eval() + likelihood.eval() + + # Make predictions by feeding model through likelihood + with torch.no_grad(), gpytorch.settings.fast_pred_var(): + mean = model(train_x).loc.detach() + loglik = mll(model(train_x), train_y) * T + resid = (train_y - mean).detach().numpy() mean = mean.detach().numpy() @@ -491,7 +608,7 @@ def _get_single_residuals(self, array, target_var, return_means=False, standardize=True, return_likelihood=False, - training_iter=25, + training_iter=50, lr=0.1): """Returns residuals of Gaussian process regression. @@ -517,6 +634,12 @@ def _get_single_residuals(self, array, target_var, return_likelihood : bool, optional (default: False) Whether to return the log_marginal_likelihood of the fitted GP + training_iter : int, optional (default: 50) + Number of training iterations. + + lr : float, optional (default: 0.1) + Learning rate (default: 0.1). + Returns ------- resid [, mean, likelihood] : array-like @@ -604,8 +727,7 @@ def _get_dcorr(self, array_resid): # Remove ties before applying transformation to uniform marginals # array_resid = self._remove_ties(array_resid, verbosity=4) x_vals, y_vals = self._trafo2uniform(array_resid) - - _, val, _, _ = tigramite_cython_code.dcov_all(x_vals, y_vals) + val = dcor.distance_correlation(x_vals, y_vals, method='AVL') return val def get_shuffle_significance(self, array, xyz, value, @@ -693,172 +815,3 @@ def get_analytic_significance(self, value, T, dim): pval = np.mean(null_dist_here > np.abs(value)) return pval -# def dcov_all(x, y): -# """Calculate distance covariance, distance correlation, -# distance variance of x sample and distance variance of y sample""" - -# GPU_FLAG = torch.cuda.is_available() - - -# x = np.reshape(x, (x.shape[0], 1)) -# y = np.reshape(y, (y.shape[0], 1)) - -# x = torch.tensor(x) -# y = torch.tensor(y) - -# mean_x_0 = torch.zeros(x.shape[0],1) -# mean_x_1 = torch.zeros(x.shape[0],1) -# mean_y_0 = torch.zeros(x.shape[0],1) -# mean_y_1 = torch.zeros(x.shape[0],1) -# x_abs_diff = torch.zeros(x.shape[0],1) -# y_abs_diff = torch.zeros(x.shape[0],1) -# x_all_mean = 0 -# y_all_mean = 0 -# SUM_VAL = 0 - -# if GPU_FLAG: -# x = x.cuda() -# y = y.cuda() -# mean_x_0 = mean_x_0.cuda() -# mean_x_1 = mean_x_1.cuda() -# mean_y_0 = mean_y_0.cuda() -# mean_y_1 = mean_y_1.cuda() -# x_abs_diff = x_abs_diff.cuda() -# y_abs_diff = y_abs_diff.cuda() - - -# # Calculate means -# for i in range(x.shape[0]): -# x_abs_diff = torch.abs(x - x[i,:]) -# y_abs_diff = torch.abs(y - y[i,:]) -# mean_x_0 += x_abs_diff -# mean_y_0 += y_abs_diff - -# x_all_mean += torch.sum(mean_x_0) -# y_all_mean += torch.sum(mean_y_0) - -# mean_x_1[i] = torch.mean(x_abs_diff) -# mean_y_1[i] = torch.mean(y_abs_diff) - -# mean_x_0 = mean_x_0/mean_x_0.shape[0] -# mean_y_0 = mean_y_0/mean_y_0.shape[0] - -# x_all_mean = x_all_mean/mean_x_0.shape[0]**2 -# y_all_mean = y_all_mean/mean_y_0.shape[0]**2 - - -# for i in range(x.shape[0]): -# X_i = torch.abs(x - x[i,:]) - mean_x_0 - mean_x_1[i] + x_all_mean -# Y_i = torch.abs(y - y[i,:]) - mean_y_0 - mean_y_1[i] + y_all_mean -# SUM_VAL += torch.sum(torch.mul(X_i, Y_i)) - -# SUM_VAL = SUM_VAL/X_i.shape[0]**2 - -# # Todo: dCor, dVarX, dVarY -# # Todo: Better batching? - -# if GPU_FLAG: -# dCov = 1 # dCov.cpu() - -# return 1 #dCov.numpy() - - -if __name__ == "__main__": - import tigramite.data_processing as pp - import tigramite.plotting as tp - import matplotlib.pyplot as plt - from time import time - import sys - - - # Example process to play around with - # Each key refers to a variable and the incoming links are supplied - # as a list of format [((var, -lag), coeff, function), ...] - - def lin_f(x): - return x - - def nonlin_f(x): - return x + 5.0 * x ** 2 * np.exp(-(x ** 2) / 20.0) - - print(torch.cuda.is_available()) - - for samples in [10000, 20000, 50000, 100000]: - torch.cuda.empty_cache() - test_a = np.random.normal(0,1, samples) - test_b = np.random.normal(0,1, samples) - - start = time() - distance_corr = dcov_all(test_a, test_b) - end_torch = time() - start - - print("###################", flush=True) - print(f"T={samples}.", flush=True) - print(f"PyTorch (GPU) took {end_torch} seconds.\n", flush=True) - - - start = time() - distance_corr = tigramite_cython_code.dcov_all(test_a, test_b) - end_cython = time() - start - - print(f"Cython took {end_cython} seconds.\n", flush=True) - - sys.exit(0) - - N = 50 - - links = {i: [((i, -1), - np.random.uniform(low=0.4, high=0.9, size=None), - np.random.choice([lin_f, nonlin_f], p=[0.7, 0.3]))] - for i in range(N)} - - for i in range(1,N): - links[i].append(((i-1, -1), - np.random.uniform(low=0.4, high=0.9, size=None), - np.random.choice([lin_f, nonlin_f], p=[0.7, 0.3]))) - - torch_time_lst = [] - sklearn_time_lst = [] - - for T in [25000, 40000, 55000]: - - #torch.cuda.empty_cache() - data, nonstat = pp.structural_causal_process(links, T=T) - data = data.T - gpdc = GPDC() - - - #start_sklearn = time() - #get_resid_sklearn = gpdc._get_single_residuals(data, 0, - # return_means=True, - # standardize=True, - # return_likelihood=True) - #end_sklearn = time() - start_sklearn - #sklearn_time_lst.append(end_sklearn) - - start_torch = time() - get_resid_torch = gpdc._get_single_residuals(data, 0, - return_means=True, - standardize=True, - return_likelihood=True) - - end_torch = time() - start_torch - torch_time_lst.append(end_torch) - - print("###################", flush=True) - print(f"Data shape: {data.shape}", flush=True) - #print(f"Sklearn took {end_sklearn} seconds.", flush=True) - print(f"Torch took {end_torch} seconds.", flush=True) - - print("\n") - - try: - #print(f"Sklearn loglik: {get_resid_sklearn[2]}") - print(f"Torch loglik: {get_resid_torch[2]}") - print(f"\n") - except IndexError: - print("The likelihood was not returned.") - - #print(f"Sklearn times: {sklearn_time_lst}") - print(f"Torch times: {torch_time_lst}") - diff --git a/tigramite/independence_tests/independence_tests_base.py b/tigramite/independence_tests/independence_tests_base.py index 57bfa32b..9a2b2a06 100644 --- a/tigramite/independence_tests/independence_tests_base.py +++ b/tigramite/independence_tests/independence_tests_base.py @@ -23,6 +23,9 @@ class CondIndTest(): Parameters ---------- + seed : int, optional(default = 42) + Seed for RandomState (default_rng) + mask_type : str, optional (default = None) Must be in {'y','x','z','xy','xz','yz','xyz'} Masking mode: Indicators for which variables in the dependence measure @@ -83,6 +86,7 @@ def measure(self): pass def __init__(self, + seed=42, mask_type=None, significance='analytic', fixed_thres=0.1, @@ -97,6 +101,7 @@ def __init__(self, # Set the dataframe to None for now, will be reset during pcmci call self.dataframe = None # Set the options + self.random_state = np.random.default_rng(seed) self.significance = significance self.sig_samples = sig_samples self.sig_blocklength = sig_blocklength @@ -743,7 +748,7 @@ def get_bootstrap_confidence(self, array, xyz, dependence_measure=None, bootdist = np.zeros(conf_samples) for smpl in range(conf_samples): # Get the starting indecies for the blocks - blk_strt = np.random.randint(0, T - conf_blocklength + 1, n_blks) + blk_strt = self.random_state.integers(0, T - conf_blocklength + 1, n_blks) # Get the empty array of block resampled values array_bootstrap = \ np.zeros((dim, n_blks*conf_blocklength), dtype=array.dtype) @@ -927,7 +932,7 @@ def _get_shuffle_dist(self, array, xyz, dependence_measure, null_dist = np.zeros(sig_samples) for sam in range(sig_samples): - blk_starts = np.random.permutation(block_starts)[:n_blks] + blk_starts = self.random_state.permutation(block_starts)[:n_blks] x_shuffled = np.zeros((dim_x, n_blks*sig_blocklength), dtype=array.dtype) @@ -939,7 +944,7 @@ def _get_shuffle_dist(self, array, xyz, dependence_measure, # Insert tail randomly somewhere if tail.shape[1] > 0: - insert_tail_at = np.random.choice(block_starts) + insert_tail_at = self.random_state.choice(block_starts) x_shuffled = np.insert(x_shuffled, insert_tail_at, tail.T, axis=1) @@ -1007,4 +1012,4 @@ def trafo(xi): u = np.empty(x.shape) for i in range(x.shape[0]): u[i] = trafo(x[i]) - return u \ No newline at end of file + return u diff --git a/tigramite/independence_tests/oracle_conditional_independence.py b/tigramite/independence_tests/oracle_conditional_independence.py index 4068fdac..44b64b25 100644 --- a/tigramite/independence_tests/oracle_conditional_independence.py +++ b/tigramite/independence_tests/oracle_conditional_independence.py @@ -51,22 +51,32 @@ def __init__(self, observed_vars=None, selection_vars=None, graph=None, + graph_is_mag=False, + # tau_max=None, verbosity=0): + # self.tau_max = tau_max + self.graph_is_mag = graph_is_mag + if links is None: if graph is None: raise ValueError("Either links or graph must be specified!") else: + # Get canonical DAG from graph, potentially interpreted as MAG + # self.tau_max = graph.shape[2] (links, observed_vars, selection_vars) = self.get_links_from_graph(graph) + # # TODO make checks and tau_max? + # self.graph = graph + - self.graph = graph self.verbosity = verbosity self._measure = 'oracle_ci' self.confidence = None self.links = links self.N = len(links) + # self.tau_max = self._get_minmax_lag(self.links) # Initialize already computed dsepsets of X, Y, Z self.dsepsets = {} @@ -95,6 +105,9 @@ def __init__(self, else: self.selection_vars = [] + # ToDO: maybe allow to use user-tau_max, otherwise deduced from links + self.graph = self.get_graph_from_links(tau_max=None) + def set_dataframe(self, dataframe): """Dummy function.""" pass @@ -146,7 +159,8 @@ def _check_XYZ(self, X, Y, Z): return (X, Y, Z) - def _get_lagged_parents(self, var_lag, exclude_contemp=False): + def _get_lagged_parents(self, var_lag, exclude_contemp=False, + only_non_causal_paths=False, X=None, causal_children=None): """Helper function to yield lagged parents for var_lag from self.links_coeffs. @@ -173,7 +187,11 @@ def _get_lagged_parents(self, var_lag, exclude_contemp=False): coeff = 1. if coeff != 0.: if not (exclude_contemp and lag == 0): - yield (i, lag + tau) + if only_non_causal_paths: + if not ((i, lag + tau) in X and var_lag in causal_children): + yield (i, lag + tau) + else: + yield (i, lag + tau) def _get_children(self): """Helper function to get children from links. @@ -202,7 +220,8 @@ def _get_children(self): return children - def _get_lagged_children(self, var_lag, children, exclude_contemp=False): + def _get_lagged_children(self, var_lag, children, exclude_contemp=False, + only_non_causal_paths=False, X=None, causal_children=None): """Helper function to yield lagged children for var_lag from children. Parameters @@ -226,7 +245,11 @@ def _get_lagged_children(self, var_lag, children, exclude_contemp=False): k, tau = child if not (exclude_contemp and tau == 0): # lagged_parents.append((i, lag + tau)) - yield (k, lag + tau) + if only_non_causal_paths: + if not (var_lag in X and (k, lag + tau) in causal_children): + yield (k, lag + tau) + else: + yield (k, lag + tau) def _get_non_blocked_ancestors(self, Y, conds=None, mode='non_repeating', max_lag=None): @@ -285,6 +308,7 @@ def _repeating(link, seen_links): if conds is None: conds = [] + conds = [z for z in conds if z not in Y] N = len(self.links) @@ -331,7 +355,42 @@ def _repeating(link, seen_links): return ancestors, max_lag - def _has_any_path(self, X, Y, conds, max_lag, backdoor=False): + def _get_descendants(self, W, children, max_lag, ignore_time_bounds=False): + """Get descendants of nodes in W up to time t. + + Includes the nodes themselves. + """ + + descendants = set(W) + + for w in W: + j, tau = w + this_level = [w] + while len(this_level) > 0: + next_level = [] + for varlag in this_level: + for child in self._get_lagged_children(varlag, children): + i, tau = child + if (child not in descendants + and (-max_lag <= tau <= 0 or ignore_time_bounds)): + descendants = descendants.union(set([child])) + next_level.append(child) + + this_level = next_level + + return list(descendants) + + def _has_any_path(self, X, Y, conds, max_lag=None, + starts_with=None, ends_with=None, + directed=False, + forbidden_nodes=None, + only_non_causal_paths=False, + check_optimality_cond=False, + optimality_cond_des_YM=None, + optimality_cond_Y=None, + only_collider_paths_with_vancs=False, + XYS=None, + return_path=False): """Returns True if X and Y are d-connected by any open path. Does breadth-first search from both X and Y and meets in the middle. @@ -351,22 +410,31 @@ def _has_any_path(self, X, Y, conds, max_lag, backdoor=False): index and tau the time lag. max_lag : int Maximum time lag. - backdoor : bool - Whether to only consider paths starting with an arrowhead in X. + starts_with : {None, 'tail', 'arrohead'} + Whether to only consider paths starting with particular mark at X. + ends_with : {None, 'tail', 'arrohead'} + Whether to only consider paths ending with particular mark at Y. """ + if max_lag is None: + max_lag = self._get_max_lag_from_XYZ(X, Y, conds) def _walk_to_parents(v, fringe, this_path, other_path): """Helper function to update paths when walking to parents.""" found_connection = False - for w in self._get_lagged_parents(v): + for w in self._get_lagged_parents(v, + only_non_causal_paths=only_non_causal_paths, X=X, + causal_children=causal_children): # Cannot walk into conditioned parents and # cannot walk beyond t or max_lag i, t = w - if backdoor and w == x: + if w == x and starts_with == 'arrowhead': + continue + + if w == y and ends_with == 'arrowhead': continue - if (w not in conds and + if (w not in conds and w not in forbidden_nodes and # (w, v) not in seen_links and t <= 0 and abs(t) <= max_lag): # if ((w, 'tail') not in this_path and @@ -396,11 +464,20 @@ def _walk_to_parents(v, fringe, this_path, other_path): def _walk_to_children(v, fringe, this_path, other_path): """Helper function to update paths when walking to children.""" found_connection = False - for w in self._get_lagged_children(v, children): + for w in self._get_lagged_children(v, children, + only_non_causal_paths=only_non_causal_paths, X=X, + causal_children=causal_children): # You can also walk into conditioned children, # but cannot walk beyond t or max_lag i, t = w - if ( + + if w == x and starts_with == 'tail': + continue + + if w == y and ends_with == 'tail': + continue + + if (w not in forbidden_nodes and # (w, v) not in seen_links and t <= 0 and abs(t) <= max_lag): # if ((w, 'arrowhead') not in this_path and @@ -439,16 +516,37 @@ def _walk_fringe(this_level, fringe, this_path, other_path): respectively.""" found_connection = False - if backdoor: + if starts_with == 'arrowhead': if len(this_level) == 1 and this_level[0] == (x, None): (found_connection, fringe, this_path) = _walk_to_parents(x, fringe, this_path, other_path) return found_connection, fringe, this_path, other_path - + + elif starts_with == 'tail': + if len(this_level) == 1 and this_level[0] == (x, None): + (found_connection, fringe, + this_path) = _walk_to_children(x, fringe, + this_path, other_path) + return found_connection, fringe, this_path, other_path + + if ends_with == 'arrowhead': + if len(this_level) == 1 and this_level[0] == (y, None): + (found_connection, fringe, + this_path) = _walk_to_parents(y, fringe, + this_path, other_path) + return found_connection, fringe, this_path, other_path + + elif ends_with == 'tail': + if len(this_level) == 1 and this_level[0] == (y, None): + (found_connection, fringe, + this_path) = _walk_to_children(y, fringe, + this_path, other_path) + return found_connection, fringe, this_path, other_path + for v, mark in this_level: if v in conds: - if (mark == 'arrowhead' or mark == None): + if (mark == 'arrowhead' or mark == None) and directed is False: # Motif: --> [v] <-- # If standing on a condition and coming from an # arrowhead, you can only walk into parents @@ -457,6 +555,9 @@ def _walk_fringe(this_level, fringe, this_path, other_path): this_path, other_path) if found_connection: break else: + if only_collider_paths_with_vancs: + continue + if (mark == 'tail' or mark == None): # Motif: <-- v <-- or <-- v --> # If NOT standing on a condition and coming from @@ -467,10 +568,11 @@ def _walk_fringe(this_level, fringe, this_path, other_path): this_path, other_path) if found_connection: break - (found_connection, fringe, - this_path) = _walk_to_children(v, fringe, - this_path, other_path) - if found_connection: break + if not directed: + (found_connection, fringe, + this_path) = _walk_to_children(v, fringe, + this_path, other_path) + if found_connection: break elif mark == 'arrowhead': # Motif: --> v --> @@ -482,6 +584,26 @@ def _walk_fringe(this_level, fringe, this_path, other_path): this_path, other_path) if found_connection: break + if check_optimality_cond and v[0] in self.observed_vars: + # if v is not descendant of YM + # and v is not connected to Y given X OS\Cu + # print("v = ", v) + cond4a = v not in optimality_cond_des_YM + cond4b = not self._has_any_path(X=[v], Y=optimality_cond_Y, + conds=conds + X, + max_lag=None, + starts_with=None, + ends_with=None, + forbidden_nodes=None, #list(prelim_Oset), + return_path=False) + # print(cond4a, cond4b) + if cond4a and cond4b: + (found_connection, fringe, + this_path) = _walk_to_parents(v, fringe, + this_path, other_path) + # print(found_connection) + if found_connection: break + if self.verbosity > 1: print("Updated fringe: ", fringe) return found_connection, fringe, this_path, other_path @@ -497,13 +619,20 @@ def backtrace_path(): mark = 'tail' else: mark = 'arrowhead' - + # print(found_connection) while path[-1] != x: + # print(path, node, mark, pred[node]) prev_node, prev_mark = pred[node][mark] path.append(prev_node) if prev_mark == 'arrowhead': if prev_node not in conds: - mark = 'tail' + # if pass_through_colliders: + # if 'tail' in pred[prev_node] and pred[prev_node]['tail'] != (node, mark): + # mark = 'tail' + # else: + # mark = 'arrowhead' + # else: + mark = 'tail' elif prev_node in conds: mark = 'arrowhead' elif prev_mark == 'tail': @@ -526,7 +655,13 @@ def backtrace_path(): path.append(next_node) if next_mark == 'arrowhead': if next_node not in conds: - mark = 'tail' + # if pass_through_colliders: + # if 'tail' in succ[next_node] and succ[next_node]['tail'] != (node, mark): + # mark = 'tail' + # else: + # mark = 'arrowhead' + # else: + mark = 'tail' elif next_node in conds: mark = 'arrowhead' elif next_mark == 'tail': @@ -541,7 +676,12 @@ def backtrace_path(): if conds is None: conds = [] + + if forbidden_nodes is None: + forbidden_nodes = [] + conds = [z for z in conds if z not in Y and z not in X] + # print(X, Y, conds) if self.selection_vars is not None: for selection_var in self.selection_vars: @@ -551,6 +691,31 @@ def backtrace_path(): N = len(self.links) children = self._get_children() + if only_non_causal_paths: + anc_Y_dict = self._get_non_blocked_ancestors(Y=Y, conds=None, mode='max_lag', + max_lag=max_lag)[0] + # print(anc_Y_dict) + anc_Y = [] + for y in Y: + anc_Y += anc_Y_dict[y] + des_X = self._get_descendants(X, children=children, max_lag=max_lag) + mediators = set(anc_Y).intersection(set(des_X)) - set(Y) - set(X) + + causal_children = list(mediators) + Y + else: + causal_children = None + + if only_collider_paths_with_vancs: + vancs_dict = self._get_non_blocked_ancestors(Y=XYS, conds=None, mode='max_lag', + max_lag=max_lag)[0] + vancs = set() + for xys in XYS: + vancs = vancs.union(set(vancs_dict[xys])) + vancs = list(vancs) + XYS + conds = vancs + # else: + # vancs = None + # Iterate through nodes in X and Y for x in X: for y in Y: @@ -580,8 +745,13 @@ def backtrace_path(): # print(pred) if found_connection: - path = backtrace_path() - return path + if return_path: + backtraced_path = backtrace_path() + return [(self.observed_vars.index(node[0]), node[1]) + for node in backtraced_path + if node[0] in self.observed_vars] + else: + return True else: if self.verbosity > 1: print("Walk from Y since len(X_fringe)=%d " @@ -594,8 +764,13 @@ def backtrace_path(): pred) if found_connection: - path = backtrace_path() - return path + if return_path: + backtraced_path = backtrace_path() + return [(self.observed_vars.index(node[0]), node[1]) + for node in backtraced_path + if node[0] in self.observed_vars] + else: + return True if self.verbosity > 1: print("X_fringe = %s \n" % str(forward_fringe) + @@ -680,9 +855,16 @@ def _is_dsep(self, X, Y, Z, max_lag=None): return dseparated - def get_shortest_path(self, X, Y, Z, - max_lag=None, compute_ancestors=False, - backdoor=False): + def check_shortest_path(self, X, Y, Z, + max_lag=None, # compute_ancestors=False, + starts_with=None, ends_with=None, + forbidden_nodes=None, + directed=False, + only_non_causal_paths=False, + check_optimality_cond=False, + optimality_cond_des_YM=None, + optimality_cond_Y=None, + return_path=False): """Returns path between X and Y given Z in the graph. X, Y, Z are of the form (var, lag) for lag <= 0. D-separation is @@ -700,7 +882,7 @@ def get_shortest_path(self, X, Y, Z, search of non-blocked paths according to d-separation rules including selection variables. - Optionally only considers backdoor paths (starting with an arrowhead in X) + Optionally only considers paths starting/ending with specific marks) and makes available the ancestors up to max_lag of X, Y, Z. This may take a very long time, however. @@ -715,8 +897,10 @@ def get_shortest_path(self, X, Y, Z, compute_ancestors : bool Whether to also make available the ancestors for X, Y, Z as self.anc_all_x, self.anc_all_y, and self.anc_all_z, respectively. - backdoor : bool - Whether to only consider paths starting with an arrowhead in X. + starts_with : {None, 'tail', 'arrohead'} + Whether to only consider paths starting with particular mark at X. + ends_with : {None, 'tail', 'arrohead'} + Whether to only consider paths ending with particular mark at Y. Returns ------- @@ -731,6 +915,16 @@ def get_shortest_path(self, X, Y, Z, Y = [(self.observed_vars[y[0]], y[1]) for y in Y] Z = [(self.observed_vars[z[0]], z[1]) for z in Z] + # print(X) + # print(Y) + # print(Z) + + if check_optimality_cond: + optimality_cond_des_YM = [(self.observed_vars[x[0]], x[1]) + for x in optimality_cond_des_YM] + optimality_cond_Y = [(self.observed_vars[x[0]], x[1]) + for x in optimality_cond_Y] + # Get the array to test on X, Y, Z = self._check_XYZ(X, Y, Z) @@ -749,11 +943,21 @@ def get_shortest_path(self, X, Y, Z, # _has_any_path is the main function that searches open paths any_path = self._has_any_path(X, Y, conds=Z, max_lag=max_lag, - backdoor=backdoor) + starts_with=starts_with, ends_with=ends_with, + return_path=return_path, + directed=directed, + only_non_causal_paths=only_non_causal_paths, + check_optimality_cond=check_optimality_cond, + optimality_cond_des_YM=optimality_cond_des_YM, + optimality_cond_Y=optimality_cond_Y, + forbidden_nodes=forbidden_nodes) if any_path: - any_path_observed = [node for node in any_path + if return_path: + any_path_observed = [(self.observed_vars.index(node[0]), node[1]) for node in any_path if node[0] in self.observed_vars] + else: + any_path_observed = True else: any_path_observed = False @@ -762,18 +966,18 @@ def get_shortest_path(self, X, Y, Z, print("_has_any_path_obs = ", any_path_observed) - if compute_ancestors: - if self.verbosity > 0: - print("Compute ancestors.") + # if compute_ancestors: + # if self.verbosity > 0: + # print("Compute ancestors.") - # Get ancestors up to maximum ancestral time lag incl. repeated - # links - self.anc_all_x, _ = self._get_non_blocked_ancestors(X, conds=Z, - mode='max_lag', max_lag=max_lag) - self.anc_all_y, _ = self._get_non_blocked_ancestors(Y, conds=Z, - mode='max_lag', max_lag=max_lag) - self.anc_all_z, _ = self._get_non_blocked_ancestors(Z, conds=Z, - mode='max_lag', max_lag=max_lag) + # # Get ancestors up to maximum ancestral time lag incl. repeated + # # links + # self.anc_all_x, _ = self._get_non_blocked_ancestors(X, conds=Z, + # mode='max_lag', max_lag=max_lag) + # self.anc_all_y, _ = self._get_non_blocked_ancestors(Y, conds=Z, + # mode='max_lag', max_lag=max_lag) + # self.anc_all_z, _ = self._get_non_blocked_ancestors(Z, conds=Z, + # mode='max_lag', max_lag=max_lag) return any_path_observed @@ -920,6 +1124,9 @@ def get_links_from_graph(self, graph): latent and selection variables, respectively, are added. This corresponds to a canonical DAG (Richardson Spirtes 2002). + For ADMGs "---" are not supported, but also links of type "+->" + exist, which corresponds to having both "-->" and "<->". + Can be used to evaluate d-separation in MAG/DAGs. """ @@ -927,7 +1134,11 @@ def get_links_from_graph(self, graph): if "U3" not in str(graph.dtype): raise ValueError("graph must be of type '", "<--", "<->", "---"] + if self.graph_is_mag: + edge_types = ["-->", "<--", "<->", "---"] + else: + edge_types = ["-->", "<--", "<->", "+->", "<-+"] #, "--+", "+--"] + N, N, tau_maxplusone = graph.shape tau_max = tau_maxplusone - 1 @@ -942,8 +1153,15 @@ def get_links_from_graph(self, graph): latent_index = N for i, j, tau in zip(*np.where(graph)): + edge_type = graph[i, j, tau] + + if edge_type not in edge_types: + raise ValueError( + "Links can only be in %s " %str(edge_types) + ) + if tau == 0: - if graph[i, j, 0] != self._reverse_patt(graph[j, i, 0]): + if edge_type != self._reverse_patt(graph[j, i, 0]): raise ValueError( "graph needs to have consistent lag-zero patterns (eg" " graph[i,j,0]='-->' requires graph[j,i,0]='<--')" @@ -955,13 +1173,11 @@ def get_links_from_graph(self, graph): # Restrict lagged links else: - if graph[i, j, tau] not in ["-->", "<->", "---"]: + if edge_type not in ["-->", "<->", "---", "+->"]: #, "--+"]: raise ValueError( - "Lagged links can only be in ['-->', '<->', '---']" + "Lagged links can only be in ['-->', '<->', '---', '+->']" ) - edge_type = graph[i, j, tau] - if edge_type == "-->": links[j].append((i, -tau)) elif edge_type == "<--": @@ -977,9 +1193,216 @@ def get_links_from_graph(self, graph): links[latent_index].append((i, -tau)) links[latent_index].append((j, 0)) latent_index += 1 + elif edge_type == "+->": + links[j].append((i, -tau)) + links[latent_index] = [] + links[i].append((latent_index, 0)) + links[j].append((latent_index, -tau)) + latent_index += 1 + elif edge_type == "<-+": + links[i].append((j, -tau)) + links[latent_index] = [] + links[i].append((latent_index, 0)) + links[j].append((latent_index, -tau)) + latent_index += 1 + # elif edge_type == "+--": + # links[i].append((j, -tau)) + # links[latent_index] = [] + # selection_vars.append(latent_index) + # links[latent_index].append((i, -tau)) + # links[latent_index].append((j, 0)) + # latent_index += 1 + # elif edge_type == "--+": + # links[j].append((i, -tau)) + # links[latent_index] = [] + # selection_vars.append(latent_index) + # links[latent_index].append((i, -tau)) + # links[latent_index].append((j, 0)) + # latent_index += 1 return links, observed_vars, selection_vars + def _get_minmax_lag(self, links): + """Helper function to retrieve tau_min and tau_max from links + """ + + N = len(links) + + # Get maximum time lag + min_lag = np.inf + max_lag = 0 + for j in range(N): + for link_props in links[j]: + if len(link_props) == 3: + i, lag = link_props[0] + coeff = link_props[1] + else: + i, lag = link_props + coeff = 1. + # func = link_props[2] + if coeff != 0.: + min_lag = min(min_lag, abs(lag)) + max_lag = max(max_lag, abs(lag)) + return min_lag, max_lag + + def get_graph_from_links(self, tau_max=None): + """ + Constructs graph (DAG or MAG or ADMG) from links, observed_vars, + and selection_vars. + + For ADMGs uses the Latent projection operation (Pearl 2009). + + """ + + # TODO: use MAG from DAG construction procedure (lecture notes) + # issues with tau_max? + if self.graph_is_mag is False and len(self.selection_vars) > 0: + raise ValueError("ADMG do not support selection_vars.") + + N_all = len(self.links) + + # If tau_max is None, compute from links_coeffs + _, max_lag_links = self._get_minmax_lag(self.links) + if tau_max is None: + tau_max = max_lag_links + else: + if max_lag_links > tau_max: + raise ValueError("tau_max must be >= maximum lag in links_coeffs; choose tau_max=None") + + N = len(self.observed_vars) + + # Init graph + graph = np.zeros((N, N, tau_max + 1), dtype=' j + if (x, -tau) in dag_anc_y[(y, 0)] + dag_anc_s and (y, 0) not in dag_anc_x[(x, -tau)] + dag_anc_s: + graph[i, j, tau] = "-->" + if tau == 0: + graph[j, i, 0] = "<--" + + elif (x, -tau) not in dag_anc_y[(y, 0)] + dag_anc_s and (y, 0) not in dag_anc_x[(x, -tau)] + dag_anc_s: + graph[i, j, tau] = "<->" + if tau == 0: + graph[j, i, 0] = "<->" + + elif (x, -tau) in dag_anc_y[(y, 0)] + dag_anc_s and (y, 0) in dag_anc_x[(x, -tau)] + dag_anc_s: + graph[i, j, tau] = "---" + if tau == 0: + graph[j, i, 0] = "---" + else: + if tau == 0 and j >= i: + continue + # edge_types = ["-->", "<->", "+->"] + # Latent projection operation: + # (i) ADMG contains i --> j iff there is a directed path x --> ... --> y on which + # every non-endpoint vertex is in hidden variables (= not in observed_vars) + # (ii) ADMG contains i <-> j iff there exists a path of the form x <-- ... --> y on + # which every non-endpoint vertex is non-collider AND in L (=not in observed_vars) + observed_varslags = set([(v, -lag) for v in self.observed_vars + for lag in range(0, tau_max + 1)]) - set([(x, -tau), (y, 0)]) + cond_one_xy = self._has_any_path(X=[(x, -tau)], Y=[(y, 0)], + conds=[], + max_lag=None, + starts_with='tail', + ends_with='arrowhead', + directed=True, + forbidden_nodes=list(observed_varslags), + return_path=False) + if tau == 0: + cond_one_yx = self._has_any_path(X=[(y, 0)], Y=[(x, 0)], + conds=[], + max_lag=None, + starts_with='tail', + ends_with='arrowhead', + directed=True, + forbidden_nodes=list(observed_varslags), + return_path=False) + else: + cond_one_yx = False + cond_two = self._has_any_path(X=[(x, -tau)], Y=[(y, 0)], + conds=[], + max_lag=None, + starts_with='arrowhead', + ends_with='arrowhead', + directed=False, + forbidden_nodes=list(observed_varslags), + return_path=False) + if cond_one_xy and cond_one_yx: + raise ValueError("Cyclic graph!") + # print((x, -tau), y, cond_one_xy, cond_one_yx, cond_two) + + # Only (i) holds: i --> j + if cond_one_xy and not cond_two: + graph[i, j, tau] = "-->" + if tau == 0: + graph[j, i, 0] = "<--" + elif cond_one_yx and not cond_two: + graph[i, j, tau] = "<--" + if tau == 0: + graph[j, i, 0] = "-->" + + # Only (ii) holds: i <-> j + elif not cond_one_xy and not cond_one_yx and cond_two: + graph[i, j, tau] = "<->" + if tau == 0: + graph[j, i, 0] = "<->" + + # Both (i) and (ii) hold: i +-> j + elif cond_one_xy and cond_two: + graph[i, j, tau] = "+->" + if tau == 0: + graph[j, i, 0] = "<-+" + elif cond_one_yx and cond_two: + graph[i, j, tau] = "<-+" + if tau == 0: + graph[j, i, 0] = "+->" + + return graph if __name__ == '__main__': @@ -1043,62 +1466,143 @@ def lin_f(x): return x # links[2].append(((1, 0), coeff, lin_f)) # links[2].append(((0, 0), coeff, lin_f)) - # coeff = 0.5 - # links ={ - # 0: [((0, -1), coeff, lin_f)], - # 1: [((0, 0), coeff, lin_f), ((2, 0), coeff, lin_f)], - # 2: [], - # 3: [((1, 0), coeff, lin_f)], - # } - # observed_vars = [0, 1, 2, 3] - - graph = np.zeros((8, 8, 4), dtype=' 0: - # Copy and fit the model - a_model = deepcopy(self.model) - a_model.fit(X=array[2:].T, y=array[1]) - # Cache the results - fit_results[y] = {} - fit_results[y]['model'] = a_model - # Cache the data transform - fit_results[y]['data_transform'] = deepcopy(self.data_transform) - # Cache the data if needed - if return_data: - fit_results[y]['data'] = array - # If there are no parents, skip this variable - else: - fit_results[y] = None + # Fit the model + # Copy and fit the model + a_model = deepcopy(self.model) + + predictor_indices = list(np.where(xyz==0)[0]) \ + + list(np.where(xyz==1)[0][1:]) \ + + list(np.where(xyz==2)[0]) + predictor_array = array[predictor_indices, :].T + target_array = array[np.where(xyz==1)[0][0], :] + + a_model.fit(X=predictor_array, y=target_array) + # Cache the results + fit_results[y] = {} + fit_results[y]['model'] = a_model + # Cache the data transform + fit_results[y]['data_transform'] = deepcopy(self.data_transform) + # Cache the data if needed + if return_data: + fit_results[y]['data'] = array # Cache and return the fit results self.fit_results = fit_results @@ -164,6 +168,8 @@ def get_general_fitted_model(self, def get_general_prediction(self, Y, X, Z=None, intervention_data=None, + conditions=None, + conditions_data=None, pred_params=None, cut_off='max_lag_or_tau_max'): r"""Predict effect of intervention with fitted model. @@ -191,7 +197,10 @@ def get_general_prediction(self, Results from prediction. """ - XZ = X + Z + if conditions is None: + conditions = [] + + # XZS = X + Z + conditions return_type = 'list' @@ -211,16 +220,17 @@ def get_general_prediction(self, raise ValueError("y = %s not yet fitted" % str(y)) # Construct the array form of the data # Check if we've passed a new dataframe object - observation_array, _ = \ - self.dataframe.construct_array(X=[y], Y=[y], Z=XZ, + observation_array, xyz = \ + self.dataframe.construct_array(X=X, Y=[y] + Z, Z=conditions, tau_max=self.tau_max, # mask=self.test_mask, mask_type=self.mask_type, cut_off=cut_off, verbosity=self.verbosity) - intervention_array = observation_array + + intervention_array = np.copy(observation_array) if intervention_data is not None: - tmp_array, _ = intervention_data.construct_array(X, Y, Z, + tmp_array, _ = intervention_data.construct_array(X=X, Y=[y] + Z, Z=conditions, tau_max=self.tau_max, mask_type=self.mask_type, cut_off=cut_off, @@ -228,8 +238,19 @@ def get_general_prediction(self, # Only replace X-variables in intervention_array (necessary if lags of # X are in Z...) - for ix in enumerate(X): - index = ix + 2 + for index in np.where(xyz==0)[0]: + intervention_array[index] = tmp_array[index] + + if conditions is not None and conditions_data is not None: + tmp_array, _ = conditions_data.construct_array(X=X, Y=[y] + Z, Z=conditions, + tau_max=self.tau_max, + mask_type=self.mask_type, + cut_off=cut_off, + verbosity=self.verbosity) + + # Only replace condition-variables in intervention_array + # (necessary if lags of X are in Z...) + for index in np.where(xyz==2)[0]: intervention_array[index] = tmp_array[index] # Transform the data if needed @@ -238,9 +259,13 @@ def get_general_prediction(self, intervention_array = a_transform.transform(X=intervention_array.T).T # Cache the test array self.intervention_array = intervention_array - # Run the predictor + # Run the predictor, for Y only the Z-part is used, the first index is y + predictor_indices = list(np.where(xyz==0)[0]) \ + + list(np.where(xyz==1)[0][1:]) \ + + list(np.where(xyz==2)[0]) + predictor_array = intervention_array[predictor_indices, :].T pred_dict[y] = self.fit_results[y]['model'].predict( - X=intervention_array[2:].T, **pred_params) + X=predictor_array, **pred_params) return pred_dict diff --git a/tigramite/pcmci.py b/tigramite/pcmci.py index 8f55e5fb..f1ac8e61 100644 --- a/tigramite/pcmci.py +++ b/tigramite/pcmci.py @@ -189,7 +189,8 @@ def _set_sel_links(self, selected_links, tau_min, tau_max, # Set the default as all combinations of the selected variables for j in _vars: _int_sel_links[j] = [(var, -lag) for var in _vars - for lag in range(tau_min, tau_max + 1)] + for lag in range(tau_min, tau_max + 1) + if not (var == j and lag == 0)] else: if remove_contemp: for j in _int_sel_links.keys(): @@ -801,7 +802,7 @@ def _print_parents_single(self, j, parents, val_min, pval_max): p-value of a link across different conditions. """ if len(parents) < 20 or hasattr(self, 'iterations'): - print("\n Variable %s has %d parent(s):" % ( + print("\n Variable %s has %d link(s):" % ( self.var_names[j], len(parents))) if (hasattr(self, 'iterations') and 'optimal_pc_alpha' in list(self.iterations[j])): @@ -817,7 +818,7 @@ def _print_parents_single(self, j, parents, val_min, pval_max): self.var_names[p[0]], p[1], pval_max[p], val_min[p])) else: - print("\n Variable %s has %d parent(s):" % ( + print("\n Variable %s has %d link(s):" % ( self.var_names[j], len(parents))) def _print_parents(self, all_parents, val_min, pval_max): @@ -1343,7 +1344,11 @@ def run_bivci(self, def get_corrected_pvalues(self, p_matrix, fdr_method='fdr_bh', - exclude_contemporaneous=True): + exclude_contemporaneous=True, + tau_min=0, + tau_max=1, + selected_links=None, + ): """Returns p-values corrected for multiple testing. Currently implemented is Benjamini-Hochberg False Discovery Rate @@ -1354,6 +1359,14 @@ def get_corrected_pvalues(self, p_matrix, ---------- p_matrix : array-like Matrix of p-values. Must be of shape (N, N, tau_max + 1). + tau_min : int, default: 0 + Minimum time lag to test. Note that zero-lags are undirected. + tau_max : int, default: 1 + Maximum time lag. Must be larger or equal to tau_min. + selected_links : dict or None + Dictionary of form {0: [(3, -2), ...], 1:[], ...} + specifying whether only selected links should be tested. If None is + passed, all links are tested. fdr_method : str, optional (default: 'fdr_bh') Correction method, currently implemented is Benjamini-Hochberg False Discovery Rate method. @@ -1374,8 +1387,19 @@ def _ecdf(x): # Get the shape paramters from the p_matrix _, N, tau_max_plusone = p_matrix.shape - # Create a mask for these values - mask = np.ones((N, N, tau_max_plusone), dtype='bool') + # Check the limits on tau + self._check_tau_limits(tau_min, tau_max) + # Include only selected_links if given + if selected_links != None: + # Create a mask for these values + mask = np.zeros((N, N, tau_max_plusone), dtype='bool') + _int_sel_links = self._set_sel_links(selected_links, tau_min, tau_max) + for node1, links_ in _int_sel_links.items(): + for node2, lag in links_: + mask[node2, node1, abs(lag)] = True + else: + # Create a mask for these values + mask = np.ones((N, N, tau_max_plusone), dtype='bool') # Ignore values from autocorrelation indices mask[range(N), range(N), 0] = False # Exclude all contemporaneous values if requested @@ -1795,7 +1819,7 @@ def run_pcmci(self, # Initialize and fill the q_matrix if there is a fdr_method q_matrix = None if fdr_method != 'none': - q_matrix = self.get_corrected_pvalues(p_matrix, + q_matrix = self.get_corrected_pvalues(p_matrix, tau_min, tau_max, fdr_method=fdr_method) # Store the parents in the pcmci member self.all_parents = all_parents @@ -2138,6 +2162,10 @@ def run_pcmciplus(self, val_matrix[i, j, abs(tau)] = results['val_matrix'][i, j, abs(tau)] + # Update p_matrix and val_matrix for indices of symmetrical links + p_matrix[:, :, 0] = results['p_matrix'][:, :, 0] + val_matrix[:, :, 0] = results['val_matrix'][:, :, 0] + ambiguous = results['ambiguous_triples'] conf_matrix = None @@ -2148,7 +2176,7 @@ def run_pcmciplus(self, # Initialize and fill the q_matrix if there is a fdr_method q_matrix = None if fdr_method != 'none': - q_matrix = self.get_corrected_pvalues(p_matrix, + q_matrix = self.get_corrected_pvalues(p_matrix, tau_min, tau_max, fdr_method=fdr_method, exclude_contemporaneous=False) # Store the parents in the pcmci member @@ -2313,17 +2341,22 @@ def run_pcalg(self, selected_links=None, pc_alpha=0.01, tau_min=0, conflict_resolution=conflict_resolution, ) - # Symmetrize p_matrix using maximum p-value - # and also symmetrize val_matrix based on same order + # Symmetrize p_matrix and val_matrix for i in range(self.N): for j in range(self.N): - if (skeleton_results['p_matrix'][i, j, 0] - >= skeleton_results['p_matrix'][j, i, 0] - and (i, 0) in _int_sel_links[j]): - skeleton_results['p_matrix'][j, i, 0] = skeleton_results[ - 'p_matrix'][i, j, 0] - skeleton_results['val_matrix'][j, i, 0] = \ - skeleton_results['val_matrix'][i, j, 0] + # If both the links are present in selected_links, symmetrize using maximum p-value + if ((i, 0) in _int_sel_links[j] and (j, 0) in _int_sel_links[i]): + if (skeleton_results['p_matrix'][i, j, 0] + >= skeleton_results['p_matrix'][j, i, 0]): + skeleton_results['p_matrix'][j, i, 0] = skeleton_results['p_matrix'][i, j, 0] + skeleton_results['val_matrix'][j, i, 0] = skeleton_results['val_matrix'][i, j, 0] + # If only one of the links is present in selected_links, symmetrize using the p-value of the link present + elif ((i, 0) in _int_sel_links[j] and (j, 0) not in _int_sel_links[i]): + skeleton_results['p_matrix'][j, i, 0] = skeleton_results['p_matrix'][i, j, 0] + skeleton_results['val_matrix'][j, i, 0] = skeleton_results['val_matrix'][i, j, 0] + else: + # Links not present in selected_links + pass # Convert numerical graph matrix to string graph_str = self.convert_to_string_graph(final_graph) diff --git a/tigramite/plotting.py b/tigramite/plotting.py index b2219377..9342c48c 100644 --- a/tigramite/plotting.py +++ b/tigramite/plotting.py @@ -902,13 +902,15 @@ def draw_edge( "--x", "o-x", "x-o", + # "+->", + # "<-+", ]: arrowstyle = "-" # linewidth = width*factor elif d.get("outer_edge_type") == "<->": arrowstyle = "<->, head_width=0.4, head_length=1" # linewidth = width*factor - elif d.get("outer_edge_type") in ["o->", "-->", "<-o", "<--", "<-x", "x->"]: + elif d.get("outer_edge_type") in ["o->", "-->", "<-o", "<--", "<-x", "x->", "+->", "<-+"]: arrowstyle = "->, head_width=0.4, head_length=1" else: @@ -926,7 +928,7 @@ def draw_edge( if d.get("inner_edge_attribute", None) == "spurious": facecolor = "grey" - if d.get("inner_edge_type") in ["<-o", "<--", "<-x"]: + if d.get("inner_edge_type") in ["<-o", "<--", "<-x", "<-+"]: n1, n2 = n2, n1 if d.get("inner_edge_type") in [ @@ -943,7 +945,7 @@ def draw_edge( arrowstyle = "-" elif d.get("inner_edge_type") == "<->": arrowstyle = "<->, head_width=0.4, head_length=1" - elif d.get("inner_edge_type") in ["o->", "-->", "<-o", "<--", "<-x", "x->"]: + elif d.get("inner_edge_type") in ["o->", "-->", "<-o", "<--", "<-x", "x->", "+->"]: arrowstyle = "->, head_width=0.4, head_length=1" linestyle = d.get("inner_edge_style") @@ -1025,6 +1027,16 @@ def draw_edge( zorder=1, ) ax.add_collection(circle_marker_start) + elif d.get("outer_edge_type") in ["+--", "+->"]: + circle_marker_start = ax.scatter( + *start, + marker="P", + s=marker_size, + facecolor="w", + edgecolor=facecolor, + zorder=1, + ) + ax.add_collection(circle_marker_start) elif d.get("outer_edge_type") == "<-x": circle_marker_end = ax.scatter( *start, @@ -1035,6 +1047,16 @@ def draw_edge( zorder=1, ) ax.add_collection(circle_marker_end) + elif d.get("outer_edge_type") == "<-+": + circle_marker_end = ax.scatter( + *start, + marker="P", + s=marker_size, + facecolor="w", + edgecolor=facecolor, + zorder=1, + ) + ax.add_collection(circle_marker_end) elif d.get("outer_edge_type") == "--x": circle_marker_end = ax.scatter( *end, @@ -1163,6 +1185,16 @@ def draw_edge( zorder=1, ) ax.add_collection(circle_marker_start) + elif d.get("inner_edge_type") in ["+--", "+->"]: + circle_marker_start = ax.scatter( + *start, + marker="P", + s=marker_size, + facecolor="w", + edgecolor=facecolor, + zorder=1, + ) + ax.add_collection(circle_marker_start) elif d.get("outer_edge_type") == "<-x": circle_marker_end = ax.scatter( *start, @@ -1173,6 +1205,16 @@ def draw_edge( zorder=1, ) ax.add_collection(circle_marker_end) + elif d.get("outer_edge_type") == "<-+": + circle_marker_end = ax.scatter( + *start, + marker="P", + s=marker_size, + facecolor="w", + edgecolor=facecolor, + zorder=1, + ) + ax.add_collection(circle_marker_end) elif d.get("outer_edge_type") == "--x": circle_marker_end = ax.scatter( *end, @@ -1945,6 +1987,8 @@ def _check_matrices(link_matrix, val_matrix, link_width, link_attribute, sig_thr "x->", "<-x", "x-x", + "<-+", + "+->", ]: raise ValueError("Invalid link_matrix entry.") @@ -3166,16 +3210,22 @@ def _links_to_tsg(link_coeffs, max_lag=None): val_matrix = np.zeros((4, 4, 3)) # Complete test case - link_matrix = np.zeros(val_matrix.shape) + link_matrix = np.zeros((3,3,2), dtype='" ] @@ -345,7 +345,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^0$ has 3 parent(s):\n", + " Variable $X^0$ has 3 link(s):\n", " ($X^1$ -1): max_pval = 0.00000, min_val = 1.000\n", " ($X^0$ -1): max_pval = 0.14650, min_val = 0.065\n", " ($X^1$ -2): max_pval = 0.14650, min_val = 0.065\n", @@ -369,7 +369,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^0$ has 1 parent(s):\n", + " Variable $X^0$ has 1 link(s):\n", " ($X^1$ -1): max_pval = 0.00000, min_val = 1.000\n", "\n", "Algorithm converged for variable $X^0$\n", @@ -411,7 +411,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^1$ has 2 parent(s):\n", + " Variable $X^1$ has 2 link(s):\n", " ($X^2$ -2): max_pval = 0.13766, min_val = 0.067\n", " ($X^1$ -1): max_pval = 0.16411, min_val = 0.063\n", "\n", @@ -430,7 +430,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^1$ has 2 parent(s):\n", + " Variable $X^1$ has 2 link(s):\n", " ($X^2$ -2): max_pval = 0.13879, min_val = 0.067\n", " ($X^1$ -1): max_pval = 0.16543, min_val = 0.062\n", "\n", @@ -473,7 +473,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^2$ has 2 parent(s):\n", + " Variable $X^2$ has 2 link(s):\n", " ($X^0$ -1): max_pval = 0.00000, min_val = 0.504\n", " ($X^1$ -2): max_pval = 0.00000, min_val = 0.504\n", "\n", @@ -492,20 +492,20 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^2$ has 0 parent(s):\n", + " Variable $X^2$ has 0 link(s):\n", "\n", "Algorithm converged for variable $X^2$\n", "\n", "## Resulting lagged parent (super)sets:\n", "\n", - " Variable $X^0$ has 1 parent(s):\n", + " Variable $X^0$ has 1 link(s):\n", " ($X^1$ -1): max_pval = 0.00000, min_val = 1.000\n", "\n", - " Variable $X^1$ has 2 parent(s):\n", + " Variable $X^1$ has 2 link(s):\n", " ($X^2$ -2): max_pval = 0.13879, min_val = -0.067\n", " ($X^1$ -1): max_pval = 0.16543, min_val = -0.062\n", "\n", - " Variable $X^2$ has 0 parent(s):\n", + " Variable $X^2$ has 0 link(s):\n", "\n", "##\n", "## Step 2: MCI algorithm\n", @@ -642,7 +642,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAEoCAYAAAC0OiEVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3deXxcZbnA8d8zSZq2dKG0pZSgDFKWwmETWUIpoIAgiIAgoGyC15vBihsXoYiGiNhbFUGkmiDK6qUgICCyyKJQahFk7YGyVQJ0mpbSplvSrPPeP96TZjKdmZyZzHYyz/fzOZ/pzDkz87R95znvebcjxhiUUkqVh1CxA1BKKVU4mvSVUqqMaNJXSqkyoklfKaXKiCZ9pZQqI5r0lVKqjGjSV0qpMqJJXymlyogmfaWUKiOa9JVSqoxo0ldKqTKiSV8ppcqIJn2llCojRU36IvJJEflUhu/ZT0QWisjTIvKkiHwiX/GpYMimHHnve1REVonI5fmISw0v2ZazUlPsmv5pwDYZvqcFONYYcxjwC6Ah51GpoMmmHAF8Dbg4x7Go4SvbclZSipb0ReRoIAL8UESu8fs+Y8wKY8wG72kX0JOP+FQwZFuOAIwxy/ITlRpuhlLOSk1lsb7YGPOYiLxrjJmZzftFZCvgKuC83EamgmSo5UgpP4ZTOSta0heRbYEVCa9VAAuTHP5XY8yVccdVAXcCc4wxr+c1UFXShlKOlPIrWTkLqqIlfWBvwI1/wRjTCxyc7k0iEgJuB+4zxtyXv/BUQGRVjpTK0BblLKikWPfIFZGdgL8Ay4wxx2bwvlOBm4F/ey8tNsZcmPsIVRBkW4689/4OOASoBlxjzEl5CFENA0MpZ6WmaElfKaVU4RV7yKZSSqkC0qSvlFJlRJO+UkqVEU36SilVRjTpK6VUGdGkr5RSZUSTvlJKlRFN+kopVUY06SulVBkp5to7Sg2qZc6samBcim0MUIGtvMRvkuFrnUAb0B732J7ktc37ps6e15vXv7hSeaLLMKi8a5kzKwRMBLYHarzHbUmdzMcB473HEUUI2Y/EE0Ur8CGwMmGLf23t1Nnz9AenikqTvspay5xZgk3O2ydsNQnPpwJVRQqzlHST/sSwDFgKLJ86e16sWEGq4U2TvkqrZc6srYBdgF3jth3pT+ijixfdsNUBvIs9AbzjPfZtzVNnz+sqYmwq4DTpK1rmzKoEwvQn9d3i/rxD8SID7O0w1wHrk2wbsbXnGGC8x1iK56mOMdillbfCnsAGe+zbJJ9/6TRiwAckPyEsnTp73oY071VKk345aZkza1tgdwYm9V2Bncl/88s6YHnc1gKsJXkyj986Sq0d3GvWGkn/iWAMts9iSsK2bcLzrQoRHvAK8LK3vQK8rR3Pqo8m/WHIS0o1wCeB/b3HT2KbY3JtExBlYELv2/peb5k6e15bHr47ULymssQTQd/JYTvs1dY0YOscf/Um4FUGngwWT509b2OOv0cFgCb9gPMSfJj+xN6X5Cfn6Cti2PblN4G3vG0pttNxObCu1GriQdcyZ9Y22Kuvvm1a3J9zdeI22OahvquBvpPBcv3/HN406QeIN/RxZ7aswU/IwcevoD+pv0V/kv+PdhyWjpY5s0YDOzHwRNC3hRn63JvVwAvYG8svAJ7Tq7ThRZN+CWuZM2sc9h6uh3mP+2HHrmerE3gdm9Dja+5vT509b93QolXF1jJnVhW2z2YfYN+4x0lD+Nge4EXgGW9bOHX2vA+HGKoqIk36JcS7rJ+JTfKHYWvx2S6V0Y69XH/R214AlkydPa87B6GqgPCa/7ZnyxPBLmQ/AulN+k8Cz2BHDWkiCQhN+kXUMmfWdvQn+MOAvbL8qA3ASwxM8G/qiA2VitepvBcDTwR7k928i5UMPAm8PHX2vJ4chapyTJN+AbXMmfVxbHI/3HvcNYuPWcvA5P4i8I7O4FRD1TJnVgX2CuAQ4FBv2yWLj2rD9gk84m1v6JVA6dCkn0deTf5Y4NPYRL9jFh/zBvA08BTwLPCu/oBUobTMmTUFmIFtdjwU269UkeHHvAc8jD0BPKFDRYtLk34OeTWlA4DjvG3/DD/CYMdT9yX5BdpppkpJy5xZY4CD6L8SqCWzSWfd2FFBj2BPBK9pJaawNOkPkdf5egw2yR9LZiMleo0xL8S6e5/vWNP21po3V6zoXLdpPHZiVQ12pE6lt1Vk8ece4CNvWx3354+SvL5m5qKF2g4bUAtqZwh2VnBN3Na3+N14hl6OkpWf1VIhrWNqJmy91ZTxn6geP8qpHFl1gIRkSgahL6P/BPD41Nnz1mf9j6B80aSfIW80xD701+Zr8TnCxhjT293WuaJjTdv6tpXrTfuqDVuZnthUSmf54FYGngyigOttr81ctHBVEWMrWwtqZ4yiP4EnJvT456VSjtaHqiq6KkdWVVaOGjGuclRVaMTYkYwYN5LqsaOoqE45laAH+Cf2BPAw8KpeBeSeJn0fWubMGgscRX+i9z0rsqO1jfYPN9D+0QY6W9sxsUD/e68EXqP/RNB3MtDaWQ4sqJ0RP/luP2/bF7tMw7BRMaKSEeNGMmKst40bxYixI6mo2qKrYBlwD3AX8KwOVsgNTfoptMyZFQa+iE3yh+FzQbLe7l7aP1zvbRvo7SyLFpP3GXgicIE3Zi5auKmoUZWwBbUzqoDp2MTel+T3BcYWM65iqhxV5Z0IRg04KYQqQmCvOu8G/gQs0hNA9jTpx/GGVJ4KnA4c6Pd9nes30b5yPW0r19PR2ma7YzOzAVuo+7a+xcpWYzu+erytN+7Pic+T7avGtvNO8rHlYimHeDFgMfC4tz09c9HC9hx/RyB4zTN70Z/cP+k9r87xV22gv+zEb+nKkZ8yla4cJb6+TY7/TowYO5JRk8cyevJYRk3cilBlRUYnAG9OQqfOHbDKPum3zJm1AzbRn4Ztnx9UrKeX9lUbN9foezalnOTai13qNllC3/x85qKFRV8DfUHtjErsD7bvxzsZu76L423TGVqS6sK21z6GPQm8MHPRwpSTxxbUzpgNfAU70uOymYsWrh3CdxfUgtoZY7DDdI/BDtWdTubDHOP1laNkCX3zayVUjiaQuhztwVDKkQgjtxnNaO8kUD1+dFRCkvQE0DJnlnz4ygcLOta0zageP2rDuPCksz/x85vvz/5vNzyUZdJvmTNre+BUY8xpIjLDz3u6NnbQvnIDbR+up2P1xmRt863YiVIvxT2+nS6xBYn3Y96Z/h9v37YL2SW0tcCT9J8Els5ctNB433UoNtn3WQx8buaihdGs/wJ55I2c2Qub5I/FjmnP9v4EfZPv4svRW8OoHFWQvBztShblKFQZYtQk7ypg0piVVWOq54vIn4BFLc+/e1Jby7p7+o6tGlNtJu25fWTatbffkJu/TTCVTdL3JkqdYmKxryBSKyKDrjuyafVGNraso33lOrrbBiw0uZyBP8oXgff7klY5WVA7oxp7U5bEH/FOGX5UMzb5P4YdDXVHwv4PgGNmLlq4ZCjx5sqC2hnbYDv3j8Um+2yWPG5hy3L0XhmXo13Zshx9IpPPqRxVxejJYxk5ccya3q6el1a/tvzI+P0VI6uYtMf2P9p13v9dmavYg6Ykk77ruh/HdqCOwy75e6/jOBnP4muZM2tbE4t9KdYTOz9UVfFJH3meTWva2Lh8LRuXr6W3oxvgPyTUvGYuWrgy01jKjZcUPw0cjU2OO2fwdoOdyj8m4fVW4PMzFy38p58PcV13B+B47Dj1ldhylFUTiFdDPYD+2vyBZLYY3rtsWY5WZBNLOVlQO2MCthwdhS1L0zJ5v1SEML0Dm/xDlSEmTt++cfcb7rzAz2e4rrs98HnszW1WYctRYFelzVnSF5GrsKNcVgLnGGMy7rRzXXdroB6ow/7wq7DLAfcAlwG/cxwnbWdMy5xZ47vbOv8Lka9Vjqra3U+NvqO1P9H3bOp+GztZ5FFgYZDakkvZgtoZO9H/wz2S7Dv8OoAzZi5amLJt1nXd8cAPgW8wsBzFgB8ATY7jDLra6ILaGVPpT/JHZxjzUvrXnlk4c9HC1gzeq1JYUDsjjC1HfdvErD4oJGyz63b3b7PrlJNTzQVwXXcscDlwIQPLkQF+BMzzU45KTU6Svog4wOXGmDNEJAJUGmOuz+QzXNcdh11AbAfs/UcTtQMPAF9xHGdA0C1zZlV0rms/FeR/Royp/qRUhAatgXW0trNxeSsbW9a197R3PY5N8o/OXLRwaSZxq8x549H3o/8kcCiZde4ZYPbMRQvnJu5wXXcM8Dz2hiKpytHDwJcSy5EX22Rsx/4Z2LZ5v8sPtwF/x6swzFy08B2f71NZ8srRPsDRCJ/FMJMMJ6iN32nSm5P32mHPxBVpXdcdDfwLe2WRqhw9CZzoOE6gho/mKulfALQbY24RkR2BucaYMzL5DNd178PWqNL9+NuAix3H+S3A0ovOORiorx476tMV1ZWDJo2Ote1sXL6WthXrlnRv7HyA/tq83hmqiLwhjYcCnwW+iv+lLG6auWjh+fEvuK77J+yleLIfap824HLHca71vn9r4GRsoj8S/x2Kr2LLUF9tvtPn+1QeLKidMRKYIZWhk0Xkglh3r6/mt9FTxq3e/76HB5Q513VvB05h8HJ0peM4W1Q+SpmvpC8iO2ML+DRjTIv32pnAz7GLL50NvG6MuU9EtgbuMsZ81m8QruseATyIj4WbTGdHe/Vt191XPbrq+BFjR44f7PjOde1sbFnX3r5y/ZOd6zbdDfxt5qKFLX5jU4WzoHbGhcB1GbylF6jq6/h0XXcGNgkPXo56e9vXXfaDb5s1rSdgKxt+aoit2I7mR7DlqCRHE5W7V04/4a7176/5Uibv2eGwXat2mntTD4DrugcA/8DfvQU2AWHHcQKzMKKv+2kaY5aKyIPAd4BLRKQWuB44xhjzgYi0YjvL8B7XZBjHucCoQePo6Wbs/TeOrp4y9ivpjutu66RtxfrlbSvX3b3po41/ZJAx4apkDHoST9CZMNLlbNLXzAAwxrDxmmurzZrW3/n4jhewFZJHgOe1HJW+no7ujNrZJST0JXzPWfhvbuwFTgB+n8l3FlMmN1GeCzwpIrcB9wIRY8xz3r5ngNnALdiOr4V+P9R13RBwEj5GQsg7S6gelfzKO9bTS/uHG9a0f7Th7o3LWufOWLDgP35jUCVjnjHmCzHDARWhAU3p3dgO3G5sORkBrAe+3neA67qCbYsftGkmtryFnjffSnfcYmA+cKf28QRPx5q2b1SMrJrZ1d71sQHlSDASCsVEMMYgGBOSilDvqEljLu87xCtHp+O/iW8McA7DMekbY14UkeewnRtzjTF3xu1bLCLvicgC4EPsP4Jfe/qOY4cwsSVPE6qs6PteOta0tXesaXt044p1PznwocdezOB7VYn547PRA/Du1CSwRIRFBp4yhgVAc6NpTtcWuRs+avkAoUmToLoaOgc0wb9Nf6J/Lbu/gSoFtz3zwf54TXwCb4qw0MDTXjl6d5BytBOZr390iOu6oaB06PpO+iISwl7KxLC1/gGMMbOzjGGS97mDGzOONXt+hhGvLoKVKx7vWNt29frm1Y+W42SWYeoq7FhoDEw3hulAX0dtS0TCz2DvHvYC8HTCj3cidmjvoKR6BOMuvYSOf/zDdD2zcC69vX/CjpvXcjQ8XIk3vNbAbsawG/3laIVXjhZh50s8laQcZToM02BPMkVfBsOPTJp3rsb+IN8GzgT+kKMYMpp6LbvuQfeuexjguH0COEZWpZVuieapwJe8DWBdRMLTGk3zR97zjMpRxQ41bHXWmb1bnXXmlY7jlOVCcMNYunK0HbYZ8NS+YyMS3q3RNPdNlMtmSRGT5fuKwteQJhGpww5pOwlby7/Yz6Qnn9bhfyx0n54gTopQyUUkHIpIeB/sgmx+R1b1TcDqs47MZsjiHa/LPw8TXjnaC3gOu1SKH+OAK+KeryfzBF4JBOa+v4PW9EXkKOCnwBHGmJUicrf3/ETgvhzEsJjM7/jzUg6+VxVJRMKV2LXjD8fO4p5Jdks7L4v78xIy/7G+kmyClgqGiIQrsOXoMGxZmkl2M73jh96+lcX7lwy2UkApSZv0RWR3bOfW2caYxWBv+ScivwQuIQdJ33GcDtd1n8SuteNHO3DrUL9XFU5EwiOwN4k/3NtmMPSbhTwK/KLvieM4Xa7rPoatjPixCS1HgRKRcBX95egw7IS+cUP82CeAn/Q9cRynx3Xdv2KXWvfTAtEB3DbEGAoqbdI3xrxBktmRxph5wLwcxnEb9j8xcYGtZELk5gpD5UlEwiOxk/b6amC1+Jvo4sc/gFmNpvn1JPtuxc6o9VOOBC1HJS0i4WrswnZ9lYVDyF05egb4RqNpXpxk3+3Yhfr8lCODHcIeGJl05ObT3dgFjHYjfbvsJuBmx3F0JmQJiUh4K2xi76uBHUTmN8pYi11DfzrJV1J8H/gecG+aIXf3Y1dF3ZP0TT2bgD86jtOcYYwqjyISHo0tR32VhYPJvBytw5ajXbD5JNEy4H+Au9KUo4eAN7FNR+nKUQdwt+M4b2cYY1GVzNLKrutOww7FG0vyy6pu7H/EgY7jaOdbkUUkPAb4Ana9mmPJ/KYhq4Cngae8x8WNpjkWkfBSBq6h3okdPDC30TQPOsrGdd2dsEPxxpO6HL0DHOA4TluGMasc8yoMJ2DL0efIvH9vNf3l6ClsOeqNSHgJsHvccV3YZWPmNJrmQf/fveXdX8aOWExWjnqwy2Xvn+1y3cVSMkkfwHXdfYCbsTW9vkurGPaH/1fgAsdxPkr+bpVvEQmPwv4wz8Auajbo0hlxWuj/YT4NLElW04pI+DygEfvj/zNwUaNpfjeTOF3XdbCzw3ejfx0eg62ZPQJEgrRWynDjNf8diy1HJ5BZk80K+svQU9hytMWkqIiEzwJuxF4p/AX4bqNpzmh2teu6ewA3Ya8c48vRJuwNfyKO4wRuHa+SSvqweRr0idj1LyZg75h0jeM4rxQ1sDLldZ4djf2BnoT/Dtj3GFgDWzrITMj475wMxBpN8+rMI7a8cvR57LpOE7CX9b9yHEdnbReBV46OxJajk/HfAfsBAysLb2dQjiYBJgfl6FjgPGz/ZhS4znGc57P9zGIruaSvis8bCnc49gd6Cv6Gwb2LXV/8aewsx/fyF6EKAq8czcSWo1Pxd8OTZux9CfoS/Xt+k7zyp1Q6clWRRSQcwnacnYGd9bqdj7e9jx3SOx94WX+cKiJhwXbkn4Ed9jjVx9s+AO7ElqMXtRzllyb9Mub9QPfD/kBPBz7u420rgLuwP9Bn9QeqvHK0D/3lKOzjbR/SX44WJWuXV/mhSb8MeR1pZwLfxXZSDWYNdljtfOxCZ7qmvOobR/9lbDna28dbWoF7sOXoqUbTHJhZrMOJJv0yEpHwROAC4JvAlEEO34AdPTMfeLzRNOtaRwqAiIQnABHsDcMHa77ZiJ0ENx94rNE0661Ji0yTfhmISHhnbG3sfNIPs9yEvUvUHcDDjaa5owDhqYCISPgT2LvnnU/6W1J2YIdYzwf+2miadV5NCdGkP4xFJHwIcBF2iFyqdUR6gYexif4vjaY5UBNNVP5FJHwQthydQuoZ8zHsHIg7gAcaTXO65Y1VEWnSH2a8YXInYqea16Y5dCNwA3CdDq9UibxydAI22R+a5tA27CSoX2U6iU4Vhyb9YcKbzn4e9vJ75zSHRoFfAb9rNM1rCxGbCg5v/Ztzsc2Bu6Q5dDlwHXBDo2luLURsKjc06QdcRMJTsR2zF5B+TfqXsUsR36WdsipRRMJTgFnAN0g/iWoxthzN107ZYNKkH1ARCe8OXIxdriLdIlUPY291+aSOqVeJIhLeFdsUeA7pV7T8GzbZP67lKNg06QeMty5NA1BH6k61Luya4L9sNM2vFSo2FRze8N0rsFeIqZYP7gb+D1uOXi1QaCrPNOkHhHf3qQux94Udn+KwVuA3wPVxN3pWajOvHH0DqMcuG5zMWuxKp79uNM1+7zWrAkKTfonzprifiL20TtVB+x/gGuAmP2uFq/LjlaPPY5v6UnXQNmPL0R8aTXNgbvStMqNJv4RFJLwv9kd4RIpDlgKXAffo0ggqlYiE9wZ+iV3aOJl3gR8Af9KlEYY/TfolKCLh7bA3az6f5JOq1gFXYptxOgsZmwqOiIS3xZaT/yJ5/88GbDm7Tmdflw9N+iXEuzPVd4HZJL8pcwxoAuobTfOqQsamgsNbCO3bwOUkv+lNDDuh6keNpnllIWNTxadJvwR47a2nYe8Fu2OKw/4GfE9H46hUvHJ0CvAzYKcUhz2BLUc6GqdMadIvsoiED8S22x+S4pA3sFPhH9bx0SqViIT3x5ajmSkOeQs7Hv9BLUflTZN+kUQkvAMwBzu5Kpk12GF1TTqDVqUSkfD2wFXYpROS9f+sxc7r+I3OoFWgSb/gvEvwr2NHUyRbnrYHuB64stE0rylkbCo4vHJ0HnAtydvte4HfAlcM5cbgavjRpF9A3qicG4HjUxzyF+DiRtP8ZuGiUkHjjcq5ATt/I5mHgP9pNM1LCheVCgpN+gUSkfDJ2B/qpCS7F2M71x4vbFQqaCISPgFbcdg2ye7XseXo0cJGpYJEk36eRSQ8DnsJfl6S3W3A97Ht9jq5SqUUkfAYbJPg15PsbgcuBX6rk6vUYDTp51FEwocBtwDhJLv/CZzTaJqXFjQoFTjeHdBuAz6RZPe/gLMbTfPbhY1KBZUm/TzwJsf8GLv0ceKIih7gR8DPtHav0vEWR6vH1uITZ9T2YkflzNHavcqEJv0ci0h4L+yyxnsn2f06cFajaX6psFGpoIlIeA9sOdovye43sbX75wsblRoONOnnSETCIewSCj8l+U1NrgUuazTNmwoamAoUrxxdiJ2dneymJtcDlzSa5vaCBqaGDU36ORCR8I7YtvvDk+xeBny10TQ/UdioVNBEJPwx4CaSr4bZApynI3PUUGnSHwJvgszZwK+BcUkO+SPwTb0BuRpMRMJfwd4AJ9kNcv4ERHSynsoFTfpZ8m4314Rd4CpRK3BBo2m+s7BRqaCJSHgbbLI/Pcnuddiblf+frpejckWTfhYiEnaws2fDSXY/hr0MjxY0KBU4EQlPx5ajZHdEexLbLPhBYaNSw12qG2urFCIS/jywiC0Tfge2A+5YTfhqMBEJHws8y5YJvxM7IOBoTfgqH7Sm75PXfn8Rdq3yxLH3L2CHYr5R8MBUoHjl6FvY2bWJla6XseVI75mg8kZr+j54k2R+D/ycLRN+E1CrCV8NJiLhKqARO3w38bf3B+BgTfgq37SmP4iIhCcD97DlzSliwHew96nVTjaVltfxfzdb3uTeYG9uco2WI1UImvTTSNNhuw44XcdMKz/SdNhuAL7caJr/WvioVLnSpJ9CRMLHA3ew5Q0qlgKf1+Yc5UdEwscAd7HlPI53gRO0OUcVmib9BF5H23eBX7Bl+/0/gFP1TkRqMF45uhB739rE9vsFwCmNpnlVwQNTZU87cuN4HbY3AlezZcK/AfisJnw1mLgO21+x5W/sJuAoTfiqWLSm74lIeBK2w/awhF0xbM3/19rRpgbjddj+Cfh0wi6DXWr7l1qOVDFp0gciEt4T29G2U8Iu7bBVvkUkvDvwINphq0pY2Sf9iISPA+ajHbZqCCIS/iy2wzZxwTTtsFUlpazb9CMS/m9sDT8x4f8DOEgTvvIjIuHzgYfZMuEvwJYjTfiqZJRt0o9IeBZ2Nm3iv4F22CrfvIrD79EOWxUQZZn0IxL+FvYORPFiwLex65Z3Fz4qFTQRCV+ArTjE65th+7VG09xV+KiUSq/s2vQjEv4udrGreF3YcdMPFiEkFUARCV8IXJfwcje24//PRQhJKV/KKulHJHwxdpXMeJ3AiTpCR/kVkfB3sJOu4mnFQQVC2TTvRCQ8my0Tfgd2hI4mfOVLRMIXsWXC7wRO0oSvgqAskn5EwpcDP014eRNwfKNpfrwIIakAikj4EuzyHPE6sFeKDxchJKUyNuyTfkTC9cCVCS+3AZ9rNM1PFiEkFUARCV8G/G/Cy5uwY/D1SlEFxrBt0/cWvGoAfpiwayNwXKNpXlD4qFQQRST8I2xZiteObRr8exFCUiprwzLpewn/KmB2wq4N2Br+wsJHpYLGK0dXAD9K2NWGbRp8quBBKTVEwy7pez/UudjFreKtB45pNM3PFj4qFTReOboS+EHCro3YisMzhY9KqaEbVknf+6H+Avhewq512Fm2zxU+KhU0XjmaA1ySsGsDcGyjaf5n4aNSKjeGTdL3fqjXAt9K2NUKHN1oml8ofFQqaLxy9DPsrNp467EVh38VPiqlcmdYJH3vh/prYFbCrjXY9U9eKnxUKmi8cvRL7A3v463FJvznCx+VUrkV+KQfV8NPTPirgSMbTfMrhY9KBdTP2DLh65WiGlYCn/SBS9mySWcVNuEvLkI8KoC8mbaJTTqrsVeKLxchJKXyQowJ7p3bIhI+D/hDwssfAp/RNcyVXxEJnwXclvDyR9iKw6tFCEmpvAls0o9I+HjgfqAi7uV1wEyt4Su/vDte/ZWBV70bgMO1L0gNR4FM+hEJHww8CYyKe7kT29n2dHGiUkETkfCnsHdJ2yru5W7ssExdokMNS4Fbe8e7+fRfGZjwY8BXNOErvyISngY8xMCEb4CzNeGr4awkO3Jd13WAE4EJQBS43XGcVREJbw88AmyT8JZZjab53gKHqUqc67rTgZOx5WU58EfHcVZGJLwd8CgwOeEt32k0zXcWOExV4lzX3Q34IjARWIEtRy3FjSp7OWneEZHxwGPAHsDBxhg3m89xXXcqdkbtyUAV9qTUAcQ2rFh17S2fPf8LGOMkvO3KRtOcuDaKKmOu604Bfg58CVuGKrHNf71tq9b8+qYjzz0GY/ZNeNvcRtN8aYFDVSXMdd3J2GG8p9OfjzqxLQvXAFc5jtNevAizk6uafjtwPPaHlhXXdScB/8bWvqrido0EeP2eRy/GmKqEt90I1Gf7nWr4cV13G+B5YAowIm5XNcDrf37se0nK0a1suTifKmOu644H/gXUkKQcAd8FDnVd9yjHcQJ1T+2ctOkbY7qNMauyfb/rumbG518AABiVSURBVALcBUxiYMLfbOOKjxJffwC4oNE0B68nWuWFV47+jy0T/mYbW1YllqOHgf/ScqQS3ApsT4pyhO1T/BR2FdZA8VXTF5GdgVeBacaYFu+1M7E1+4OMMR8MMY5jgANI/Q+Mc8bx/OfJZ+lcv5GKEVUP93Z1f7nRNPcM8XsBiDbUjQDGpdnGA2O9+Cq8rTLuz4nP0+3r2zqxTVeZbonv24idRLSmpr4pUDWOPPgMcCjpytFpn2Pp4/+kY+16KqpHPN7b2fWlRtNc7v9uKo7rujOBI+mv1acyGviu67rzHMdZnv/IcsNX0jfGLBWRB7FT1C8RkVrgeuCYHCR8gHMZOIpiC1P23IWvPnYz7WvWto3fYbv5iW1p0Ya60cC23jbFe5yMTdiDJfTB/nMDIdpQtw47qWi1tyX7c/xrq2vqmzqKE21enM3AUV1bmDx9Z8599A+0r1nbNnbqtnfuvc/ebQWKTQXHmXjNyj4Y4CTgN/kLJ7d8d+SKyCexY+MPxXbafscYc2fCMTcDv8ikI9d13Urs+iZjfMXRuYmRS577z8ilr75Gf5LflkFOGiqlNuyJYBXwAfCetzXH/bm1pr6ppJs/XNcNYRfYG5/B2552HOfwPIWkAshrIlyFHanj17OO49TmKaScy2j0joj8DZgBzDXG/Dhh30PAvtgk0WSMudnPZ7quuy/wNLb5ZFBbLfwLI1Y0+45Z5cRGBp4EEk8MK4t9UnBdd0/gWXxWHjw9wAjHcUr6hKYKx3XdXYCXyKwS2QtUO47Tm5+ocsv36B0RCWH/cjHsnakGMMYcl2UM23if6Uvl2qz7i9PpxS7hsH6QrQubKHoTNj+vxT832HbnauxlpN8t8fhR2Caqidg5DZLrfxjPGMDxtmQ6ow1172NPAO8CS4DXABdoKdAJYQL23zYTgv03HU5NXGpoJmB/q5mIYU8S63MfTu5lMmTzamBr4G1sm1fiQmfZyihRdYanM+qNfyfb1YVdbC1+W4W95E+XyNcBHcWuqQ5VtKGuAltgJ2JHQU30+eeKZJ+XoWpgF29LtDbaUOfSfxJ4DXBr6ptyffbO9oSXrxOlCqZsyoPJ8n1F4Xf0Th12wtRBwBHAFSJyk8nNwj1ryeAfrGOPg+mumdY97on5pzMwwa8PeuIeipr6pl5s2/xHwJt+3hNtqBNsG/hEYDtgR28Lx/15RwbpHB3E1th+oEMTvnsVcScB7/G1mvqm1iy/Zy3ZDUHWWr6Kt47MK0KV2CbQQBi0TV9EjgLuBI4wxiwWkQrgLeAiY8x9Qw3Add0R2I7c0Rm8bYHjOIcN9bvV4LwTw2QGngTCCX8el8OvXI49AbyKnRzzLLBssBN6pgMCPM85jnNQtoGq4SfLAQEvO46zX55Cyrm0SV9EdgeeAc4xxjwU9/os4CxjTE56rF3XvRd7JeHHRuB7juP8LhffrYYu2lC3Nf0ngV2BPb1tD3Izqmo5Nvn3bS/U1DdtMf3ddd35wGn4u3JsBy52HCcwQ+1UYbiuewtwFv6uHDcBlzmOc21+o8qdklha2XXdk7Ez4PzU0jqAsOM4K/MblRqqaENdCHsi2BPbCRx/MhjK3Ihe4BX6rwSeBd5uPeXC44D5+C9H0xzHiQ4hDjUMua57NHAv/srRJmAPx3Ga8xpUDpVK0g9hf8D7kr6foR34leM4lxUkMJUXXqfzJxh4InCA3UixDIcPawz8q3Pavk73lI9v37vNdhVmRMrzSjvQ6DjORVl+lxrGvLH6T2KHp6crj5uA3zuOc2FBAsuRkkj6AK7r7gC8jO34S9aR0gm8CBzhOE5XIWNThRFtqKvCjgBysOuaHOw9ZtWR3Dt2Aj2Tauie8jF6Ju+AGTESbDl6FZjpOE5nbiJXw43ruttiy8kkkuejLuB1oNZxnEANBiiZpA/guu40oBGopb9jt8fb/gDMdhwnEGNhVW54J4K9sCeAvi3Z0NC0DELvhMmx3jETXqlsXXl5xca1j9fUN2nlQaXkuu6O2OUVjsBWPATbtNgN/BHbJ5TtaLOiKamk38db8Og07FDC94Emx3HeLW5UqlREG+omAQfSfxI4iMxHELUDT2GXFHkMO1y09H4Mquhc1z0IOzdpMrAM+J3jOG8VN6rslWTSVyoTXofx7gy8GnDIbMJMC/A49gTweE19U2DvjKRUOpr01bAUbagbBxwCHO1te2X4ES79J4GnauqbdDVONSxo0ldlIdpQtx1wFP0ngakZvL0De0/de4AHhzBrWKmi06Svyo43y3g6/SeAI/A/iawHO5zvXuD+mvqmFfmIUal80aSvyp5357SD6T8JHIC/2ZgGO2P9XuDPNfVN7+UtSKVyRJO+UgmiDXUTsLX/o4HjsLOK/fg39gRwb019k69F75QqNE36SqXhNQXtC5wCfBHbLOTH69g+gHuBV3Q4qCoVmvSVykC0oW46dnHAU4BP+nzbu8CfgFtq6ptez1dsSvmhSV+pLEUb6sLYE8AXseu0+JkX8BxwMzBfRwGpYtCkr1QORBvqpgInYk8An2HwG3F0AfdhTwCP1dQ3ZXqLPqWyoklfqRyLNtRtA5yAPQEcw+DLSLcAt6HNP6oANOkrlUfRhroxwEnAV7FXAIM1AWnzj8orTfpKFUi0oW5H4GzsCWDnQQ7X5h+VF5r0lSowbxjoDGzyP53B79DU1/zz+5r6psCu7qhKgyZ9pYoo2lC3FXYE0Ffx1/zzMPArbO0/lt/o1HCkSV+pEpFh88+bwK+BW2vqmzbkOTQ1jGjSV6rEZNj8sx57V7nra+qbluY/OhV0mvSVKmFe888pwDexC8GlYoAHgeuAJ3TZB5WKJn2lAiLaUHcQ8G3gS0BlmkNfxyb/2/XmLyqRJn2lAibaULc9EPG2yWkOXQvcCMyrqW9qLkBoKgA06SsVUNGGupHAadjaf7rF32LAA9hRP09p009506SvVMB5Hb+HAN/Ctv+nW/fnn8BPgEc0+ZcnTfpKDSPRhrodgAuAOmBimkP/jU3+D2jyLy+a9JUahqINdaOAL2Nr//ukOfRVbPK/Ryd7lQdN+koNY17Tz2HA97G3fkxlCXAVcKeu8zO8adJXqkxEG+r2By7HrvqZyjvAT7HDPbsLEpgqKE36SpWZaEPd3sAPsOP9U6310wz8L3BzTX1TZ4FCUwWgSV+pMhVtqNsduAz4CqlH/CwDfgbcWFPftKlQsan80aSvVJmLNtTtDMwGziX1TN+VwM+B32jyDzZN+kopYPMqn5cAXwNGpDhsGfBD4Laa+qbeQsWmckeTvlJqgGhDXQ1wMXas/8gUhy3Gjgh6VMf5B4smfaVUUtGGuinA94BZwFYpDnsC+H5NfdOLBQtMDYkmfaVUWtGGuonApcCFQHWKw/4I/KCmvum9ggWmsqJJXynli9fm/xPgrBSHdGGXdP5pTX1Ta8ECUxnRpK+Uyki0oW4/7EieI1Mc0oqd3Tuvpr6po2CBKV806SulMuYt7/BZbPLfK8Vh72Engd2h6/qUDk36SqmsRRvqKrA3c/8JUJPisJeAi2vqm54oWGAqJU36Sqkh81b1/DZ2kte4FIc9Anynpr7pzYIFpragSV8plTPRhrpJ2EXdvgFUJTmkG7usw09r6pvaCxmbsjTpK6Vyzlva4afY2zkm0wx8q6a+6S8FC0oBmvSVUnkUbag7ENvZe1iKQx4Avq03bi8cTfpKqbzyRvqcDvwSmJrkkE3YjuCrdRnn/NOkr5QqiGhD3TigAXsLx1CSQ94EZukon/zSpK+UKqhoQ92+wG+A2hSH3AFcVFPf1FK4qMqHJn2lVMFFG+pCwHnAXGBikkM2YJdwnqf37M0tTfpKqaLxFnObA3w9xSGvABfU1DctKlxUw5smfaVU0UUb6g4Gfgvsm+KQ3wOX1tQ3fVS4qIanZJ0pSilVUDX1Tc8CB2A7edcnOeRrwJJoQ92pBQ1sGNKavlKqpEQb6qZix/afmeKQ+cA3a+qbVhcuquFDk75SqiRFG+o+jR3ls3uS3SuBupr6pvsLG1XwadJXSpWsaEPdCOy9eH9E8rV8bsfO6F1T0MACTJO+UqrkRRvq9gZuBvZLsrsF+O+a+qYHCxpUQGnSV0oFQrShrgq7dPMPgcokh9wMfLemvmltIeMKGk36SqlA8W7XeAvJ79gVBf6rpr7pkcJGFRya9JVSgeO19f8QW/OvSHLIjdilHJIN/yxrmvSVUoEVbaj7FLbWv0eS3R8A59fUNz3uHfs57EliGXbIZ1l2/mrSV0oFWrShrhq4AjvKJ9mE00bgx8BbwBjvtaeBI2rqm8ouAWrSV0oNC9GGuoOwnbnJxvW/D3w84bXza+qbbsp3XKVGk75SatjwbtD+Y+AiQAY5fDWwe7mt56Nr7yilho2a+qZNNfVNFwOHAm8PcvhE7E3ay4rW9JVSw1K0oe5j2Hvwplq5s8/hNfVNTxcgpJKgNX2l1HB1C4MnfIAmbwhoWdCkr5QarpIN40xmd+DqfAZSSkqyecd13UOB07Ftbu8BNziO825xo1JB47puLXAGMBk7euN3juMsLW5UqlCiDXUXk1mb/W419U1vJb7ouu6BwFeAbbFj/H/nOM5g/QUlKydJX0RqgV8CXcBy4BxjTHemn+O67s7Yu+fMAEZ7L/d42++B2Y7jbBhywGpYc113J+ySvIcBo7CjOPrK0c3ApY7jrCtagKpgog11+wAnAJ/B5pV0zTjfq6lvuqbvieu6H8eWo0/TX456gW7s6p7fdxynNU+h502ukv72QKsxZpOIXAW8ZIy5O5PPcF13B+BlYGuST6vuBF4AjnAcJ+MTiioPrutOxd5XdRtSl6NXgZmO43QWMjZVXN5wzhnYE8DRwP70D+vsBXasqW+KAriuuy22nEwieTnqAl4Hah3H6chz6DmV8+YdEWkAXjHG3Ov3Pa7rhoBnscumJls9r087cK3jOD8YWpRqOHJdV4BngAMZvBz9xnGciwsSmCpJ0Ya6rYFzAAe4tqa+6XXYXI6exJ4gkq3h32cTcKPjON/Kd6y55Cvpi8jO2LPeNGNMi/famdhbmh1kjPnAe20n4E7gUGNMl98gXNc9CbiN/inS6XQAOzqO86Hfz1flwXXd47G30vNbjqY5jhPNb1QqaFzXPRq4F//laLrjOM15DSqHfI3eMcYsBR4EvgOb2/CvB06KS/jjsEOkzs4k4XvOwd8/MNjLsC9k+PmqPJwFbOXz2BhwYh5jUcF1Jv19ioMxwEl5jCXnMhmyOReoExEHexaMGGOeAxCRSuAO4ApjzJuZBOC6bhVwTAZv2Qp7klBqM9d1K4HPM/jU+z6jgbPzF5EKIq+p+ST858ZRBCwf+U76xpgXgeeAfwG/NcbcGbf7y8BBwI9E5B8icnoGMeyNHVWRiYMyPF4Nf9Oxta5MHOC13yrVZ1eSd9yms7frupm+p2h8J30RCWGbVmLYWv9mxpjbjDGTjDFHeNudST8kua3J/Mda5dXslOqzNbZsZmpkrgNRgTYem+cy0Yv/5umiy6R552rsD+ttbJtXrmQ7fKj0ZpWpYtJypHIhm/IgWb6vKHwlfRGpA07GtnXNBS4WkVxdFrf6jSNOp+M4mZ6N1fDWSuaX5QY7bl+pPq2kH+6bTAhoy0MseTFoshWRo4CfAicYY1YCd2NnteVq5MNi/He+9XkmR9+tho8lZH5ZvshxnMDU0FRBvEPmFYEXglQJTZv0RWR37Ljns40xiwGMMb3YJRcuyUUAjuP0YIeD+v3xbcBOgVZqM8dxYsD9+G/XbwNuzV9EKoi8SsDd+K9AtGOHqgdG2qRvjHnD66B9KOH1ecaY2hzGcSv+L48qsScJpRLdiv0R+lGBXWtdqUS3Yydd+RHCVjYCo1SWVn4EeB67kFE67cCPHcdZnf+QVAA9CfwTuy5KOu3A/+qsbpWM4zgLsGVpsGaeduCXQZvVXRJJ37ukOg1YRerEvwl7B/ufFyouFSxeOfoysJLUiX8TsAi4qlBxqUA6B2ghdTnqwC4AeUWhAsqVkkj6AI7jfAQcANyD/WH2tal1Ys+oc4GTg9RhogrPcZw12AXX7iJ5Oboa+ILXl6RUUo7jrMVOAr2DgeWoy3t+DfC5IK74W6o3UdkLu77OBOz6/Lc5jrOquFGpoHFddw/sUOMJ2Frb7Y7jrCxuVCpoXNfdHfgidpnl5cAfHcdpKW5U2SvJpK+UUio/SqZ5RymlVP5p0ldKqTKiSV8ppcqIJn2llCojmvSVUqqMaNJXSqkyojciUcqHkQdEjIQqCFWNIBSqQEIVhCqrvMcRSIV9DPU9T3hdQhVUVIYQEfsYEioqvMdKSf56RQgJQSgkhCpChEJCZWWIipAwwnus3vy8wj5WJL6e/LEqFKJCoKoiREiEqgohJDLwtZB4x8rmYyoGHCuIQEUIQggVIbtcbkVICHmPIlAhQkigQrB/T4GQ916J9SImBrFeMDEk1gMmBr09SV+XWA/E7Ot2fw/EejE93faxu3vzcxPrhZ5uTG/vwGM2H9sFsRimpwsTixHr6tn8GOvtJdbdg+mN0es9bvm82z7f/L5eYr0xTMzQ29WL6bWPsYTnA/Z39xLrNd57Db09MXqNoStm6DV4j4auGElfjxF/TP++RtOccuVirekrpVQZ0aSvlFJlRJO+UkqVEU36SilVRjTpK6VUGdGkr5RSZUSTvlJKlRFN+kopVUY06SulVBnRpK+UUmVEk75SSpURTfpKKVVGNOkrpVQZ0aSvlFJlRJO+UkqVEU36SilVRsQYU+wYlCoLIvLfxpgbNI5+Gkvh49CavlKF89/FDsBTKnGAxpJMXuPQpK+UUmVEk75SSpURTfpKFU7R24s9pRIHaCzJ5DUO7chVSqkyojV9pZQqI5r0lcoTEdlGRB4Tkbe9xwkpjvuZiLwmIktE5DoRkWLE4R07TkSiInJ9jmM4VkTeFJF3ROTSJPurReROb/+/RCScy+/3G0fccaeKiBGRT+UjDj+xiMjHReTvIvKSiLwqIsfl4ns16SuVP5cCTxhjdgGe8J4PICKHADOAvQEHOAA4vNBxxLkSeCqXXy4iFcA84HPAHsCXRWSPhMO+BrQaY6YB1wBzcxlDBnEgImOBbwH/ynUMGcZyOXCXMWY/4AzgN7n4bk36SuXPicAt3p9vAU5KcowBRgIjgGqgClhZhDgQkf2BKcDfcvz9BwLvGGP+Y4zpAuZ7MaWK8W7gyFxf8fiMA+yJ72dAR46/P9NYDDDO+/N4YHkuvliTvlL5M8UY0wLgPW6beIAxZhHwd6DF2x41xiwpdBwiEgKuBi7O8XcD1AAfxD1f5r2W9BhjTA+wDphY6DhEZD/gY8aYB3P83RnHAlwBnCUiy4CHgAtz8cWVufgQpcqViDwObJdk1w98vn8aMB3YwXvpMRE5zBjzdCHjAL4BPGSM+SD3FWySfWDisEE/x+Q1Du/Edw3w1Rx/b8axeL4M3GyMuVpEaoHbRMQxxsSG8sWa9JUaAmPMUan2ichKEZlqjGkRkanAh0kOOxl41hiz0XvPw8DBQEZJPwdx1AIzReQbwBhghIhsNMaka//3axnwsbjnO7BlU0XfMctEpBLbnLEmB9+dSRxjsf0q//BOfNsBD4jIF4wx/y5wLGD7OY4Fe0UoIiOBSST///NNm3eUyp8HgHO9P58L3J/kmPeBw0WkUkSqsJ24uW7eGTQOY8yZxpiPG2PCwP8At+Yo4QM8D+wiIjuJyAhsp+QDaWI8FXjS5H4SUdo4jDHrjDGTjDFh79/hWSAfCX/QWDzvA0cCiMh0bN/PqqF+sSZ9pfLnf4GjReRt4GjvOSLyKRG50TvmbmApsBh4BXjFGPOXIsSRN14b/TeBR7EntLuMMa+JyI9F5AveYb8HJorIO8D3SD/CKJ9xFITPWC4Cvi4irwB3AF/NxYlQZ+QqpVQZ0Zq+UkqVEU36SilVRjTpK6VUGdGkr5TKORFpFpEuEZmU8PrL3po2Ye/5gSLykIisFZE1IvKciJzn7TvCm5ikckiTvlIqX97FTjACQET2AkbFPa8FnsSu9TMNOwP3Aux6NCpPNOkrpfLlNuCcuOfnArfGPf85cIsxZq4x5iNjvWCMOa2gUZYZTfpKqXx5FhgnItO9VSVPB2739o3GzgK+u1jBlStdhkEplU99tf2ngDeAqPf6BGyls6VIcZUtTfpKqXy6DbuO0E4MbNppBWLAVOzJQBWINu8opfLGGPMetkP3OODeuF3twCLglGLEVc406Sul8u1rwGeMMW0Jr38f+KqIXCwiEwFEZB8RmV/wCMuIJn2lVF4ZY5YmW6nSGPNP4DPe9h8RWQPcgL1hiMoTXXBNKaXKiNb0lVKqjGjSV0qpMqJJXymlyogmfaWUKiOa9JVSqoxo0ldKqTKiSV8ppcqIJn2llCojmvSVUqqM/D/LjiDpYiWtHgAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -760,7 +760,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -814,7 +814,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -872,7 +872,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -940,7 +940,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAEjCAYAAADe/dHWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOydeXwcZf3437ObTHoms2mZpmmhHKUgLKfKfUk4FZFLDlEkVH8gUkS/WOVrXSVWv1pU1KKgX+ui4JdDDgFBrgLlBrkZKFehHA3ptk0m2yudZHd+f3xmmj1mk93NJrubzPv1mtdmZ2d3nuw+z+d5ns+p2LaNj4+Pj8/YIFDuBvj4+Pj4jBy+0Pfx8fEZQ/hC38fHx2cM4Qt9Hx8fnzGEL/R9fHx8xhC+0Pfx8fEZQ/hC38fHx2cM4Qt9Hx8fnzFEWYW+oij7KoryqQLfs4+iKE8oivKooigPKYqy43C1z6fyKaYPOe+7T1GUNYqiLBiOdvmMLortZ5VIuVf6pwONBb7nY+A427YPA34JXF7yVvlUE8X0IYC5wHdL3Baf0Uux/aziKJvQVxTlaOAC4IeKolyZ7/ts2+6wbXu989QC+oajfT6VT7F9CMC27Y+Gp1U+o42h9LNKpKZcN7Zt+wFFUd6zbfvQYt6vKMpE4KdAa2lb5lMtDLUP+fjkw2jrZ2UT+oqi6EBHxrkg8ITH5Xfbtv2TlOtqgZuA/7Ft+/VhbahPxTKUPuTjky9e/ayaKZvQB/YEjNQTtm0ngAMGepOiKAHgeuCftm3/c/ia51MFFNWHfHwKJKufVTNKuVIrK4qyA3AX8JFt28cV8L7TgGuB55xTr9q2Pa/0LfSpdIrtQ857/xc4CKgDDNu2TxqGJvqMAobSzyqRsgl9Hx8fH5+Rp9wumz4+Pj4+I4gv9H18fHzGEL7Q9/Hx8RlD+ELfx8fHZwzhC30fHx+fMYQv9H18fHzGEL7Q9/Hx8RlD+ELfx8fHZwzhC30fHx+fMYQv9H18fHzGEL7Q9/Hx8RlD+ELfx8fHZwzhC30fHx+fMYQv9H18fHzGEL7Q9/Hx8RlD+ELfx8fHZwzhC30fHx+fMYQv9H18fHzGEL7Q9/Hx8RlD+ELfx8fHZwzhC30fHx+fMYQv9H18fHzGEL7Q9/Hx8RlD+ELfx8fHZwxRU+4GjHW6lyxQgHpgRsrR7Bzjkd+oBgim/J3v843AWmCd85h5uOfXNcxd2Dvs/6zPsNG9ZEENMI30fjQDmMrQ+hBAJ9l9xqsvxRvmLrSH9z/1GSqKbfu/0XDRvWRBLTCdfkGeOSDd8xPL1cYUuskeyO8ChnOsaJi7MFG+5o1NciwKvPrTNMq/c+8juw+tBl7H6UcNcxd2lq95PuAL/ZLQvWRBANgR2AfY13ncE2gClDI2rZT0AMvpnwQM4DXgA391Vxq6lyyYBOxFej/amcpYFJSKj0nvQwbwesPchRvK2qoxhC/0C8TZRu9K/6DcF9gbWY2NRdYjwj9zIMf8ySA33UsWNJIu3PcF5jB6FgmF8h7ZC4o3GuYu3FLWVo1CfKE/AN1LFowD9iB7BT+uxLfaAqzKONoRlUufcyQK/DsJTEJ0uu4xJeO5ezRSemGzBngMeAB4EFEPjbnO5qhnppMu3PcBZg3D7daS3n9WAR1I/yqmDyUQlVEj2X3Gqy9NKPH/k0CE/4PO8WjD3IUbS3yPMYcv9FPoXrJgMvAZ4DjgEGA3+o1ZxRIjW5hnCviucgrE7iULgoBG+gCeDnwCCDuHPsTbrEQG7gPAQw1zF64doD07ANcgu6efNcxdeNcQ7z1iOEJ+F+BY4GjgU4i+fSj0kLvvuOfay70q7l6yYDzpk8E2wPb096FPALVDuEUv8CT9C4nnBrIzdS9Z8C3gPOBZ4LKB+txYYkwLfWeA7oUM0OOAgym+U3YDLwAvpjy+0zB3oVWCppad7iULdGB35winHA1FfJyNfD/uJPBEw9yFm1PudT8iMF2+3TB34W+KbPqw071kQT3QQn8/KnYVbwNvk96PXgHWjIZdkuPYMJv0/hN2zhVjhDaBh+mfBN5xv6fuJQv2Qb4/lzeB4xrmLlxZbPtHC2NO6HcvWTAVESjHOkdTER/TQbpwfwFYORoGZiE4k+YMsgfxboi7ab5sQVRB7iRwNbBfxjVXAN9vmLswOcRmDxnHcL83IuCPBQ6icPfnPkR1kdqPXm6Yu3B9CZtaFThq1F3J7keFTp7v09+HNgN3ZLzegQj+l4fU4CqnIoW+YRizgM8CkxFr/63hcHhTMZ/lGF73o3+AfprC9NfvkT4wX2yYu/DjYtoyVnDURXsjk+tRiKqsroCPiCO/febv9HfgvHx2T4ZhBIDjEWHSCzwdDoefLaANaXQvWbANcAzSj46hMHXXZuBl0vuRUW51TKXjGLs/g/Sho4GdCvyIONkOFnHg5Ia5Cx/K5wMMw2gCTkTUn2uA28LhcHeB7agoKkroG4YRAi4HvuacqkFWgb3AfCAaDocH9RXvXrJgBjI4j0M6jFZAM94C7gXuA55qmLuwq4D3+njg6HoPoX8S2GcIH/cAcOpAK2LDMI5AdgszARUxaieBx4GLw+Hwm3m0uQY4gP5+tC/5LxZ6gGVIP1oKLG+Yu7Avz/f65MCx9RzlHC2I/aAYeoGvNMxdeFOuCwzDmARcBnwbUbvVAhbSjyLA78PhcFUGNJZM6CuK8lPgMCQY4xzbtgtamRuG0QA8j6gLvLxjNgI3AV8Lh8NZje5esqAJ+CJwJrLdzpcNyMC8F7ivYe7C9wppt0/hOKvmI+lfwRW6jX8bOKJh7sL2zBcMwzgTWIK3J0kCEcgHhcPhVzzaFUAmpzOB0xBDZL4sRxYK9yJeJpsHud5nCKSo2Nw+dCiF7SYBLm+Yu/DHmScNwxgHPIUY5L3UlJsQmXFSOBwuu7qxUEoi9BVFCQMLbNs+U1GUC4Aa27avKuQzDMO4A1G/DPTDbQS+GQ6H/wrQvWTBFOAUZJAeQf7GoJeQwXkvspofFcbWasSxC+yEDNwzEWN6Ph5TPcDODXMXfuSeMAxjV0R9MpA9wUYWJrPD4fBG5/6fcu59BrLoyIc46YuF9/N8n88w4OwmD0b60bnkr367uWHuwjNSTxiG8WfgSwzcjzYCl4fD4SsKb215KZXQ/wawybbtvyqKMgv4hW3bZ+b7fsMwPgPcRT6Rh8nEhhkv/PNbgUTvKcgkkY8BbR1wPzJA72+Yu7Aj8wLLjCnIDmMyogfMPCYhW7xgjqNmgNcyDwURWpnH5hznB3p9varpVZ8ewbEDtFOYrvy6hrkLz3GfGIbxGLLLG2zy31wXj12rL3+oCxH2O+Z5vxfoXyw87ecrqjy6lyw4D9np5YsN1LgOAoZh7IW4heYTc7AZmBUOh9cU3NAykpfHgaIoOyGuY7Nt2/7YOXc24lGxPxBCDK4grouNBbbjq+Tj7ZFMor++dHwg0ev9owZrUerGQ914ApO0NwMhfXlgyvR3lZAeV5TAZGTr/lnLjNXjLdyrMQGdbZmxLtITYQ32d2cFThRJpB8VwgfuH4ZhTEGM9IPu9sZ1tY+f+vbj38jj803gHuDfwAMNcxeuLrB9PiNPoS7EvYjgdzmL/N22E8AJQLTAe5aVvIScbdsrFEX5F3AJ8D1FUQ4ErgKOtW37Q0VRuuj/shuQrHx54XhZnEQeg1XduI66LRuCwZ32JKBtg1I3wRHy8qjUpP1WuzjHaEdBJtlGJE9LPtiWGTNJnwxWIwFU76c8rhqpyaFh7kK7e8mCi5GFxKSMl3sQg34SGZAK8ATwo5RrTkAG8KB63Umxd1DsnKrYjYir343IrtD3sKku/ozYYzLten1IH7IQWVOL/NbzMlytv0T+Qn8ScA6jUeg7/AJ4SFGU64DbgAts23Zd4B5HLN1/RVQuTxTwuWHyjHrtGzeZ2v2OpWb6DgV8vI8HCrKqDjHwRNFnmbGPSJ8IUh8/UjW9JPaQeDSiKoHAobZtj0MWDc8g/WqZoijP17e29QzyESeRPVl40jtBY7yZZgPeAtyNCPq7G+YuLMo92Kf8KIHA7sAs27aTwBuIquZRRVEeA96vb23Lqc82DKOZwoz3AIcYhqF4OZdUKnkLfdu2X1AU5VlkMP7Ctu2bUl57VVGU950vNobMfvkyBdkmDUqydhwBvVgvrbzoRdRTcY9jA7JKSJTgAFmRjnOO8Sl/D3RkXjceUVMNFzVIGP32wOEer9uWGWsnfSJYgQQdva5qeiGBRocDX1IUBWTXcrxzAFjxaOQ5ZDHxInB/fWvbuoz3553qoHvG7iSDNYzr7nhuXDy2GLijYe7Cqva99tnKT4AZTj/azTlcF/D2eDTyOOKZ8yLwWH1rW+qWbwoyxgvNrTUe8eipCvIW+oqiBBCBlURW/WnYtn1ZkW0oLLeNkpeDTi8iqN183h8gwqgDb4G+Hoirml51W3nLjNWQnhBrCtkJsTL/LlR3ngs3IncG4jmR2bb36c+Y6GZPfEPVdC93xoEGjYps17du2ePRyG/qW9u+nXJN/v0oEGR9826sb97t/nA4/Le83+dTDQzkKtsMnO4cABvi0chu9a1tHzrPi8mzZVNltsBCGvsrJMjpbeBs4C8lakM3BUTIJu0kgcF/m1pEuE0hXa+/ComMfMV5XAO8X4FGzbxRNb0P2V3F8n1PykSROhnMQFb0s1IeC93qZjLLOT6Xci5pmTF3N2AARrJr9bsEa+tJ9C5FVvz59MuLkMAZF7PAtrm7Op9RQDwaURAvrCeQQLp8XG8nAT+lXzMRp3AB7laoqxry9d45HzgZ8dQ5AvixoihRuzSRXa8iK7m8WN21nmmhyT01wWAx6Y3dVelnU871WGbMQCaBrROCqumFCpGqId+JwjJjE4HtSJ8IUh+nF3H7gN1r7Zxc9/HOybWrTkquXYVtroHchtVcZO7K7kMCdPLN+dOD2Ax8qhBHyM9BFgnukW+MRSqpHlkrEfVOISmiX8snS0AlMajQVxTlKOBnwBG2ba9WFOUW5/kXgH8OtQHhcLjHMIyH6dffDsjGHmvDux+vmzdnpv4A8qPvknLMAXagsIx945DgnE+lnrTM2Af0TwTuZPCOqulVF4FXLKqmb0QiTZd7vW6ZsTpgW/ongh3oT5y1M87vYFtbSK5rJ7l2Fcm17SLkGdJ6YRPiX5/K7cDCAj7DBp4eSiN8Rg5HyO9Gv4A/jOKSJabyFPA990k4HE4ahvFPZOWfjwzpAa4bYhtGnAGDsxRF2RVZDZ1j2/Y9Kee/CXzZtu0DS9EIwzDOAv6Eh/dFIKDQ3NjAhHH9m4GkbT8ZUJRTVE3P8pt2BNFO9E8IuyHpk3djaLm8QYTNq0hE79PIVvIdVdOrxnI/EsSjkSnUqi3U1p1IX+8hWD2lKRgSrCE455O9NTvv84wSrHkK+Q2eVjW9HcAwjLeRNL1pePWhLVZfR51as7dXH/IpP/FoJIAUMEoV8lNL9PEvABfUt7b9J/MFwzCORrwT85NFSfvZQEA5sZr6UUUkXDMMowYRpnNImWEDAYUdp29DsFYlOG4iSrAGO9FHomcjdp+1BZiV75dtmbFaZBW6V8Yx1OIgaxG3MPd4LoehctQSj0Z00rfZ4UI/Q5nYgDK5kWSHd+qjwMydqQ0fjDLe0yvzA+DpTT1W19r4xq9usXrHub26lH3IZ/iIRyNuZla3Dx1K4Q4Hm5HVexOyyMskBnwf+GuG185WDMNwY0A+TYomZDT1o4oQ+gCGYcwB/kNKSt2ZUzUmTppEzcQGHBcsAGzbpm9jN3aftUzV9COGcl/LjDUhJRBTJ4JdKd4i34usJLZOBO5KdDQRj0a2RXLVnAl8soiPWI5kolwGPDru5Is2WU/fPS/58XttqRcp9VOo3eswAlPzV9fatk2P1UeP1cv4ulrGT5g4rH3Ipzji0UgNYiM8E8mhVaiQ34gIaLcf/ae+tc2KRyPPI8ZclwSwGPhxfWvboMZ7wzBmICrdEM4idCRk0UhRMUIfwDCMvZEArx2BSXNm6tRMChGoydbKJPt66dvQZauaXkzFnQFxVES7kT0ZFBsksJL03cCrjjG1qnBW9KchoeqHFPj2V0kR8vWtbVlG5Hg0Mh5R2ewJmNSoP6k77qsvKrV1n0bSHB9IEXrccvQhH28ctc2BiKA/ncJ22nGcgD3neKG+tS0r/1E8GjkD+BviIPIQcHF9a9trhbTTMIxdgGsRFdPEcsmi4aCihD5s3V6dBHx5zkz9lNqGbdJmVhfbtuntXoOq6aUu6O2Jk5CtGRH++yE+4wdQXHDUBiTIzZ0Enq5Ub6F4NKIhnltnIjnM8/FlthG7hzs4H/MIpsp1vwBii1lR39qWFu3r/AbbId+7e+zLIN5fldKHxiqOEXZvZLFwBvIb5kMXUlHN7Ucv1be25eUp4yxQautb21YV3mLBkUXHAHPnzNS/OFr6UcUJ/VQsM5asmRRSKnV2tcxYENFfH5Ry5JuxMRUbUQnd7xxPliq9QTHEo5GJSC6bsxCvqsFcam2kFsIjyOB8vL61bUQmMWdXtjf9O4EDyMjPP8gKDaQ62v04RdtVTfcL55SAeDSyK7JYOJP88mB10t+HlgGv5tK9jzSVLosKodKF/iNKjXp4NenRLDM2HRE+7iTwSQqIQ3DYiHR+dxJ4c7g9hOLRSB2SN+lMxB03H1/lZ5B8NTfXt7ZVjN0i5Tc4EjhPqVHHD9CHMt+eBJ5DJoAHgKfKOQFXG/FoZBb9gn7vfN6CeMvcADxU39pWkWrPapRFuah0oT8NeF+pUeuq1WJumbFxiOB3J4GDKTzS9UNE+N8HLFU1Pe8spgORYkg7CzGk5VNW8hVE0N9U39r2binaMZw4fegDpUZVPfpQPh+xEUmtfCtwj6rp8eFsbzUSj0bcqnVnIZPtYGwG7kT60b15JNMrO6NBFrlUtNCHrV/2v0mvq5oAZquavrIsjRoCjl56R0T4u5NAIS6ONuLl5O4CnlY1vaBiHvFoZBvgQuAb5Jeo7B1kJXZjfWvb64XcqxJw+tBNZCeN+wgxJOa7E7OQ7/w24E5V0/OyU4xGHD394cCliApwMNVGL1J85gbgrvrWtg3D28LS4/SjOxGbnosNhFVNr5pxUfFCH8AyYwHEFzvVb+90VdP/UaYmlRTLjG2D1Po8xjmaC3j7euBh+ncCK3KpguLRyBwkX825DJ5J8CNEUN6AeElUfkcZBMuMfZn0CMqVwO5I4M/RzrFHnh+XQFRwtwL/VDX944EvHx04u8PTEGE/mKtuEumbNwC317e2lWSHWm4sM/YK6f3kQlXTry5XewqlKoQ+gGXGrkSKuLjcqmr6aeVqz3Dh7AR2Q/TrxyCrqULyDLlGyTuApT23X9WL7CguRXT1A3kYrAH+gWy7n6gUI1qpcCqmxUgvtLK/qunPplzTRH+x7aPJL7+QjQQF3QrcVo070MGIRyOTgbnIomEw75snkT70j/rWtqzSpNWOZcZ+QHrKj6rR50N1Cf0DkIHl0gPoBeZsrzocm8Ah9O8C9srnfbadJLlqxaa+5c9ssjeYA4Wvr0eEVUUb0kqFZcZuQ1xQXX6tavp/5bg2gERmngKciqT3yIcXEBXQraqmvzGE5padeDQyA5gHXMDApQhfBv4PsfWM6iLxlhmbjWQbdrGBmdUShFlNQl9BVrGp7nhnqJp+c5maVBYcz5RUVVBacIvd10vig+Uk3nkJe+OANscPgd8Af65vbRszxknLjJ2BrEJd3gd2GMw7yul/eyDC/xTyt8MsRybV61VNf7PwFpeHeDSyB/BfDFw+0EZ03L9EdobVIUxKgGXGMqN+v6lq+h/K1Z5CqBqhD2CZsV8iHdFliarpX8t1/WjHWYnuARxjb1r/+b73jIMS7xlBenPXglEatqFm5737As2z71OCwVsZYwZJJ130OtJVPLuomv5WgZ8zh/4dwKcGudzlKSTK8yZV0ysul79jnG1BVIHHDnDpFuT/uLK+ta1qJrJSYpmx7wP/k3LqDlXTTypXewqh2oT+UYjvtMsHwPZjOctlPBr5BPAd4CsMUBQ8MG0WwZ33ITB1RmZUYQIxtt0G3K5q+qjTwWZimbH7EX29y0Wqpv9+CJ+3HaIyOhVRxQ0WmdmDfN/XIsFgZc3HHo9GapFI2UsZWH24DrgK+INXGo2xhGXG9kZKLrrEgamFetKVg2oT+uOQ0OxUw+au1bRtLhXxaOQw4LtI5Gwu+gLbzHyrJnzwlIC2TT6umTaSwOo2xCA5KnWzlhn7LrAo5dSdqqZ/oUSfPQ1JI3IKEhw2WOK+j5A8Mdeqmv72INeWFMc4ez7iIDFQRrt3kMp5f6tvbauaWrDDibPL7iA95uYQVdOfKFOT8qaqhD6AZcbuQ3TZLhermr64XO0ZaeLRyC6IDnUgYW8CVwOL61vbPk4xSJ7qHPmminge0UffqGq6d87jKsQyY3shuYFc1gNTSr1Ks8xYI+IxdQ4SBDcYTyCr/5uHMwjMSWN8HuKBMlDCsyeQvnZXvjlvxhKWGfs7YvNwuVzV9B+XqTl5U41C/1LgipRTd6mafmK52jNSxKORRiACfJPcq8eVwJXAX3IFvzgGyT3pnwC88o57sQwRSLeoml51gTWpOJPgx6QLvENVTR+28omWGdsREf7nkpEbyIPNyGR7LfBwKau1xaORzyAG/D1zXGIjO71f1be2PZXjGh/AMmPnAtGUU0+pmn5QmZqTN9Uo9PdE3MNcNgCN1aBLKwZH33o+cDlSzNyL/yAT4e2FulxaZmxXRBVxCvnlxd8I3IKkwF5WreUjLTN2PXB2yqmfqJoeGYH7BpDYi3ORIKfBchx9iHzX16qavqLY+8ajkdlIH8llbNwM/AUxzhZ9n7GEZcZmIOo5lwSi16/IjLku1Sj0FWSVlqqjPkzV9MfK1KRhIx6NHAf8GvhEjkueAP4bSV085B/SMmPb0++Rks+K5X1EIP1tKAKpHFhm7Byk7S5Pq5pekvKfBbRhMiL4W5FKUQNhA/cAvwUezNd5IR6NNAALgG/h7Xq5GdHX/ybf9Nc+/VhmzECiul1OUTX99nK1Jx+qTugDWGbsOuDLKacWqpr+w3K1p9Q4Hjm/Inex+PeB+UjE47D8gJYZa0Y8Us4mvyRaj9Kv/qn4gDnn/0vNtZ5EVmllSavsBPycA3yVwSNelwO/A65zitdn4aRLmAv8hNwJ/v4OXFbf2vZhUY328coUcLWq6ReWqz35UK1C/yuIx4PLM6qmH1Cu9pSKeDQyBfgRkgzNq1jJRuBnyBZ8xOrwWmZsF0QYncPAXh4gxeNdffQjlaz+sczYq6QHWZ2qavpt5WoPbFX/fAZR/5wKjB/gchP4M/D71NQP8WjkKGSHmCuP0DPAJfWtbU+XoMljGsuMHY/swFxWqJo+u1ztyYdqFfrTgdSQ5ySwTalSDo80jt7+QkTge9UJtRGD0YL61rayJfZyisa0IALpZAbPCfQBokL5ayWqfywz9mskl4zLH1VNv6Bc7cnEyRV0OpICYSB7SxK4o+/dV2/re3nZ6cDnc1z3EfA9JFtqxU7G1YQT7NdJeqbWnVRNr9i041Up9MEz090XVU2/pVztKQYnAvKziConV2WhR4Fv17e2vTBiDcsDy4w1IALpXPLT/z9GfzSqp0pipLHM2HFI2m6X91RNL6by2bDi2LEORPTyp5KxC7StHvre+A+Jd18F21OWbwJ+AfzS97MvPZYZewjZnblcoGr6H8vVnsGoZqH/KyQS1eVPqqafX672FEo8Gtkd2YIfk+OS95Dgq9sqPaeJk5LAVf/MHORyE1iCqCTK6vtvmbEJSLBf6iptdiXuSlwsMzYTqYNwvp1MTkmsfI2+5c+AlaMOSY16C33WJUOpFeszMJYZuwxRu7rcpmr6qeVqz2BUs9A/FinK4LIS2LHSUzI4qpwfIl43Xnr79cBPgd9WQ0WhVBz1T6o+eiD1jw3chRgkHyrX72aZsaVI5KxLVeRGX/+PX+9rW1tux9rsafRVGpuo3eNQAo3TEoiN5beIH3lFj49qxDJjn0RKbLqYiLq5IjPWVrPQ91ql7axq+jtlatKgOIWir8dbP2sjRrkf1re2VUXZtYFw1D9fRCaAgwe5/HVgMQN4owwXHomzblc1/ZSRbEMhxKORAHAx8HO8ci2Nn0xt+CACM2Zn5lgCeBzx5nnAF/6lwzG+x4ApKacPVDW9Ig3lVSv0ASwz9iBiWHSpyPSmju7+m0hwjNfq9xFEb/+Sx2tVj2XGdkbC/r9O+sDIZMRVP5YZ2xdJN+ESR1IyVNwqLR6NzETsIi0eL29k/KSr6448K6ioda0MXO/4GUT43+ML/9JgmbEbkaR1LhFV039SrvYMxGB1LSud+zOeH+15VRmJRyPNiLFwMdkC/2OcxFyjVeADqJr+tqrplwHbIsI/1/+qIamzV1hm7J+WGWtxjJjDyUvA2pTn9UieoooiHo2cBbyKt8C/CZhTf+b879bp234HsatcgOygvNgf+BfwnGXGTnZWqj5DI1MW5bLVlZ1qX+nvg1Qpcqmo9KbxaOQ04I94p0+4FTh/LEZBOoL8YERNcQretg2X15AJ8/rhUv1YZuwG4MyUUz9WNf3y4bhXocSjkRDwB9Lb52ICF9a3tt3g9V7ne25BJtLjBriNgSRfu6XcaZ6rFcuMbYu4KLv0ITvGiitQVO1CvyLTmzqh74uRHPdZLwMXAddXulfOSOAMlguQ/EJlUf1YZqwVyTvj8qSq6YPZIYadeDTSgsQ5eAXEPQScm280rWXGPo04EOTy4Qd4A3EiuLES1VuVjmXGlgO7ppz6gqrpd5arPbmoaqEPnqu0b6ua/ptytScejRyORAt7eVU8Cpwz2muIFoNlxsYjv+PFwN4DXOp6/fxK1fRHS3TvzFVaDzC5XIIvHo2MR1wAL/F4eQvwfeB3xQRYOcU/FiDeVblY4dz/ukrZNVcDlhlbjCzoXCoyPcxo0OU9l/E8V8rYYSUejdTFo5ErkCpUmQK/F8mVc6Qv8L1RNX2zqulRpO7oYcA/kKyFmSjAicAyy4w9apmxY4aq91c1/UPE+8JlHFCWUPp4NLIP0qe9BP5LwCfrW9t+U2xErarpL6mafhqSfuIGZBLNZMtRmvwAACAASURBVCdkV/W2ZcYusMxYzopsPmlUhCwajNGw0j+adCPK86qm51uztCQ4RaT/jneuEwP4cn1r28ser/kMgLMC/wbw/xhY9fMsopP+V7HeKJYZewApOO9yhqrpNxfzWcXgFDb5LtBGdjZMG4mo/VF9a5tVyvs6eZX+G0msl8u2sgqpNPYnVdOrKnZkJPGwMa5UNX2HcrUnF6NB6OtAql/7FmDSSGzNHZ/pbyNbYTXjZRuJuF1QbUFWlUYBqp+XEeF/W6GJ3iwz9kvE4OnyM1XTf1BoW4shHo3sgKgED/F4eSWiEhzW1OGWGdsJuAyJrM5VpOdD4AfA3ys5kV65cMq5biB98tRUTe8uU5M8qXqhD2CZsQ7S8+vvpmr68uG8Zzwa2Q4xsh3h8fKHwFfrW9seHs42jDUcNc5hyMp0IJe45YhB8qZ8J3+P/Pr/UjV9IKPnkHHiN85FopIneVwSRbJhjpgHiGXGZiFJ2eaSvZBxeQmYr2r6AyPVrmrBI7/+sFZkK4bRoNMHeCXj+V7DeTPHWPsC3gL/emBPX+CXHlXTbVXTl6mafizia57LM+ITyO+w3DJj51lmLJfwSiWzDw2rPjYejajAnxCvoUyBvw44tb617byRFPgAqqa/7+SD3xFJ3eC1S90buN8yY/c69YZ9+hlRWVQMo0XoZ+rLh23AxqORucADZOuYu4Az6lvbvlLf2lbR5dJGA6qmP6tq+heAfRCjr9eWdTb9BslvONvvXCxHfKtdtrPMmFea6yHj1E24H/iax8v3AOH61ray5vVXNX2VqumXADsgwt/Li+dY4EXLjF3r2F98RnjxUAyjRegP+xcdj0aC8Wjkl0h+nExD2wPAHvWtbSNm+PMRHG+U0xFvlOuR3PKZbIcEOK2wzNglTt6mzM/Zgvipp5KrCEnROFXRnkHq5KayCTFan1Df2tZR6vsWi6rpHY7w3xW40eMSBbEDvGWZsf9xci6NZUZsAVoso1Xol3RLFY9G6oE7SDf0uUSA4/zUteVF1fTXVU3/ClKXYAnpq3aXZuBKYKVlxr7v1KhNZVgXD/Fo5FjgacQlMpV3gU/Xt7ZdU6kBe6qmv6tq+lmIWs0rPmIcEj+wwjJjF+epUhuNZPahPSotzcVoMeSqSCnBVK+DKaWopBWPRrZHgoHCGS9tRrwqqqpwy1jBMmPb0W+QzOVn3oW4Iv5W1fTNlhmbj7hGuvxZ1fSvD7UtjsH2IuA3ZC+0liH6+6pJx+EY1D+HfHefyHHZCsQb6JaxlNTN+W7Wkp56paKy/1bUDFQsqqZbiE42lSGv0uLRyCGID3imwG8HDvMFfuWiavoHqqZ/EzFIXolM0pmEkLTKb1lm7FwkpiKVUvShWkS19Duyx9sS4JhqEviw1aD+L+T7+X9IKpRMdgJuBp6yzNihI9m+cuJMcJkqnooy5o4Koe9QUl1aPBr5KrCU9Lw+IGl496tvbcuMvvOpQFRNb1c1/TvALETAr/e4bCbiHvnLjPNhpzBMUcSjkUak0E9m3V0bqfr29VIHW40kqqb3qZr+v4jB/EfIbjuT/YFHnaypFV0wvIRUtDF3NAn9knzR8WgkEI9Gfo7kLc/US96CrPB9/X2VoWr6GlXT/xvYHvgxksAtk0xVxQSy9e95EY9G5iD6+yMzXtoAfL6+te3KStXfF4qq6RtVTW9Dvqur8U6f8QXAsMzYjwbxohoN+EJ/hBiyMTcejUwCbkN0wZm0IS6ZfmHpKkbV9E4nbfJOSEH6wVbaXvnrB8TJjvkMsHPGSyuBA+tb2+4u9DOrAVXTVzs+/mHgnx6X1CETruEUpR+tVLR6Z1QYcgEsM9aEFCVx6UHSMeSVH9yJsL2T7B9oC5LC1stdzafKsczY9kjqhrNzXJJADLA/y8cxIB6NXABcRXYem8eBU+pb29YU39rqwjJjhyDV4g7IccktSFbcj0auVcOPkzZkA+mL6oZKya0/moS+guTgSdXBf0LV9Ezf6yzi0ciBwO2kp3IAMVCdVN/a9kzJGupTkThlExeRe2VvIqkdrvJKOhaPRmoQg/FFma8h6R3Or29t21Ki5lYNzrg8G9lV6R6XbETsAb8bTWmcPXLrl73Oh8uoUe/ksJoPqkuLRyNnI+mQMwX+S4jB1hf4YwBV019Aym1+M8clGrJqfdMyY19O9b2ORyMacDfZAt9GVIWtY1Hgw1ZPn+uR+Infkx05PRExoL/g7AxGCxUbpDVqhL5DQQaUeDTyAySKM9OP+3bgkHyrEvmMDpyFw1/wNkS6bAdcBzxvmbGj4tHIDOBJshPAbQROrm9tWzRaDLZDQdV0U9X0i4D9yM47D2IHeMwyY1HLjGV6zFUjFWvMHe1C3zNwJB6NKPFo5MeILjeTnwGn1be2DUs9Vp/KxlHdvJlx2qsv7G1v3vAA4ya+RXY/+wA4uL617Y7haGM1o2r6c4iO/xt4e1Cdi+ymzq+0SNYCyUsWlYNq/lK9yKxK1ZR5gRMd2YboEVOxgK/Ut7b9oNiqRD6jhsx+dD5izN2qc7Y3rcd67Hbo2ZiZx+cpRC3oF83JgarpCVXTr0FUPn/1uCQEXIMEdu07oo0rHYPKonIx2oT+6oznaXp6R+D/FKkRmsp6oKW+te36YWybT/WQ2Y8mqJr+bZykY/amONZjt2NvTK+NEZg2q6fu+PN+P+7ki2L4DIqq6TFV089Fks+95nHJfsB/LDP2uypM5DagLConY0boOwL/50g+kFTiSCh8RRU68Ckrnv1I1fR3e26/6rItD/y93d6U7n0XaN6R2gM+O04ZN+F64F7LjGX66PvkwClwvw9SRzozDiYAzENqI5ww0m0bAutIz/iqVUqt4dEm9LtIz/s9yTJjEx2BfwXSqVLpBo6ub217eqQa6FMVZAr9JoB4NLIjsIxkojn1xcCM2dR++liUwFbX/GOQAKTLHZ9tn0FQNb1X1fQrkN2UVy2B6cBdTu5+bWRbVzhOfFBmTEZFrPZHldB3vC/SBqyd6JuG1KrNTItsAkfVt7Y9O0LN86keslb68WhkJ+ARxHunHyVwS+0nj/q5Eghm+pirSNrtV0d59GlJUTX9Q1XTT0WyeL7rcclXqZ6I3sxEdL7QHya2DljbtrGW3vA/wCUZ13QhOnw/aZqPF2mDNdm9dhaSAjmzOtT/YSfPqpvSfBkSye1VInMn4N+WGbvFMmMzh6W1oxBV0+9B3Dh/SrYL7QzkO/2TZcbqR7xx+VORev1RK/Rt26bvlUexN3afnvF6JyLwXxj5pvlUCVsHa3J9F9YTd+yDCJpUrkfqKfQBqJq+HInmPZvswQ5wKvCGZcb+yzJjmZXXfDxQNX2zqukLkEydXoberyM7qYLzI40QvtAfIVbbtk3fy8tIvPtq5mvrgCPrW9teLEO7fKqH1eAI/Mdvhy2bazJe/xuSjyltBepEn/4fope+iuzSjW706fOWGTt4eJo++lA1/Xngk4gjRuZ3uh3woGXGfm+ZscwC8+XGF/ojgZ1Mru576RES72XWw2AN8Bnff9onDzqT8c6E+OFnJVW9FjgvU+Cn4kSfzsNxOfS4ZA/gccuM/cUyY1NL1ejRjKrpW1RNvww4mOzgOYALgZctM3bYyLZsQDwdAsrNqBL68WgkYD166+GJlVk7wRgi8LOW/j4+mfTcftUnrMduU9iSJfCXAHMHEvipOCvUA8kdfdqKRJ9+vcqjT0cMVdOfRtw7f012Hp8dgWWWGfuNZcYyg+bKQUUackdNls14NBIE/hcZSP3U1m2hd8u+9a1tr5elYYOwetG8cUjB7hkpR7NzjEfq/tYgqXprCny+EanXuc55zDxSz3dOm7941GQ5LJZ4NLIHXhXTJky+nU3rTys2WtsyY9OQLJ7n5LjkMaBV1fQVhX726kXzFGAK2f1oBjCVofUhEDuYV5/x6kvrp81fPCJCxUnQdi3ehW7eBs5VNf1J59r9kBidDuB7I5Hm2DJjRwP3p5xapmr6EcN938EYFULfEfh/IXNAjZuAeuAJL4zbPvzJkW7T6kXzAsiASxXkmQOyGRmslYJJ+kB+F6kbawCvTZu/uCLygQ8X8WhkL+BB5HfbSnCHMDV7HPqFuinT7xzqPSwzdjhSM3c3j5c3ApcCf3SLiedYFGT2p2ZyF38faXpJ70Orgdfp70fvTpu/OK+dUj5YZmwiki/rYo+XbSSlcxtSqN2dyB8GWoa7YLtlxvYkPdvmG6qmlz0HT9ULfSfwagmZK/xxE1EPOYnA5NA7qqYPa3Tk6kXzxiNZ9PYB9nUe96ByBmKp+ICUScB5XD5t/mKvouNVRTwa+QSy2k6bhIM77kHNnoehKMrXVU3/cynuZZkxFXEj/hFSkhHbtrE3rqdv7cf0rXpvxZY3X15Bn/UJst1Eq50e0icB9/hoKDsEy4wdgdQ53t7j5beQKmZKyrmvqpr+t2Lvl2ebppGu4ulSNb1xOO+ZD6NB6P+MzNQK4yaiHnoygUkawAZV0yeX6n6rF81rAPamX7jvi3hrFF1Au8pJIquozEH8drWoi5z0yE+RIWCDO+1JzR6HoigKwA9VTffKylowzi5wp+CUaUcFp06/NLkxvmNibQd2ttF4LBEnvf+8BhjT5i/OO4+R471zBdmF6EFW/alCfy2wSz7V0IrFMmNBJJFjqr1mnKrpZa2tUNVCPx6NzAN+l3H6I/XoL08LTNJSfaEnqppe8IhavWieTrpw34ciC2UPQBIp89gOrEo52pE0EX3OkSjw7yQwCVFVuMeUjOep5xtJHxRDxUIE6QOIyuS5Um7rS4VTAOUxJBBoK4FtZj5ae/AXDnMEPkjFrHmFfv7qRfNqkLS6qf1ob6BkCxGHDaT3HffvDqTkZzF9KIEIrEa8+4xXXyp12olVSP95EHhw2vzFmcbRLBxd+hIG3yX9WdX0rw+9iQO2pYN0A+52qqaXtU5H1Qr9eDTyReAmsmfvg8adfNHDpAfT7Khq+nuDfebqRfOagWOB44BDEF3pkJpJuiDPHJCrgNWVIAxXL5oXRFLauoN3OiKsws4xh6HtZkxEl+pOAu/k2s6vXjRvdyTlbj2wcNr8xcOyDY9HI+OA+4BMN78/1Z104aOKEkjNuvoPVdMzA/2ycIT8/kg/OhoR8OOKbqSioIyfmCSZfNfu2WSQoz9Vir1l9aJ5E+ifELZB1C1uH9qDDHtJERj096FHp81fvMHroi1rV03f/OzDz1vvvT69ZptmJhx0HIFJnsG7w1rG0DJjL5NeQOXTTk2BslGVQj8ejRyBDFY15fQm4Ij61rb/WGbseWRF5XKg4+qVxupF8+oQ4e4K+j2G0Kx3gReAF93HafMXe0VmViXOd7ULsDv9gziMuMkVw/vIwH0AeGja/MVbk1OtXjTvESTdrstCIFJKrxDH+H8TEimbyh3AaeNOvugIp20uj6qafjgerF40b1ukD7mCvtg0wJuUiZNXq7PmbBucOr0mOLWJYEhHCW6da28Cvqlq+roiP7/sOLvncMaxOzLBF0ov2bvJPoCNrz758IZ/33CEe6EysZ7Jx59FsDGrTO9rwD7DVZ/XMmP3I33C5QRV0+8ejnvlS9UJ/Xg0sieyHU/tJH3A5+tb2+4FsMzYPcDxKa+fpGr6HQCrF82bjQj4Y4EjcQxpBZAEltMv4F8EXpo2f7GXH/aoZ/WieZNI3xG4K7rpBX7Ui/RPApcj/u2p/AU43x3UQ8Ex/i8mux7uk0gSvs2WGduD9OpHb6qavits9ag5lP5+tHsRzTDJWCQAb02bvzhhmbE5yE7nAI/3rQa+rmr6XUXcsyJxXE5n4j0ZFOIM0Y2zm5xwxImXb3rkzrRdhaKOY9JxZ1DTtF3m+65QNT0zA29JsMzYdcCXU07NVTX9L8Nxr3ypSKFvGMYewBeQYtQfAdeFw+F18WhkFjKzZwqUr9a3tm1VAVhm7GbgiwB2r8Xm/zy8aIvx7CRkgBaik7eQgZ86MF+dNn/xmLa45cPqRfN2AI5yjhYKc021ED/xzIClu4Ezps1fPGgpS8MwVOAsZELaAjwD/DscDtvxaOS/kUReqSxH6iJ3AlhmbAecLI+2bZPsWvtR/JZrrkAE/REUprv+mGwB//5AOxfHCHgp4m6oelxyLXCJqundHq+NCpzd5YFIHzoa+BSFBJTW1EJfxgI+WMPEI09G3WHX1LM2YtR9O/MjDMPYGTgN6b8dwN/D4fDH+TbBMmNXk25YvlDV9Kvz/h+GgYoS+oZhNCORdiciHT2IuHglano2XDn91XtOU8RTJpXv17e2/cJ9snrRPGXS58+5N7F61TG9H62gr+MDSOYdT5NEhMO9iProhWrxQKlkHG+VvZGBexSySi7WnfUZ4IRp8xevzXWBYRinILlvJiPGbBvxgX9Lf+ORf41bH4tkvGUVcFB9a9sH7omNrz61u53oM3o/XEHfRytIri9oI7cWCcq5F1g6bf7i9kLenIqz4/grYgTO5EPgPFXTHyz286uJ1YvmhYDP0D8JzC7qgxSFCQcfR91un0o9u0DV9K0LAcMwpgL/g6zS3WC1LYiMuBL4aTgcHnTxN2qFvqIoDci2fDfgANu2sxLfDIZhGNsggQxTgawshNqHL/fWd7yZef53wCX1rW326kXzdgXOdI5dCrh1OzI43QE6bC5cPoIT13Aw/YN3HwrzHPoYOHLa/MVvZL5gGMaFiNteltpOSfTaM166Swkk0zRE3cgK33DUNscjfehE8jfAJoCn6e9HL0ybv7hkdZYdv/4fOIeXMf1qYL6q6Z5GzdHK6kXztkd2kUc7jwUZidVd92HCoZ9DURQbCKua/jqAYRiTkR3ZdnjvsjYjOZVawuHwgOrG0Sz0axFVzBXALwsV+oZhKMBDwEF4f8lMWfEUEzvTPJ1u3ry26zJsTkcG6V553s5CbALuAH1tpMLGfbxZvWjeVMS+cp7zmE/q4T5gt2nzF2/dkhuGsQ/wBDlUL8Etm5jxyr9ST22xk8nje9Z11yF96GTyNyh+RPpiYdhtOpYZ+xSy6veK5l0BnK5q+phMGe7sJvdCVLgXk6dNKTh1+pr6U752pqrpD7nnDMP4B3ACA0/6m4Bfh8PhHw70+aNW6G/9MEW5luKE/vHAzchW3BN1/Vr0tx9D6bPo3dTzSmJTz2bENW5watUOeq1bkAH6SKZOOGEsDTj3rh/gmIQIo2AJDgVRW2Uem3OcH+j1bqArGG4pu9vnUHBcRtdRmOfLDdPmL/6S+8QwjOcQry3vXYNt0/jes0xa9z59ieSWvu71D9uJ5KfJx94QCNokEw/SL+iXl2OxYJmxcYie/1Ky/08LifS9ZrhTDFQqqxfNuwDZ+RRC0N2ZGYaxH7IAnZjH+3qAHQfS8Vei0M/ME+6Joig7IQbN2bZtf+ycOxtZ2e9v2/ZQgw3OYZAv2Zo8lVV7HE/oiduTwU09e2ZdEAgQUOsI1NWh1I1L1k6bGaiZ2kSwIUTA7ntR6d08CVlJXpIwlnoJ9GrGThhLu/BOipXr70qbKJLk2OUNwNZ0qoZhTEM8PnKriRSFzh32Y3NtPRNffaxOwR6w5J4ysR51+12o3XY2NdO3+6Bum5nHFNi+kqNqeg8w3zJjdyCr/lTHBBXJ63OEZca+PhJJxSqQvGRaCj0ZqrizyN/elEDUgH8s8J5lJa8vyLbtFYqi/AtZRXxPUZQDEUPZsUMV+IZh1CBbqUF1ujXrO6np6wmM33lXgvUNIuTVOpQ6lUBNmkag38JvrYd0983RiIJETTYiQVT5kDpRrENcAVci/vOpj2Yw3DLsq8Zp8xfbq6+4eK5SW/crO9E7nUQiQfqOxg1dn4j8vvcjibZcTkRUPgMPWEWhtmMlSlZW3q2sBm6unTVn2cRjTr8lJSK3olbOqqY/YZmxvZCEYudnvHw6sK9lxr6oavpLI9+6srKEQPBYpbb2OHtLj2t8Te1DW5A+MhEJntwakeuomc8k/4ljIrJgHX1C3+EXwEOKolyHVKu/wLbtUhQV34M8B1Tf5ClM3mc/1Cl+3YkSkDpRDMT6hLE0cyJIfVxTiknB6mwfH5r7/XOA6bZtW4qiPIfo5x8HnlQbm3N66zicSH5bcvpC06hb80HqqS7gFuBGYJnjK79Dwf/ECKNq+kbgAsuMLQP+RPqOdTbwtGXGvgX8aayoe0Jfu+xgxKW2xrbtdkVR3D70BPCy2tg8kOF1JoUH1u1vGEYgHA6XzHA/3OQt9G3bfkFRlGcRl7lf2LZ9U+rriqLcg7jl7aIoyh9t2742z48OkV0CzbsNtXXUNG7DMC26NiIzf65jA6IzTZTgAFltjHOO8Sl/D3RkXjce+f6KjQDNh8n0B8t4sdmZFNyJYAWidnkN+KCACeEIxAceRVFUxKh/EPBdAKuz/U0keOoN4B61sTnTbpT3SmDzTvsQ2n0fJoRCSWy7i2DwOUUJdCODfi+rq2M5SvXUNFE1/QYnCv0fpIf81wHXIOqe88eIumcBzuSnKEozEq/zRee1jVZn+9PA80j/vFltbO5JeW8IifItJAbDdq4fNHakUshb6CuKEkAEVhJZ9adh2/Zni2xDQUm+khM1Apu6ss7bAIEaCAQTBGoSdrBGdZ6j9G6+TulZv4wBBHqF6bcLImEsraU/KVZqIqwpA5zTSnT78UjsRGb8BMguwZ0AUrMndnhMBoNlU9yFflfcX1id7X9TG5u/mvJ63v1o0oRxTGycDKImmkJ/CgWXJHZyZcbHVnQWVVXT37LM2AHAb4D/l/HymcAnHXXPaC8XumaA1yYirp1uIfU/WZ3te6mNzW75xWITDlbPCoHC1Du/QgTF28DZSFh8KTAp4Mvum6SjTAxBohcCQRH0wRpQAiD6V9dDZis2nIFk3HvcOV5TQ02jZtUTDLf0IrrovHP9JIylNaRnT5yBJMealfFYfLIw2SUcQHY6gU5nMjAAw66b9DEN06ZQoz6MRGDmc8+zgVShn70SKJ4AW3MKbZ2btrW6OlYi7r5uP1quhpoqZluvavpm4HxH3fNH0tU9OwPPWGbsYuB/R5u6x+psr0E8t95AgtZmMrhcqUNqGrgeYN0UbggOUEWrfMjfe+d8xId5f2Qb/mNFUaJ2afw9XyU/v2wAVndvZFpo0qZadXwhOXNUpN1HOM+TVlfHy/QP3sfVUFPRUZPVSDDc0oesrnOusBPGUgXJlJg5EaQ+Fpwi2A7UNNp1Ew5FnXCoXTcBaooKzs0MRLobyZY5aL9Yv3kLEzbW9tZPqFMURSlkkM9yDjeXSqfV1eHqjB8HnldDTWXNlQ6gavr/Oeqem8lW9/yRfnXP+rI0sARYne0qkpbhcOc4mOK88N5K+ft9xC26ENnyUjXp8yEPP31FUY5CsvsdYdv2q4qiBJEv6r9s2/5nKRphGMbtwEl5Xr4euGDOjKkP0Z/cy33cncITqLm8S8okALyhhppG1Wqo1DiTgkb/BLADouZxk2U12ADBWmx1AtRNkMeaQj0zs+gCTlQbmx93TxiGMRPZhea7M+ncflpouloTnEN6Hwo7/0cxbAGepX838JQaaipbIj7LjI3HW90DMoa/qGr6Kx6vVRxWZ/s4YD/6hfxBDC13v40sFE5UG5u3jnPDMK5GPHryUedtAi4Lh8OZNT36212BfvoDCn1FUXZFOu85tm3fk3L+m8CXbdvOzIRYFE6ulL+SMVMHAtAcqmfCuH4hsanHSlqJxK76zB2ykiNZXR0BYHtQ/gYcPESD7zrSJ4EX1FCTNZQPHAtYne0KMBvbPhw7eTyKcihKYJtB35gPyQRKPGYrm8zliqQ9cI/Xg+GWhGEYBh4ZL7360Rarr71OrdlXDTVlqcSsro7JQAsotw+xD9nITnarSkgNNX00lA8sBsuMnY2s8DO9m3qQ6NU/V5q6x+psH4+o+lwhfwClKz96H/CtFF3+VgzDOAyZDPKSRRt7rE/P2GF2zijoqhP6I4VhGAFkhbQXjsopEIAdm6YSVOsIjpuEEqzBTvSR6NmA3WttAXuW14CF9CybyP93EdjdSKKvQ/AOYx+MzYiAuRO4TQ01fTDI9WMCR8jvgqjODkdULIUVn7Ft6O2x6duiMMHDvmzbKBu7UNavQbE9d9LrgWd7qFm1holnbEatSzi2tWL7UWqWTacN74P9ZaT/HIqoE4rxmnLrCNwGPDhSCwnLjO2CePd41Yz4O3BBOXP3WJ3tk5DVuyvk96MAta9DDFhGf6rvTN4Fvg3clbq6T8Xx1b8X6c8qDFkW+UI/F4ZhbAu8hKgLAjOn1DNx8mRqJmqkBMhg2zZ9G03s3i3L1FDTEV6flSb0hTNUTb956+tdHVOQQXuIc3yKwjvYs8CtwK1qqGlFge+tahxBvwcSvXgm3sWoB/wI5Ptb5hxPBtuXb0lMmXUhdRN+m3bllk0EujtQ+gpTlVsE2UQt6pQZjJvcUHA/yhL6sFLV9K1qH2dXuTv9k8ChiPGwELqBu5B+dJ8aahrWAvOWGZsA/Bb4msfLrwMnqpo+Yn3Z6myfiARmngl8lsIjstvp70PLgDfVxmbb6mz/DzKmXTYjgXy/zHDR9MTJsPkyoAM1Q5RFvtAfCCd39R+B/efMmDqhZvKUzEhbAJJ9vfSt77TV0DRPV6nBhH7W9V0d45GVhTsJHERhlXxeon8CWF7A+6oKq7N9Z2SAunnq86UH2SW5g/NptbE5S8A5xrn7kFXWB9j2ZYGP33hZ6fcAOgARtHl7eyVm7E4x/Wgwoe+F1dWxHf2TwCHkjm3wYiOiVrgVuEcNNQ3bqtsyY19G/Pcz1T2dwGmqpj88bPfubK9D3GPdTKZ5BdQ5fEC6kF/htWK3Ots/h+xeJiE7qkvVxuaCdubOIvT3wFFzZkwdPwRZ5Av9fDAM4/A5M6Y+UqtNS5tZXWzbptdcjRpq8hz8hQr9rPd3dQSRlaw7CRxK/iqL5Uh0563AK9VuDLY627dFXF7PBD6Z59s2IYFU7uB8Vm1s34Bd7gAAIABJREFUznupbnW268AarwHt5E3aj/SJIGfCtMSM3RmsHwVXvVaTGadRjNDP+j+6OhoRvbQ7CXya/FazPYiK4VbgLjXUVPJCKZYZ2xVR92ROTH3ARaqmlyy1gONOeQSyWDiF/GNE3iVFyKuNzSsLuOdEQFEbm4c0eRqGsd+cGVOfGYIs8oV+vlhdq5M1kxuVImfXfwGfSzl1sqrpRXsaWV0dCuK3/QWkpupBeb51Bf0TwHPVMgE4Qvc0ZJAeksdbepCB+Yjz+Lza2DwiumrHg2gnRPgf6DzuheN9MfhKfx3BVa91IZkV7wceCIZb3rPM2O5IHIHLW6qmF1KnIQurq2McYvM4BXGBzirY6kEvUqviVuAONdRUsvq4jrrnz8jvnMlVwLdVTS+qPKXV2R5Afo8zkVxA+fyv7wJL6RfyI2709mKIsuivSH4el6+pmr5kmJqaFxUs9DseUWrrDi9Sj5ap0ztY1fQnS9i2GcigPRUZxPlE5H2AowJCXPkqyrfX6mzXkP/pLCRicbD/qQ8RkjcAd6qNzRUT7JYwlk5AVtVHJrbZ8RJlolafsx+t7yS4bmXmR6ywa9TXkw1Nn6dukgQBwuOqph9aqjY6u8lDkD50KvntJBNIDdhbgdtzGQ8LaocZU4DLyC4fCWJwPl3V9LwC3xxbz95IHzoDKUIyGB8hLuE3AC/kMrCWkyHKontJj/Y+sdz1jStZ6E8D5X2lVq3zsJj3gr3tABbzD5AIXJfZw2Wgsro6dCTG4FSkAEg+wT4fA9cDf1BDTSuHo135kGJIOwvJRDqY6sFGVvM3ArflkQSt7Eg/4n2lti67H1k9KB1vEkjmzsBhA9RNxFYnvBRYv+aEYLhl1TC0MYAEProTwPZ5vM0GHkV087eqoaYhlfW0zNjJwHVk69jfRgRVVpWyre/tbC+0at0aRLV0I/CE2thcUQugTAaRRX1gzxxAFr2ITIQu+6uaXopElUVTsUIftg7Ym0A5DGxF7Hc2wPVqqOkrnu+RlUsP6QJs8ki4ozk63M8jqpFjyE+I3gUsBpaOlPrH6mzfEUmTfR75GdKeQVZi/1Abm6suctnpRzc7/Yit/Wjt+0uDWzbsiyTaypenEOPgbcFwy7uDXVxEWxUknYA7AeSTKvtjRPj/SQ01dRR9b0nVfCfZK/RuxC5239ZrO9uDyGLnUrLTbHgRR763G4CHBsl2WXEMIIvuUUNNn8v5PjPWTnoVr+1VTX9/eFs7MBUt9F2sro6jEVWCy1tqqMlzRWGZsRDiheCyUdX0ES+SYnV11CN2hVMRd7TBogeXI3rUvw2X54bV2b4fMkhPZXD1zSvISuxGtbH5veFoz0hjdXU8gNTldflacNVr1yJC9mjnOJj83Xddr63bguGW10vYVGDrBLA7sog4lcG9gXqRFfRi4JliFhGWGdMR4XxwxktJ4Dsk+/4MnAt8h635iXKyGVnU3ADcm4+7ZKVjdXXsi2TpdFkH6F7qWsuMBRD35NTo3vFOIZyyUS1CfxKSmC31y5vutapxvBJS3SbfVTV9p8zrRhKrq2Mikjb4VESdMlC+mjgQBX6vhpqyoo4LvrcY1E5AhP1gOul3kAF6o9rYXHIhVm6sro4fIqUGXf6mhppSk7aRMJZOBA6zx9dfQe+W3QuID3gDZwcAvDAchWesro459O8ABvOkeg4R/jcVmg/IMmNuSuZzt560bbCTgO0WIclFL+J5dCNi6xlVxdodW0wn6S7dYTXU9FrWtWZsG9JzW3Wrml6q7LZFUxVCH8Dq6nia9Jq4Z6ihpiw3TMuMHY7onV2eUjU9X2+bYceJCTgLmEe6rs+Le5GBe2+hhl8njP0rwH8xsIqgA/FprlhDWqmwujoOQzxDXFaqoSZPN0zLjN0DHE/vFpSeOMr6NW8pyUS+VcneR4T/rcBTwXBLyXXWVlfHrsBFSKbRgXaya5ACK9cUkgLCUZN+B9tehJ0M5JGO4iHg/4Db1cbmzsEurmasro67kd27y4VqqCnLDdMyY2EkDYfLkD3ASkE15YF+NOP5YTmum5bxfMgeDqVEDTVtVkNNf0FUCocgngu59JvHIQE7b1pdHZdYXR2Dhv1bne1Trc72CCJ4/khugW8gK7lZamPzpWpj8/OjWeA7PItst122dwKqvJB+VFuHPXkbks27fRXRdX8LmTgGEuSzkHD/x4FVCWPpHxLG0gMd99KSoIaa3lBDTRchKbG/hRhcvdgG+AGw0urq+IfV1XGYozbKidXZrpDsO4xk3xHYiYEEfi+SYj2sNja3qI3NS0a7wHeoalk0GoV+U8bziviiM1FDTbYaanpCDTW5aQx+Qu40x7OBK4FVVlfH1VZXR1buIKuzfWers/0PiGvo5chg9+JBZDLZU21s/utI+dNXAmqoqQcxSqeSS+WVNWCD4ZYPg+GW3wXDLUcgxrn/h0QQD2SUbAK+gVP1K2EsvSxhLC00XUNO1FBTXA01/Q7JbuouErykdBCxDSwDXrK6Or5mdXWkZaS1OttrrM72M5DJ8RFELZgDBZSgRaDmDrWxOUu1McrJkkU5JtKKFPrVpN4JIUaT1C93ihpqSltZWGbsp8B/p5y6XNX0Hw9/C4eO1dVRh0QSz0OiTgfiIeA32Ml1iL7+JHKnJ+hDdKy/Uhubx1qh7DSsro6FyMrX5U9qqCmtsLij2thCukF3oqrpm7w+M2Es1RABeSoieAdL75xEAq6uBe4IhltKmnPH6uqYDVyIeGcNtDvsApZg2/8L9mcRj65ZA1zfgxIYJwI/rWD8ZcCiSsvUOVxYXR0q8t2lTpqzM3NwWWbs28CvU05dpWr6vBFo4oBUzUpfDTV1IR4lqXhFi1bk7JoPaqhpixpqul4NNe2P2C+uI10dIdg22PaR2Mk7kYLPJ+Mt8NcDvwR2VBubvzLWBb5DPjvGEOkCf0MugQ8QDLeYwXDL9cFwy8lIFbIvIjaSXEVKAkjAzg3Axwlj6TUJY+kBpVL/qKGmd9RQ03eQBHDfQEpUZmPbIezkpWC/iewkcwn8/wCnowRCKIFrSE9HoAA/B66yzFhFl5QsFU5m1KcyTnv1o4qURVUj9B0yo2q90sRW5BddKGqo6Vk11HQOokf+IZJR0EkV7R45+QhZ/W+rNjZ/V21s/nB4W1tVZA7WOU56hFSKVhEGwy0bg+GWW4Lhli8hqQe+gBh0cwVPNQDnO+16PWEs/V7CWFpYauocqKGmDWqo6RpknBwJ3A4knUUDeRhn70SE2f5qY/M/1FBTj6rp3wC+iUQHp3IhcIPj+TMWyEcWVaSqudqEvpHx3CvT46gQ+i5qqGm1GmpaiJ08GDv56OADVXkclM+ojc2/UhubS56oq9pRQ03rESO3SwCpH5tKZh8qKuApGG7pCYZb7gyGW05D0ixcDOQsuIHo5X8OfJgwlv47YSw9PWEsHUqNYmCr/ehh7OSp2MlvSm2JAfvRRlB+gBI4VW1sfizTwK9q+h+QnUpmVbAvAndbZqzgEppVSNXKomoT+plpi72KoVTk7FosVmf7BKuz/UfIFj2X8RrZZSugKIegKK9ZXR1XWl0dU0eomdXGYP2o5IM1GG5ZGwy3LA6GWz6JJIS7EnGn9CKA2AZuQtQ/f0gYSz+V49q8sDrb90WMuFczoJ5fASUwEUX5KfCK1dVxkpeRUtX0pYgRPDNCuwV4xAnyGs3kI4t8oV8CMgOGdnXylgBbDXAlWaWVG6uzPWB1tp8NvAn8GO/av4+D8gJKQAxr/bpWFTHKvWt1dSxwgsN8+snsR5mrtGEdrMFwyyvBcMt3EHfLLyBql1weQBqil/9Pwlj6VMJYembCWJp3wR+rs3261dn+FyRYy8tTqQu4G5Turf2on084bXvC6urIeq+q6QaScTaz7OC+wBNOeurRyluku+1u5wSRplKRsqjahH4M6aQu40k3PjWQnu9mUzlLwBWL1dl+AKIzvB7vakwGcLTa2HwoivIppBiFl7FuMuIK+o7V1fENq6uj0Opgo5URX+l7EQy39Drqn1MQ9c8lSMWmXByAGH9XJoylP0gYS3PWHrY628dbne0/QPz3W8k29CeA3wGz1cbmE1CUnYBfIV5LmRwIPGp1ddxldXWkpYJw8sgcgrh5pjIbeNLJ5zPqcKKcM5M47ur+4aRgyNzt+Cv9QnFyiQy0SqvI7VS+WJ3t21qd7X9HjHr7e1yyBinIsI/a2PwgbNXX3oWoDM4FvIy2TcAfgNetro7TU3dHY5SyrvS9CIZb1gTDLb8Nhlv2BvZByhrmymLaDCxEdP9/SRhLt0Z2W53tiuNr/4Zzjdcu7x5gD7Wx+VtuMJUaalqnhpouRYL5rsU7+OwEROVzrdXVsXWxpWr6WkStc1/G9U3Ao5YZG0AtWdUM1I9CpGfcjZc7545LNQ7+gVZpVSn0rc72iVZn++XINvlLHpf0AlcAO6uNzX/0ylCohpoSaqjpr/+/vXOPc6Qq8/73JN01w2WgKzP0hAxoI8wAUtxEkIvLLSA3uXhBxQXau7wsLuiCjTe8LUq/K6y6IiqK24y8orDclpVRaGRwRW7CABlBBoZmYDKZFpIWGJip7uS8fzyV7qRS6U66k3TSOd/Ppz/pVFVSp6tPPXXOc57n9yA37b9QLDqXZzfET/ygm0nFa/YHtB7+PrS7m0kV3qCz2o/CTnxV2IlfgLh/3kux2GAh85BR/KPZxODK0ece/Txa/wHJyQjKNH4SOMGKxE6yIrHAsp6WHV1n2dGPIoOIIN13hUg/PO1mUpd79abxZtSnIFIMhWwH/M4dGT5tkj+5VWlJW9SKRt//dC280P6O3jQXOgjPb38W4h+8hGAlzpuBt1qR2Ocricax7Ohmy45egVST+haidOjnAOAuN5P6nafh0lZ4OR+F/tVO5Hrl8fejWfHFhp24G3biN4ed+HFIP78KKUVZhA51kOva8XC9/eJ+lPKrY4IMAM5DsrBXVHJuy44mLDt6CrIOEFSAyEKUNte6mVSfm0l1Wl3dLqL39F3fsfOA/3JHhoMKsrcyLWmLWtHoP+17X3hx/bGyZQs/zDZuOnkoUiz8WoKrJj0GHG1FYu+1IrFnqv1+y46OWHb0S8jo/seUxlWDSAmv8m7aSoq/zCUC+5E7MmxR4Jv18C9UNpywE38y7MTPRUb//wIMaaXIbbuIXPeu6K0DxBu1zjE2ei3it79yOhr2lh39X8RnfyqlRg5kJH8Z8ICbSe1jdXWLBLNk6RYSAq52R4a/6AVczAVa0ha1otH3PzELwxL9i0aTLYrNCp4r50okk/bAgEOGgU8CB1iR2O9nej7LjiYtO3oOost+Y8Ah85Cb9j43k9prpudrIfz9KL8ougfF2bgvWl3dTSMi5mX/XpGN7n5mbvGylN5uBwgF3MabXyU0vDYUHn7m7HDyyRuyicGTs4nBad3v3rrRbcA+iLRDkFrn/sCf3Uzqq+hcp9XVfRnwCUrXBi4FvuctdLY61dgiv5rArNGKF94f21wYwbCPb1/TXGgYL2LyCJK9WLIbMb5LrUjsp1YkVr6G3zSw7OhfLTt6OrJAHPQwORB4xM2kvtAmo/5y/cjfh5pq4OCmk51uOvlNQqF7CYX8OSkwupnQy+sIp19EZccVPOJIdu3j2cTgGdnE4LTkErx1o58j60YXURxJB7Jw+TVkzWg/rwD4e5BKdoV8BrjOm1W1Mv6F9h0Kchqath+1otEPvNBewYLCsmQupdOvWcFTL7wE8Y0GSR3fCOxpRWJfqHeBccuOPogYgTMQAbui3cg6wP1uJhWUVj6X8Pej/CitaUdoXi3aPwFfpvTefYns6IWhvw19UW3ZVE52Yy9kofUv2cTg2dnE4LQe7p48+HeQvnx9wCH7Ag+5mdTX0bkVSOlQ/3rUh4D/dkeGG17VroZsoviBNg/Y1pOi8EeEPUGT0HJG37KjmyhenOxE/Ir+J+tqq6t7RsWia4GbTi5FdNW/TnHlL5BKVUdakdjpViRW83qr5fCm69cjRuCmgEMOQKbqX57Dsf2VjvRn3eh7YZjnAY8SXDHrh8BSa4c3X97hHP1tpIzh6Ui/C2IZMAD8NZsY/EQ2MTitEbdlR1+y7OgZSISR39XRgQQnPIzObUIWhDf4jnkXMOiODM96Nanp4IWQB/WjPSgO13zB6ur2z4pmjZYz+h7+C72IJrtZvRv100gd1aCY+x8D+1mR2MqAfQ3BsqMbEY31D1I68u1EErsecDOpuZhg0xLuHTedjDFRQc2vw7MBON6KxP7JisTGdXDCTnzME337B+QhcR3BcfdvAa4G1mQTg+dOV+fHsqM3IwOI6wJ27w08iM59EK2PpHT2fRBwZ6safoJnjE3Vh/zMFaO/A000LXfTyShwO1Jn1C+fMAy824rEzrEisU0Nb5wPb9T/ayTcrKT8JLJA97CbSX3V0xGfK5T0IU8vptBPvoXyFanqjptOno64Bd4VsPtGJMHKnxBVRNiJPxJ24mcio8+fExzF9SbgSuDZbGLw/GxiMEjyY1K85K4zkboO/hDXMPAl0Dehc+chkhCFvB0x/Ha1520CmtoWBTGXjH5TPF3ddPI05EY9MWD3rUhpuf9pbKumxrKjf7Ps6AcRt4D/+hYu0O3f6LbViUr60Gqrq7vqMMeZ4qaT27vp5HLkIRzx7X4FOBv4gBWJ+ddkyhJ24mvCTvxjiKLoTwiWeo4hMfbPZRODF2UTg1X72y07eisy6r82YPdewAp07l609rueWtXwV9KPjNGvAf4QuoVIhyqkoRfaTScXeMJWN1McugXwGvBx4D1WJFZOWbEpsOzojcio/5cBu/dFDP835sCo39+HumiCkF83nTwC6btnBuxeiSRYLZ9uPeOwE38u7MQ/jSSj/YBgrZ1u4P8yofEzZW3mQiw7mrbsaC9wMqUqnCHgc6AXobW/qM8BtJ7hb8p+NBmtavT9U9QdKRZa22B1dTfMuLrp5DuRf+xHA3b/EdjXisSuaZXC494C3Ycpv0D3FWSh920Nb1zt8PchxSyO0Nx0cp6bTv4bEk7rz+Z0kRDJuBWJPV/y4Wng1fv9DLALIvMclLm9ENHvGcomBr/ulYWsGMuO3g44iJaPnz1A74POvUhxydZWM/z+frSAYqG1zUjARtPQqkbfz86+9w25Wd100nLTyW8jJfj8MrJjSK3eIxoZmVNLChbofhGw2wH+5GZSQQ+6VmVWjL6bTu6DlCS8kFI1zCeAA61I7Du1zt0ACDvxDZ7Mcw/Qj4Qh+ulCInGezSYGL8gmBiuujmXZ0Yyn5XMisN63OwTsBPrVAMN/VwsZ/kL82fWz4iKcjLli9P0jo7rfrG46+VZERuFiSm/UJ5ESc9+ux43aSLwFurOQNHx/yJ0FXONmUv8xR0I7/RLLde1HnvbShYjB9+dFaKS+8UFWJFb3/hx24sNhJ34xIlX+r8jagZ8IMit40tP1r1hOwbKjdyADiJ8G7F4AetRn+N+GGH7/mkaz4zf6TeXagTlj9JV/pF/XC+2mk6cg+uFBi5rfQyQUJiuL13J4afh7IfHdfs5DBNxauVpSB8UuwqQnGVwX3HRyG+AGRD3Vvz6yDtFdusiKxBoqxxt24i+HnfhXEOP/VUqzbkFmtb8EHsgmBo+o9LstO/p3y45+EqkK5k8g6wStAwz/nS1m+P1Gv6kWcWHOGP3GuHe82PvPA7dQqlOeBN5lRWIXWJFYkH+05fGm6h9Bsin9f+PhSGhnUPJQK+DPTq3bzeqmkzsBf0DWTPwsRxZr76nX+SvB0/j5BuL2uQQJRvBzIHBPNjF4WzYxGFQuMBDLjv4WcaX9xrdLgQado8D4t9iIXxmj3yAKfX+j1EHRzk0n5wHXIH5P/7T2V0jM9J21Pm8zYtnRXyFl8vyLijsD/+tmUv/Y+FbNGL/Rr8ts0dNfeojSWWIGCcM8u5kK2oed+CthJ/5NJNrnSoLLOp4MPJFNDP4kmxjcMWB/CZYdHUH09y8NPkIXGv79aR3D79fRN0a/Afyl1vILbjq5A3AXUpmqkCzi2jgjX4GoXbDs6Cokttov3jYf+IWbSX2nxYTb/GsSNb9ZvYpWKylOAMufa38rEruh1uesFZ7P/zzKS3eEEHXYZ7xInwVTfacn4PZlJDckYAG5JQ1/odTKequru+JcikbRqkZ/MpXAmt6sbjrpIP77d/p2jSBViK5slVDMWmPZ0ZeQbFF/0QwQzfc78pWVmhB/H6qbe8dzC34NESfzSx3cBhxWq1DMehN24k+Hnfj7gMMQ8Tc/WyPuoDXZxOA5lRRx93JDDgGeK91bYvgH3ZHhZupTDbNFtaJVjf5kT/uaTcvddPJERBmzx7drDXBwu7hzJsOyo2OWHf0sUkLPn+hzDKK26A+FbAb8fajwXnCpUeEUN53cCjH2Xw3Y3Y8k7AX5y5uasBO/DzH87yNYqmIxUunriWxi8LSpIn0sO/oEMnO8q3RvkZ9/P2TE3yyGvyG2qJa0qtHfYZJ9f57pl3sjs88iNUL909TfIwZ/1qspNROWHb0WUVL0x2LvgsTzv7/xrZqUyfrQY7VwEXpiafcCH/DtGgU+YkViF1uRWJAQWksQduI67MRvQlw+51EqSQCwO5Klfm82MThpMp9lR9PACcDlwUdov+FvBldPXW1RPZhrRv91gqecFeOmkxaiTXIFpdfnJ8Bx7ea/rxTLjj6EJNb4dVW2Bm5wM6lL3UxqWgU86sBkN2u5QuQV46aTByALtm/37XoJCccMCn1tScJOfDTsxK9ESnP+K8HZve8EHsomBr8/mayDN3O8EJGhCAhXLTL8t7sjw/4oukZTrh/lgLsb2ZBKmWtG/x6rqztIS6Qi3HRyIXLD+ws454DzgXOsSGzWNfqbGU+uOY5M7f18EbjNzaSaQUZ3MqM/I7edm06+HwnJLMnORJKtyunctzRepM9XEFG3n1Eq5xxCqmb9NZsY/PBkLh/Ljl6HuI8CCsKMG/5DgBvckeHZTAz062zlebiZymwW0nJG382ktgG2KrN72jerm07uCTwA+JNNXgFOsiKx77frgm21WHbUtezoucCnKFVzPBERbdu18S0ropzR38Q0Z4ueW/DLSNKVv4/+D3CoFYkFLFbOLcJOfH3YiX8CER7zx+KD+PuvAwaziUF/halxLDv6CDJTCqg5Me7nPwG4ZjZq7nqlEcv1oxnPFutFyxl9gp6sanzAMK0L7aaTxyGSCn5DtBY4xIrEVkzne9sdy45eDRxJqb76UuBeN5Pao+GNmsDXj8b70D1WV7frP3gq3HRyPqJR9M2A3ZcDp9a7FGazEXbiibATPwk4CbmX/BwFPJZNDH6rnIa/ZUeHgWMRRdAANGh9JnC5OzJcsSxEjdiG0misPE0b5NGKRr/ck3U9onlTMd7I7DPIaGQ73+57Ef2cv1TfREMey47eh4zWHvTtigEr3UzKaXyrgBqO0LyiOfcAH/btGgM+YUViF7a6BtNMCDvx3yACfd9AIqMK6QS+gNTtPSXo85YdHbXs6GcQefKAB7IGrS9AdLAaSbkB6GvIILIpaUWj7894y3On1dVdsfvFTScVMgL7PqXX4RrgWCsSq5v2Sjth2dH1iNvMX06vG7hnlgqzlO1H1XyJm07uhrgF/SUx08AxViT2s2m0bc4RduJvhJ34VxHjH3SN3wzc6kk69AR9h2VHr0HkPgLuSw1af8sdGf5kzRo9NeX60LRmi42iFY3+sjLbKx6heQb/+8Bnfbs0klT0CSsSa9p/Witi2dHNSMWnn/h2LQTudjOpoDrC9SSoH71IFRIeXtH7lZSqvD6FLNjOWv3jZiXsxNcAxyFhrP4CKyCSDn/JJga/GCThbNnRBwh2GeIZ/h+5I8NBmkb1YMa2aDZoRaPvE3Yad+MNVvJhN50MIf7B83y7XgNOsSKxK8yCbX2w7GgOOAd54BbSBdzpZlL+rOe64GZSNqVSCAC/q3S26KaTuyMG3x+h81skj+PZmbVy7uLF998A7IlINftdX1shmjyPZRODR/s/b9nR1cjM0Z8TAugQWv/SHRk+qtbtDqCcyJwx+jUmaLX/Uaure3iqD3oG/4fAub5dLwHvtCKx22vQPsMkWHZUAxcgksKFLAB+62ZSJTd5HSjtQ+KLrci140V63YNUbCvkP5Gi900jmNbMeCGen0NyO+4LOGR3JMLnOr+Qm2VHn0ZcPQHyFdpC61vdkeF6V3bz9SMFEmL6dJ3POyNayuh7IVJBT9cpb1bP4P8Y+LRv19+Ao6xIrClTpucinuHvozTSZWvgf9xM6rg6NyGoD2kCJQCK8Yrn/J7SmcLPgI9bkVhTVUlqBcJO/DEkm/vjQJBA2YeRwi29hbH9lh1dixj+gFmVXoDWK9yR4aV1abQQ1I8qni3OFi1l9JGFv6ASapNOpzyDfzWlSVcbgSOtSCxRm+YZKsWyo9qyo5cAX/btmo8kcJ1cx9OXmy1OunDvie/dQ+kC3tXAp1pZUmG2CTvxXNiJX4OM7q8OOGR7ZCZ1a+Go37Kj6xDDH7AWo3dA6zvdkWG/C27GuJnUPEpDvKGJQzXztJrRD5qWb0aKjwfippNhJBrnY75dKcTgm5DMWcSyo5cii+dFm4Gb6qjXEzQtn2rgsA8ywveHev4IydQ2Br8GeJW7PoVk264KOORkYHVhRq9lR5PI4u4TpYfrN3uGv9b1dpfit59KaSpcW5xNWs3oB02nVlpd3YEl5TyD/3NEAbKQDYjBr3mxFUP1WHb0CkoX1juAX9WpIEtVLkI3ndwP0VHxx2X/EDjXGPzaE3bi9yOVuT5HqZaPjYT/3phNDHbDuPzHUUBAmVL9VrS+wx0ZDkwAmyZBfeiRepbYrBWtZvT3Kn5bfvHNTSc7gGuBs3y7kojBNyqZTYRlR69EinAU+kNDwHI3kyqapc2kCLubSS1AYsILeYMys0U3ndwfGb35pXz/AzjPRHrVj7ATHws78X9HxNWCpDHd7gDOAAAXHklEQVTei4z6Twew7OjLiO7TA6WH6neg9c15nR43szHsZjbuPoMs3r0CtjV11E6eVjP6QSF9JRfaM/jLKc2QfBE4worEmnp1vV2x7OhPkVlZ4chZAT9zM6lzANxM6grgVTeTesTNpILCLqfikJItSgUK9XlKmYOUaqZ/FzjfGPzGEHbiTyMLvRdRWrNhEfDrbGLw+mxicJFXhvFdBEYD6Xeh9XVuJnUQ6DdAP4XOveCODJfT8pqMw4rfTu0ibBZaxuh7sdV7+zZvBIoWYd10shOZ+n3Id+wLyAj/mbo10jBjLDu6HDiD0lqsV7mZ1GVIQt08pIpSGd31STk8YFvJbNFNJw9Eonn8vuArgM8Zg99Ywk48G3bi30EKpT8UcMgHkVH/aZYdfQUx/PeWHqZPR+pk5GeLS9D6X6tpi5tJWZQYfd5ghrLujaJljD5ykYunYkoVhUd5Bv+XlBateB4Z4ZuEmRbAsqO/Bt5PqUJnn+/9aZ7qajX4VFRLR2huOvkO5EHgl4D+N+BCY/Bnj7AT/wtwKCLT7e8f3cDN2cTg8vD61RZwPKU1nPPHFaDPqLIZb6NUaO33M5F1byStVLh60hGaV/zkeuA9vmOGkDj8obq1bJoM9fWGkfC/Jb6fmPezFfI/6kBqcXZU+X4Tknj2svfq//FvT/f0DzRFnLllR291M6lTkapLJen4Hlsj0RzXV/KdbiY1HzjYt3kjMB7B5aaThwArKBXguwz4YjMa/KG+3m2Z6Df+vrSImfUhEB2hcn0maPtrPf0DdbtOYSc+Bnw7mxi8HRhAZn2FnAnEw+tXfzK7ZK8TEFnr+CRfuaOb2fhmy15caZ3iUlukVNOHauZRWjddHw7EzaQep8i9o7IotYPV1Z3xDP6vgVN9H1uLGPx1DWuox1Bf7wJgJ4oNuf+GjNJ8s60MEzfvWsR9lv9Z19M/0LBIFTeTOh5xp+xO+et0q2VHT6vw+w7Hr82uQj+wuro/A+Cmk4ciBt9fIvNS4CuNNvhDfb0hpI/4+42/P/kfULONy0Qfyj9U831odU//wKu1OpFXeP0LwFcIGMTmVGi5ju5+JOidCU1WtE19z7IXX1DJOd1M6i6KHiIKlHqz1dXdcDszHVrC6LuZ1LZIMZMC946607IXv8sLy7yB0hH+s4jBD6i8U1uG+nqjyJRv/4LXXep93lngNaT602qKHwapWo/sPLfNCwQn4xUdCiz2FvCm+s5vIMZhAhU63Orq/oObTr4dcQVs6/vYN4Cv1dvgD/X1diJhgIX9aN+A9swFnqe4/ySAp3r6BwJDryshmxjcHxn1F6375baJoLv8ahmBbLDs6JRJXF65z9cocu+oVZa9eDaUYqdFqxj9Y/GvjKvQWeTGrkPK8vmlFdYgBj9AkGn6DPX1KqCHYuP+NoLFu9qJNKU3caKnfyAz3S90M6mtEPdUJSF1H7Ps6M8r+M7HgH0mtqgMSi0iN/YWJNrDn3j1NSsS+3rFja6Qob7erb12FPajvZGktHYlh9y3CYoHFWsqdTlmE4MWcAmiqx8GyC1YhN6unAKyH/Vmy1486WjdkwH35QKoz1r24u9WeJJZp1WM/s8ozqjNokIRcmPnIyOxQp5GDH6QbGvFeP72ZZSO4Gtd3/VlJHdgve8nCfwdiWIZQ5QIq/k9h4wSFxX8LPS992/3hybOlASy7nIXcG9P/8Br1Xx4y0vrP6/C4f4KDr3bsqOT+WzzERevM+GnBtR/orMXIwb/Lb6PXGJFYkFVsKpiqK+3C4kzL+xHe1Bbt94oxX2o8PcUEuY4nT6U9doZoXyfCfopV01qOryGSF/chfSlJ6eaVWYTgwcio/49cyqE3mEX6KykSeo/LHvxP092hJtJfRO/dIgKLbG6umdkbxpJUxt9N5NaDPyK0rq1q9C5KynV6HgBqUP6YrXn8kbxDqL1fTwSzz2TDL4ssI5gYz7++0ymtLVmqK+3A3GnLEIUJPdErkn+ZyYPvFEkpC3/EHi43AhuqK/3IOT/vqBzcew/F33kn/dQSp00yXdrIGbZ0QCN9fF+dCf+kF/N+yD3JcQQF9JvRWLTqsLkreUchfSjY5F0/ZkwwkQ/Kjc4eKmRay1T4c1kFiEzpx6K+9BSih68VZNE+s9dwF09/QMbgg4aXfXbHTMP3P/YG8+v26Fz4UK6jj6ejp2XQnjSvL43LDsaeM9P2CJ1RHH+IM9ZdtQ/YGhqmtboy0VWz6tOa154/raocAc6O0Z282voUVejs5ri0VIGkUeuWEtnqK83AhzDhKGfrjDTFuBxZNr3qPea6Okf8KePtyzeQ3FHim9gB8lMnM7D8e+IDz3/EFiTH8EN9fX+EQnLy3NV9LPfuC40b97XKR+F8T3LjpYsxE3ej7bk0Dn/iPta4COV+vC967IP0n+OQxIIp5sxvJ6J/pN/faGekTCNZqivdz6yMF/Yfxymvwa2mok+tDI/m3xtxcCfXvr93eORWqF581h4dByrZ3f0gkUQKhe4qGzLXly0PjSlLULv7Wn8twTNbPTvUZ3zjujYpgs1UfgcrTVjm0bQo1tAjw9uNiOl6coKr8G4y+btTNyg76D6afYriBBU4c35VE//gD9muC3wIkx6KH4Q7I0sSlZzbdcxMYX/J0qzr28Czoxd3H8w8G1KyxNeZdlRf50E3Ezqj6pz3qFl+5Fb9Fz+LXCyFYlN+r8c6utdiIzi8/1oOms6z1Js3B/t6R+YsibEXMULO30rxf1oP8rXMg5iDG822XXQQeePPPhgkXSGCnew8PDDmb/zm9DbLkRvuwhCvi6qQttaXd2bCjdVYItyqFDM6ureWEVbZ42mNPqJROLwZUsWrexYsJBQR+mgKTc2ytiradAayOWA91mR2C1B3zXU17sjEyP5Y6nOb/03fDcmsLaZptLNylBfr424OY5BrvtuVX5FllI3wP8Cp8Qu7h9BEvCuQtxRG4E9LTs6vnCcSCS2BT69bMmi70zdj7IADyNrQSXrDp7b60CkDx3v/V6pZksWeJKJ/vMosKqnf8AUWpmCApdrvg8dQTWzylDIMw8FKIV98MFsu9tSdChMrmtHmL9dft9Dlh09qPDwRCJx4LIlix6csg8ptdLq6j6ymr9vtmgqo59IJHZDCp0cvGzJoq07uxYXPVnzaK0ZHdkIKgS5sXOsSOzH+X3eaP4fgBOQG3Sfki8oz+uImuIKZNT37FyaWs8mQ329PcjNewziovErVlbKauCEnv6BF0DE1yw7Oj4yTyQSChFu6wesivqRzj0DHGZFYuMj7aG+3sXASUwMFqpZz1iD9KEViMth0xTHGypgqK/XQtba8g+BA5nmgvh2++7HdnvvjVKKHKBQl3Q4R48v3CcSiZ2AK4FjKrRF2urqbracm0BqYvSVUocgSTQustBytta6KndHIpHYGXGbbA+Ely1ZRAVPV6yubuW5GA5B9HZOp3yV+iCeYOIG/WNP/0BLpFK3Mt7/a18mbt5/oLqIjxHE8N/v35FIJL6MhOxtA7BsyQ50LIhMNdLf1YrE1nprPO9F+tFRVG5QXqNgsNDTP7C2ir/FME28yKgjkT50DOULlQcyf6edWHTEkahQKAfsGnbiQwCJRGIR8Bgi19BRjS2a0R/UIGpl9GNARmv9hlLqUuBRrfWNlX4+kUiEEDnU/fCy6nZauB3bLFhAOT8auSw6l9PJb190OSK2tHOFp8sgfuMVwO96+gdqGstvqB5vce8w4HxkhlaJPEgO2L+nf+Dx/IZEInEY8r8dV01ctmQRqnNe2X6kR7fo5GV9ZyGG/jgqX4RdhcwGVwD39fQPuBV+zlAnhvp634T0n0uoMCgjvGDBcOy09xwTduJPwPhMcQXyMLGgclvUKiP9mmjvaK0LY1TzMeLVcCoSuzzenmTmFXadbzG2aYSSFfMxF0KdbH5+jQIunKp5wINMjOYf6ukfyFbZPkMd6ekf2DzU13sPcBuV98kQ8CXkgZ/nRxQYfIDXt4yxNSq4H426bF6/TgO/qOB8L1M8WAgMFTTMHj39A+uG+nrnUUUUXvbVV7tfWH7t6p7+8aCwdyIDkPFEuUpsEeQCFD2bk4puMKXUrkhI4m5a6w3etn9EVAffobV+wdu2C/KkvbTKdpyFL908l4PnNr5Mz+KF6FEXsd0KFQ5DqBM9upmRW8req68AtyJCS3f19A8EFVs2NBc5SuWUp2JcM93zwZYsFifTf+ctOy4klJ+Ge/0IpdC5LCP/NTDZ6GwVcAtwB/BnM1hoCap1z77mC8w4A5+rcSpbRG5sC8WDj6amIqOvtX5WKXU7cAHQ5/nwfwAcV2Dwt0Oy4M7SWlc81U0kEhYyrS5hbEyzdsPLxCLbs/V8efDqbI7N69YwcssvyL1eFGjxBjJSvB5Y0UxJT4ap6ekf0EN9vR9G1Cx3Rm7ezQU/W5C7zUaiem7p6R/4XsFXnErADDOX8/chmZ5vfv7ZoD4E8FdEnvtXPf0Dppxm63ENoqT6bmQ26O9DW5DZ4PbI2tDH8x/0XDunE5A8FmiLcjne2LLl1a3mdS5tlXBNqMKnr5R6G7JY9U5kmnuB1vpX3r4OZGR9udb67moakEgkDvC+d2qlwFGXbW76Mcodt+cuMgq7Hri92jR/w9whkUjcgUTaTEnnkw8z7+EimfUhpA9dDzxuIrbak0Qi0YNEh1WTbJgDOh3HaZkw7op9+lrrR5RSDyILrv15g+9xBpIsc4lS6hLgKt/+yejCl9dclk6L19/dS8fQU7l5j6z8CPDfPf0DU6orGtqCqdQ4xxnd4wBy22xHx/rn7ux85vFLgAeMoTcgo/9qXYxZJFKsZnLR9aZio6+UCiF/YA6JgR5Ha70cqUk7Haq62fQ22zG610G53T/4semezzA3qbwfKUX2TcvIvmnZ/Us/+S8lYZ+GtmU6D35F9YErs0o1IUaXI6PyNcA/1rANmSrbASK5azAUUu1i/Rak7xkMeUaoXjdJIeuJLUNFxlYp9WmkSMlpyCj/IhWUnjY9nqi0HQUE1b00tDe3Ud1gYAxZSzIY8ryACAFWw4Ot5M+HCoytUuoY4FvAyVrrjcCNSAyrvzThtHAcZwy4ncqnVq8A19Xi3IY5xa1Ul3eyCQlDNhgAcBxHI5Lelfr1NyGqrC3FpEZfKbUHEtFwltb6CQCtdRaRXOirYTuupfJRWieSCWkwjOM4zkakaEslg4ctwP/zbnKDoZD/R+Wx/mFksNFSTGr0tdZPaa0Xaa1/49t+pdb6kBq24w5E5XCq+P5NwMWO47TMSrmhoXwSiceeik2UVlwzGHAcJ5+9P1U/eh243HGclsvMbgqtCG/E9QFkMa6cUNvrSH7ADxrVLkNr4TjOo4gsx+tlDtHevpMdxzGLuIZyfAx4kfKD0M3IIPVrjWpQLWkKow/gOM7fEKnUm5HV8HzK+2ZkZPYt4EOttmhiaCyO4/wQOBvYwITLUHu/rwKOchznvjIfNxhwHOcVRLV3OWJ/8j5+F7FN/w6c6K1HthxNpaefJ5FI7AOcgoSIrgeWO47z0uy2ytBKePIeZyB1fl3gfuAO48c3VEMikVgGvB+p/7ABuM5xnJYpgh5EUxp9g8FgMNSHpnHvGAwGg6H+GKNvMBgMbYQx+gaDwdBGGKNvMBgMbYQx+gaDwdBGGKNvMBgMbURNCqMbDHOd+Qeeo1UoTKjTIhQKo0JhQh2d3quFCstrKP/et12FwoQ7Qiil5DWkCIe91w4VvD0cQoUgFFKEwiFCIUVHR4hwSGF5r/PG34flNezfHvzaGQoRVtAZDhFSis6wIqRU8baQ8o5V48eEi45VKAXhEIRQhEOiMxwOKULeq1IQVoqQgrBC/k4FIe+zKpdF6RzksqBzqNwY6BxkxwK3q9yYFK0d/9wY5LLosVF5HR0df69zWRgbRWezxceMH+tCLocec9G5HDl3bPw1l82SGx1DZ3NkvdfS96PyfvxzWXLZHDqnybpZdFZec773RftHs+Sy2vusJjuWI6s1bk6T1XivGjdH4PYchcdM7PuRHiqrgmxG+gaDwdBGGKNvMBgMbYQx+gaDwdBGGKNvMBgMbYQx+gaDwdBGGKNvMBgMbYQx+gaDwdBGGKNvMBgMbYQx+gaDwdBGGKNvMBgMbYQx+gaDwdBGGKNvMBgMbYQx+gaDwdBGGKNvMBgMbYQx+gaDwdBGGKNvMBgMbYTSWs92GwyGtkAp9Smt9U9MOyYwbWl8O8xI32BoHJ+a7QZ4NEs7wLQliLq2wxh9g8FgaCOM0TcYDIY2whh9g6FxzLq/2KNZ2gGmLUHUtR1mIddgMBjaCDPSNxgMhjbCGH2DoU4opSJKqTuVUmu8V7vMcZ9VSq1WSiWUUr9USs2fjXZ4x4aVUo8qpW6vcRuOV0r9VSn1jFLq4oD9Sin1fW//40qpt9Xy/JW2o+C4A5VSWaXU++vRjkraopTaXin130qpx7z+8dFanNcYfYOhflwMDGqtlwKD3vsilFJLgH8G3q61doAw8KFGt6OA84Ena3lypVQYuBI4AXgrcIZS6q2+w04Alno/nwKuqmUbqmhH/rh+4Le1bkOVbfkn4C9a632BI4HLlVLWTM9tjL7BUD9OBQa83weA08oc1wFspZTqALYGkrPRDqXUTsBJwE9rfP6DgGe01mu11i5wvdcmfxuv1cL9QJdSasdZaAfAZ4D/AoZrfP5q26KBBUopBWwLpIGxmZ7YGH2DoX4s1lpvAPBeu/0HaK3XA98B1gEbgL9rrX/X6HZ4fBf4PJCr8fmXAC8UvH/R21btMXVvhzfzeg/woxqfu+q2AD8A9kQGAU8A52utZ/y/6ZjpFxgM7YxS6i4gGrDrSxV+3kZGeLsAI8ANSqkztda/aHA73g0Ma63/rJQ6sppzV/L1Adv8YYOVHNOIdnwX6NNaZ2WAXTcqactxwCrgaGBX4E6l1B+01q/M5MTG6BsMM0BrfUy5fUqpjUqpHbXWGzxXRZC74BjgOa3137zP3AQcClRl9GvQjsOAU5RSJwLzge2UUr/QWp9ZTTvK8CKwc8H7nSh1YVVyTCPa8Xbges/gLwJOVEqNaa1vmYW2fBS4TEtc/TNKqeeAPYAHZ3Ji494xGOrHbUCv93svcGvAMeuAg5VSW3u+2zg1XkitpB1a6y9orXfSWvcgC8l318jgAzwELFVK7eItRH7Ia5O/jWd7UTwHI26uDTU6f8Xt0FrvorXu8a7DjcC5dTD4FbUF6RtxAKXUYmB3YO1MT2yMvsFQPy4DjlVKrQGO9d6jlIoppX4DoLV+ADEujyB+2xC1z8icsh31RGs9BpyHRMM8Cfxaa71aKXWOUuoc77DfIAbtGeBq4NxZakdDqLAt3wQOVUo9gURd9WmtX5rpuU1GrsFgMLQRZqRvMBgMbYQx+gaDwdBGGKNvMBgMbYQx+gaDoeYopYaUUq5SapFv+yqllFZK9XjvD1JK/UYpNaKUSiulHsxrzCiljlRKvdj41s9tjNE3GAz14jngjPwbpdTewFYF7w8B7gZWArsBC4H/g+jRGOqEMfoGg6FeLAfOLnjfC1xb8P7fgAGtdb/W+iVPd+fPWusPNLSVbYYx+gaDoV7cj2T27umpSn6QiUzjrYFDkBwFQwMxMgwGg6Ge5Ef7K4GngPXedhsZdNY669YwBcboGwyGerIcuBcRlCt07WQQNc8dkYeBoUEY947BYKgbWuvnkQXdE4GbCna9DvwJeN9stKudMUbfYDDUm48DR2utN/m2fx74iFLqIqXUQgCl1L5Kqesb3sI2whh9g8FQV7TWz2qtHw7Yfh+iFX80sFYplUbE5uouAtfOGME1g8FgaCPMSN9gMBjaCGP0DQaDoY0wRt9gMBjaCGP0DQaDoY0wRt9gMBjaCGP0DQaDoY0wRt9gMBjaCGP0DQaDoY0wRt9gMBjaiP8PNq6leIam8MQAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -1014,7 +1014,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1072,7 +1072,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1140,7 +1140,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1177,7 +1177,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1227,7 +1227,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOydd7wdRfXAvyc9BAIhQAgJEEoooUiTKkV6M1QRRDoigj+aShHpiKAiSJUuKEgAUXqTJtJD7xCKEDrSqxDO74+ZfXfevNm9e++799378s7389nP7vSzs7N7Zmdn54iqYhiGYRjtRr9WC2AYhmEYKUxBGYZhGG2JKSjDMAyjLTEFZRiGYbQlpqAMwzCMtsQUlGEYhtGWtLWCEpH+IvKQiFzt3fOJyL0i8pyITBKRQa2W0TAMw2gOba2ggL2BpwL3ccAJqjoeeA/YpSVSGYZhGE2nbRWUiIwFNgLO9m4B1gQu81HOBzZtjXSGYRhGs2lbBQWcCOwPfO3dI4H3VfUr754KjEklFJHdRGSy3x5vvqiGYRhGo2lLBSUiGwNvqeoDoXcianKdJlU9U1WXU9XlgM+bIaNhGIbRXAa0WoAcVgEmisiGwBBgOO6NahYRGeDfosYCr7VQRsMwDKOJtOUblKoepKpjVXUcsDVwi6puC9wKbOmj7QBc0SIRDcMwjCbTlgqqgAOA/URkCu6b1DktlscwDMNoEjK9m9sQkcn+W5RhGIbRi+htb1CGYRhGH8EUlGEYhtGWmIIyDMMw2hJTUIZhGEZbYgrKMAzDaEtMQRmG0WsQkZtF5JRWy2H0DKag+ggi0k9EBrdajhgRWV5ErB0aZVkTmNhqIaYXRGRYq2Uowh4MTUBEdmlDZfAL2nNdwntxq9YbhtHzfCwi67RaiDxMQTWHs4EVupuJiCwtIos1QB6ACQ3KpxmY4ck2og07VzHdWl1ARB4UkWMaJUy7ISIqIjPWkGTOpgnTTfq0ghKRD0RkniZl/3X1KFV5ELi7Afm0lBKWj1Mr1Tey/HlEZHQzy+hpRGQuEXkuJ2yoiMxcZ74CfO730ytLA+v1VGEi8iMROb+nyvN0UlBVhtEb8axqCn1aQeFWSV9URBYWke0bnHejLnqjHhRd8hGR/iLS1BXtRWRL4IucsOwmqukcRWSIiCyf8F9QROYVkU2jG/Il4K5ayqhBlgEiMkNBeLPuscWBBRPlnQJMAt6M/L9Zso1n8hZeExE5L37TEpFviciiJcroLj22PpuIjGtANj8CGv18SRK0t/j5M01E5spJZgqqjekPHImz0NsFEbmglg+JIjLcH7abgkpxJdBhc8t/OxvY4DIW8Hl3vKn6HuUwYNbMK5VQRGYWkUUiPwWexX27inkOuB/4O7BkmAyo640iKHfZhN+COGXwSUHSaWXG+P0DP+8BkiLvOu0JLAoM9vmu5v1/B5wvIruKyEwF+WYydDEGKiJzB84dg7gZd+DqvtnMm/IUkfEi8n0R2aCBZb0oIjV9IxWR2RpRsIhM8O09L3x2EVk88s7afer5kzeU1ymu7+Rp5PcjEelfTeayiMhWIrJ0tXimoFwdFPXItgMWAhCRP/iV1IvIHmTTQk8R+ZeIzFGHfCIi24rIqJKRh+QFJfy+RecH+dnAUiKymYgsVLK84SIye4moI4LjPwLrBjKtlJPmNOCpoKws/tzp6IB7KwZ4SER+n1N+LiJyQngjisj6InIaMDkR/Tlg80y2gmGxBUoUvSOwm+8QnS4ip4rIXgXxBwTlfsMfZ6Zo+nv3SOD2KN1ZOFtrwyKFk5Epr+F+CDy8N14WkfBcUg/BvM7GdSLyk4LziePPICJDC8JT9+yzwIXAtan4IrJrlTIXEZFfBu7su+3VRXKIyOBsGFtEfge8Hb3h19vJXLhK+F+AxyK/bEQkdW1+npNPXJe/BRCRUKH9kYJ2LCKXi8jl+aJ2YRLw16qxVHW63oDJBWEKbOorSqOwUcCBPs4y3u+hOF6UZmlgfZ9muURZLwbHS0XhI4BRiTSf+v1ZwOXAUGB+XAPsF8Wf2ceVhGyTfNj8wCze76PsfIJyVvT7qxN5rAQsFPndVKVODvD5fSNR7+P88Qc5aa8M8wb+4ONrqkzv/0UcJy9+Iv1QH3emwO/BIL9jEuWF2845Mu0euAXYIHAvhvteEOdVKDNOMSrOuKfiFH6W7mW/nyOuA799D/iTP/62l+FIH2+C958vlsG7xwfH8wAzAP0Dv+ciOfsB433Yv4J2OqzKtXgGuC+nPrNtJeDAVFiUZvZUe8B1fp71dTcaOClxvtWug2Z16d0feL81g+uU3VsDw2sf5TMAWNgffxt4BNjMpxNg7SDuYJ/XvxLnurJPswQwm/db1vtdFsQbhOucpuorrON5A79F/PFPgAHB9V02iD8auCvK72/A3YF7VLV67YhbLUJv36iuoLbEKyjc29KpwA+BF4NKPz28cFXyy7Y7U2HB8cQo/GHcNPB/AyODeJ9F+e4D/Ngf74B7CP0GZ3n4BO/fDzgKuCbIP1NQ2UP+m8DHkUzhdo1vbAosEcR5KpL7vSp1kimodagoRgU2ofIQ/DAn7RU+/BLcQ+TuUMYq9d/lgVQg4w50fsDPmJdnlfKOj8IHev8fB36jw3xSMifkPxjXm56BilL/nt9nHaIdE+mzB/OIyH9L3FtG5v5DUNb4RD5DcQ9JBRYM5J7b73/nr6cCL0R1sFOQz+2BTP+qct8q8FmVa9zRgQH2isIOA4b7sG+m2kNiO8nvBwXXrtN1x9mhmxGnCE6J0s8BvO+PV0uU9XiYV3ReuwXy/d7HzxTUhEiGF3FvdSkF9e2ozONw954Clwbx9oni/TWnjhcP/BYNjrPOxrVR/I2C40dxnYgwfHvcUHDmnrOoHbSryfeepD+uogAuCPzD7wqdvl/4oZx+qjot8FM6s7KI7IvrKR6dKFd9umHAbcA3vP8qwHgRece74yG7E4Lj2YCNca/u8wJbZeIA21D5/rMD0awe3EOraIh3IJVhsZtxN18o94w45TmLdy+pqo/645mAEar6MpWhhhuBySLy7SCfrP31899fpqnqmz6Pa4Ds2993cW9+Xb4DVSMYpskLj68bVIbIah1z78hLRNYGnvDO+RLl7g0sUy1DEVkFONpvAGv5fVZ3a/h9amg3k+fFyP9rOg87hcep72mfAntXROoYyvyV3y8P/NQfzyciK6hq9o0wHELOFCnAqr7uR6vqGx2CiKyMG6nIO6eQxX2a/jglG3I4cLgf/iz7KSM7r4eBd3PivIHrRK6RCHsz4ReyGIAfJh0OPKaqX4nIGCD81pq1+wP9Pj63cbi6eb6T8O47bzxxZn/gNX/8tY83P5Xvvxlbi8iFwD8j/xOBtf1xWI+r+v2KUfzwflqCrpOTDgU+DNyvi8hsqvpfUhRpr+lhI/EGhRtnf8FX5ra4HnrcmwrfXP5C8DqMG6P9CPeWEb7t5G0/yo6DuBsTvOpG24pV8su2n3v5Y/8vgSlRedmWvUG9HPjNlMgjfFt5J8jnieD4riiN4D7SXxqUvV8Q/iZwlT/eErglCPsYeDmnF5fcfLz5gXtLphlQpUeebfPgOiVLp8r06S5OpPttlO/aQdhK3v8C73695DWOtw39/tDI/1eJuLPn5PFSVPcdQ1vA2Jw0p/n9IrjOVBh2W+T+mkoP+8TA/xZcm43zPgj3wM2GWC8Lwn4KbJJzvbLh3O3K1l+VdhK/EaWuu1J5S6p3eyE4vhv4T+CWgnQH58i/eMn2f3GJeDsU1NkPcR2Yorr8vIQcDyb8RsX3pqrScgXSIgW1VtEFSWwXRe5bg+MPyj5Q/Xa733+Pynh/vK1SMq/9ge/nhE3x+2Uj/ytL5n1v5P61339WcL6DI/eadB5KeAc3y05xvb+vovhZ3mVl3A7YhfybJbX1x3U4BuLeQPPinZvjP6yorBoU7Bsl5e2JLVRQ8+TEOdPvF0+E3Z5K4/MLvxv+q4oczxSEzUDXh3fWfn5Y9lyrXJtTq6Sfs0n1/05wfHI9MpRVUFQ6AXnbxwm/bCj+rMh/WAPrYF5TUOmHx851VOa/I3dRr6eWfLJttZLp/1kQlimoq0rmFW+PF4TdneP/QDcb6Rc1Knul8rF/Usn4y5eMF4+th9t6BWFlH2JfdrOuGrl9AR0PuXFV4i5VQ753Aq80UM7zc/x3LZtHlfZ1dZX0P+mBa1FvfZ1UIs4zuBGHRsla9jlVZhtnCsq5Z40q5kcNqNz+Dcgj3L7ThIZf6/ZEC8r8Xx0KKn67rbY90gZ125abr/v5qsT7ZavlTGy1DJcWvUHc1wbn8t82kKEVW1JB5U6S8P/T7IL7V2YE7qPhncC5qvpZXrpeQPyhveinxbI0+n+y0xucXz007Ke8GqjnJ+Ftaoy/ZPUofRM/UeWkKtGO6glZaqSWteT+UxD2ze4K0gBqWUNvekJTnkWz+C7ADSEdgJvbPzNuaOMC3Kyq3sqNkTuehVIPjV7Xq8tf/C2g2k+CTaHoz3mj6bzaagF6gDI/lbcSWzg5oKjnP6eqnqmqL6vqB35/Fm7mWcvwf/Y/IyJTROTA6imqskUD8li3AXkYhmH0VZKrbRS9Qf1LRC4CrqPzG9S/Gy9bOfz/DqfifjybCtwvIleq6pOtkskzvHoUwzAMoxZyFZSq/lKcLaJVcf9GvAccq6qP95RwCZYHpqjqCwAicjHuD/ZWK6gdWly+YRjGdEfhShKq+gTwhIiMUdV2GJ8eg5uGmTGVhGFAEdkNt3QIuH9dDMMwjPYl+e257OyzeyVhbqAFpMYpu5yY/3a2nKouh/sJzmgtn7ZaAMMw2prkN6iyCuoA4MZgOf9KriITReTO7khWA1PpbGphLJV1phpBtbW0jPo4pdUCGEaCF0vE+U3TpTByKaWgVPVC3NpxJ4nIwSIyUER2EpEngeNxNlh6gvtxC6nO5+2vbI1bFqdRbNvAvJrN4a0WoAam4VZ6MIx2ossivgmOaLoUBsD/Up6lfzBV1btxs+cOwg2b7Yl7SC6sqqc1QMAyMnyFW27kBpwtl0v8d7JG8Imq3kz+KsbtxutNzDv83tiIDsA0GteJeb56FMCtlxiyc4PK7wkewJmpMFqMqtY6PF3K0KfRheTzrJSCEpFRInIszo7HnX77ArhVVXvUnr2qXquqC6nqAqr6q+opcrkBt9hkRrY6xrRE3DwO6Eb57Uz4s2AjfpydRmWViH3pahKgFvalnNKMh51jy6Nlea/OdHXjv5/+iTrMizSYa1pcfnc4rEScolUlLqO1s3M3oDLRq9k0s7NbimydrZiyb1DP4+wNraWq6+GMUt2HmzxRaG+njbkSt+5VTC0K6oIc/w1x/4yVGeMuyzkl44WrUDwThT1SLbGqCmlz0d0hVFA3q2r4FvR5Dfm8papXqeomJeJ+hFsxfhtVFVVNmWwvw5d1pquHj/Am5D3xTZs3kzasw380ShhV3bjGJLF5+VZSZkj56Rz/E4DtVTXv/k6xH24x27Lm3R8uClTV6/3CCHkypjikIOzMgrA/1lBGNd6I3HmT1O4olVvJBVfnz/H/EfA2sF6rF4WtYbHYzEbOnnReZPItH/6qd+8WhP2VrosbPoybpt9l4cOgrE0D/8cScfdL+D2Ul2fkt2/kPh2/4GLgF1uzPCOVd7CN9unfDPxS5hVq3Q4GfuCPB9e4IOwbvo0p8Hp0LTM7OjMD/+eP38YNswxKtIUszyNqKP+tHP88MyfxFtoqihdi7bTyeULe2BzLXyL3TTj7PJ8EfuEq9PfT1ZxMZvJiajXZa7xO/6H8StlvRu4Taignb4ttNM1RIs0ywXFm5XVIQbsZhWtrYR7Z82Ksj7tQTln3RO7sPo/v4y5tgYo5jkernM8efn9K4lrsn5PmIyrWGI4K/A/Emf74dZUy4+3O4PgS3CS2VLzRoTv3+d0ABbA2/uHejhv55jb2xL2VZJWUKainswoLKy9RwXfk3cBBOZsH/pPoemMuQVd7TbEdplCGBQK/2OTD4tH5HZqQ71BgrqiML3ATYBRnJRhgd++eueAhldniKTLLETb2naK6WdSHPUlXRRpuZ/j4PwO+H13HiwmUlo9/VEFbyPLcIFHOATnlv53jP2OJ8y5qR596dycDcJG8gntILOHjZA+gG6O6DG34/DUqbwk6y5Q9QKqZSvgk59p/Hbnn8vurcCuqVK0Tf82z43OB5QL3dSXzyLZ3cZZqQ+X9Ky97yohjaHNqrjBN6hrE1y9RJztm7cGHLezdWwRxZk2kmxxco8z0ynfxhihzZFiLzoZG460/MF+OnHn38s6Bf0fHLchjo0SaT+j8bAu3s3H35e4+/Uvef8Mwng+7KC6vy3k3SAks3GxF0w3ZUgrqDt+oQ4NbZ/mwuYDx/nhDYNHowma2Z27z/s8FYW9FFze0VHsR7uEQ9vQGBXEzpRH3tPYFfhbE6yiDisI6I9GYvxXJPRcw0PudjHvw3oYzBJe9CYoPnxCdR9wIX/HpFPcmuSWwl3enzJf8HG8lOCHn5jllZNsZ8fUL0g8DZojyO7IgfpZndt0zi6xaIMPxOf6xcUbFDa9lx9tksuGVhD++Kqrbj0MZqsie3eQ3RHmcgrOLdQkwR5Qus36bvb39KZBljbx6D9J/EYV94PcbRPV2FWnLzEpnExLrEPTug3IyA5JFRvC2Tvgt5tOHBiYzBZV1/j6iYkrjcSpKajROIeyLtyRc1G5y7ofts/bgw8YE9bIBbqgwlW5uYGnv38/7zYrriHWRw4d/m3x7UTcl0mSdwFD2V4M0L0X5H4F/ww78N0yUFRtpnUTFUvQGkQwvBPXRcT3y6rbLORTdFNPDRkJBFTW+KvH2Co5PC26sjgse5xWE/QTX6x6RVybOGFwnY4CJOAsEF3xuH2/JKE6/ovPD9cz7R+4LA/ecOTfkpzjzK7MF/o9G8b6XaND7FdTpAv74K5wNqn7AyCBtroLKya9IQT0W1J3iJsYoXXuXHYbxvP9PE+eUPVRWS/i9DIwJyh1Apaf6u6huP6qh/Y3y+2vKpPHplg7OYzBeUQXh2dBopnimReH9qRi/VCpDhutHdXklzmx76uF5CJXho+HV7rso7cPBsRDcP3RWUNvgZvYq8OPo/tiSSsfvfipvPXMGZY6pIs+zgfvSoPyls2sfhA/PyWdRog5KIs7PU+G+jNWpDM3OQOd6uD4nvw+i65kZOV0BWCTKf+tE+nC04emsrQRpnqcy8qJ0VVALAMtG5TwduNcFRubWR9mbv7duVFdQXxY1mLiB+ONZ6fz2k40NvxTn5W+O/vi3kyCvZJl0tpL7TiJ8/qjBTSgh97ndrMNMnrcT/o8H7odJG7wblZPvXCXKrFVBFQ3xPZLVHRWFq4ky/+Dd2cOvy7fCIP5oCq5nQoYjojI/LpvWx38Z10ko9d0X32sN3AKsnIj3IJUHeBd5gPPwD0Ef75tRPVwV1ePZQX39kMobZzYUdmfBPdDxbdi75wCGBuGZov6cQDH4sJljP+9/jU8zJpBxVBBe7Q3qicA9BBgR1OfeNVy/YQSdl0T4ejn1vzquA7QrcHjUXhW4Nie/3aPrvyqwfyLeDATPqMB//aCM7Dvy+0H590f1tHSV8++koKrWV9mIvXWjsQpqjZywjXGv5mcCd5bI69WCm2EO3PDjaIK3nCB8ZBl5I7lLP+QL8lCib404ZdrljcXH/YKK9dUuH55LlPlwrbL7+AcVhD8UPPSUSDl4v4/wb4iB/3jcEG3HeHwQf2zoV0LGocBSgfvTsmnrvHZzlWzf2QSa+2o4l/BhHyqoy+n8jXQ3Klanh1WTC9cB/EuRHLjp/8k385z4s9D1+0xZBTUBmLtZ16gb13adoI5Xz4kzAzCxG2WMws/i9u7JwJX+eBwwexB3YIn8/gb8omz5hYvF9hHKTgvNjauqVwNX15DPK7gbNJXXW7jvTElU9b95chRQy9T50qjq2jlBO+P+DH+MOi2wqupSdRgvXBL3TTCPcPr8Dbgbb48oznWq2mlqrKo+h5u1h4jcjPtYnVHTtVBnjTqcYrwKTTRSp6qvUU7GrI08iRu2KpN3ctq7qm4OICJL4NpAP7r+uvAWcFxO+ndFZEqVskeUkTGI/z7u+28n75JpW20tIYmq3iQi/8ON5iSn+Kv70bjun+1V9U3cMF3G8kHYS1Hcqr9kqGpN9vdMQbWGWh+83aW7/zXNjhu3L7XwrqqeByAi83h3Lf861Y2qVvsZt6MeVHV9ABHZP4rzFcWED+U1cN8E7iO4cWtBVR+qJ10TyNrkD3EzXGvhUeD6LhmqPi4iAB+rqvrjLOwr3OzOPGrthNXKtriJQhlfNLm8ZvEL3Ft5j6A9vDCDKSjXYyz7w3KjbpqeVFBb4CZe1I1/o/hdHeleFpEh3Sh6W7quCNEdutxcqvpJ4FwXN1GjiN3xK4hkvVYRWRf3XaI30x86esE1/Zysqt8oCB6Pm8kFsFBU30WUXoatHlT1osj9djfbaktQ1eNbLUMzMQXl/sHpaXpMQanq5T1VVk75dfdM44dIAyisd1W9qWoGbojus8jvA9xsqd5MUx7OqjolOC4afo1p9htUF7rTVo3m0OcVVA09uoYW24IyjRY89HoRk3C/QbQLdq0MU1A1sC6NW2vsZNwPg0bPchGdvzsYHlW9DreKQ7tgCsroWDlgukVEJquzrGsYRi/BW084QN3ixUYfpakfIg3DMOrkZmpbyduYDrE3KMMwDKMtsTcowzAMoy0xBWUYhmG0JaagDMMwjLbEFJRhGIbRlpiCMgzDMNqStlVQIvIzEVERmc27RUROEpEpIvKoiCzTahkNwzCM5tGWCkpE5sbZOnk58N4At/DkeJx9mdNbIJphGIbRQ7SlggJOAPan85p1mwAXqOMeYBYRGd0S6QzDMIym03YKSkQmAq+q6iNR0Bicob+Mqd4vlcduIjJZRCbT+80gGIZh9ElaslisiPwTmDMRdDDOANe6qWQJv+QyGKp6Js78umEYhtFLaYmCyjMV7k1Ezwc84q1vjgUeFJHlcW9McwfRxwKvNVlUwzAMo0W01RCfqj6mqnOo6jhVHYdTSsuo6hvAlcD2fjbfisAHqvp6K+U1DMMwmkdvsgd1LbAhMAX4FNipteIYhmEYzWS6X83cMAzD6J201RCfYRiGYWSYgjIMwzDaElNQhmEYRltiCsowDMNoS0xBGYZhGG2JKSjDMAyjLTEFZRiGYbQlpqAMwzCMtsQUlGEYhtGWmIIyDMMw2hJTUIZhGEZbYgrKMAzDaEvaWkGJSH8ReUhErvbu+UTkXhF5TkQmicigVstoGIZhNIe2VlDA3sBTgfs44ARVHQ+8B+zSEqkMwzCMptO2CkpExgIbAWd7twBrApf5KOcDm7ZGOsMwDKPZtK2CAk4E9ge+9u6RwPuq+pV3TwXGpBKKyG4iMtlvjzdfVMMwDKPRtKWCEpGNgbdU9YHQOxE1aW1RVc9U1eVUdTng82bIaBiGYTSXdjX5vgowUUQ2BIYAw3FvVLOIyAD/FjUWeK2FMhqGYRhNpC3foFT1IFUdq6rjgK2BW1R1W+BWYEsfbQfgihaJaBiGYTSZtlRQBRwA7CciU3DfpM5psTyGYRhGkxDV5Gec6QYRmey/RRmGYRi9iN72BmUYhmH0EUxBGYZhGG2JKSjDMAyjLTEFZRiGYbQlpqAMwzCMtsQUlGEYhtGWmIIyDMMw2hJTUIZhGEZb0qcVlIiMbrUMjUJEVETmKQh/VUS26EmZjN6JiKzYahmM+hGRIa2WoVH0WQXlb8JeudisiMwjIksmgpLmRzxzAas1QZbtReT+RufbFxGRGUWk7qVdRGQbETmimzL0A+729td6Bb5ztkCr5QgRkdHNrEMRWSHV4RSReYHPmlVuT9NnFRQwc6sF6AbXAo8k/FuxbtXGQI8tJSUi14tI263BKCKDRGT2bmYzs8/rrpJl9heR/v74m8BFwKEiMrQbMmTPhFIPVxGZRUTqtoogIss1oN7AdcDaideArbqTgYgM8IZbU9xDxXhryAifVkRk/pLlzCoiM9YpZl6eM4vI9wvCVxSROavl05cVVP/uJPY9pIkJ/6VF5Obu5F2CvAdCQxWUiGwuIk81Ms8GsB6wc1EE36Me1kPyZBwLvJUjz5x5wy4isnsQNs3vVypZ5o3AHf54/cD/qJLpU2TPhJVLxn8POLQb5d0PnNqN9BltsaioVyoHeOes3cxuT+CVGtNkimYF4PmSaV4Hrs4LFJEZvOmjQnxnI3uu7ghcGIUvJiIjvPNu4MxqefZlBXVNLZF9j2SRwOsI4Ao/JBKyMc40fTOp92bcC0BEDg8aUhFbAItUifN17CEiPxKRsxP+M/p6PEtEhopIP++3aynpSyAig/zhDL5nWPU8RWRJERnXjTKHAUXfM18HLs8JO52KQiq8riLypYhsHnitCawkIjPhbKhlfM/HH1TH22bWnu8QkVlKppm3KNBf67cLosxfdmjTt5mRqaAy6XuAL3GdlS6IyDkicmQNedXzVpMpx1rSDqL4Gu5KzvNSRO4PlNf9wOY58b4NPA6cEXhX1T99TkGJyBy1PIxE5BsiMjOwNhC+TWR19404SbcErC7PvMBCOcFlFddhFH+vypjRlzms4AEywMfpJyKPeb+9gF0ScT8CfoRr8AsAB3q/s0rK3UE2wUVEFgqGuYYBh/sobwH/BX6ak76/iKwuIqNww6U3FJQ1e/aWIyIDRWQpfzzA9wg/JqGoIzYoCMsmJXS8ZSU6PuDqenkRuSYK/yXuzTIj66WOAXYWkeFhfP9Gt4+IPJ0oI1ToybacGD762g/1vZeKjxu6nM13RlJvth3DWD7vmQP3ISJymvcfhHvLfEdEZvXhgzMZcsruMRKdIYnCdgZ2L5HPfiJyGJU36rLlL03l+tX6HCp6doTnMVREfh2c63I4E0j7efegLqkdt/j9kOzalZNKdbregMmRW8OtRPos7pF+PxBYAmeLSoEVg7jfKJtvnecyb0p23ANKgeVz0v0lTBOczzPeLcBCiXRX+rib5J0T8ImPM8jvJSGfANt4/2P8ftGgDhU3JLFMkGZuYLGorPHx+fvjXXETQDSxXQYsBswa5fXdKN7z3n9tYMkg3to+/L/GdsYAACAASURBVI/evXtQ9hO4IbYwn0F5bShwrwEMDsJeTLTNsUH8a/w5KnCc308N4v4hSvslzl7awoHfgT6vuVJtKChrXBC+ATARGOLDJvj96lH9nwtMKGgjo3y8KcDDibp5Nchv26iuMll+Fl8v3MP4ae9eOcr3TGB44J4Z1w4fw/XyFVg0CO+H68xsAiwV+C8GLJHlEch0XuI8w/aswE+CsIHe723gt8BmUVtfGTjZ77N76oCCOs3KmC3hp7g387y0gxJ5vRC454jC9w2uzyM+/khchykr70K/3xbXNqflXEfFvWkp8M+UfJ3Krhaht280TkG9ljW64KZU4OWg4R4V54t7Y1gyke+bwOgqZZ8KnJEnO5HCAjbEP0yCNDPE5+uP7wn8v+33u0Rpr06kXR+4LSFTpqD6B37L+zjhQ/F4v1+Irjf0Jz5+SsmNj+KG53Jaom5S2+lBftsX5Pe0P16RysMi3mb3+88j/+OiOlwkcS4K7Bwcv4x7QIb5/Bu4Kohzg9//tuS5KnBzcPwnn1cnhZpoc+sk8jkM2NQfC/CdqL7OxT3Ik/cTFQXVpczg/BXXSen0UA7SxW1FgWGRexzwc3wnAlgjyud7Ufzv+LDVgDkD//uBtUK5gzy6XE8fti3wYJT/Pj5sY2A77/eO398NzIS7by4N0pxH1OaqPJcUr1Ajv6mB3HsBI/zxxEi2V737+SjvWQL3bVEdKG5CztKB+xq/fyKSY2eC+zmxDS18Btb6wO9tGzUoKOCHwA1F8XHDUgrcGfidlogruF5bFvfHiYucudcFlgF+BfwGN/z1dBBvdlwvK5blg9RF93kOIlJOgVyx38Z+/z9gnE8fPzAVd9Nmx0fjZhNm7iF+PzjwO8HnNWcirwWo9Lqy7Usfv6Nuvfu1RMMPyzy/4AZIXm/cN8RUvSnwJLBU2Tyj7XOfz9u4XmYcvrrf7xr4XerrM+9aKq5Do1QUfJnt1cj9cU7+A4N6Wa9KngOpKKtZA/8fBvkNwT18s7fEOaI8DgH2D87txSAsT0GdS1dZYgUVb4cCSwK3e/cZUfiHuDcWBS4J/O+P8wpk2TnymzEIi+v3vMRz4b3I/Sfc8FfReRzs40zKeS6tlvOsUiojFm8lrsOMwfHzOOW7oHd/H1gcN/yaxTkqSn97TpnxVnh/moIqoaBwva5s2GRN3I1Y9DC4Nzg+M5F33FvLtpUid3aDfBH4dblBcravcvyXBq6g8lALt4USfhtH7j2pDEmE2+8KZMmU4ZOB32RfL6MS8cfhZqHF/hvl1E/R9qeS9aXAj/MUVCDnY8BNNeTZpU3VmOZC4G/1ltfNbUO/H4Br73FbiLcFi8IT575GUEa4fU3XB164xW8FKQX1zRLn925wfFkDrunJgf+v/D7vDeFPuFl4RXk/BtxaJc5/IvcGkXuT7pyb36bk+E/tZr4KvFCtbk1BFSgoOg9LZdtFVSr998Hx6aR7y83epuX4f4KbfJAKixWkUhkSCbf5GtTAB1MZDgu3eUgrgfit6h8NrrM3cUOCDxXEebI7ZdShoJpxnrVuuzUinzrPPbU9SudvHCkFVet2STfSZvf3KYmwMp2oZm4XNyCP53L8P2y2/EXP75pn8YnI9rWmaWfE/eD410TQNlWS7hscT8P1gHuavOs3A/nTTFP/t5ye8Nu2Rlny/uT/nPT/QUL6X7T4nDapUY5qzIEbbl2qIM6i3SlARB6qI1mjz7NWxrW4/JglcG/yGdqAPFfoRtqsraZmId7ZjXwbwfcakEfez92Dc/wbhoh8nhvmezypRBNS3rjhrFUSYW2JiExW1eUCd+qEP6a+fw6M+jkcNxV97hbLYTSWLWhcZ+0U3KSkdiCT5XnyO2NG/fTThDIqUlAf4sY14/n066hq3vIbTUdE1sdNq+0PnK2qyZ/igvhlFJRhGIbROgaoapf/vorW0HoK+Lmq/jf0FJGaVmBoJP7nsFNxU2GnAveLyJWq+mSrZDIMwzC6zUASPyYXfYNaB3g/9lTVjRooVK0sD0xR1RdU9X+4j4OtHrs3DMMwusfAlGeuglLVD7NXLhEpsyxOTzCGzosnTiWxZI+I7CYik0VkMjBbTwlnGIZh1EVtCiriXhFZtoHC1Etqfaku35RU9UxVXc5/e3qn+WIZhmEY3aBbCuoA4EYR2TIOEJGJItJT0yyn0nnW11h6qdFBwzAMo4NPUp6lFJSqXoj7w/wkETnYr+i8k4g8ifv7/MLiHBrG/cB4EZnPr2y8NW5B01poxf9KPcHUVgtgtJz9qkcxjPZDVT9O+Zf+UVdV78ZNnDgIN2y2J+5floVV9bQGyFhGhq9w/yLcgJtleImqPlFjNvfWEPc48u34dJdxDc4vuwbHNDjf6Zk9q0fJZdOGSVHhohrj74JbKudaVRXc0ldG/dTzg3UeSeOV0wlfNiifQsOjUFJBicgoETkWtxLynX77ArhVVXvUDouqXquqC6nqAqr6qzqyKC2vqh6oqlvglsdJkafsUitTxIR/T79YVqYCzvX7qmaU25h3S8YbUSVcgRMiv7US8Z4Ljn9fsuyMKTXGL8OJNcb/m6ouGcysreUfv31Kxvtnwm/jGsppBt2x4FtEPBpT9QFaQJ6ySymuETiTOb2FV+tI8wbuBQfcSu7gllEqpOwb1PM40w5rqep6uAU978NNnkitONHOlL2Jtw6O8/4XSw2rnYZb8v8L737W7+P/x0I5Xi4pU8ZNCb+sV1Pm/BYMjhfDrQOXR2Y2ersS+dbKmTibRRnZOTxSZ35/8nvBLVCZMQG3IGfM13Q2QlkL9fzwnTej9A0AVb3fu0spalX9IPIq6nzFeZY1hpeahJT6F/J/JfMrw0c5/g/jVkGPTdrfnYrcXVT1PNxCt7UyhHyDgaOJ/vlR1fdxZlSqES8JtA7wTCJevb8C3VYyXvym/i+//1NeAlUdTaWjrzh9UvX/1bIKaklV3UZVH/KFqaruixsCu11E1itO3lbk3cTxzR42+ryb79exh6ruqaqvBu7sAfxggUzh/2Y/IMdsckDcez8M+KxKmpAvgUm45fufpPMre/z2d6DfP0Q5K7y1cJyqPhu4M4usP/P7GxNpct8QVXUnXMdgGs5cSeb/VGoZFVxbWLpAvnhJm3BCTs2zQ+Of3gMWx60RCM52Tzb0WKREbkv4pd52vkj4xawauf8dHJddaii0pNrd76GpB+x9qrq0qmYP8nD05DE/xJlqL3lc6/fh28ArcSRVva5kftm1mqyqX5CjoFT1a/+pop5hsiUi96Ok3yYfSPg9n/CLidfdWycZq+vzMKu3uL3uFLmz++cwVS3XKW/AauFrA281e1XybsgXr2a+D+lVdZ8Gtgrc8wRpVqGrBVals8Gu3QhW5sXdpJkBPsU1pCzuXnQ2QbFndhykz1v9dzhdTWHsHaTZKZHmkcg9d1QnP/L+l+MUVBbvsqCsxX3cSd79y0Q54fZvv78+x/+V6FwfADbzx4JTREsE6Q7x+1FU7EBdB1zlj4/zeS0IjPfHx+XU6Y5+v3DgH9pj2jhLF5SjuBmkGxVcp4eAPQL3E7ghHY3y63RNctqt4hTXhbj17cJydsOtXZZKl7XTEUG9Zm0uzOP/cuTS4BpnYaFl3lT8eEuZUSm7jcEpzLjN/CynjhTYyrsz+2TVTE8sSKVtDQ38hWC18ir34hu4zmTmXtuXm5lziU1iKPBmkOcW+JXCvTuzo3as318VpT3Pxzs48BuNt0AcX5+E3Df7vPcHPsW99SjOFt13/PH+UZpxfv+NwO+bdLYRdToVEyyZva1zqdjJmjeUKbp+2X2cDFdVGqUEFm6VAiohW56C2obOF+NOOhvkm7fghsi2zKhdtqbh4kHc0cCYIN0vwovhwxXXE9wKujSuuIHmNb4b8abRvXuzRLrYSuo8BfU1KYi3cZDvUlHZhwfxzgoab+aX3XCdFJRPvwOwYVRXw/zNEp7jLFE6JTBx7f2W8/6rJ87lmJw6y67bQO+/Oc6cwtvef6WozOsC9yDgqJw28VDg96mXv8MMSxT/N/E1TbS1kTnl7FRw/QYCa/rj1ahYIs7sbO3o93vh7J5t4uNmFpbvJFBmifKfzbkXwi3VmQu37ehaJ/8CDgrk7tLmc+poQuKe+RbO3lfS5IyPO2d8TfzxAJzNtOsK7vvBeLPpJa5htm0BrB2FbxKU2x/3tps9FzLTIJnF5t8n8p0ZZ7ZGcfbfzouuWWhRObb0PIDAaq73WzuSOVNEHR3iIO5IYNZIppWBn0Z5zklO/YTXPjc8L2B62chXUAtQuVnVV7gA8/s4/as0OMX3LErIoDjzHNsEDXKM958b94CMG8CeUVlrAQvEsiTK2SRIcyTwRkL+eQtkHUPFMmjWCzoHGBblExpVnCk4r6+AdYN4N/njjreSgrJXiuNkN40/7tIR8tdL8VZFo7CjojrNjEgu7vf9ovhHAn+nq4K6Nk92nGLNLAA/GqQJ38BPjuR4E2d6e+usrkq0oeN8Pq8CS9R4DyiwUeTeK4pzQ3DO/XGzdTVKo8Az3j0x8DsqawN+GxEc70Klt97xoAzbrz++PShr9SD+G1XOK7wn5sebcffu0GKshmVG+ayb8k+cuwJ7RGELFLSN3DJ9+GBgi5x0l+HewDPDqMdH4UcG7qyjdV5cViCDlGgn60bnmlnC7ld0HkE54xL+c5RId0VueC0NvTdudFVQcS/9o6IKjNKGN85xlFdQy/vGODNuBXbwJtz9cYcV2SBNNlT0GXBPzoWNG+MPqLw2H5OXJtWQoniZAceZcsI3D2/+Ko3vlhqv1/yReyDw3SppFFg14f+LqE639nEnVJG7tILycbI6fzBIM1cQvmrZNtaMzcuzROTeO4ozIqx7/BBVou18J+G3TeQeHhyvQP6w2T7BcaigFvV+h5B4gEd5zF0QHhoifSavveLfwqvU4TU5aYsU1G8oePhWOa+/4YYfs7b12yj8O4l058ay+LhXlSw3NlI6W3Qf5NaRD58/4T97iXSH5IUXrWY+XaKqN9L5A+b1uO8aZdLeLiKfAUNV9QARWbhqIpfuPn/4BbCrP45liLkA9zZytuZP5Q9nqqGqfwEQEUh/hH0fN+xUODlGVaf5PPI+9F4elFM0g+o9YHJRWYm843P6Eri0TNKE34m4YY6MspOCHsLNxAT39ngpBR+1VfVzEVmczpNdwskJdwHrlyy74aibQBAzLYrzHpVJKtD12p+PG4q5KsxXRDai6+QMxX3XuApXJ/vg3sjmD+KMpFJfvyUw+qeqT4nIQHWTCYr4CQUryfh2PA2nqJIrFXheoPokgrxZeXn+qOr+VfIsLE9VP4OO+6yjfedcT3BD0SmDpGVnhb7oipNZqQw1hlRbkCElV96MzE5FFwk1XW9Eb1ANyO9TOvcEF68zn1mifGaloDeYSK/AnTlh+5L4zoRbaSD3zSiR/9AqcdYBFioI70eJoYUGXJO9gSEl4mXfGBeloFfXAHkUGNzs8+6GfKtWqy/cW9DRdZy3AjN49xxtcK5feZmW9duldeazDe6/s9h/oUa3JS/v3yP3z+vMazFg5jrTjszOzcvw54K4E+u514HvE31XDrdcg4XTC7HBwgbk9wnuBsztOfUEIjIK+Fy7/gtjFCAiM+N6h0+1+hpOb4jITsC57VSvIvIdnDG8vzcp/7G4GakNO2cROQ24UlWv9+4xuBmAPbpSiH+T+q+6N2UFzlLV3XpShj43xNcADsR9GG8pqpq3uoVRgKp+ICK9ebWNduZioK3+idRgSLJJ+U8VkZENznOPyF3Pyg2NIBwW3R+4uqcFsDcoo88hIvMCL7VTT98wjK6UXizWMKYXVPU/uP+DDMNoY0xBGX0SVW3GYq+GYTQQU1CGYRhGW2IKyjAMw2hLTEEZhmEYbYkpKMMwDKMtMQVlGIZhtCWmoAzDMIy2xBSUYRiG0ZaYgjIMwzDakrZVUCLyMxFREZnNu0VEThKRKSLyqIgs02oZDcMwjObRlgpKRObGmXJ4OfDeALc8zXhgN+D0FohmGIZh9BBtqaCAE3Cr54Yr2W4CXKCOe4BZRGR0S6QzDMMwmk7bKSgRmQi8qqqPREFjgFcC91Tvl8pjNxGZLCKTcSaTDcMwjF5GS+xBicg/gZRNnoOBXwDrppIl/JK2QlT1TODMugU0DMMwWk5LFJSqrp3yF5ElgPmAR0QEYCzwoIgsj3tjmjuIPhZ4rcmiGoZhGC2irYb4VPUxVZ1DVcep6jicUlpGVd8ArgS297P5VgQ+UNXXWymvYRiG0Tx6k8n3a4ENgSnAp8BOrRXHMAzDaCbTvcl3wzAMo3fSVkN8hmEYhpFhCsowDMNoS0xBGYZhGG2JKSjDMAyjLTEFZRiGYbQlpqAMwzCMtsQUlGEYhtGWmIIyDMMw2hJTUIZhGEZbYgrKMAzDaEtMQRmGYRhtiSkowzAMoy1pawUlIv1F5CERudq75xORe0XkORGZJCKDWi2jYRiG0RzaWkEBewNPBe7jgBNUdTzwHrBLS6QyDMMwmk7bKigRGQtsBJzt3QKsCVzmo5wPbNoa6QzDMIxm07YKCjgR2B/42rtHAu+r6lfePRUYk0ooIruJyGS/Pd58UQ3DMIxG05YKSkQ2Bt5S1QdC70TUpLVFVT1TVZdT1eWAz5sho2EYhtFc2tXk+yrARBHZEBgCDMe9Uc0iIgP8W9RY4LUWymgYhmE0kbZ8g1LVg1R1rKqOA7YGblHVbYFbgS19tB2AK1okomEYhtFk2lJBFXAAsJ+ITMF9kzqnxfIYhmEYTUJUk59xphtEZLL/FmUYhmH0InrbG5RhGIbRRzAFZRiGYbQlpqAMwzCMtsQUlGEYhtGWmIIyDMMw2hJTUL0MERkgIjO3Wo7pFRFZQES6/QO7iMzYCHkMoy9jCqr3cQjwfquFaCUi0sx2OwX4SXcyEJGBwEeNEcfojYjI/CIyU+TXT0QGt0qmPLxcK7ZajhSmoHof87VagFYiIuOAaU0uZmZf1qIiMrSO9D12X4nIDCKyfU+VZ5TmeeD0yO8Q2nNt0NWBu1stRApTUEZvY9YeLOtJ4OA60gl0mIhpNhOB80XkByJyTA+U17aIyCgRmSFwrywirVyJYEQgiwBrt1CWIga2WoA8TEEZvY2efuCU/pYkInOLyIVUVt7PVVAicqeIzNNd4YIyDgQOakB+tRXuLFuv19Pl5vAGcEbg/karBPGE139V4Fs1ZyDyqojMlfBfREQW7I5wYXYNyie/AJGPww6UiJwjIptUS2cKqvfRv9UCNAIRGScic9eRtJ3X5lob+D6VG77o/loZWL5ahiJylogsVaLsr6pHaQpbAdukAkRkTJ1DpN1hdHC8UQ+XHRM++IfXmcdcwMYicqqI/Dzwfwp4pG7JOvPdshFFZJCIzOmPJ4rIdgVx5xCRN71zGJ07UDsDP6xWnimokojIMP/9Iy98YJM/3mdsURQoIreKyJZFcRqBiKwmIquUiDdQRIYlgp4HHoji9heR66tkmaugRGQmfwP1F5E9qslWklp6l4v4fdYOkmlFZK0oXhG74pReHlkZpRWUiOwkIseViDe6WpwqTAVO6mYe3aFQQYnIt0WkmR2+8Pp2arciMkREBpXM5wxgD+DIyL/L0JyIrCMiB/njwSKytIjMJSJDgjh/8aaMsqHHXUrKAXAs8Lo/vgK4oCDugsAcBeFV278pqPL8HnhRRBbOehARHwIn9IAcg8D1ZHLC1wA26wE5bgduFZF/i8iognh/AD5O+Pej6/DZUGA9ABH5v5x81Ydn33kmBt8Z3gfOw00kOdWH3ysipb5bBR2MgfEMrJLs7/dZPv28gh4RxdsmileNoniZgpq3ZF7gerL7i8jE3ExFvkV5e2vZNRmQ6KTNXoNcsQyj4zbQ4DeyW0godnHkluNnvR1U4vtW2EGJ4z4OXJ2T/5oi8t1E/rE79e3oUCAbStsDeBB4FTg+iLMtcI1XWsfmi59k32oRROTXIrIj+R20Cf5wg2p5mYLyiMhYEYl7KCEj/f5p4KpE+BDqHPP2N3bZnlx20WcWkRVFZJGOAN8rAlREFheRZs/MGYgzLrlMFyHdB+tLgIUK0g8tmEhwEnC8iBwW+Wc3aaZAQptg/ai8xeBvwOVDGaoonn38/mBch8MnkedFZPU4sogcKyKL++PwgRYO8R0NvJtTXj8RuSinwxNSZlizkxL2irufP543evvP5LtCRDS+Bv4N7468gkTkDhEJP/hn8r2I6yCUQkS2EJG9RGTznChPEbxli8hI4FMR2UdEhntFErefLnUlIieV7aR4fuLLOSsnfBkqSqCIpIISkTOABYB1vPtgERkqIrP5c7wZuCSRXxelKSJLRs+OrLMwBgjbVepN5ltUOlVhnkeLSOnrmOBA3D2Ud28/UTonVZ2uN2ByyXg/xV3cAcCvgPeCsFt8WLa9gHs4zwpc4eMocKs/fhvY3h8fCWzlj8cAIxJlZ/nOC8xbRc4s7uyZLN7/NOAf3u9C30A0SCfAMv74AmCkP94dOLCgvNWAYYG7PzB/VB8bAZsADwbxNvNht2RyAP8H/Dk6jwlBmpmCuB35R/IsntVVHM9vD+KGFhT3RqvAMVH9XZpzro8n8jvZ7w/NuRa/88fHBmlm9fsZgL8kzuHsqIz7vP/suI7QTMCxQRnHA2t699CsTO/eN1VX3r2IP34f+DwIez4qv18k335hft49GFgnyPuE4Pgc3DCkAk9EMvwTeAj3tjwgpy13qp9E+JY4Zb964PcL3LTtL+P4/nhUdI6bAYMT7VOBWYB1g7SnJepzaBC+YiJ8dELuB4G9gP8C60fyhLKGfvG1iTdJpAnluD0vbUK+S3PC3/Z+I4Gxgf8sKbkLrtuqqbiRXOOAd3KfP3kB08tGeQW1X1BpNweV+WzOBb84uMATs3TBBfhjcPxQ4iKdir9hE3n/sEDOLM6cfv8iTqkq8Fkir7uAHwNLe/cwv+90w+SU1c+HHxb47ZYo4zLgj1Ej3yyK0w94LNFIFwvSLOH95s+TLWv0wHY5dfcgMD7hP0fRTeXDvk6kOyWrA+Ao3Efr8dm5AKf4tCcHaeby+xkDPwnKiRVUVifvJPzCeFfieu8KrIV7+N8TxbmUygN2YZ/HV979X9wb5QtRmi2iejgkIcMKfp91jE4MwsLz+RLf6UjUZabMF4jDg7KvAY7AfUQP0/5fIr84bSjzglG8HwdhX0Rho4L8nwHODMJ292lGevcRuGH0LPxbuIkZCqyUOO//krjfgm1Q5P5f3nn6LfnMCOqgFgUVb8v68Ldz0k2J6jiLsyRuaLF/5J/dq8MCv2ujMtcPy+hyT/aksmjFRqSgcA/KIYl4xwSVdkviIsTbYwm/m4I0pwbHk6kolDDfOQvKGBrIdhIwPIo7MTiePSePbHs/OD6pqPFGdbKLD/8tbhZSP+CXOWV0KChcr+ihKHxCcDwyOF40KG8P7/ePKK3g3uRmjmVOyPEQ7oZJybhY3vnS9a0w2272+8P9fm9gz4Qclwd+8/j98MBv3aCsixPlbJS6Jol4KyT88rbxPo8vA7+9cZ2aMN6lgWy/jcKyN5GVI/8TgWX98VmJsudM+P2DSltdIwq7s8r9FreJLm038DsMN4QWxjugoE7nwg11Ze5zo/AtqLwVK+6tKCXLesBsOWHr5vgvX8P1VJxC7Bf7B3VwX0HaacCOVfKfjXwFFXbgfpFI+xRuJmvmXq3E+ZwelhFvffEb1CHAZ+G3CBEZS+3/kHyd8JslOJ4WHWczXxCRu/zhEP+dJsUzInKtiFyJ691dHoWH315yvxd4wrX7UjPqEJF5/X6aiFzux/azcftZgQ98OXlLtahPr7i3znhqdDjuHFo4/lpELhCRpfETG3DDhSHL4HqGnZZ4Sn0Xwg2rxZMSMpJTfX0+p+WkWTOL5vc/x71Vhelfi2TO1vIbGfhNEpH1fT1PoCtdPphLek3AVLvL41kROR5/bTzL0vVbxpYiktXNalHYpX6fknmy36d+F3g94bcw8JY/XjMKW7nKd9iq/8wEHJ7wK8r7LiCc1RhPPriM8j/Zvp3jn3fdFi4ZL+MOnBLqhIhcLW79x28WpO2He9Mvoj9OSaUIvyn9KhG+CJ2v035VygL3iSGfVr/htOANahLuhv0+MCinR3Wv38+YCMu2R3P8x/l9OATyfkE+ZbepuB5Kd/P5e0HYXcHxJLoOH1XtCdWxHeX3+9WZPrWdnOPf8eYTtYkyeR5RQ/nZm8UeibDbcQ/2es9tuQbWU7hlbzBFPfBw+0M3y/uowfIPjdzfjdyHZNe9RF6pb5Hh9rcc/7y3pKLtZw2sgwkl4sTDm/E2OuG3NU45lZHhtBrK6thyn98FD/b+wObApgQfN4HvtlrpNEhB/bxEg/2kG43lZNLfQqbXrV4F1ZPbA8HxOsD6NSioeraizkC9W963jEZsA5qYd7O366qEH9YDMpzSA2UUbUs0II/zcvzjIdO8ra7OeN7zu2iI7wLc0MpSwL+lsqzGjwvS9CbmApDin01nKAirxk9wQ119hW6bqOgBwiGKG4HrRKTMMEQjymsU1zUhz4x6/v1qF9avEt4TK7Ds2QNlFFH0m0xZdszxn1IyfUNNARUpqLlU9Zeqejjux8KzRWSNRhZeD34c/xkRmSIiB9aRxVZ+n/3z8u8GidbX6Q0KKvWQOj7h1yhq+W7SDoxptQBNZGyrBegBNm21AI2mSEENFm+7RFVfBL6DGy9dvCcES+E/op6K+wN5ArBN8Fey0Vp6g4JastUCtDmPtVqAJrJTqwUwaqdIQe1HMBtKVT/C9QibOSRSjeWBKar6gqr+Dzddt7f1UqdXftBqAQzDmL7IVVCqeo+qvgEdy2agqtNU9S89JVyCMcArgXsq0/ewhGEYxnRPYg1HoPxafPeKyLINlKdeUh+dtUskkd1EZLKITCZ/Tr9hGIbRHiQ/EZRVUAcAN0rCjINflPLOPDERsAAAEp9JREFU7khWA1Pp/FPgWBIrLqvqmaq6nKouh1s+xjAMw2hfkj/Xl1JQqnohsDFwkl95d6A4mzJP4mZBXdg4OQu5HxgvIvOJMzexNW59sr7GXdWjGH2IN1otgGF0k+QKN7X+9LoYzrbPB7i/4bciWgm5B3683RD3f9HzwMF1/Khb9MNYo/9ur3V7smS8xZtUvm1u+2YPlLFhA69vvGrC9LatgZtBXMs6hK3czqb1P+12d/tPD5c3Nvn8LqkURuHMCbwL3IBbkfZOYPZWrxTRYAV1dEHY21XSNmIrtVRKifMou31aMl68UGi92yUNyufYBuWTt32jB671OAKzDX57Mri++9SQ11K0vnPVtK3g/m3EEmI3NUHm1Rt4jzZ7y1uyan3Syx41/RqHW9lvUM/jbBWtparr4VZevg83eWJ6+Q/pVCoLY/48EZ76zjaN9GKHpyT8ypCyPBvzm8h9c0Hc31bJ6/ES5aGq4ZBi3qKqZchbWeEiv3+ZclZcD++GDNVYTFUfCdwP5sQ7ooY8UwunKu58Q84Pjp+rIf/XVLUnV4E4owfKuBVnB6qIRqwOcWgD8oiZluP/Ne7tqhaq/b81tcb8YibRdRHlQap6PfB5N/MOOS9yb5iMFVFWQS2pqtuo6kPg1J2q7otbAfh2EVmvvJwtZ/4c/72CB9PDifAt/P5i3OsvOGN0qYfuPnS1uhuv7t2BqmZ5lFka58+R+/3I/WZwfLTfN+wPc1WtZzmXrH2E7e1bfv93KjfhU4F/oRiRTFm9xTfUwrg1xMryB1V9MvLLvq/GHZF4dfkiDkv4fUDX631OcByuUB+veF1E3B6aQeoBPJL8pXbqedB9vyjQX/OUgroo4ZfHyyRMvgd8kOP/Du5tN4+sfYa/5PwEZ8OryMr1jZH7Xaqvbv5Kwu93VdKEiLp/XDvKVtUv/eH/4sjBvVZEaoWfTvWlquGSXXvkZVR2ksQLOf5n4JZBih+abYu6VTE+886PA/+4IXRaXl9Vp+Eu4m+oPFiyV1RwK5+HcU+O0mfK727getwwVUxo4gLcquox1XpMu/n9Tqr6oaqKql5Bwlw0lfP4TyIspu7ZkKp6I+4NNex534N7mJys7qdrcKsfl+kRasJvLPDrwL2Fqj4btN28N6G8fKfiRg0ykxLXEJgfB57OySM1aWcZv+84f1V9H2d64rTA7x38eniq+mHgX7imo6pmJizuAW4rihtwXJXwS0k//KBrXX6gqu+qakoRg7Mh9mv/cFuhjHDq/sFMtYWxVMyUp65p+MN4ZqAxj2qmxx/J8R9TJd9Mcb4E7qGuqqeq6m1Bnl/j7HJBpQMSKoS/4Yaar60iY0phFCm1Z+msOJ/y+63p3LmFivLeO/T017FoibiUEn4T2CEnfhdTM2FhjfjOs3CrvzWV/Qbl/TLjhJnRwaejMe51iJaXj9JnHxDPBX6YheNNMqTGywP37/3xxETYt/zxh96dWZ98DLdixipB3lf5sMvCcnBvIIo3OR/J/dco7h64N4GLvDtlXuPbPu0ukaxKgfVOgkkAkQxZuET+Rwbn/5yPc3Ai36VTdev9MmOKNyTKzIzMhTLHxhtnLdGe7vZx+ydkexqnJGP/k4O62yqvThJlxe2jcPwe12bDdpsyqplth+AegLPT2bBitvWns7XXzBzKF76s+737BOCgQIYfJ/JaK+/c/JYZe3wSN5tr/SDegIJrEVujXcP7v+bdD1epu+uoTIjZNBH+e7+/3u+XobPhybx8V/XhW6Sua/hs8vGH4ZTpgUEeA6NyPsEplrCc/3oZV6WzocljEjIdDZwZ5Pl2LJu/5nsE7swwYocB0CAs99tdIPM2gX+/wP+F4Pirwvut2g3Z2zdyTL77ynnQ78cF/u8D88QNMEr7MpUHz67BRTkwuoipi3ZiEL4LcFIQljXsC7z7ar/fLCH/YTkNJLOA+oOcG3pG6NLYMsWVNbr5/P6dIM4SwBuBrB/hvhMUNdJ9gFcS9a6xbFGcA3y8GVL5BvkcgzdT7f2+ncmYKDNTUDf4/SA6K5lnSranTKml7OPcQdeJD4pXnEEe/aM8j0vVCd7uUNyWgm1h4BeJdDPiVuufAaeE5sU9kD6kYq7j0NR1AQ5J+K8bHH/pj38EXFBwb12BM50+rCCOAgsF7qXquL/D+hjn/d4IzzFRb5nivh5nnHD3KF5mpn1h3BvbdTnXJ4u/MrBZ4F6lpOzZpKFBRfeH91srOH4d14nuj+/o0Vm5/SpxzrNHeb6cOqecc1wmlovKfdTFpEyQbr1Eus2Awf74qLgddim/1gbR2zaKFVTWC0zORvRhw4G1I/9XfNiMeFPd3n9x4Iog3mzAM9FFO7mgrPn88e7evbXfr5+I/4NEIzw8yGvZVDmpm4CKgjo3kvWFnPSZocfjyJk9VrbsnDjZ2+WwvHxxDw4pyicqc2+/z+wGDaCzknm2ZF7DgeXCcwm2OwL/zKjdIvjOREGe/Qk6SYH/ptH12JsSdZxTxlzAmCCvw1LXBVgg4b9ecPxlyfr+SYk44fU8mjp+WcEN1yvwt8BvV+CXiXOLH6DXJ2S6gUrHZbz3nwB8L1H22sAOiXJWLin7KHyntOj+8H5hp/msRF6rBOUvQ+Kco/iLAR+XvJbLx/kAP8V36qiM5qQU1Nm1ttVO5debsLdsFCuov9VTebj/Mrb0xwLMUhD34uiinVoi/92DNEunblxfbmhFdG6CnliV/D8E/hy4lwV+AQwBZvN+8+FMrhTlI1SGAdaiMlSTW6fVwqO42dveCuT0YkvmsxPu257iviUplSGHZXHfOibVkW+mNP7s90sGYf3wwzREQ7815N+fyrCn4t5Id6qlDgvkPjx1XYAFI/9jgeFBnMIhmSBeNQV1KIm3vzrP52Zgm4LwThZyAxlTCup6f3wZMLSOelVgpW5eG438JAr/Y07arEM7MDxf4JpuypMNpd6bE6cfruO2Em5GaZZuPbyF3XrL7w0mEprFWNyrfM0z3NR97MyOleKZU38Cvhe4y0xM6Zj+rX7mZEIGBT4Tkcyd90E7lXZ45H6AygSAz73fiyXyUUAzGXCNsgzVpr9nfAb8Q1Xv9ctpVTNKl0RVzwMI5MyGQ1DVB0RkfqrPlkpxPXCKukkxcZlfB3mWnS0b5zGNzh+jv1DV80RkU+qsi4AvI/cLuBmunWbcqWo8I6usEcbCtqCqjTCul+W1VpUop+Em6fwZ2C7wz/3NQlWrTXFvFnvhhsFCWeK6jK9dxiXAfar6pYgMA2ZS1XjiQ02on7Xn752k7TTf1j/EfZ+dKwrOm3Jfij6roFT1VX94cZOLihvIf6slUNV/U/5BcCGwba1CNYH3gUeBzavEOxSntKviH9DZzXoWbtZbdxFV7TSDTSuzCGtCVTcoGbUuBRWxGJV/o74HDO5GXt+k6wy264A9VbVoFmXWQy9D2Xg9SdiJG0L6Qf9SA8qpp7MDgKqeTDQDOEFSQXlF8YI//hT3I36j+Afuk0itHIpTnHXRZxVUi5ibxjxkQ95rcH71MLuqviMiD+HejnLblaoeVU8Bvid4Zp3yhTTDDHs1PqwepRgN/s9S1c/pxk+Uqjo54X05ML5Kukkli9ibbjyUmkB2jxyOm3WIqn6RiDeCxjzUm6mcPyW9aEBTUdXNqsdKpnuPzv/01YQpqObT0Vir9E7r5d0m5FkT6v7fyXpwjey1NYNWLKx6Au57Z9uiqrcAtzQor5MakU8DmQTcpe4H1Nz/+dT9m9YImtbGVDW9qGr7MZEGtCdTUL2fY+i8RI6Rz2jyVwdoGn4IcUpPl2s4fMepzM/ojeBEVY2XsOpzqGq8kk5dmIJqPi/i/rtoCn6oIrnSh9EZ9RaiDaNJPE3x2phGjZiCajKq+gHuT2zDMKZjVHXRVsswvdGI2UWGYRiG0XBMQRmGYRhtiSkowzAMoy0xBWUYhmG0JaagDMMwjLbEFJRhGIbRlpiCMgzDMNoSU1CGYRhGW9K2CkpEfiYiKiKzebeIyEkiMkVEHhWRZVoto2EYhtE82lJBicjcOJPG4ZpWG+BWWx4P7Aac3gLRDMMwjB6iLRUUbvXn/em8bP0mwAXquAeYRURGt0Q6wzAMo+m0nYISkYnAq6r6SBQ0hs4Gx6Z6v1Qeu4nIZBGZjDNMZhiGYfQyWrJYrIj8E5gzEXQw8Atg3VSyhF/SMJiqnkljjNsZhmEYLaIlCkpV1075i8gSwHzAIyICMBZ4UESWx70xzR1EHwu81mRRDcMwjBbRVkN8qvqYqs6hquNUdRxOKS3j7fhcCWzvZ/OtCHygqq+3Ul7DMAyjefQme1DXAhviLJN+CuzUWnEMwzCMZiKqyc840zUi8jjweavlaFNmA95ptRBtitVNMVY/+VjdFPOOqq4fe/amN6hG8rmqLtdqIdoREZlsdZPG6qYYq598rG7qo62+QRmGYRhGhikowzAMoy3pqwrK/pHKx+omH6ubYqx+8rG6qYM+OUnCMAzDaH/66huUYRiG0eaYgjIMwzDakj6loERkfRF5xtuUOrDV8vQEIjK3iNwqIk+JyBMisrf3n1VEbhKR5/x+hPfPtbslIjv4+M+JyA6tOqdGIyL9ReQhEbnau+cTkXv9eU4SkUHef7B3T/Hh44I8DvL+z4jIeq05k8YjIrOIyGUi8rRvQytZ23GIyL7+nnpcRP4qIkOs7TQYVe0TG9AfeB6YHxgEPAJMaLVcPXDeo3HLRQHMBDwLTAB+Axzo/Q8EjvPHGwLX4RbnXRG41/vPCrzg9yP88YhWn1+D6mg/4CLgau++BNjaH/8R+LE/3gP4oz/eGpjkjyf49jQYt5bk80D/Vp9Xg+rmfGBXfzwImMXajoKzpPAiMDRoMzta22ns1pfeoJYHpqjqC6r6P+BinI2p6RpVfV1VH/THHwFP4W6uTXAPH/x+U3+cZ3drPeAmVX1XVd8DbgK6/Pnd2xCRscBGwNneLcCawGU+Slw3WZ1dBqzl428CXKyqX6jqi7jluJbvmTNoHiIyHFgNOAdAVf+nqu9jbSdjADBURAYAMwCvY22nofQlBVXantT0ih9WWBq4FxilfrFdv5/DR8urp+m1/k7EGcf82rtHAu+r6lfeHZ5nRx348A98/Om1buYH3gbO80OgZ4vIMKztoKqvAr/DWf1+HdcWHsDaTkPpSwqqtD2p6RERmRH4G7CPqn5YFDXhpwX+vRYR2Rh4S1UfCL0TUbVK2HRXN54BwDLA6aq6NPAJbkgvjz5TP/672ya4Ybm5gGHABomofbXtNIS+pKD6rD0pERmIU04Xqurl3vtNP/yC37/l/fPqaXqsv1WAiSLyEm7Id03cG9UsftgGOp9nRx348JmBd5k+6wbceU1V1Xu9+zKcwrK2A2sDL6rq26r6JXA5sDLWdhpKX1JQ9wPj/SybQbgPlVe2WKam48e5zwGeUtXfB0FXAtlsqh2AKwL/lN2tG4B1RWSE7z2u6/16Lap6kKqOVWd7bGvgFlXdFrgV2NJHi+smq7MtfXz1/lv7mVrzAeOB+3roNJqGOjtsr4jIwt5rLeBJrO2AG9pbUURm8PdYVjfWdhpJq2dp9OSGm2X0LG6mzMGtlqeHzvlbuCGDR4GH/bYhbvz7ZuA5v5/VxxfgVF9HjwHLBXntjPuIOwXYqdXn1uB6WoPKLL75cQ+JKcClwGDvP8S7p/jw+YP0B/s6ewbYoNXn08B6WQqY7NvPP3Cz8KztuHM6AngaeBz4M24mnrWdBm621JFhGIbRlvSlIT7DMAyjF2EKyjAMw2hLTEEZhmEYbYkpKMMwDKMtMQVlGIZhtCWmoAyjDRGReUTkYxHp32pZDKNVmIIyjDZBRF4SkbUBVPVlVZ1RVae1Wi7DaBWmoAzDMIy2xBSUYbQBIvJnYB7gKj+0t7+IaLaum4jcJiJHi8hdPvwqERkpIheKyIcicn9kBG8Rb0zwXW8Ib6vWnJlh1I8pKMNoA1R1O9z6bt9R1Rlxhu9itga2w5ljWAC4GzgPZwjwKeCw/2/vjlEiCIIoDP8Fa2ZsaiaIsXgCMw+ggTcxFy9gugcQMzNNPMiCYLKbKQYmQhnUgBsIgo5aA/8HAz3M0NDRY3qgH8BQiXFLlTBuASfAZUTs/fIypFEZUNJ0zDNzkZnPVHPtIjPvsvqFrqiuL4Aj4CEz55n5llVYec3HIabSJMy+fkVSE6u18esn95vDeBs4iIintecz6kBTaTIMKKmPsU5ufgTuM/NwpPmkf+EWn9THiqpr+KkbYCciTiNiY7j2I2J3hLmlP2NASX2cA2fD1ty3/xdl5gtVCnhMtbMugQuqr0iaDPugJEkt+QUlSWrJgJIktWRASZJaMqAkSS0ZUJKklgwoSVJLBpQkqSUDSpLU0jtmhNiE9p84ewAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1340,7 +1340,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOydd7xdVZX4vyuB9EJCSEIInYA0RQREARUUUewNxbGMZbDhOM7oz7E7VuwzdtGxK2KjI1aaDKJREeldDCU9IT2BrN8fa6+39zn3nFveu+/d+5L9/Xze55x37in7nLP3anvtfURVyWQymUym3xjT6wJkMplMJlNFVlCZTCaT6UuygspkMplMX5IVVCaTyWT6kqygMplMJtOXZAWVyWQymb5kh14XoFNE5G5gDfAw8JCqHtHbEmUymUxmOBh1CipwvKou63UhMplMJjN85BBfJpPJZPqS0aigFPiliPxJRE6r2kFEThORheHv+hEuXyaTyWS6gIy2qY5EZJ6q3icis4FfAW9W1Sua7L8w91NlMpnM6GPUeVCqel9YLgHOAY7qbYkymUwmMxyMKgUlIpNFZKqvA08Fcggvk8lktkFGWxbfHOAcEQEr+w9U9ZLeFimTyWQyw8GoUlCqeifwqF6XI5PJZDLDz6gK8WUymUxm+yErqExmlCIiO0iId2cy2yJZQWW6hogcICKH9boc2xFbgDf2uhCZzHCRFdQwIiJbReToXpdjBPkd8JdeF2I4EZGTRGRur8uRcGCvC5DJDBdZQQ0vAmxPHsXWXhdgBLgE+EivC5HwcK8LkMkMF1lBZbrJ9qCg+o2Hel0AEXmziHxGRB7R67LUISLzReSYXpejXxGRD4vIKb0uR5msoDLdZJu15kXkZyJySfL/OBF5fA/L87qw2nMFBXwOeCvw+l4XxBGRx4jI2cmmj2Ih6O0KEXmpT27QgncDHx/u8jgiMkdEPt9qv6ygOkRE8jOrZ5tVUMDzgCeHdQVeC1zVu+LwlbDco4dlKFP5/sX4YpuCslscBpySXPOOUJbtpv2GDM/vAy9r85DJw1icMqcCp7fKQt1uXlY3EJF3AqvC+ngRmdnOYcNQjntE5PRun7cLDDrEJyKPFpERHTguIruIyE4dHLI6Wd93GMozTUQ+k/z/CBFREVkjIj9Kto9PDntJmParH6gzUA7Fsg33GrmiDExC4M9mbVge0OmJRORQEfmnrpRqZJlYWrZiJL+xNyMsd2y2U1ZQnfEiwC2yzwHLg6v6KgARebKIzAjrbSmmIJg7VWK7A0/o8JiRYCh9UH8G3tmtgtQRxg65gP8rnYV9VoWlAvuH8w3aABGRKSKSfk7gaOCtIvIuEfkQ0TuagtU9Z7fSqcr/dx0RmS4iDYKu5JFsLf02NtzfIWFTU2HUDYJCPxqYFjZNCEsv+6Ednu8YYCHwve6UcGQQkRsAN2raVVBDveajROSxbe6+S1hOarZTVlCdkTawXcPyXcA3wvqviUJ2XFim1m4VfwYG03nbD30PZVqG+ERkgYjsWfPzE0TknUHItHpug+VtwMawPh04uINjHwxLAY5MzjFYZkJByXmd+QjwHiresYicS2zczrArKOBe4KwQrjsp2Z6G7crv35WEG1MTGEYSD3wa8b34NR9TKlOrcx0mInsAPyG+l1FBiOwcBDwjbGqqBERkbFgdqgFxJfD7NvedFZb3icj763bKCqoz0he4ISx3L+3jVmTZcmvGYBruqFRQwK3A1TW/zQI+GNZ3rdlnqOwEICI7YkK3E7whz8QE4N+BnYdQlvGlZVq/NmF1J03MGA88Byhny3VFQYnIJBGpO9dkYD6wIC0TUfBDvYJ6Uli2ZcmLyBNEZDBtwsOuDwNPCesTRGQf4Lnh/3bDoX8BLiCRkb2etSOEgH/Uek+Wl/5v9dy93g3VgOhEn7iRNZEmn0zKCqozUgGyPl0mldcbqVeKdl76YCp+PyYktBviq/M6dsE8Shg+BeWDbGcDazo81i3pA4F7sD6poXT8TwlLF5peZ+4K596baAgB/CYs0zr1aYagoEpC99PAoia7r6HRGj8VC5VCY5309+z9PrVtQUSmiogru8uBFzcpRx1uLE4FPNQ0AQvJgrXVWSLSbnh8PNEogd7Ly3lExduK9Gvjw6qgRORtIdTbyfOZlayvqtup1w+8J4jIWwfZsVyloLyBu7U4GA9qTLDoO6FrHpSI3CEir03+nzJIa7FdpTkQMhGRfxIRt6DcM7mF4VNQ88JyDualdIKHkBZgCmoD7XsFVUpkSmnpAn0FpkA/j4Ujvwt8iFjXfL+FmBc4FA9qq4gcHtYne1lF5CsV+27ysibhtMOBL9Wc++zS/80E4H8DC5M+rY1VO4nIrjV9YYKFtSA+n9vDNV3JbMZCp5c3KUfKWIoystdff9iJFkokyLVNwNeTzU1DfFh7fKjVuWuuNxb4JFZfO1VQ94T1rKAcEXkl8BkGkc1DdYjPwzNuEZQ9qFpBm8R+F2CNpxO6GeLbBzg2+X8N0DRrSUQ+LiLl8Fa7HlTa0L8H/E9Yn4AJl1sxBTIcTMf6kmYTFFQHytjLPRbzNDaQNH4ReWJVGrPY/ISLKq5zRVi6seQZhSuw8BLABlV9BfBzove3M3Chqh5JUFAicoKIvDbxQjrh5LD0PrbDgNe50ZTc045JGV2Y7QXcFNbL/YZpKHINNcpcRE4AXh3+dWVXZ7DdB3w+9GWmCSYnE+vRdCzMdWcokxtEAwZU6NBvpXDGUPSgGvYXkZki0koBdIvpwMQW9XVX4H5VTZ/NK0TkbBGZXXPMOOzdD8aDcsO8QUGJyL8FeUtpu2Dy8r6waWXdybc7BUX8ntQuInJihZBtRtpZ6pXEhYsrqMNEZBfiy35kk/N5gz4EQER2F5GG712JyLMqKmVTBSWWotxJosH60v+1noGITAf+H4339rD/LvWTxlaV+2FMuQmWfnpXWCIiR1RZzENgcjj/HKLAaRAwIrKnGxCJgE6f573YM5sY9hHgMuBxFdd0r63OKPI6lHpQ3hfnnsRqoqc0m2ggrcCUxonA1zCvqi2SOuVLT6O/MCy9T8c9vNnE9OCJoZ9oCtYxvojmCUHLqReA/5as+ztplv6/F+FZisjeYZsL5DWY0NyEPbsJxHabJkhcC7ykyTWgPQ9qOfCdFufpFv5MmiVtzKQ6XfwUrP+yih2xujymDaVdV6Y5NOqTz2JRgDLTw/V8mE5t5GV7VFAuiHcBfokJ2nYZBwOejzfG6ZhwdQX1HMxDm4B9jn5BE4vHz+GC4DJKWTAisjtwPlEwOK08qJuw0f0DAlZErpH62Q/WhX280qyt2Q+sbwRgeuneXEicQf2ksZvDdfZKtrly2og9k3uJ9/tH4D+alKVTJhEVlAvMKmF4NzYYl2S/KcSw4L0UQ3zuPVYpZs9avElE5gOUkgBcAaQe1Lqwnioory//nGzfFLa3lZ1Wws/nZVlX+t0V9zTMwt6HKFQmYh7dA6q6BZuFoKygbgc+FdaXUa+gUuNIgCU0V1ATiM/7zuRebgbOwtpklYIqe2XuIV4iIu8TkVdLMg6N9kN8TScPFpFmRmonlL3XKvxdVVHn6Y3D2qU/r05I+xnHVvxeZVzOwurDc4FLaaJwt0cF5Zanu7tlz2EAEfmtiKShpnGYEJ4PvCls2wkTVh9L9tuMvZhlYb2sXByvDC7wd6Wxgnhnb/klthPi88rxsNg8aUdhfQaIyK9E5IeJgvHn4o2gWR+dC6JzgH+p+L1Zf9qWsLwr2TaWYohzJVEQQvSmxorI50TkzU3O34pJmFCbQ3w+dcJwRggjufCfiikPiB7UpJLVWdUftFey/szgXaaGwm9DOC31oLxepgoqxd/XZqxuDCioJHTcioGBnCLyYhrT11MFdS9m6b4mbJuAPcMl4X9XlClupIF5GnWecKoYp2F9E55tWTX+ajyNymISZhRtoF5B/aB0jNfFkzBv6lSCURdoV0GVFTsi8q8icmoo+19D3T05REMG25fl9aMuVHo0FtVIFdTlxPFQk5N9dwnt/1Zsiqp9GJyC8rbz7FJZ3OjaoSIEuguwTFVvAi4mK6gCLti9MTbzFI4HHg0D4RCP1aZhuBlY400HAK7BXvSG8Nv89KRJh7lXhlml31OvxBXk+NJv7SQkpErM+wM83vsUbJzEk5Lr7k/saP5ak/OmgqhqTFNlf5rYIOaqDD5XUF4fV1JU6l7Bnw+8GRskXT73vDYt1dSDmggsrSkTRKMjfT+pgnIPKn0eZSEPRQV1NCZIPwn8gWgoTSM29p/S6EGVhWDZg0qzCdsNifp+RwI/pBhqA1Nc7p09iGX5HZocO5GoSKsU1GTgb2F9KfVGT3pvuwCLk7I9APy4tP8EkvsVkVnh3Ouw55KG+CZj7fYyipltAN+VOKZrDObx4V4uVi9d2a+lXkFVyZD/waIzaaTlbCwa8sea87SilQd1NfaOUgW1hpgUkiqKY7BMyQXECEXbST8J3k7LuuSOZH2dFJPAZmH1AaKBVcn2qKA8DOWj9Ft5IgeJyBOxh7gFe4kHJb/vRLQiHe9w3Ih1BHofBCKyAOsw/wGxopUtozRc4wLMK7pnvO0dzvfvIvLJ9PyJEkvvzRXJFIp4v8hELHvOO+ebJQ+kgqiqDjUoKLE50T5Zsa+fYxOxL+R+4Hmhrwtiwxq4roicWDrHhcR050rC/UzCBOBU7J4X0zycBEUF5QreFdQMovX4H7RWUO4RTwOWq+pSbDyVDy49VlX/QsmDKnV6QxMPivbH+nh9O7bm90OJAn8N8M3SsROTctQpqFvC+o2E2TcqSIds7IYJLxdaE2jsuxtLUSE/Dnuv60N53YNaAXwR6+PdrKoNng7wirAcQ2yHhyTbvH6vol5BpUMB0gzH64ltfCYxmWSwn+BpJ8QHRQX1EPH5pgqqKnPuQWBaCHm2OyOEp/Z7MtgDYVlOyDgiWfcQH1j9rY24DEpBicgEEXmTiJwVbuYH4f8RmVJjiHhD98ZSaMwi8l0ReWzSMf5RzPraiFX6uRTDeRNozEJ5mNh4vRPb8fVTiSO9y6QV0AWeN37vozolWHrvx2ZHcG4lekVpVp17bamC0nBepdpyqrNs0vJVhZOqPKivEcNDAIiICy/3oDYBqOpVwA1EQ6BK4JY7X+dV7OMp9C8N/47Dnsla7L4nYYpmeumYcoOZRbSSN2Cpykuwhv9RYujoD1QrqLlEIeH9jbOJAyofJCooD+W50CvXreWl36s8qHazylq1Vx+LNBHLJrwHq283YZmEE2n05ICBZ7gDdt/HYlmIDQlAgYcwT8vT65dRVHblOraFeL/Lwrp7UJuwNraJaDhOoT5L1qeQWoB5FVuSa48lGk2bSRSUiIxJDLhy9uovwnIHYluZgbVNaB61aUZ5dow6UgP6oaR8aTuqkv2rwzU85DmAiOwnIseH+06Vzz7AdZiCupVYz/9CEp2hGPrehaKC6roH9R3sRb4Dq8T/GS40UtksQ8EVlPf7lIXfy7CMlwarPTm2jFsj7n1MIHpQqygqqPR8BxBDRs6a0j5ezvFi2YEQBeLuFeWH0M+EhWi8cXulnSoibgm7glpFtbBqyMoKjfKpyaa0cnl90rBvKliqvizsRoIrqNSqux6r/FDsC3HKSmSgz0pEbheRncUyIvchKvBJRCHmGWj30ehBlRMOHoU1QoBNqvoRVd1KyXIO5a8KF87EEke+TxRO04id6+ux97NTOEfqMf2jdK7bwtKt5KokiVdIMQW7jlYKyr318URP7oOYkrwQe351HtRkYK0aV2H9SoVQd8I4bLjBhnAfS4FxIuL9m2PF0rndCHkoXPu/sH7QVwMfxt7teqyuCVGxTaJeQaVRhj2w+uAKYDLWHp8Y9tsBBkL0boSCtc15icKaihlY6bilmcSwfO24Hyf0vf22tNnraav3dmVYPhur+14XUllRlXE5CRtz5+VN+TjwW+B0LOrg7IFlRM7AZNlEERmHtZm0nzk13IY9xDdXVc9U1XtUdXVYfo3hG7sygIg8TURuCULoPwdxCn9Znl6edhy+MaxupWiRulBJn9fRxJRer3AuND38UaWgUg9mHjFW6+Vajk3PskpEjsQ60+/AKttULJ3XheXehEYoNhK/nNo+mVgRn4F5C1OxLDC/5rhQxiqrO7WIff1ErJI6C5J1v3+/x6nh2DcRQ4z/FZapFfkoLAyWVvx/EMMHc4NF/sXk93Ld9VRZMC9lH6zhADw6hAsnh302YYJwK9V9UOWkluOBX9FIWUGtAw4WkQtDZ/g3Q2OdAHxYVV9GcQCqe4GPxYyO1INyriv971mE/vy8gaf1td2ssU48rXRQs39mZC7NFVQaUluJCfJJIjJZisMpxofj/Vz3Y/d0Zvh/LBYidGWdRijWED+Dsh5TDGBe27fCejMPqmzo3BfK80Aow3QsajGgoGicAWQy1rb8g3/TsIHHqYLaA/PWLqF+qq+UBVi9S9mJmIBVxQ3Akar6AQBVvUBV/070oFLZMwE4r3T8I4lG4fESJ77eA+v/hca5K6diGa9gsmsy8EKsfS7BDAgohvyG3YO6IoT1Xi4izw7L7zHMHwQLFvkXgadjFuepInJQ86MaKFuWqVXhAnArxZf5BS9CWG5W1WuIcVUPw6Rxc0+SKHf4p8JwPtb/ADGjaB3WQKYDz8Re4CLgvcALwn5+nfRbQJ9Pzu2VaArFcMDZFC0Z96CWUnTp3QJ7Igx0Gm8MFmLqCV0BPF5EvA/Dn6Vb866YX5cc4x6je9vpR+6eR3ym64gC9NHhN4jPaS8R+XoonxtGaefzGIpTGU0mZp1txCzEtdi9nyYi70r2LQ+uPga4JqyniqCcAeoC+RmYEv9n7N2vTDyiVFCWld4EEsWtqqKq95f28fP4c6jyoGZBZaiyPKNFOyH5zdg9p4r1nZiymEcxxFdOnR9QUOH+H8DewXuBa0XkoFCnxtOYxVkO8fk4m+sxpeJKLX3H95CMA1PVZZgynUq9gir3K90f7sOfL6q6maKC8nfgXobX0/1E5ECsjV1LUUG9jdjnWTteTIxxVE9/NhOTF+WQ9K5BNk6hcR4+km1lD6rZTCq7E/uM0zT6ckr9ZEJySbjOlHDsp1V1Iyaz/pVGD2r4FJSqvgebcXkyJgwnA2eo6ruaHjh0jgJuV9U7Q6X5IfWDz+r4NdGyhurxI0pRQfl9lQc2uvfjQve/ieGyNMRXp6B2S471l5Smeu6JNRhvXAeHda/g6ZxiexKtFO/knUlRaNxIsYN2TDjX+RS9l5vD8sdJxQezorzD+kZVfSLwbeLg1LKCKic5gN3vYVg23hzihK2vUdV/qOqfwv/ljKJ9MeH9/GSb92m5N5wKISGOVAcTUgtDGTeFY9aFbXsDHxGRvUTkDZjg/QlFvO8vfX9VHpTjz2AGxX6kAaGgqn68K98HK5IhypQVlFvUqfDxelH1McNFInJcWJ+Ize+XljtN+Lk9nN+z4rzcitWXXWkR4itd+4FwjNenG7AIgQtLf9+bKAqtNFS8JPxWpaCuUtVVwJ+SbT49k9eNujFCzmJilmB67lRBednckNk5WR6EZc156Njbn7eB1TTvQ3pWKPPpUEi4AGvft9AYkr4PeENFmZ1fYN5b2YPaSDBCA7dQ5DUhcpImCZWzdicT5eBaTKacEcrkdWUpRQ9q+LP4VPUGVf0K8B1V/YqqXt/yoKGzG8WY/CIqxp2IyGkislBEFlJK4VbV64gzMK+lulN7K8ks1YnQEOwl3hi274c1qtXh/wswj8AHMa7AGlQa+nQB59cod4KnCmoPrFF7w52JCab0d2ce0WUfj1koe1MUGldSTIefhIUS1hGzmaDoGcwgeg0/ISYjeKW6DThGbEoTF5Ke1ValoJar6l9VdauqLiEKvnKG1QaKDWqvcC9pCMyVqu83TkRcaOyIPbfLwv9fDcsFRKE1n2j9gc1396Vwj/cTBez5qroSG1R4U7J/eaxSqrBcQR1IHEwK1Zb8+WFZlWVWR6qgUiH2pmS97qOK/j59rN73k998iqsfYkMTqjwosHpb9qCahfjAnulcilEMH76xiVhPykIrlVMrqFZQp6uqZ5C9BAtFe7lSD6oymSZhPeb57kR7CupuogyahtU7709NFZS34dVYqHN8ks6e4u/G2+MLYcAbnobVpaqs08OwZ1kOEbv8upU4j+IuxOfnBuKLsehF2auaT1G5VCkoVzap4k2/FLCEopydSZR764HZdRnD3Ugzv0YGN//XYKi6iQaLM/SPHaGqR1Ax7Ufo4AYTcFXzU23FKvK5FENQY7AxIwNpucGNTdmIVcbjsJDn3RRfqgttF36rMCvysvB/aknuhTXqdKaB1IPakygE5mGWo4fO/owJqLTS3EWx4vwVU2KbsXCTx/LTTtxp4fqXh/08acMb6b2YF/stiorot8m9pgK0KikEqhVU2hD3whp/2oBWhIyizxMFkXtNE0N5fH+3FE+iKGzT87lAn4k1uuMxr/3FAKp6AsU5Cl0hLQu/p9lc3iCPotjn0BBWSY5rZwDnjel5VLU8Hi7ts9on/aEi68z7cQY+FKmqvw6rs8O53YOqU1B1HlQhxBd4AKvr6X1+BXhpON7rS/lcaVh1JVb33APwzLgBw1VVb0/uYzP2PteH39ZhMuO65L69T82v7Ubt0mR7qqC8bD/A6qWXe0firAwbMM+vnBruM4J8mMYEmHQ/56yQUezZjQ8BnxGRH0sywTMWev9NmNWjinVERbAEUzwbie/oHFVdS6MHtjsWNfkYFl4tK8fUEElD42n0ouxBTSV6sldh77Qyf6EbCuodwC9F5IXlH0L/1FUVxwyWRRS/vzSf4oPolGUEQVKK178bs4puVdWvJtvHqOqa8CJTUsXpltM8TDn9nWoF5Q3+ZlW9GntR3j/i3tvemILyY44L5U07a5cm69OJwvA2rCIMhKRC5U3DH2tCWTcFK8v7w9J+j2nE0MGq5F5cQaUC1+/pbEwY7SIiz6JoPZUVlBsQ5WdaVlA+oa4/6/PC+tMxJbCCmL0IUUGlgvUVqvrLUpnTdReE07Bw20JV/WNqhJRCcC6cf0LjZyr8nqdRvGdvmM+ic6Zgg2mfDFxUs49nTm2lMdnD331q1W9Q1RU0hndSb2YqjYq10oMSmwldiSHZlB2xsWLp8IqDk+OnYAkQZQ8qXff+KfcArsQUzcVUsymUJVUGc4ATiMrcv2/1rHA/87EwVSpwqzwoJ83MHAdsCfVkR2zqJYjP07N0GyaRFhsrOJNiMpAfuxsm69xAfCFwYmJ07Eyx3Za5F1PMzwz/P4I4mJlEsfn5bseiBbtjz+VcYtdBiiceQTGiU/agZod7/CrmRa/x66rqiYn3W2DICkpVv4/d9OdE5N0isqOIvEpEbsRGNX+/+Rk64o/Y3HZ7h47ElxDDI4PhNmCmiJxPY6hvTxo/aFc3cPXmZH0ZVll89P0KYKck7dcVxgYAVT03LN+DvbhNFLNcVhIrJViFeS8x8SDtM9iPqLBWYp2W5RDon5P19cQxIxAVVBp2nIZN3T+dYkquW+6p4Eozy67CLGNX8D8My7KF5vdZ50G5EnBPz9/JW7DGkc4+kTKJ4jgdiFO+eJmfRjHkln72olVfBcSG+UFVLX+4Eux5evjKWQGgqhdW7N8UVV2nqg+p6m9VtW6AuT9Pz6hKeXRYpiE+f75p3T6QEFqiuQc1gcaZJNxrO67imM9hz9WfVTqw2jvyfXqwun6JFZiCOQgzrB5W1TOaPA/3iFIPa6mqLk+u6XVyJXHA+FKsT/l94bc6BXUysQ5OJ4b4yvjz9XFWBW85yLMHMWVaVjTTsCEZt1IcLH0rUfHNpXHCgAGCkXUeMfpzCLAx9Nk1fB9LVRdgUZWdKT2/pMw+8H0dNh4wVayp47AMGwA8DpvNQ2hzLFhXZpIIHsCJmCWzDIuDfwA4QFXrvhUzmOs8hHUe/gLT7j9S1RuaH9WU32GV4lmYVXovsY9hX9r84qqq3qKqXgGXE+LcqrqxotPbFdTHKA1ADPtuxBSUW92TsEZyTrLfMuB/w79pY9g7OW4N9i7KVs8vkvV03jKSRp6GNqaF8hxHDD0eEP6HovB1JbMFe7Zzkm1vwAyZNBkDYsy8bKFvwKzJJUSBNllVF4VnvR57Nv4My2NLjsIawsDzV1W/hgvOuyg+PzdS9qI9BeXCPd03Hbvi4dj03mo/LZCWdRDcCuyT3OM6YLKIvE4aZ+x3RZwqqFgI1ZtV1et+Mw8Kiu/PPRuwlOvnpgeE/t9vh38PwRKWnD9i8zq+msYQX9V1D6goUxX+fqvasrcVP89yYt1YqqofU9UPhf8PxyaBJpTN6/ViYh2cTgzxgc3mDUXDbiuJghKRX4jIvsS29bxQrtSQnIoZn7eHfm4v7y4UxyvVKqjAHcSZTNyDQlWvrNl/Feb5eJ/R07HBt35/XwbGBi/o3ar6ZSz56dxS1OFh7Ll8M9nW1qd5hqygRGSOiJyBudpXhb9NwKXtFqITVPViVd1fVfdV1Y8M4VR7YuMs/KX64GOfJWJfGsOHVTHjMiuwilr3tdbpmNV1Zs3z2YhZQ6uw+PxPQyM5M90p6Xtw72pdabkFU1CPJVEKqvp7zAODaP2mQnqSql6a/P/psFxGsMhV9VZVvaviWLeKthDT6/0aa1T1orLCTv4vC8oNmOW2TlUXhftKrfx1mHXncwyW+2J8XrlmUzGtKr0DD48+kYrO5go2AKvTfiBVfTLRE01DUc7FFA2AlKEoqDHJOxmPhagmY3XIswT9ulUe1KXE/q2ULVR7UC7cywoq9S6OqTif3+NNxPb0hiDkvq6qF9Pag3IqP2pYwp991ft0D2oj9vxuTvYvC/udgEeGBINxxGf5IEUFtSMhgUVV/z1s93ZxCSYf0+f0VMx4c4U8G1ihqmm//lTsHbgR5vu+jqL3Uzb+yizGPDGv8w3GCcU2thpzOnYMxvYlmJwfF7yn15UPVtUvqOrzytsDL63ZXks3PKg7MGH/ZFU9CYsv/wFLnuh0jNKIoTa42FMgnaNU9buYtbU3RatrGTFM1ey8LvzqvjM1HVhc4Vk5Pp3SSlV9Q7A6oTq8eCgxbu7C1RXCFuzenoa53ycnx11DnP2unVYAACAASURBVEgTknCDxtRnD1vuj1XkR2GenCu3tLyON+otlAYoV3Tmp+ykqreVtrkH5Qq3bjZvn+jy71TzUcz7/L+kLJ4mXfZm7iLOOtGOB7WYmNyS4gLAFdSAElfVc1S17sNxQ1FQ6TvcjAlFV0QuuG7AFFE696OHml+vquVBmGDeZFV2lz+78owWA538qnotjewcfttKfCfl8WQ+pupuzFh4DdFwXFbarxX+7KsMRhf4y5P26MqkzohYghl9Xo411HtQjt/fv2PPbT7FPsgdKSZH+LP9aVjOJiaFlElD+HVtwNmA9X25d1ZnRKf7FwjvLR2L2S7lmeTbohsK6pGqeqraBJeo8VZsaozLJc4W3K8MWEpqE3dCFKypgppLHA/Vik81+a1qtoAU96DKwrOhQqjq9ar6F1WdSOzo9cbwEGYhCvA9Vf15ctyvwjEe0mqYZFVVDySOBp+ITY//cVX9cGnXVEh4R6cLyPG0IehVtep5+H24giqE8IJA8fdzLaaIoDgv2uPVUtqfr6rHlI6fq40ZT6uJgqlqwGO53CtU9bkVP7kyrvKg6riUwfen/oQ4RY2zjuhdpjMJ3AacFAY3P5ZqKzql0Gea4NEFH2LxMNZ3soDmpB6Qj58p9z963d8L+IeqfoOYnZp6Ce08V9+nQRirDXWQEDZz7g7LOgUFxXE8qYKaRKOCup/4bbTbqW77Ph7R8Wf0Eqz9XYQZa1X3uxPR872n4vcUf4fe/1mloNL3XDfpcLMQbB0far1LI91IkrizZvtXsQlRyw2n36iK204G7iuFbh5u4vWU+S8snbmKVgpqE2bllPtU/lyxb4oLjPRLq1vBBGnNMdPC77dX/Rju98thvW4kftpovHPXs5hWYQr3ZS3KXoUrNhdeVQrDDYaPEZWjjwWbotY32gmriRZ0K2u0GWUPqqUgVdUTVPWNrfarOfZFqvq+0uZ1xEHZ40OSzhFYX9VjsOd1NO2PvSrv5+ndqQFyPcVMyireTjSMXBGVw76biLNspDNmQLG9tqOgyoZOK1xplhVUKszTJKYNRDk6kfjVAwBUdR7wKuCEEMasSuZIpySDmEjzEHH6pFlUe1DvxGTKvTTv3/SyQrzHKgV1LNGwqVN4g1FQLecfrGJYP7ehNhbhuJY79pal2EzK5Wy3Vu5vLaq6Vi2duUAy2K5jD0pV/9GiTJeF5VqsQ/UntB5X085XWFv1xVSF+LxvYQ3WmNvpKyhTVlBVwwncg1pObHyvAY7X6k8rtGIVQTDVCJJ2ccNmIjaWqh1B2m3S+08HPJeFzrmDOB9qWXBQrKd/pzT2qoyqblJL8kn7H6vqodclN4xc6a8kTsrcTj+hT77bbn/4YuCftHF8Y+oZziOki5eMVp/jsWDMqWUNpv26ZaZQDAUPGGOqejkWeq7zoADuUNX5bRjQ6VyHUO1V3q2qPuTgx5iCPLm02wban8fRSRVUO+FzYAS+B5XcbL+yBJt1uSwAByNU6/D5wWZj3kXdYDqwSjiWamuoth9Hbc62uWrjtO4IDbLV+/0UxU+HVFH7xeFAOUNtDsHrwpTlzgzuWZYH8N5RsY/3k60IAmWMqq5U1csGcT2whIcraf5F4HYoC8M673M4SdN40+mZfkmsR59Q1VbCwiMBDfUghMdSwbOCivE9LVhK/OpuStqfCeaxXB7qtUdlWiUFQHtKbIDQRVHVX5I+z8dgKe7pe32YOGyj0/c9Getj+hM2QLpc5nWYgqprR+0mH/g7dO+vqeEUnsWP0+6BwHLq+9jrzuVl/x1xlvyWbI8fLCyzlGr3v2sKSlWPJI6mbtVg/LpVLnHTr+iqarnBvoc45UvV/l/S1vMntnLNC5N8quqSxFpdR31ooimJEner8MM0Vmw3KsqfqBgsK8N5huI9gSUJPUCcVbzXHpR7KJcF4efhuXbCND4AuR2PdAVxKqFWIWkAVHW2qi6s+KmgoNTGgD0pbEsTLVrRVjnaoBweKyv2VEE1M0CdNCTrHtSmpB88ZT3NPah2owV+D4OODgWWUppCrgNWduK0tDO1yrbOr6gOH3XTg4I4ALddBVXlQXUkOIPCasfKbMZPaR6mTRtNWZmtoz77qF0ehoHswsKnslVVRWRWEm4aKq06mdvlXyh+obWXCir9RpX3052KJZb8unxQBZ304XhSzuexz50PBe8XrfJGfkabnyZX1b9RP8C+bVR1a5i0wacQS9vxn8P/87EIQisPahesTnwQaxsDCqpm/3VUj0VLf2+HVEFdTHGCgU4oT13ULq+l8fMxTdnuFZTaJKBVnwkZDgX1C1qPoPZKWKWg/o0R+OZWSvAmmn1G5SHMyzmLOOO34w2nVaZYM5oOxO6icoKhJUYMEJJrHhYRV9i9CPH5s1+JeVAPE8atqOpfaV9o+3lahXohypMZFX04neID5huMMrVJhj9b3j4CvBQr14soKgX/BI2/5/LXnguo6rJkarXFmILai3rPy6+VPtMLMVnxghZdBineDteqat3XvNthGfHjk69vtmOKqv5v672KbPcKqoZnMXjrog6vvFOa7tXEg1LVluOwRprgxawATqtITKhqWJ3wdKrHGXWbE7BU/I76K1qhqg8Fq7vTMSPdwBXKakxB3dJGf1MV5QHgzfg+NjC4o/6JKlR1qYgc30Fyw7CjqmcBhHe6Ndm+JdkO7YX4XPEuxhK0ms24k04nBfB+LPJzevXutZRnUhksa7AQ32otzlXadXIfVAWqemFd6vUQ8MrRqp+kmQfVryyoyZpzb3FQDUJVL+mCJd7OdS5V1YbPtnSJFxA/0z5iaBwisQmbcqjZN4iasaG0bHZNf9+D7Z8on++ybpxnBPEJfFsq86S/dAWtjdaCoaeqHwxDKDqS38EAe3wX+mo3YHWq/CXqrpMV1MjhHlSr/gi3voYyS/uIEsKkVQzVgxr1qOrPtPksGsPNTlh/TdP07zpCJpd04MmcSZxvb1umKpnhjLDsxFN9kDjjx+Nr9vF2VJYdHc9Dqp2PDaxiI9YP98dWOw6VHOIbOdxqadXQZ0JhYtPRzHavoPqAA1rv0j1UtWF+tm2QOVQrKPcgOwkVj8MchbVNlEddosqnsGnLRhr3ps9pulcXyB7UyOHTofyq6V6jyHNqg24kSWQGz6mUZhTPDJ0wlKIqTFY3b2QzPLzX7Bg/byHBSm0C11byZDio+oL0sJA9qJFjLIBWz902gNoMFENOi+0T6kITmRHAk2pE5Er6f0aXbYHBeFA+312r2WWgfww9L0c7mZ1DIntQI8fY1rtsc6wDNvdTJtZ2SrcGq2aa4wZZu31QnwD+J6w3Gy4h0JWB6N0ie1DbINujglpL7n/qB95G42dSMt1nLfDpdsclqeo7YGCOzmazK/RbRCUrqG2Q7dFbXUdWUD0nDLYe6vQ2mRaESMHbWu7YeNz3WuzSbwoqh/i2QfbqdQF6QFZQmczQ6Tc5nT2obZDjKX6sbXtgHf3TsZvJjFYWMrSvLXebTqa/GhJZQY0QqtqL8Qq95lag4/m3MplMRFV/QX95UT5AeNiNT+mfxJDhQUQWquoRvS5HJpPJbCuIyMTwhYFhpZ+0clNE5AMicq+IXBv+yl95zGQymcwIMBLKCUZfiO+zqvqpXhcik8lkMsPPqPGgMplMJrN9MdoU1Okicp2IfENEZtTtJCKnichCEVnI4D8zkMlkMpke0ldJEiLya2BuxU/vxr7WugxLt/wQsKuqvnoEi5fJZDKZEaSvFFS7iMhewIWqekiPi5LJZDKZYWLUhPhEZNfk3+cB1/eqLJlMJpMZfkZTFt8nROQwLMR3N7A9fBgtk8lktltGZYgvk8lkMts+oybEl8lkMpnti6ygMplMJtOXZAWVyWQymb4kK6hMJpPJ9CVZQWUymUymL8kKKpPJZDJ9SVZQmUwmk+lLsoLKZDKZTF+SFVQmk8lk+pKsoDKZTCbTl2QFlclkMpm+JCuoTCaTyfQlfamgwhdzl4jI9cm2mSLyKxG5LSxrv6ibyWQymdFPXyoo4FvA00rb/hP4jaouAH4T/s9kMpnMNkrffm6j/NVcEbkFeJKq3h8+XniZqh7QwyJmMplMZhjpVw+qijmqej9AWM6u21FEThORheEvf3k3k8lkRiGjSUG1jaqeqapHqOoRwMZelyeTyWQynTOaFNTiENojLJf0uDyZTCaTGUZGk4I6H3hlWH8lcF4Py5LJZDKZYaYvFZSInAVcDRwgIotE5DXAGcCJInIbcGL4P5PJZDLbKH2bxdctRGRh6IvKZDKZzCiiLz2oTCaTyWSygspkMplMX5IVVCaTyWT6kqygMplMJtOXZAWVyWSGjIjsICJTel2OzLZFVlCZzCARkX8XkWm9Lkef8ClgTa8LkSkiImNEZG6vyzFYsoLKZAbPp4ETel2IPuHQXhcgU8m/APf3uhCDJSuoTGYQiMgOYXXLMJ3/GyIydjjOPUzs0HqXTA/YB0BExve6IIMhK6hMZnDMCcup3T6xiIwDXpVcw7e/UESk29cbKiIyCXhCr8uRqWTXsNynp6UYJFlBbceIyEtF5C29LscoZV5YzhyGc3uywXwAEfknEfkU8GNg1jBcb6gc3usCZGrxPtLde1qKQZIV1PbN/wD/3etCjFKGU0EtDksXKh8E/iOs7wsgIqeKyMeH4dqD4ZHAucDWfg5LishhIvLRXpdjpBCRxwP7AfcQjJ3RRlZQXURE9hKRJ/W6HHWIyK4lAbLdvv+kD2mwuIKq/XDmEPCyzReRCRTDM77+ZuD/DcO1B8Mc4DrgDuCgHpelGa8G3tnrQowgVwEHA9fTZx6UiEz1zyc1Y7sVUN1ERB4hIvsDnwMuHeK5viAiO7ax34Ei8r0OT38f8Lrk/+3y/YvIXsCWIPwHy25Yw9+tG2WqYT6NAv95ofxLh/G6lYjI3iKyd8VPOwPLgIXAo0e2VB2xDmCk+/FE5J4eh9L7TkEB3wTuE5E3NttpuxRQ3URExgA3AZcBG5JtgznXDsCbgBlt7P5c4J86OLc3yp2SzT15/yIyrywkRGSciLy2jWMPEpGh9nncFZY7Nd2reN0dReTlYX0KcCxwAUNQUCLyOBF5rogcLSJVIZi3Aacn/28BXgicSQgDisgCEWn7PobInzBhV2ZnYDnwALBL1YEicqaIfGEYy9YOk8KyZfsSkUkioiIyJ/w/MySvDIbdgacN8thBISL7Jv+2paBE5OwRrEvez/rFZjtlBTV0jgpLAfYP6wMvWUTaUTaO92dMarrX4NgzLNPR/gPhPhF57WAV6yC4F3hWadsjga+JyMQwK0FdWS7DBGU3mN7BvguA74jI8diA1CcCZxGzpAAQkfkismf5YBEZW3FPFwDnYN8++3bYrywEX0X8OOclYXkvwRsAbgU+2cF9DIoQIZgBTBKRcqKGK6il1CgobDzOPw9bAdujk8xL/0TPHmG5HPi3IVx78hCO7QgROZRi3/INxJB03THjgVNokfAiIscOuYDGyuSctR7tdqmgRGT3Gou1nWNVRNLBmZMxITEN65C8m9AvISL7ASs6OL03/IKCEpFrReSDyf/jCcqlg3DFE8Myve8xyfm+RnueW7fYLVz7sSJyEeCj3R8H3InNTFDF1i5c+1pA6UxBuWL/YLLtfooKH6wu/F/F8XcA3ypt27liPxeeXwAOCOt/D8ubMQ/qURTryNq6QneRJybrzyj9tjewCAvz1SkoaFHOELocTtxwbGdKJg//zkqMhqHMlDEZQET+IiLdMrDquBp4JuY5KSaDKpWyiFwX+s33C5v2r9ov7CvAlVVeVsg0fW9VkkwwzsrJKSuT9VfXXXO7VFDAlcAtQzj+Rcn6eCy0MQnLlrmX2Eh3B3tBbZ7XFVTZ2noUxdj+RuBDYf1gEVnQxrn3wfoIUgHi5XLraqDvS0T2EZGWVp+HQAaBn/ulwMlED+9U7LnVjavZNMjrpUzFBOp0EfmyiPy0jWM8XfdYTEl+EfNiys9oIjBPRMrZfXsCL2+SRONfDp0A3KeqbwZuC9tuDMtJmLJ6NHAYZlQAPFg+mYjs3M7764ANybp7b4SO7hlYmLuZBwVNBHxoI3dJh9PyNItQiMg0EUk9dX+HU8PvY6R+AKtv34X4joeSWOPnOAw4fJizHf1aH8La+DrqlfKhWPvzUPXB/oOITBeRNDQ5MSwLzywY4t/DjLcfV1xjLvDOUt/6w8BbMM+6djaW7VVBbaWDMJoYY5LMr9eLyFPC+niiNbAKa6Se2eXhgXbjut64q8r294ptAH/DrPZymSdIMVNtFmaBp+EZf//uVU0Mx74Fs/ibho5EZDrwgHtx4Rk9Ofl9XROB4+d2L+IxmOHg/9d96rltISEis0XkwIqfpgL/wDyoFwLPb+N0qbf1ZFU9HTMUdiw95/WYB3VcUo7Uy/1qzfndM5wYzova567nY31OrwM+q6oLsXczC/glln5e9cXoZcAP2rivdkkt8L2S9X2BW1V1K6YoC5a6iDw7EUyrq04chPVD4d+2ZzwQkbuBFRKSXUTkOUm7BAuPni9xEtvpmDHpZfw8sT/SzzldRPYhelCpgqqUGSJysYg0U8zQ6MEMan48EblURI5uc/ebQx1aS3Ov8e2YkbGaREFhfaA/T/73c5Sfw23J+vMqzu/yMJU9kzDFeTPF+lRge1VQi9rdMTSeuykqHoBPiMhuWINyq34TsCTZz/snqkI5VVSG+AIbK7b9ocm5rqaYUTgLs3LThuTv3+dR80b57FJ56nBP0o87EPg1WFIBdh+F/pi0HyZYr955exxwMWGcD/XjizqZMfsMoveRMhVT+DvTfngsnRR2DQwokPXE8M1ETIH+iWJqeCqcfPBtua/JFdQEknetqveqcaaq3hE2L8cEyoZQ/pNF5CgaaegLa4cQdj2gtHkmcDbwQ+CTST/b7ljUAEqWejBgzsOsZKh/d2l97+T9ehmOCd7iucA3kt/9uX8rLKeHsvo1TqHUh4j1K95BVJT70EJBAU8HloR+uiq2YF51mgS0R82+rXhS+Ksk8SgXYsYrVBtSZfbEDKuDw3m+jt1Xij/P8nNoFdX4c1im8nMy1naaKs+OFZSIvKLTY/oJsQyw48J6Q4UTkcUi8pxk035YZZoJfD3Z/mhM0Z1FDI3dRzHM4ZWlqYISkaeLyFmYJQNJ2CgJBVRVrpuT/fYq3c8U4FiJYw3cg6pSUG7t3ygiJ2IVB+BFIvKqJkX3EJN7FxrKMpXolZUVzUTi/HUbiaG8nTGFuwC4nYpQUXgWk8J6O57UnWHfJ4vIxyUkYGDC57pwrRVhn1Ze7nTMQ4ZiSG0t8X15ssCdwD5J+HMX4jPdMSiyi0rn1yBkv0trj3tT2Gd9su/jw33MSOpB22EkETlJYsrv74E/S7GfdiZFxfvY4Bn+gGhUpM8CovHxReAv1Bsdab0thCVF5LdV7bTEr4mGxu4i8p9hfR8slOQKdFpY/5mIfJXq55waa/dgAtuvP7G8c3iXznGl3yaLyGcwhQexvYAZcx2RGHeVnmjgTcD5qnpkMKBIvKhmId8DMAN2vFgSzGuwqEZKnQd1U6mcOyTrqVJKuwMmYfV3DYNRUGLpvOW/gymOoxmNpO7xf1X8PhuLEzupFXooZpmUheN4zKp5A0UPyhtAoWGKyFtE5Gci8oGw6WLgJcSGnlYAbwC7i8jnS9e9OVm/C/hK8v9YTKB4yGMeJvgnlOLfGyhm+PySKEyhxv2W4iA79y68rLthzwIaQxmTKQr4L4flTWH7RGJDmRDChq8J+8zGFMqDWP9Rq1kcPLR2ADao9SCsMazFnt0J2Pu9i9bjd2YQQ6lpX8o64FIReSsWonwQM1LmYOHP8eGat2N9iYsxheWN1eujhnIeRouMK0xBCfaevEzu7a4A3h/WO5kg9KMUU369v8uZjD2307GQ9tnAB8Jv7wjLcp/cHsDlYf1WYEYp3Jley+vcNaFPwwXy8bSfyu9e6MfCch5wPjAl8ej/Gn57GdZWHy55s24Yjcfaz8E096BSQ+rh0m/PBd5K43v4KlYXOsWv1Wz83uMoepFOqzDfIzAD7E5KbT6EPCF6UGVFPZnopa6hWAcel6yn7XUyVl/W0iSrspkH9XssBvn25O9tDDJs0C1E5GkicouI3J5YSp2wIVm+TUR+m5zbs0keDP+/AfgJ9izAKuhKVX2YohDfUVUvV9U1NHpQW2j0oP4bi9W+X6oHi6YVySvDM4hjYjaHZcFyIWZ9gSnHvwK7Bo9mj7B/ucN0DSb4H0q2rUvWqzJ2phNTniF6UN6A5xG9wTnJcRr+X0cUzG7driZawb/APJFZmBX39eD57oplzk3D+liWJ+eeKiK/KRXVn50L3gOB34R7vgpTSrdjYcCGxhv6sLycu2JeFzQqqP2Bz2ANezImwD1xZVI491pVvY5owKwETlTVa7DPdgiN4aY6PKSyWlXPxWaVmCEiHkqbH8rVyUDkZRXbUvkwEdigqn8kCsBHYkLNs9LKCmouFh7/FfA7zGOuEkauDC8O/3vHvBs+08XGJZ3tB0h1ksHvSv/Px5KhpmEK4SZVfR+W6DIJi36UPQuPhkwIZRqLGR5ezjKphzDwu4i8D0scgOIYpGdg/TqDmbzV62gzD/uRxHqasp7mhs/jsXfZ0I8I3CEiOxMNhfJzmEkMJ5Y9onPD8uuE9xn66x6DtbtBh/huAt6uqq9K/4gWyIgTKuUXsdjoQcCpItLp1Cp+z88Ny+OT37yD0CvAC7CXdW34fxIxzLOGmEKeZqeUPag7qA/x3Ub0msCU/2cp9v0UMmeCVblDuEY5E3Frss80zEuYB7wC+LWqbiFUiCQ04UojjSPvGI55OdVZWauwhgDWzzVNLJMwVVDOlFAmt1IPxASZK1d/hp5tBHBNWJ9EHJfxp3DNByrKAzau6gQpZmWVLb1jwvnWqKrPxDA1XGuyiLygZOF/DLhaRI7E6skNYXtqnJT7sNZjz+cR4f9J4Rq+35JQjick5zsPe07tdpwPKKiwXIkJCff8PZRVq6BE5BBXaCLyJeCpYf3o0n67hfqU9o15UtBGit5PWdhPB1ap6lNV9QvYu67yemcR+9PAQsvHJPv+ETgEOCWpt1VCbaBDPxhDB2NtYBpwEnBF+Pn2sLyLRqXq8mF8uL/UCKxSUGkWYdpuPTrzANZeNwP/q6oXYwk6LfugROQKKY478utXyhMR+RqmlKsSqq6mmH2cKnmXhTdgCqrKUDqZOA7swxITU8Zhz9frRJ3CeZBocMwFFqnqfVjdGV8Xsm+moE4kCuMBVLU8BmIkOQq4XVXvVNXNWIftc1ocU8Yf0v0E5SQ2kn9/TEhuAN4XXoA3GFcEE4jPZC1hcCVFBZV6ULMxJVQXiroLazgAqOo9mMWZKoWykN0ds2SXqupNocw+uejOocJsCtv/gSmLRwDuKXoF2hlrPGuxRpYK5umYAl6KGQG/goHZFB6R7HcyIdyGhXC8o977Lm4jWmOu9N8KXKSqD2IN5jzM6DiXqKBuIwqOVHgcQ/z42gUUM7DSvjbvK00HVr6BODg49YAmYMLjLMxb9jFsRxPDo3/A+iL/BHzbY/uB5cn6xzHrfyVROUzEjBCvS4swA+uXqur3shaz6tttW2UFtYIoKBdj3tu9NA/xvRXLDgQ4LSwvxARZyiKsjk4kRh9cGG3G6r6XZyMwLhF80yiGc1cAB4rIY2AgFX4iNvj68OQ8T8C8oVQQXxOW64MR4e34Y0QjM00K+hBwJHGM4vHEfr8lYekhpiqBOjPcz+3JtkNDyDltK9OwwdafpjqpyJN09iR2j9wD7CEij6zYH7E5M8/B+rTSRAWXBS+RisHgwGsBQkZlmUtpNDYnAutV9TxsVprLsbaxJyYb0vvZH2vD12HejzsG87G+90uxyMdaYKrY9G9+/GlEOUFYrg5lVaqHawBNFJSqPhhCWYhlq/UDu2FC11lERXxaRE4TkYUispDGSjMN+ISq/k1VL8MEzNVYGG8nYoU8gPhCF2Exeih6UPeF9QYPSuxT4PthL31nsQ768vO+C6vYEENe5bEkZQV1N8nLTNJ7wQTTJmIf2XKsoU0jCjN3wWeFsrpym4Q1yDVYZVyJCYnLsWSL2ZgwSC3KG8M13GPycs3HvM5PYN7arOQ6RxGEoKr+RFXvU9XTVfXL2LN9t6quJoYkUqv1yVjDuQIbyJp2urrA2ico6WeG/91D+xmxrqQKyvuIHL+Xq2m0cm9S1X8ubUtDY+er6l0UByFOCmU9Mvx/Nibw0+NcMVel6DbDFcYKTJjvgRlT+2F1s1mI71YY8LZdoNVNOzOXogflWVk7ABtLnfEDWY0kgigp5zlYPy7YM0iVcnloQd1XeheGMt2oqu8K7fgVYbtHQb4dUvLdcvfQK4mBcTOJggret/cjvRRrS+6NHILVjT8A6bg5V8LXEhRqKWzvnvpal6dYm9kJ+GsInZU5lujVpEzC6v4lhGhBqf/sQuoNdveyUyYSvF9V/UEo34NYPVqmqm58vRdTWnth8gfiO/4vYJaq3q2qT8Pe93TiuDhU9WvhOu8JCS/lenE9NXW13Sy+a9zq6TFVHawN42VCSu4RqnoEjbH1aUQLCmIfyAxMgL0f+BEWs56HWXM/JaZ0px6UK6jUPV0WzvVCzKq4EhOWv8Qyo96Q7OsewIdCXwQk6ewhOeAR1I+BcjbUbF+FVYbpRCW2FrMmPxDKellSjvuwincAcLWqrsMa6hhMwfgnH0jOtZQ464MbA/MxYeSNPw0bjaFolQ6gqltV1Q2BvbEGl6bu7g1cpapPxPo1ROJgVFdQV2Cd0P6e3g7srqrpO3cF9XrgXyk2jmeWMo/S8lX106Qe1J1huTSc988UrUaInmwqLDqdCWJ8KI/X/UXYWKhnYkbDWOxdjqswihzPpJxBbENXEA3Ahcm+O5N4UKr6e0wheGguxescVCsoD1W7UZdOPlvOTnsW1vnuEYzLjavyNAAAIABJREFUwvJwTHkNeGeq+l1VfVhVbwSmJin5qYJan+wv4T485L03poDvwfoTd8UU1Kew+nNDOP4xFJWAK6hlxPqfjpnze/J+4/S9QfXsLWmyRbk/ej0ms+ZgiuofiTc1lYpB24GVFdeaT1EWEo7fn9B+VFUw2XdkuBdvu25En4hlnjr3Ud2/5sbkrpTqhao+XlUXVxzTtoJ6B/BLEXlh+QexgXhXtXmeobKIYoeju5edcDFRSEBUUGDW/UpMqTwHq3D/FyqUv3gXfD8mhh0GPChVfSjsexzwO1X9A2b5PAZTep7ocCxRMaRjdVIP6uuYF1IYTFiBl2kd9uK9rKsxSy2tEGuxQbLPwaykd2MhqBOw8U9jgCUhhAomgMpjdjYl51pKDCV5yOJITKm6gtqrdPwdtMYbeTq+Z76qXggDjXwJseKnQiHNvBqrquVxbz6O6auq+jOKXuoHMWOiTN1kmy7oTyF4iUFQfh575h4SfSD85t5K2hGdKqgzsPBbM8ohqfuTdTcWlmHvqS7M5/c8m/B+VXU9lvWGqh5JrEc7Uxqfhd3bXIr9cVDsZ6oK8Tme0OF9sLdT9DyvwLyIO6j2MPenRhiravo8XUGlfWUpnkXmxsVPiUJ7Q4gkef3x41O5Waeg7sHCvV7GLVSzszR+diKtj2mEyO9hMfbsp2Hv7+MhrLob9bN1DLwXEdk39NE9n+gNO7tgsiB9F/di9XgDFjpdlNzrvcD/JvuuIoaOATyRzbNN59FouNTSloJS1e9j1tnnROTdoS/iVSJyIxai+n475+kCfwQWiE37Pw5LzT6/kxOo6m9U9S/Jpl8k69Mwa+1C7OVdl7jlBQWlqp8LVtpzsTEDKUswoewN625ipbs3HH8VUfGsKh2bhvh2xypG1SzSzkuBo1R1CmYleQN1dzsN8aVewLJQFlXVS4OV+EMsHOZUNeobwnGbiJ7LrZhi8okpLySGE9NBrvcHz6wV7tUcgFX4d6jqvaV9FhMTUqYRkw52ICqs9NqHY57NBaXzpGHE+7F37Y3MZ3WoG9z9Q+A1qvrjkmUM9uz2x+L2qRe5P/Di5H9/Hndh4edWH5EsCLRE6T1AFLRe9j09bbuE18fHYYrsBX66ZB/P7NyFYh8UmAA+kEYP6kHguHDNkygqJV+/jxhOfB1wj6ouwOqd95V8OPx+ByFyoqqriM/qIOq9hRQ3kqZQzE511lCUIf8ghqPLHnNVpKJOQS1T1V8QnmdF3XBeRKOR7Qr+m8ALRMSzGyeFMjxAzJD8Ofb+/gML7dYpqGXEtuJe0GNpTLTyb4ylfUK3EPobwzv4HsVM5VSZle/zGrCoFtbPfApmNHdPQYULXI25c+/EbvZNWJjoAFX9UrvnGQrBOzkdUyo3AT8KQnUopN4Uqnq/qt6NNZz0g3D+QFeV9j9PLfU2ZSmNCspZjKUFQ1RQ6ctahllV6bu5HxOulbMpq8028MewrsRQ6GqsIu1GbMxpFmYanvJznaqqaRjSPak0DT1tUGdixouf14X/7ZhwmAN8JGzbQqPFVkcazr1SVT9Rsc9UTOGACQo/9xhMSFxHInxU9S+q+nlV/VHpPP+arP8NC1H4O22aqq2q16lq1bgTMAW1NzYV0MrkmNtSZZsYQS9I92tCXTr6+PD+Z2DZoJuxdnJ5xb6uoJ4LnBc8yTL+zk8h9lE6t2CRg4dKxxyLTSH0M+z93JP85nXQDcT3heUeAKr6V1U9IYRSvY7dQdGjcMH5LNpQUBqHhMym2tgqP+9vEjNFaxWUGGOIGZqpgkoNwlbDcvYP55shNv/lbGKSkU+L9fRgkHuI72bMwDkWM0h2wRJ0oP6ZPIANEk/7bQ+h2KfvYewPE+f6dLm7EzFLNI3yzKRohJQ/opk+36tCmbvrQYnIHBE5Awt9XRX+NgGXanXGyLChqher6v6quq+qfqT1ES2p7N8J/Vhp6LIc4mtG2YNKQ3Qzk2suxyp3Go/1VPBUCF0ftns/2Dktrv9gOJcLlDnEUGZqMZU9kgYSyy+thPcnv9+rqhcRBZWf8x6sIqdjs65Q1WfSOXUe11ZsclmIc9OBCbGdgJer6m1VB6aEvggPsy6jqNC/g2X4DYZ1WOJKZXy9gqo+ripOo/pbYN43tSrUFxciN4Klk0ucSduF/vEUQ8xp+NXf6VgszDcgoFV1A5ZI8jeq8azNVEF9BVOI/jwupcJICqQKKhWqNxLrYnk6pjoeJA5sLuOG0GXAd9XGMnp7Lb8Pb0+bgHeF3yeE864DxlYkAXwHMxbKvBGbWsiV2gXYvS7GhPyriYp8adjPQ3z+zGdjxm+qBCsFf2jH11IcILwrJQUV9n2vWuJJum1D0ge7FJvlfSzmmabyawNm4HkGbNrH9RtMyb2jrpxl2p148w7sAT5ZVf8S0iw/gyVPPDN0TI5KVPXBkDX6QZpPp9+JgvLMHResaR/ByYSR7qqqIvJ6GpMGHiCkjAa8wbiAeAHNeTLR8v8S8MYkrJZWjHIHaTNWEkME11b87gJpIXCBqq4SkfLzrBIQdZyOhQrfRX38/qXE8PJumDd8DdYIlfYVA5jRdRDxmTyIKbqNQzDClmL9cu18XmFcUCotUdU6A6Xug3pPEZu0dwFxXNlEzFDak6KH/zniQFxXUGuxd18OcR1LY0jnIMxj2z2UNZ1XcCVwXjK2Zzk2/qpq4OkqrJ9qBaY8vJ/3kZhS2VJx7Tq83FXP96FQtnQ85N1hWfauXJktxfrDZhDriIrIckyRDyQlBeOtPK0VqvplEZmHdVOADaFI+V3oBxYRuQEzbKdi2YBbQrLVlzEPyrNNvxEURB3XEuXKPeG4u2v3rsc/q/IUrBuk0D7UMlnvojGpLTU0u6qgHqmqA7HtoI3fKiI3A5eLyMtCvHVUopap0opNWAVv14OC+EIWhr8jMKE5EBIM/Xtl7sFc+B9iFbhgZTaJZ/vvqWf0HsxycdKKUZlNV8MDRIv1ZzT2O14O7BC8kWeHcjxcHDJSqdgqUdUvBkNoHvWDw9dgYy7mYwJ0saoeHRr0QXT2WfQ3Y+m0M7FQ6hq1pIGh4O//Pa12bFc5taDcni/ArNmDMQNsLQwM6JxItL4HFLkWhy24gvL7KGQbViluVb1JRC7HsljrJk91wb9M44Dp8nmUOPfl85PtPvQlzT5sxbrknGXeh6X+p9feJCLPp7FvyJ/vP4hT+OxM9Kw8zNduCGsF9QN2U0/2IMxr+ixxomt/R9cRk2ZaffH3WmI3wQ0MXkF5iO8wwuTQbdKxgmo3SeLOmu1fxUIs3636fVsiVO530Z7XUVBQqnqFWlYUwBlqyQXN+AfWAe2uvIc07qE+JFKJqq4s9S94xThcVevCM1W4kngGpggKFUxVP66qT21y/BupnvuwFjVepaoNYYiAd4D/KOzvfTmeyNK256Oqm1R1sdrgZz/3UPGQW6eZpoPhcEqTe6rqszGPHeKMFmBW9IuJoea62Tl+ib33h8P52v0Wl8uLe2p+9/fUbkizgRDGbEvI0ThHXnqeFap6ZcX2cyoUmisonxNzM6aQXEF5VmnaB9WMFdQolZq6O5Oo3H+E9W+mBvNfGo4okhp6HwBOH2R0YDV2j/PoLIs6VVBVX2doYCgf4AJAVX8tIse13nP0o6p1X3ktUw7xpdQJ2xRv2AUFpaoraP0JjFZ4w+lE0X0LCyf8K/DzVh5ciedgDas8A0M3WIMJ3d0ojqf5MMVJKjtlx9AxPFQuonFG6GFBi5mpKYuw2TomU8xoBMu0fAU1fZEakmVEpJ1hASmesFOn0GaE37tdH+r4b5p8KbYDfIYMn6T5HsyTcGF7O9a/8mfqlX5K3de29y39vxlTZLsQBxs/BNydjCc7T1U/0+J6N2Ke2b7AHWpDYAZD2u46GWKUysO2DMAhKygAVR3K12m3RdyDur+0/aWYUGhFpYLqEl4x2rJgANTmYITqgdKtju1oGECHbMKiAD75ql/z5xQ/tNYRXVJOPpTgpJY7DiOqulVEvoylIU/D+mM8QeIGYIq2Tvvv9L3/lDj+q4of02QG626jqt/p0qk+iI1vvBYbNvBlzDBKPajXY6Gzd1SdoES5Xb8L09vliNUcrE/n8PIxoT8KGrMpGwh9WvuJyJto7F/rBFdQHXlQSVlPUMsKb8n2+sHC4eZybPR5oRKo6llthkn+gSmSe4BPdxBaaUkIg91ImzHgfiZY4Gsx67JZgsv2zlrM894VSyDx6bUWt6GcoIPvSsFAaLbWaFXVP6nqmzo5Zz+gNqTkbeH+rsHq3FiigvoQ1te8D+a1tsKVzbfC+T+mqmdUXHcVZlTMpXHcktMsOaJ8vi8OMrTnrMfC13vQ+UQJ0EH4PCuoYSBU4La/2lvB37CU162q+rZulctR1YO7qfR6zBpsxuwRHe4wyliHfVrkFiwM5eMW27Wia/twtnMK0YjgeX8Ey2JtJ+nFFdQ5tJ4oeDywVWumBKI7faZtEQzDdViIrxwlasVHaD7pQIGuhPgy3UVt3rg3ttwxA9YwN7fca/vGhdfvVVVF5O/AKztQ6m/BButminhfczo+7FziN5Ba4QbCyqpEjQqaGQojpqACPj1W255b2L9lRmtKVlCZ0c4aciSgFR7G+zsMhHnb7pdR1QtonB4qYwNtX0kH/bkpqrpZRAoD9VtQp6CeTWfJCt1gPPUD6LtGbtiZ0c5ahtbhuz3g1vWtTffKdIonAA1lvNzvaa8f5xZqBnyr6gUhw3ckuZH6/rCukT2ozGhnDcWvAWcacQHaVuZUpj1U9QERmaM2PdJgz3Fim7seTvsDk0eCx9Jh8sxgyAoqM9pZwwiEGkYzajN67KrV37PKDAEtfmdsOK8z1FlNuooWP2kybGQFlRntrKW96ae2a1S1nYGjmUxfkRVUZrRzE7kPKpPZJpGRm22kN4jIQrVPv2cymUxmFJGz+DKZTCbTl2QFlclkMpm+JCuoTCaTyfQlWUFlMplMpi/JCiqTyWQyfUlWUJlMJpPpS/pOQYnIi0TkBhHZKiJHlH57p4jcLiK3iEhPPwSXyWQymeGlHwfqXg88H/hqulFEDgJeAhyMfcnx1yKyf5iZOZPJZDLbGH3nQanqTTVf43wO8ENV3aSqd2EfXjtqZEuXyWQymZGi7xRUE3bDPoXuLArbGhCR00RkoYgsBCaMROEymUwm0116EuITkV8Dcyt+ereqnld3WMW2ynmaVPVM4MxBFi+TyWQyfUBPFJSqPmUQhy0Cdk/+n097H/rKZDKZzChkNIX4zgdeIiLjRWRvYAHwhx6XKZPJZDLDRN8pKBF5nogsAh4HXCQivwBQ1RuAH2GfGr4EeFPO4MtkMpltl23+cxuZTCaTGZ30nQeVyWQymQxkBZXJZDKZPiUrqEwmk8n0JVlBZTKZTKYvyQoqk8lkMn1JVlCZTCaT6UuygspkMplMX5IVVCaTyWT6kqygMplMJtOXZAWVyWQymb4kK6hMJpPJ9CVZQWUymUymL+lLBSUi3xCRJSJyfbJtpoj8SkRuC8sZvSxjJpPJZIaXvlRQwLeAp5W2/SfwG1VdAPwm/J/JZDKZbZS+/dyGiOwFXKiqh4T/bwGepKr3i8iuwGWqekAPi5jJZDKZYaRfPagq5qjq/QBhObtuRxE5TUQWhr/r6/bLZDKZTP8ymhRU26jqmap6hKoeAWzsdXkymUwm0zmjSUEtDqE9wnJJj8uTyWQymWFkNCmo84FXhvVXAuf1sCyZTCaTGWb6UkGJyFnA1cABIrJIRF4DnAGcKCK3ASeG/zOZTCazjdK3WXzdQkQWhr6oTCYzTIjIvwNvBx6nqnf3uDiZbYS+9KAymcyo49PAXCy6kcl0haygMplBIiJjRWRsr8vRZ+zc6wJkth2ygspkBs9FwKW9LkSfkRVUpmvs0OsCZDKjEREZA5wEPNzrsvQaEZkcVreQFVSmi2QPKpMZHK8Ky7Ei8qielqT3TAceAF5MVlCZLpIVVJcRkceJyNxelyMz7ByarJ80XBcRkT+JyO7Ddf4uMQlYD6zGlFWmzxCR2SIivS5Hp2QF1X3+D/h8rwuRGXYmAt8O68MZ5jscOMT/EREVkX7zUiYD64A1wNQelyVTzWJGYYZlVlDDw0O9LkBm2JmIeQwAO7V7kIg8v11LNtlvc/jf2+u8dq83QrgHlRVUHyEiu4rI+GTTpBb7HyMihw9zsToiJ0kMD5t7XYDMsDMRuBBrQ7u0c0BQMD/FhPja0m+nAD9V1dQb83DZuLCcGZb99rHOrKD6k/uAT4vI48P/G1rs/zvM6Grb4Bpusgc1PGzqdQGqEJFnicifel2OZojIgb0uQ5tMxBr8QmBCm8dMKi1Tzgb283/C99DeE/6dEpauCPfvoJwjgYf4HiQrqL4gGZ+3H/C4sD6uZveUvhrXlxXU8DBiHpSIzGy91wDPAA4Xkb4RIiLyNBF5OKzPBG4Ukaki8sQeF60VrqA2AeNb7Ot4OvaUdGOSpp3OO/Yu4D9K+3vyzddE5LCOStslROSkpLyOe1DrgIlJKDITCN+oG8nn4m38qGRb0xBfYESjaiJySrPnkitSFxCRBSKyUUSODps6UlAispOI1H6AsclxzwCWi8gT2jzkEWG5a6fXGkb2J9ZDDy28Brisz7OOuqagiB/fnAQDfU//kvz+PyGT7yTi983avWa3uYRi2SB4UKq6FVNU5fvrW0SkHaE91GuMBb4K7Dbc10rw+/K2/j2szrZixDwoEdkRixzUGqNZQXWHAzCB8Yrwf6cv+SIsXtwpHlu+vM39p2ACbi6YIBSRYwdx3W6yOpRlIrGPxa24YUuvFpFXiMhjOjxmQeLZDUVBlT2Q2aXtaR/TYswafhqwD/Bq4G5gqoicLCI/6IHHUg5pTsYUE1g/1LT0RxF5ioi0nJVaRHbs9tRRInKbiFQqhuAJrhOR4fYadiothxURWYCF9VYnm9fSngc1LAoqGOHl8YKzwrJ2Mu+soAaJiFyeCHeveE8BfgK8vEOhMZfBVYw9Otx/CnAXUSAeBFw5iOt2ExfKc4mC2RXTnuWdg1I9oAvX/TbwkQ6P+RhwWVivVVAi8mgReWbF8Q0eVFCSft8uQPbB3hPADWF5DPAiTAH8FVNaFwGn0nk9GCp7ishjk/9nAcv+f3tnHm5XUSX63yKQ4SYkIYGQBAhDSIAwqgFFnwOCAi2K4PDgqZ/Te2o7YDtjO3W3QzsP/YkTKI04ACLK4MCk0CoICagkAgESIkkIISHzBISs98eqdav2Pnuf4d6b5IRbv++737lnnz3Wrqo11KpV4f+qQInr2zzvA8D3+3lvZQ4Get2hInKuiLwyfD0ofNbOWxwgd7hPC2grmGYAuAbrhxaH76dhCkQ7FlTTfitMc+iL1flq4D9K27wfamjnbd1MpprggnkB8IywyTWAacACrMPZt4NT9nXMqrdjEpF2BkBHAsuJFXVIONZdS98QkU92cgNhTKKTZy3j2vYYogXlz1VVcacB9/ZH6xURFxBPdnjofcn/YzFrtMqC+hFwdemaApwZvo4K2/bCgiy8E0wF1N/C/x/HIv98sc4NmDa8O3B32HZih89Ri4i8oY0O6B3An5PvexFXuK6N5BOR17c47xSgI6u2GYmLOO2YT8PmlgFMDZ+V9TdY9WtF5EX9vJU9S5/bmtXhcz0wTVV/hSlTrd5r0+kxSXlWKY67ishMEblQRA6vOPxgGl2/LrCzgGoXEZlemjvg23dJOrYZ4XNt+HwNcE/43zu9vcJxVS+rTF+j/lIXWDt+/5HAY8QO1YXD3uHzHODdHd7Db4Evd3KAiOwtIqtK9zCG2GG4hls138f3/3Do4PvCtPA5JVhk/y4i/9nGcS7QT8XKbCUlARWCF2ZUHDsFWy8J4Irw6RbVQaXvU4H7w//rKQpGnxA7CovK+hxwgYic08b9N0VsAvAPgdeG70PCOEErJmCKD5QEVElxuriNccVOlYZeQttNXYmF6Mfg1TiaWK88arJubMgzhHwj1JN2lMAqXPH6gIjcKCLf7eN52mVZ+Nygqg+E/zdScr1WsLbF7+7aPaDit1cBs4A3EdtvyjQa+6j9sHpea8FmAdXIPODfKra/BWt8AJ8Kn94QhwLnYsvQe8eydxjYnisiV9CcvlpQ44H3h//bmbw5EutUvaL5PJu0gmwEEJGjReRDVCAiB/bTajoYGBs6Ky/DMcD/ImriUO2S8Mb+WeDlfbz+QcCfMM35aOCT2PtrhTewk4EvquoaGi2o2/2fMKbibSwtr7ml83lofWpBLQBeFPa9iEiasWEM8K2w/avpjYpIj4i8pU0B43j4uteHS4C/JOesc0PvRRRQ5VDzURQzbVzQ4h76M8n9I6Xvp4ZPV+Rci/e24kFDdWNDJwC/Bo7COt6+KpKjgCVYRN2LgbdJYyTkgBDapbeLjclPN2HWYzN8QnidpeXtscriSY+pUjKqLKgjwn3VWpZZQFVzYMW21B32QuBiYkMcDtykqq9U1YswLXRvwDuHM1pczyvGce1aBaHjGQl8I2yaE7aPTiy98v5DsIHTsoA6JAkY2BA+PwR8sebyc4E709O3c88JXiGfg3XGm7DymggsSvarml+UhtX3ddB5LGaV9NBZZJW/7xMAn09WFlCp63EVUdnxRv1N4oRJf09uQY0KWvo/Aber6s1qS15XWVAuoFZi2umS0r0ej43nTKN9vN57HXw1RWuw0HElwncs9qzQ6OI7nFinoEnEVmBruzdbwVvCfY0Oys+lYfshyed9wFFiUbNvBf5KvWVxOHBeuKc9w7n7UudGAPeWtr25asdWBEvu9Ca7PLdm+zyip6SOMZiiUdcmXEBVCZS0Dyik/grv4mAaXb8zsfHJLKDKtHA1VOU688Y5GetY7iMWuA+YOyvCOdodTPSsArcBt4rIraV73V1ETikdMxZYHUJ7U+4Ffi0ip4nIp5PtPplyM40uvnOwsZD0Xlwg/2vF/Q4B9hKRpoPzIvIdEflaxU9uTdyCjeX9DvgeNqb3HkxI3UW9BfUdbJ5Q26H5YlFEo0TkTVjDWItZa52kdnGBchRFAXWIiHzML5XsP5LY2CdiysT5RMHrLk3fZ1L4f4uq9ioAQUg5LqD2DNfajI05VLlPoP1JxIRzPAFMEJGjwrZ/JL+X67O/n92J3oWygPofYj1bigVCNJC0xz650UrutzkUy8Mtw5GYQNqKKQGzsICCukCIg7GOfR3RHVjpjhKRN4rIB6p+w8ptQWnbSX0cR90f+GXVMEQgtV7Sd7+JmiAJsSjL1VjZ3455Farw46uU6PTc5bo4Cesz0uCgYcCxmIU6VEQq62mtgAr+5zNF5JVpQYrIa+qO2VkQkUNprqmdJCIHl7Z5pNXhwHysgztCRD4BoKppxVgV9veXtqCF/3pz8v9UzLJIeT/wm4r7WUUjk7AKdChJ9BLWwB7GOlSvDGOxaDEP9vh+ck5351RFuvk+36n4LeX1wL9UbE81tFHEMRmA+1V1CvBtv08R+bCIeAMfh1kNy2nDrSkiLxWR74V7Ph+4EBvkX4tZkzOAa4lut2akDc/vx90+n6npcLyNjcfG/1KL60fhcx+sTh0AvIGixVHGBdRkYF0QXlWBCa48dDJfqgfr3F9EDNJIFa/ULbU8+V4WUHUWyULqtWVvHx1HzYmF/qfutynJdY4kCpURmNvrd5h3YAE12S/EctKNxoT/GqIbtk4pOpHYjsr0UAz53gKcHv46xbPof6rm99QNm1rVm4FhUh1dfABmPQ3BlMZy/+N4f3ZyhYKfejbKqbiWYPUwbT+7A5tUdQNW1yqz4DezoH6IaZfHAH9MOux/bnLMzoJHrX1QRG4RketEpDwP6UNhHxWRE2gUUGswX+9/0Bgivhrr/HuwMOGDqPBfB8toD6wjLrtoUqosOu+owV725qTSLA3HpJ3BCVhHnFpQE4hhzAC/IDbW3meSxlBbjxJ6zHepue/VNdv3xdwx/wOgqj/ALCKIDXkzUZD+M9H95M99K/CainsrMxUb24Jix78O65xmYtZjO64bv9baxKpJ32tVlJoL43FYeW0GhpfGc4ZhQTYHAP9O7Ayr2BTufW/C86jq49CrlTouoNqyoERkJvA14DqK/UKqeI3HXLuvCtf2Dmc0cYC9WT6+31Efau3CrjYzSnBvVfVZp1Zsm4RZufdg451DiBkvvhDuYz71AvUOrM2vw+rk/pjrqk5AHU2FC01E3oy5WTcR3a2uyPQlK733wx+t+d3Lfjn2PgEInpYnqK4P6fPfRTF7/t9CHwVRQB1CYx31Yy6liWcjUdR7vU6qepyqLqvav5mAmqyqH1fVf8PmWlwg/Q+37DdiqXHmicgDItLOwHYVPjb0JcxX/xJgUqj8blk9kuw/g+gzPgar2LdTT2pBNZuA+zPM5TGckuujpKG4QE0rdK+AUtX1WEfpGSUW0iig9sBcWqkFNYFoOXwJeAiYGK6ddqDleSw++OqVqi6CsG7exT7YHI1UYCwMz+IdonfkQpxYvAvhuVX171jn0yp33/hkn7QDdwvqYMy1ukcLty/Yc74OSOcApRbGheEzFXbuFhtPMeqvHGRyNzE6aiPVfCsIxvVYZ5juVxYMnbr4Xho+N1EcQ0gDeCYAy1T1inAPI10oupBM7yMpzzOAV2AuzrpEtz1YmxtTI4TAxvNWphtE5Djgbcmm67D2dwzwaEi+uwYr/xGY1u4Rtw9TsqCCK/jV/l1Vn8CslimYxVUlhIZhfUTVGM8PsMwbG5OIuk9giVlbRdVV0et9EJEXBk9XGizk5/wnVf1b8dDGuVBBYLw02XQ3ob0EoX4U0VMxItz3HKJ7GhE5CAv+OBLzqpQn2G8K23x6BERloSnNBNSwpPI9iFkLHySRrtubUGDnYRrTDOBsEakK6W1FXaOdjmmM76RY2bxy34WFlF9D46BniguoHqwTPo2SC0lE3oZFg43DBo7nlc6RmrxeqVaIpTeJuiAVAAAcYElEQVSCRhffEqKlMDTcc6qtjsUaatmC8vtaR7SmjqY4OH6giMxINPTUariU+jDRXcHmSPiGMMh8FPa8qYCaUzp2M/bc48L/c4DnU7Qc7yFGYjUglnrKBcETFMNj1xOtNb+XVi7D3YFbVTV992VhDdHdBbGuuQXlCsLemOXmA/hbsc5lM0njL+Ht1S2osoAaJSIvEQu0mYJFlHaayFYoCvK0j5hAjLJ0Cyp17/l9eCc0CuuYf6mqV2MWdZ3SMjIcu5GSNSsij4glzz2GRlfQB4hCbyQ2trQWeDsxSGI51hbSTvFMLDqyN3u3iOyPtamfla7xpfC5gGrrYGq4932aKDl+3dcBXwduoG8Cal9ijsabsDr9g+T30cBnVHU2jVSNQ/0frB+6B3N7LiP2G94HDhWRqUQX6c0kiY0xwXSrqs7FlNx0fmYPVoeWYG3OldnyuH0lzQTU+0m0HVVdh/lM3197xLbnOOABVV0QNJtL6Jsft67RzsQa0VJstrxXtknYC3Q3xj1Bk/0hZk2VWYlZL/4SqjqKV5e+f7X0PbV+0kp1mIicjI1fpNqkAp/BOo4erEMcIzHMeAzWGFMLaiJx/pYGN8BiTNtJx4l2w4SXz5FyK/Oc8Gy9HbuIvExEJgcteBTFDuCPWAfwe1V9CBufOjlcfC7FMnIXn3eK12OWSyqgHgZOTzuF4DZ1S/JWrKMCG+yfjgVgfBqzmlxAbcAE9REicqjUpMYJz1NYJiNx9f0E+ErYthWrmzclz+RjUK4g7AUsV9X7sA7r+nBvwylZCQnpZNjhFAX8BqyDvi7sdyD2bvZrMngP9Cp+7lobSrETTgMjUgG1CzZWNZ7i/Jm1RCHidQ7otY53FZELacSDeEaQjFuKyM1YRzmz9LzuevYxmQtUdWNiMR2FBUGAlcNhFN1Kvwieh+XEtlYX+n1t+JyPBZBcXhqj3pM4abpXsZViiL9f9yfhumuBT4jIO2uuWcdEisruBIr9w3iqx6b9HsoCyvv4G1T1I5gA2kVskrIHZp2JeXi8/JZSrCPjiZlElmDeKPfATAEWJ5a/C6ge+iOgVPXPqvoIgDdYVX1KVX9Ud8x2YB+KYciL6VsCxv2wTvYdFF0t52Fa7U2YNeKWwcGY+8GDGdYBqOobiVpaykJMs/EXWuWX34M4EfArqjoPsziGYXNPUndeD3E85xTM5QrFjuz88LkoXNeP90/vLHywVDC/uqfU8Wd17TzN3eVuSm9wI5LvDwLjxWaSC2ZdXosJhl2wDs3v4Xnh80YAVV2iqtf5AyRuIrByG06cY/Mg1ulOJnaSy7HGk4ZSv4Xq3ISPYo1qg6p+MrhbUgG1gqhJfgJARI4ojXGVrYWUXUnGEVX1bMz1NFxEvoBp/6mLr3dyq6q+T1V/R+hYgvJVZhKmgEAUCKkFtYni0vPDwjO/HfiyNM9x92ni2PJQitMLehKXWzrf6VhskvCpwO+T/dcDZ4jlgysIqIQ3VWybirkW34V13OPCPbuyMZYgoJL7+SXRfZu+Jx/ncOVxFuZmPIlGt9KjRKFSp7j6M7iL71UUp464dTwXG6NGRF5H0T1avq4rVZ2m7RqF1ZPPYfXgSOwd+fn2w6yYKqbSGLTkbfwS6FW4HsParHtrXhs+p4drr6CoQPemugpteAUxSe2RRO9I2YLql4sv5TbpMLHmNqLKfG5IQimW2n62iMymFDUklj/vfGCRqn6XorYxGviGqnrYrnfMx2Cdj/vmU8l/N40sw178RJJBbRGZI3ES3GTi/JYF0KsAPBGOT++7J9n3ROJ7S+/9vPD5RNjfNVs311MBNYLoRlmNNeA/he9PYeWzUVU3UYxMcgGdamFDMY1qIaGSY25gn0C6hqhRL0+2tcItqGdiFdujDfcijte5JZfW47VQGdjhlk/67lIBtYE4h8SVgTmE/GHBVz+E+smaQ2l8Ln+G/xu+Pxasqy2YYrS8tH9tg1XVR5LxuaUVz7KZYMGVtnk9agg+EMu8MJaii3Zo0KS97k8hBsOkFpRrzNOJVjjE9rgH9QLKrz8+GVe9DEtz5Nc9laI7byIxuMBTi7kr6UFMMXK+CXwiUXjuxVxZM2nU2pdjVpFQH2Ho9WEBcc5aOgTgVn3qHkuXuYDGLA1ePztdHdkzx38M65P2p+iWnUK9gAIbvkjpwcrqlmTbSuyZ9sEUcw/T/zz23ssCyr0DziLiuzmEOBySCqjLqHdl99KugPoIcF06eOiIyCtE5E8Vx2wL3P3k7EtFEIKqfk9VZ6rqTGJDcl4VPt3/6xX2GuA7qlqV2HJPTOvfLZw/FYo/oeQXD78/hHWojxE7niOAA0RkMtbY/d7Tl+vfx0PvQPNoYoYKiAEMC5NrbsGE2HyigJqHBT3shlkZHpjQE+7lfjWOU9WfhlO568LdKf8gaIVEbWsEVlnBBN39WGU+icbIPU/LA1GjbJVSBey9HIdFIq3AOqFnh3t2RcGzDvSIyDARuZv4XstjBX7tNADA3S5PYs97JPZOUuHmneIoYlh3mUuxcYuLiVYiRAHlgsWF5OPYwPQsirSVnSMoDlB0v6Ud7/2YkrGZWA5VA/jzsGUg0iCXX4bPK4neAVdmUgE1Ebv/F1K0Kq/FwobH0kRAhfGeP2CZVtxNPyM510aKXoQ9wt9qolvPy/W41LOjquep6meSY9M5SAUBFcKcn8LK4FqKeMecWlA+R6gcVr0Sa7fpqseXJ/uU+6EvY/kVD6AzUjfzOuIE8FTxbbkyglhSgKOoDlZYjPUPM2gcG68SUHtRfL5FxH66Lk/jONpIctyWgFLVH2MD/f8lIh8TS+Hy5tAhfAX4cTvnGQBmAdPEUu0MBc4CrurwHN4AnoKCsFmqqlUh9O/ANK8fUTGJMHTwVR3uUkxAPVyaTDsGy1V1eeLKeaR07ApsIuwumMA5Gut0VmCV0xtuqrmiqodg4dr7YprsEmxM4jlY5NsCohZzAkXXjONW6uZwztRKc3/1WKyBnYxF7biCsoVGi3Y9tjTEeKI7th0LKq3wnyYK4/TYb2NWZE+4t8OIHXE5bNzfXdqpp8JqY/gtFXJg4fuvC9eqFKyqepaq3qiqT5Y0URdQEvbzstmIuZD/WDrVO4gKVDukYya9c+lUdbqqvo3i/Lq6LAIjiZ3Ns1T1pnCOd6rqWaV9e118QUm4g6JQ8We8j9YW1PvCtSdiQvF/h+i6P2DvYBw2eds5Eiuz64lWiisodW5XZ2Hyf1lQQHT/pqiqulLoz5BaJmk04gRMOK0kts09sOfywKPCdYNgvJbqrDVA71zUW0XkahFxK9fH6sDalnfyXq/HUj+946XENn8bNs2jytV2BTYnsofGMfbHsP4qtfz2ozj0siT5PR2fSi2otmg7k4Sq3oqFY380XPBdWNjnIar6rSaHDhjBSng39mLvAS5TCzfuBH8Z5Y60Tppfqqp3BCHTSV6zR7DKV57fNBprlG72HkaYD5RwEyZ89yZW4PuJczKmYQPr99HIfcn5XXN5HY3RV1Opdk96p5fWjXOxrNoni8jocPwqVb0uuEPdtTSBojV5CNGCSiON2slpljboFarq763XvRhcOLOxhuRCxcejyq4TH19IO/U075s3+gcxgequkA9i2S1eizXqTnABdRfFcZ0rw+fSdOcg5FrlbXSOJ0Zz+bWqrg/mCq0L734S6/CP0SR7RRkRmYTVxXQ6RLrERopHsb6P6swR12N1slfTV9XLwudWTKl6GRaE4fX2JZgyNIsooHYNx7SqT+lY7eKK35dRFFBnEyNiUdUnVFWIHf98igrQYVh7K1tQi4jjOHWCcUQI7NlNLNPJ65MxtqMxwXwaVg+hUUD1WlDBUzKM+onea2j0DlRZUA9i9farNOYJfQQT+PtInNNUdis+TFRG06VYlgGTk+c7jxa0JaDEsk9/HtNu/hT+HseisfqTO6tjVPXXQUOcqqqdrucDcdwiHRCdT2Nnvy8wLnTAzt1UV7Qq3CpyAXUApr24gHoEQFXvrXAb3Yi51VLt6k/Ae7FGchBwflXZh23TscFlnyf2doop+EfRqPU4HqXZGxquql/AJjceiVXyJ9NrqyVNvSl89Tp1qVqEml8vVQBauvhKgQLpOyin23HLxwXjy4nzLpaG5/kmcUwsPb5KQC3E3lE6m/7Z2PN1Wt+2YOXxHKLrDILl25+2E4KY0iUv3HWVZspO3bS9ioOIDBcRd4k9STGXXvk6Eo5/OXBXqT24ZVEWUKsxF9FxNE4fAFO2nsIE6GXEpUScVcQghL8TJ+L+BLPgDgxzf9qxxMsu+SoB9ShxUP8hVb2kZAmXz3MNRQF1KPZOyxbUKpqMu4bzLcPaw7VYOV6MeYm+inkoLgd+CiyXmE/TBXLZghpNcRJ5mXWY8uWKto9XlwWUKw7/wLxjG7EJ5ABzQ9tcgg1XSLiHcvCa/5aOT/kcq8MxBbflygntWlDzMUl9oqqejGkFt2PBE32Zh7Qj8ZeXVpjpWOcfd7IIs3KjfSvtRw16dJwHQPyDuFjgERTnzRRv0EL6N1JcaXK12lwSHw8quwXT4+9X1XWl+3cLo6mAUtWfh393K23fQuyIqrIVv5hi+hV3n7nf2f3mewXB1TbJmBO0FlDDsLRQ5wFPqerXVPU9rqFTtKD+QEzp4410ITHlkHcEW1T1BG2c+NjqvhVz73k2a+d7tM4s3Sn+TlI3tb+vhyi6LadjFgxYfdyT5krDHGysqTxWmmaPSFmMaf8LiIEzzhex5/fJxpeo6g9L+9xO9DA8RRS087EO/wzMtb+F1slny1S5vx7FLO/NtJ74PQKbcDxeRH4aOuGxxDGogoAKlv/oJsqI1+10WZ7TMevzFOx552H11gMkvA9LpzyMxNpAs/fo3oyZxEn7e9IooLyu3qaqf1TVkdhinRBzMz6GPfeeWEBVarXdhbmqP4kJfu/r7sTGaO+i3qIv0K6AOkpVz1bVv0DvuMv7MK365jAvZ2fBX+6xvRtUtzbROkj2U60OAa7CLaRUEG7GtPnjaXTrlVmQ3ONvkvN4yGfdXIcyLwqfLljXY5XqYKotKKfKr+9l1CCgQvl9EZs1Pwtb7dWvNwrrIJ+pqu1aoIR7LC9J30pAQSybqqCD3uOD9er5Cr2B3Um0XN0qqUql0wnXqc378utuUFtEbiDZJZw7rcepgErLZ1Ly/wsxb0KzcZy7wn7lOrem9Onci9Xxh8vtSlU/EgT9ekLYf/liqvpbVXVBsZUYzPI4xcjHCbTv0fgF8Nyadv4oFvTzVOJKrkRVPTnvfpgbfiLRCim7+HzaQLOy9XeRKpyfC58vCNfyOW5jKL6nNFjij5gbvplV6ZkcxmEW30TsvRaGIUJfM1mTyb6q+riqSlJ+PlRQtp4gDh1MoRgM9hc6nJzcVjZdtcH1qu3fFZH5mOnddmbpHYyChe1u4+tcRePCXf7C36uqdZMxnTuI/uveRqOqP6OD5S1U9WYReZDoI96U/FbXGI+jWnillbPqWpux9X7SNX88sWnTkOOa882nOEj7Lhq1eF8pNNVQveGWx2VqMzpjltSvMPfTcsyS+jbwflW9oZP7rqBdZaI/VCmb3pkVXHwU1/O5EfOMFJZIKDEHU3DKddaVtYWl7fMxV1Sz5/Zgn2aJcQG2qupsEfGOPxVI02nMEl6Jqp7Z5GcXeu9o51wUrZTDiAJqJWZZDceev+U8HxrnFkIxzdg6TCEciZVz+p6uwiz9WzCr683YAqLN7tsXbfRnXlTlGVDVpeVtJdaHexpLKaxdVZ8SkbMw63mThukRqqoi4vMs26Lfy22Exvv8/p5nO/IHiksIbBOCxnFlafN/h892wqxnEUM1O11vqcwRWC60soZdiarOqhHgLgRadSopbkGNoT66qC1U9VuqWp4Y7VphOrPfr1N21zyLYob39Nx/U9XTQkf9d2C+ql6oqkdW7d8B44nzoLYlVZ2hv6dFFAVUOn5SNam5jIdflxXax6Ehkz9EJaKZgPLxv2Z1aRMh52Xiri7MHQtKUX/xiN62khCUhPkzgCfCNnfxuXuvZVsjlmk5XZiXuWcMcau+V3iprRc2gaJH4/81ue+t2Fj7Z4l9f19XCXYL6jBK0cQBv/+yQthRFF9f1iNpQC0Lwk6Bqt5O53MPBuraGiZ8399qX4pzZL7Zz+uWO68e4lySTrgAy/JetcZTHZ4tOs14PZCsxlyWh2HjKrdg7iVUdWG6o8Ykoa24m/4tnJdes5WlPFCcS8wI77his5KiayXtJFp28Kq6SmxJi7JW/Ruqs8CvLX1W4a7bZuWzO43vYT12z1fQT4UnoR1Lp45nEYXsKkwRaJZuqIwLit0xYXwlFgT1wXCOIeH8ntC16ryufNyrqlVBICkeFemWW18FlFtQM7CoywKqujoEepTf0Z+xZANvaeciAyKgMu2jFhXVDu7aeq+qVs1X6s899GqmHfIR4GMVGnMz1mO+eg+0GGhWYdbTUcA5qrpQRP5B357P+T59b7g7hNJYp5MKijFgy8dgi8Q5f23z/A1jpsFCqIxOC4pYs7GXIVg0aG3Wgyq3Yzj384E72rRQ2uEiWo8JV/EQFtywMdzbFhFZjwVclF3R7XC+qva6x0XkeGKSZKcqiONmYFKb1r4H/nj97mS9sBS3oPamZmKwqjbkgFTVM0RE2n13g3ZF3W6n1WDtjiAEiXQinKD1JMr+sgqbdLwncckODeNXfUJV79RiCPdOiarOwgbh12BjIx6SfFCyz/UdKE2d0uzdz6U6j2VLVHX2AAonVHWLxkm5nTAHG3tP2+pjWEh+XxSkQptXm0qwgTjGd6xWrJukqp/twBXt44ZDS5+d4gKqbuHUWjp5d1lAdT/tLhvfraxvvUu/WIVNOr5At/OcvJ2BMJa4Bhsr8bHXdhZn7C+3UrTUyhxD4/ynnYlJ2FjOXhTH0VZiodRtWaYlKrN7qy3vMgMLnOov/x0+XTD11YvmY8vNMlf0myygup+6qLOdhZYp9fuJj2EMRON9ulJ2w03E5ktts+AmVX1uVXRY8vtTO7NCEQT/Whqj9R7DogvLiYDreDkxpVNtW1HVewbCalTVX2MuudlUz2dsF8/H17EF1QlZQHU3F1HMQLAzsq1dfB6g08n8qsFGGqzg4zrzVLWcCzDTGRtKnxAVprbqo6peA/jk+O0VULMfNhG43TmdVSzDFJ3RZAtqcKKqb9IwOXpnRS2DxjZ7huCjn01MyplpZCNRy3erps9jdJleXDCVLSjoTGFyBWJbz80ECokJLqSYcb0TlmGuzKUt5tD1ixzFl9kefAoLx90mqOqxrfcavITOaKTYUvA3hG3N1gzKtEczC6pdFx/Ecdra9GfbAlV9Tz8OX4qNP/1igG6nkiygMtsctRyCV+/o+xjsqOpyEVlJzBOZ6R8+ZpRmU/cM6524ttNUTjsLruCU1zQbULKAymQGFy+j/5lJMhTme6VDJR1HSKrq/LCcyU5DePaJxIm/24QsoDKZQUQ3zq97GpCusfR1qpcYaUpNarGupmpO1kCTBVQmk8n0j940UmHCb18m/WYqyFF8mUwm0z86WkIi0z7ZgspkMpm+8wHi4oqZAUYGMKVVVyIis1V1Zus9M5lMJtNNZBdfJpPJZLqSLKAymUwm05VkAZXJZDKZrqTrBJSIvEZE/i4iW0VkZum3j4rIAyIyT0RO3lH3mMlkMpltTzdG8c0FzgS+m24UkRnYyqyHA5OBG0Rk+rZMVJjJZDKZHUfXWVBh3ZN5FT+dDlyiqo+r6oPAA8Bx2/fuMplMJrO96DoB1YR9gEXJ98VhWwMi8jYRmS0is4Hh2+PmMplMJjOw7BAXn4jcgC12VeZjqnpl3WEV2yoncanq94irVGYymUxmJ2SHCChVPakPhy3GVoJ09sWWLs5kMpnM05CdycV3FXCWiAwTkQOBacDtO/ieMplMJrON6DoBJSJniMhi4HjgVyJyLYCq/h24DLgb+C3wrhzBl8lkMk9fnva5+KoQkbnA5h19H13KnsCKHX0TXUwun3py2TQnl089K1T1lPLGbpwHtT3YnBPIVpOT6zYnl089uWyak8unc7rOxZfJZDKZDGQBlclkMpkuZbAKqDxHqp5cNs3J5VNPLpvm5PLpkEEZJJHJZDKZ7mewWlCZTCaT6XKygMpkMplMVzKoBJSInBLWknpARM7d0fezIxCR/UTk9yJyT1h3671h+zgRuV5E7g+feyTHDKp1uERkiIj8RUSuCd9z2QAiMlZELheRe0P9OT6XTURE3hfa1FwR+amIDM/l0z8GjYASkSHAecCpwAzg7LDG1GBjC/ABVT0MeA7wrlAO5wI3quo04MbwvbwO1ynAt0JZPp15L3BP8j2XjfEN4LeqeihwNFZGuWwAEdkHOAeYqapHAEOw58/l0w8GjYDC1o56QFUXqOoTwCXYGlODClVdqqp3hv/XYZ3MPlhZXBR2uwh4Zfh/UK3DJSL7Ai8DLkg2D/qyEZHRwAuA7wOo6hOquppcNim7AiNEZFegB0tmncunHwwmAdX2elKDBRE5AHgGcBuwt6ouBRNiwISw22Art68DHwa2Jtty2cBBwHLgwuD+vEBERpLLBgBVXQJ8GXgIWAqsUdXryOXTLwaTgGp7PanBgIiMAn4O/Iuqrm22a8W2p2W5ichpwKOqeke7h1Rse1qWDWYdPBP4tqo+A9hAcFfVMJjKhjC2dDpwIDAZGCkir292SMW2p2359JXBJKDyelIBEdkNE04/VtUrwuZlIjIp/D4JeDRsH0zl9jzgFSKyEHMBv1hEfkQuG7BnXayqt4Xvl2MCK5eNcRLwoKouV9UngSuA55LLp18MJgE1C5gmIgeKyFBsgPKqHXxP2x0REWwc4R5V/Wry01XAG8P/bwSuTLYPinW4VPWjqrqvqh6A1Y/fqerryWWDqj4CLBKRQ8KmE7GlbwZ92QQeAp4jIj2hjZ2Ije/m8ukHgyabuapuEZF3A9diETY/CGtMDTaeB7wBmCMifw3b/hX4PHCZiLwVa2yvAVuHS0R8Ha4tDM51uHLZGO8BfhwUvAXAmzEld9CXjareJiKXA3diz/sXLLXRKHL59Jmc6iiTyWQyXclgcvFlMplMZiciC6hMJpPJdCVZQGUymUymK8kCKpPJZDJdSRZQmUwmk+lKsoDKZLoQEZkiIutzAtHMYCYLqEymSxCRhSJyEoCqPqSqo/LcmMxgJguoTCaTyXQlWUBlMl2AiFwMTAGuDq69D4uIhqUbEJGbROQzInJL+P1qERkvIj8WkbUiMitkp/fzHRoWyFsZFsR77Y55skym72QBlcl0Aar6BiwVzstVdRRwWcVuZ2FpqvYBpgK3AhcC47C8b58CCMtgXA/8BFve4WxsQbzDt/FjZDIDShZQmczOw4WqOl9V1wC/Aear6g2qugX4Gba2F8BpwEJVvVBVt4QFKn8OvHrH3HYm0zcGTbLYTOZpwLLk/00V30eF//cHni0iq5PfdwUu3ra3l8kMLFlAZTLdw0Blbl4E3KyqLxmg82UyO4Ts4stkuodl2NLq/eUaYLqIvEFEdgt/x4rIYQNw7kxmu5EFVCbTPfwn8PHgmuvzeJGqrgNeigVVPAw8AnwBGDYQN5nJbC/yelCZTCaT6UqyBZXJZDKZriQLqEwmk8l0JVlAZTKZTKYryQIqk8lkMl1JFlCZTCaT6UqygMpkMplMV5IFVCaTyWS6kiygMplMJtOV/H8+/z9awwAC7QAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -1410,7 +1410,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1463,7 +1463,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/tutorials/tigramite_tutorial_basics.ipynb b/tutorials/tigramite_tutorial_basics.ipynb index 27d0ccc4..ea57ea03 100644 --- a/tutorials/tigramite_tutorial_basics.ipynb +++ b/tutorials/tigramite_tutorial_basics.ipynb @@ -113,7 +113,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -178,7 +178,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -228,7 +228,7 @@ "\n", "## Resulting lagged parent (super)sets:\n", "\n", - " Variable $X^0$ has 7 parent(s):\n", + " Variable $X^0$ has 7 link(s):\n", " [pc_alpha = 0.3]\n", " ($X^0$ -1): max_pval = 0.00000, min_val = 0.796\n", " ($X^1$ -1): max_pval = 0.00000, min_val = -0.748\n", @@ -238,21 +238,21 @@ " ($X^3$ -7): max_pval = 0.25822, min_val = 0.036\n", " ($X^1$ -4): max_pval = 0.26548, min_val = 0.036\n", "\n", - " Variable $X^1$ has 4 parent(s):\n", + " Variable $X^1$ has 4 link(s):\n", " [pc_alpha = 0.3]\n", " ($X^1$ -1): max_pval = 0.00000, min_val = 0.695\n", " ($X^3$ -1): max_pval = 0.00000, min_val = 0.484\n", " ($X^3$ -7): max_pval = 0.14660, min_val = 0.046\n", " ($X^2$ -1): max_pval = 0.22144, min_val = -0.039\n", "\n", - " Variable $X^2$ has 4 parent(s):\n", + " Variable $X^2$ has 4 link(s):\n", " [pc_alpha = 0.2]\n", " ($X^2$ -1): max_pval = 0.00000, min_val = 0.450\n", " ($X^1$ -2): max_pval = 0.00000, min_val = 0.447\n", " ($X^3$ -3): max_pval = 0.00000, min_val = 0.183\n", " ($X^3$ -1): max_pval = 0.12516, min_val = 0.049\n", "\n", - " Variable $X^3$ has 1 parent(s):\n", + " Variable $X^3$ has 1 link(s):\n", " [pc_alpha = 0.05]\n", " ($X^3$ -1): max_pval = 0.00000, min_val = 0.372\n", "\n", @@ -404,7 +404,7 @@ } ], "source": [ - "q_matrix = pcmci.get_corrected_pvalues(p_matrix=results['p_matrix'], fdr_method='fdr_bh')\n", + "q_matrix = pcmci.get_corrected_pvalues(p_matrix=results['p_matrix'], tau_max=8, fdr_method='fdr_bh')\n", "pcmci.print_significant_links(\n", " p_matrix = results['p_matrix'], \n", " q_matrix = q_matrix,\n", @@ -445,14 +445,14 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": { "scrolled": false }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -475,12 +475,12 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -531,12 +531,12 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -559,7 +559,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -603,12 +603,12 @@ "source": [ "### GPDC\n", "\n", - "Tigramite covers nonlinear additive dependencies with a test based on *Gaussian process* regression and a *distance correlation* (``GPDC``) on the residuals. For GPDC no analytical null distribution of the distance correlation (DC) is available. For significance testing, Tigramite with the parameter ``significance = 'analytic'`` pre-computes the distribution for each sample size (stored in memory), thereby avoiding computationally expensive permutation tests for each conditional independence test (``significance = 'shuffle_test'``). GP regression is performed with ``sklearn`` default parameters, except for the *kernel* which here defaults to the radial basis function + a white kernel (both hyperparameters are internally optimized) and the assumed noise level ``alpha`` which is set to zero since we added a white kernel. These and other parameters can be set via the ``gp_params`` dictionary. See the documentation in ``sklearn`` for further discussion." + "Tigramite covers nonlinear additive dependencies with a test based on *Gaussian process* regression and a *distance correlation* (``GPDC``) on the residuals. For GPDC no analytical null distribution of the distance correlation (DC) is available. For significance testing, Tigramite with the parameter ``significance = 'analytic'`` pre-computes the distribution for each sample size (stored in memory), thereby avoiding computationally expensive permutation tests for each conditional independence test (``significance = 'shuffle_test'``). GP regression is performed with ``sklearn`` default parameters, except for the *kernel* which here defaults to the radial basis function + a white kernel (both hyperparameters are internally optimized) and the assumed noise level ``alpha`` which is set to zero since we added a white kernel. These and other parameters can be set via the ``gp_params`` dictionary. See the documentation in ``sklearn`` for further discussion. There also exists a module (``gpdc_torch.py``) which exploits ``gpytorch`` for faster computations on GPUs." ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -628,7 +628,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -639,12 +639,12 @@ "## Significant links at alpha = 0.01:\n", "\n", " Variable $X^0$ has 1 link(s):\n", - " ($X^1$ -1): pval = 0.00000 | val = 0.030\n", + " ($X^1$ -1): pval = 0.00000 | val = 0.173\n", "\n", " Variable $X^1$ has 0 link(s):\n", "\n", " Variable $X^2$ has 1 link(s):\n", - " ($X^1$ -2): pval = 0.00000 | val = 0.028\n" + " ($X^1$ -2): pval = 0.00000 | val = 0.166\n" ] } ], @@ -665,12 +665,12 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -711,12 +711,12 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -746,7 +746,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -757,15 +757,13 @@ "## Significant links at alpha = 0.01:\n", "\n", " Variable $X^0$ has 1 link(s):\n", - " ($X^1$ -1): pval = 0.00000 | val = 0.034\n", + " ($X^1$ -1): pval = 0.00000 | val = 0.183\n", "\n", - " Variable $X^1$ has 1 link(s):\n", - " ($X^2$ 0): pval = 0.01000 | val = 0.017\n", + " Variable $X^1$ has 0 link(s):\n", "\n", - " Variable $X^2$ has 3 link(s):\n", - " ($X^1$ -2): pval = 0.00000 | val = 0.025\n", - " ($X^0$ -1): pval = 0.00400 | val = 0.018\n", - " ($X^1$ 0): pval = 0.01000 | val = 0.017\n" + " Variable $X^2$ has 2 link(s):\n", + " ($X^1$ -2): pval = 0.00000 | val = 0.160\n", + " ($X^0$ -1): pval = 0.00800 | val = 0.136\n" ] } ], @@ -789,12 +787,12 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -843,7 +841,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -874,11 +872,11 @@ "Testing condition sets of dimension 0:\n", "\n", " Link ($X^0$ -1) --> $X^0$ (1/6):\n", - " Subset 0: () gives pval = 0.54700 / val = 0.006\n", + " Subset 0: () gives pval = 0.52100 / val = 0.006\n", " Non-significance detected.\n", "\n", " Link ($X^0$ -2) --> $X^0$ (2/6):\n", - " Subset 0: () gives pval = 0.98600 / val = -0.004\n", + " Subset 0: () gives pval = 0.98900 / val = -0.004\n", " Non-significance detected.\n", "\n", " Link ($X^1$ -1) --> $X^0$ (3/6):\n", @@ -886,15 +884,15 @@ " No conditions of dimension 0 left.\n", "\n", " Link ($X^1$ -2) --> $X^0$ (4/6):\n", - " Subset 0: () gives pval = 0.77400 / val = 0.002\n", + " Subset 0: () gives pval = 0.78600 / val = 0.002\n", " Non-significance detected.\n", "\n", " Link ($X^2$ -1) --> $X^0$ (5/6):\n", - " Subset 0: () gives pval = 0.57400 / val = 0.006\n", + " Subset 0: () gives pval = 0.55100 / val = 0.006\n", " Non-significance detected.\n", "\n", " Link ($X^2$ -2) --> $X^0$ (6/6):\n", - " Subset 0: () gives pval = 0.25900 / val = 0.011\n", + " Subset 0: () gives pval = 0.27700 / val = 0.011\n", " Non-significance detected.\n", "\n", " Sorting parents in decreasing order with \n", @@ -902,7 +900,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^0$ has 1 parent(s):\n", + " Variable $X^0$ has 1 link(s):\n", " ($X^1$ -1): max_pval = 0.00000, min_val = 0.284\n", "\n", "Algorithm converged for variable $X^0$\n", @@ -916,27 +914,27 @@ "Testing condition sets of dimension 0:\n", "\n", " Link ($X^0$ -1) --> $X^1$ (1/6):\n", - " Subset 0: () gives pval = 0.43100 / val = 0.008\n", + " Subset 0: () gives pval = 0.44300 / val = 0.008\n", " Non-significance detected.\n", "\n", " Link ($X^0$ -2) --> $X^1$ (2/6):\n", - " Subset 0: () gives pval = 0.08000 / val = 0.018\n", + " Subset 0: () gives pval = 0.07000 / val = 0.018\n", " Non-significance detected.\n", "\n", " Link ($X^1$ -1) --> $X^1$ (3/6):\n", - " Subset 0: () gives pval = 0.39400 / val = 0.009\n", + " Subset 0: () gives pval = 0.37700 / val = 0.009\n", " Non-significance detected.\n", "\n", " Link ($X^1$ -2) --> $X^1$ (4/6):\n", - " Subset 0: () gives pval = 0.46900 / val = 0.007\n", + " Subset 0: () gives pval = 0.50900 / val = 0.007\n", " Non-significance detected.\n", "\n", " Link ($X^2$ -1) --> $X^1$ (5/6):\n", - " Subset 0: () gives pval = 0.66300 / val = 0.004\n", + " Subset 0: () gives pval = 0.66400 / val = 0.004\n", " Non-significance detected.\n", "\n", " Link ($X^2$ -2) --> $X^1$ (6/6):\n", - " Subset 0: () gives pval = 0.29600 / val = 0.011\n", + " Subset 0: () gives pval = 0.26700 / val = 0.011\n", " Non-significance detected.\n", "\n", " Sorting parents in decreasing order with \n", @@ -944,7 +942,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^1$ has 0 parent(s):\n", + " Variable $X^1$ has 0 link(s):\n", "\n", "Algorithm converged for variable $X^1$\n", "\n", @@ -961,11 +959,11 @@ " No conditions of dimension 0 left.\n", "\n", " Link ($X^0$ -2) --> $X^2$ (2/6):\n", - " Subset 0: () gives pval = 0.27500 / val = 0.011\n", + " Subset 0: () gives pval = 0.26200 / val = 0.011\n", " Non-significance detected.\n", "\n", " Link ($X^1$ -1) --> $X^2$ (3/6):\n", - " Subset 0: () gives pval = 0.67900 / val = 0.004\n", + " Subset 0: () gives pval = 0.67700 / val = 0.004\n", " Non-significance detected.\n", "\n", " Link ($X^1$ -2) --> $X^2$ (4/6):\n", @@ -973,11 +971,11 @@ " No conditions of dimension 0 left.\n", "\n", " Link ($X^2$ -1) --> $X^2$ (5/6):\n", - " Subset 0: () gives pval = 0.09200 / val = 0.016\n", + " Subset 0: () gives pval = 0.11400 / val = 0.016\n", " Non-significance detected.\n", "\n", " Link ($X^2$ -2) --> $X^2$ (6/6):\n", - " Subset 0: () gives pval = 0.12500 / val = 0.015\n", + " Subset 0: () gives pval = 0.14500 / val = 0.015\n", " Non-significance detected.\n", "\n", " Sorting parents in decreasing order with \n", @@ -985,7 +983,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^2$ has 2 parent(s):\n", + " Variable $X^2$ has 2 link(s):\n", " ($X^1$ -2): max_pval = 0.00000, min_val = 0.242\n", " ($X^0$ -1): max_pval = 0.00000, min_val = 0.149\n", "\n", @@ -996,7 +994,7 @@ " No conditions of dimension 1 left.\n", "\n", " Link ($X^0$ -1) --> $X^2$ (2/2):\n", - " Subset 0: ($X^1$ -2) gives pval = 0.14500 / val = 0.022\n", + " Subset 0: ($X^1$ -2) gives pval = 0.14700 / val = 0.022\n", " Non-significance detected.\n", "\n", " Sorting parents in decreasing order with \n", @@ -1004,19 +1002,19 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^2$ has 1 parent(s):\n", + " Variable $X^2$ has 1 link(s):\n", " ($X^1$ -2): max_pval = 0.00000, min_val = 0.070\n", "\n", "Algorithm converged for variable $X^2$\n", "\n", "## Resulting lagged parent (super)sets:\n", "\n", - " Variable $X^0$ has 1 parent(s):\n", + " Variable $X^0$ has 1 link(s):\n", " ($X^1$ -1): max_pval = 0.00000, min_val = 0.284\n", "\n", - " Variable $X^1$ has 0 parent(s):\n", + " Variable $X^1$ has 0 link(s):\n", "\n", - " Variable $X^2$ has 1 parent(s):\n", + " Variable $X^2$ has 1 link(s):\n", " ($X^1$ -2): max_pval = 0.00000, min_val = 0.242\n", "\n", "##\n", @@ -1164,7 +1162,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -1181,12 +1179,12 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1235,12 +1233,12 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAEYCAYAAABBfQDEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOy9d/zlR1X//5ztu6mE9ACpkASC/ujSSwCVZsECCIqgoOBXrIACAhaaiCBKU8BCEw0QQbqhQxICBNJI771nk83uZ/ez8/tjZvaee+6Z8r73fnY3ybwej/u47zLvqWfOvOa8z8zbee/p6Ojo6Ojo6Ojo6AhYtqMz0NHR0dHR0dHR0bEzoRPkjo6Ojo6Ojo6ODoFOkDs6Ojo6Ojo6OjoEOkHu6Ojo6Ojo6OjoEOgEuaOjo6Ojo6Ojo0PgTkOQnXOf39F56Ojo6Ojo6OjouONjxY7OwByxtzxxzj0cOB9wAN77q8W9/YBr4um+6Z5zbm9gtff+cufcKmBXYA2wG3Az4GN8twKHAhd579fHZ/cHrgcOAS6O4dYBq4FbgBXe+1ucc/t776+KebgO2CfGvzH+3wAs995frsqzB7Cn9/7ieLwuPntOTPNmYD1wQMzf3WNcdweuDVUwUQcQJklbvPfXiuu3ArvH8q733t8m8n0PYDHe2+S9v9E5ty+jydYGYC/v/UUxrk0x3O3xfAuw1nt/WUzvGOAs7/2iqEcX2/M6YDNBTm8EfgI4CzgYuDLGvQxY572/2jl3t9hma4FLYxkccDfgvBjPKu/9zc65XeK9DcB9vfenx/TvBiwAa7z31zvn1sT4Vsa0rgaOiG21AdgzXrspXtsar+8PnAvcB1gOXOu9vzKWz8f87h/LuKf3/joUnHPrgMNiPq8FdgFui7e3xvbdM5Zra2yTA4AzvPeLzrn07K0xvT1jne0K7EuQ04O892frtEVb+FjuPQlyfDuwCrjee7/ZObdPLOuZwNHx+pXOOUeQz2WxjIcCF3vvF+Izq2LbLo95vybma59YRhflbSVBvjcCe8X/S+LzW2L8e8c41sc6ujKmd4n3fpNzbjVwL+ACRnriGsb7fopnc2y/XYFbYhnXEmRorff+/Fi2fWO5jibI5F7xd0vMx0GEPgmi78U6TTK0lqAzrgF2F/K2xnt/Uwy/G7C39/7CeH5ErIPbCPK9MbbtgcDm1I9FWutiXs9gJMd7xPq6MNbPfvH6rsBlBDkm1u0+3vtTY3xHAlcQZGw9Qaa3xHu7xvq8IMbnoqwsxHZ6IEGXnBnD348gv3vHvO0Tn/GxfHeLOmSvWPcrgYsI+ni10mUutaVzbjlB/1zrnNtP1PsaggzfHsu+T8zrnsAh3vtT4/HGeP+w2L43xfq/StarPBd1nfr1aoJOujHe2yXWpey/h8V6uV48tx9BZpIeuzLWyTpRjj1ine4R6+8ogm4gtttCrKv1BD1OTJeY3i4E+V4R+9d9Y/gzCGPFrTGvtxJkdDGGT/nf5L2/JOZln1ify2Pcu8Uwt8br6+Lxmliue8fyLgcWks6LMn4f4PsEWb2WUV9cHfO3WbXBvQj9M/WT3WPaN8WxZi+C3ltwzh1M0Hu3C92/zHu/PsmqGJNXEuT7hwQ5kmnuEst4a2zHpAMOi/FfGcu4K0Efrkjh4zjpCLry7t77051zK2K5r4/tLOUg5elwRlxlF4J+SbrvAIK8HghcHtPbGMPuTRgD18S4AbZ671Nc2xDbcXnMt4/l2xjLdYWQvZUEnbMuxrsh1teNsV73ZzT+Xk/oRzfHsLsJuVlD0MfnxbAHxDZPOnpFvH4TQf52J8jr1TGvGwljwjb+pcqTuMo947OL3vsfx3tjclOF9/5O8QNOUec+/s4nEAZ971nAU0MVbLv+lVh5AG+P4b4h4kq/M+P/21Sc74v/bwc+JMJ/lTCYQFBEh8fr7zHi9jJPIv4PpusExZHC/lYujlKc4vqVwPfitWPitR+I+yeJ8Pe04lTX3mNc/y8dLp7vF88fauRL/54f/9fH/88DJxEGdA88HjhehP+92E4XxfOnAP9DUPAQFOC5hIHbE4iilccPq3y8u7W+gecU6upBCJnJyPTXKvH/dfy/KJYnXX808EgV9qEEJf5p4Lvx2nW5tDNtcaM4fosK82xVzl836uxdmXi/C9yfQNjl9YOBvzHCf5YwAJ8i2vdG4DMEpfzKeO1fYnr/Gs/fK+I4VpYd+H/i3gfi/5vivf9RZXtaPH94/H+zyt+1Os+qTqUMfRd4OqM+8mEV/u3G82ep+FfENL+dab8bjGc88CuEgdQzrlP070AR3/Xi+mtEWm8V9SOf/Qyh793IaEKzhwrzJ+r8dtH+8vo2narK+UyR9u+rfKyMx8fF8w3A20SYN8XrB8T/jwC/KNJ8j5GeBx6bqeu1wPtVm31H3L8MJurXEyZXHviodV/EtTHWqQdeUGgzz2icSr8r1Plu4vgl8f9kwgT0FwrxrlRl3gScqMLcpM7fEv9Pj7LwdVGmP4/3jmSyn07UgUj7Y+I89bnPqH4mZe2diSsQJoeyDEep9J5vpHmyqNek218mnvlncXyLOD4uPv90ce1A4Eni/MpYNweJaw+N/+cwkpsTKm0uf1eX6rAy5v6VOD46hvvrTNjbgEdl7h0njlfFeP4znr+YUd+4Kv5/gzDJS33hrTLv8fi6+H9ZoTx7YZQbJTe1353JgpzDYQTlr7E3YXYqcQgj68nB8X+58ezR8f9u6voR4tkDxfUjGVmudhXp3ieXaQMyPtluu+iAA7E/QalDUCYQLLUJR4rjVQ3x7WVcOzjOnrchnqf4VjbEu6v6P5SQ993j+Z7xWsIaRu0Eoc7vLdK8L9GiXMnDIer8MHW+iC0jKU85pHwfWQhzVOEejMp7MIFUJKxk1KYyvVUxziSLd4dgPfXeb62kBePluYe6t5s6308c30vk00LqE/dS11cZ1yD0szUEUp3abxmhPhxhkIEwEZX/sq61nMryHK6u3VuFvXv8T33vEHV/b8o4XBwvJ5Q9ybWWLysup86T9Xsxk97nCSRSYxWj+iuNBbJvyHqTbbxP5tkjYxpfIxAEx2Rf07K0Jv7vrq7rdkjYVx/HNwIwerOV2n4t42XQ/f9wxvWc1CkSWt4TlhEMCRJS7g7CRkqzNiasFnnSfVzjaHV+gDqXY0eqk6MIZduPPJYzPqauMtLaQ52n8SvpYNkHUtnTuKjjymF/cZz6iWyvwxjXzamPHU2wgkqsUee7QBinEjMT+TqSUf1I2U3yuZlx+Uj1LvvySsblbH9CG8g2TfmVct9aNzDeL4ZC5i3lQ8t1wjry/eEQcZz6YhoH9mZUtlSfRzDqi4fKfIg+nfRvri9BWZ/tX7g3hjuND3IFPnNNDzTOONZhJuI1lLFjvIFkHKsZddpS3Bq5BtckvwqR34lb8V/el3XXIi/WIJ0sRxKrGNVDjmBK6InASibbSw68us2XY9d3LQ+6PFvU+e3kURvASulCXT5yMmbFmepjBZN1M1iGjDhKk6f02i9XHtknJBYzz6S0ZXtvFufpmRXq3OrfqLDy2GfCpvNUby3yK6FlKpFkC1b59fNS71jYgN0+y7F1oxXOguwLuQnmCkZuNFvjsY4vV3at83IyJsud8qT7dU5/6nBO5U/39wTL6JKe18+01HFqwxZjQU4uh0KSxFRmqSdysOShlpdUX7pvyviKbWWMW7W+oeNJcmY9p9szEWYpc+k5qZcsHbxBxWW1l9UPHOOykuRIXtteRs2hbZybnMvrKc4t4p7uKzK8Z7y81XEquliBymt0Z8G6V0InyPOJNym11Jm0kpXprGK6es8NUnomPEtcJhkRQteivIcQZD2xKEGX01IU8ppu85xiqeWhRpAXMs9BG0EulX0IQa7FWSLILW8GcvG1xJEjGfLZXJ5LBFkTI10fWlmW6nO5cVwjNtJ6PQQWwW0hf6XnS9ADdoIlCxaW6TdAEbJdSwR0GSOCvIzJ/C4FQV6h/nM6zzJuyPxthbGBV6dj5WUagpx0awsBSnmZpt9KlAhyadI3DUnTdSLjT/Vda6uWdDUhk88M0VFJd1vPSIJsjfM5gixh9QMdVhLJhKGT8Wkxq06zrqe2GEKQZXlb5D33RmyqvtIJcj6cN67l4k0KPkeQZeOsZtKyNQFjQMp1jBYSpjGIIDPKv34NZcEaODZjD4pDCLIupx7c9WzTsiDnFFUpD7o82tKQUwyw9AQ5ZzEvKd6VTNbDPCzIpclTqqNcX5KyILGMMkGGUftIgqwHeYsgW/Khj3M6QPf7oXpUy9QyGizIwoKm3WHS9Vz95ghy62CbG8xlX6gR5MX4s+LKDV5apnIyJts15UlbJaclyCluncccQV7GpI4YQpBbjBBDDBYlSP2k+0pJNkpvqHLQ1lCLILda+0tpynbRVtrUx6zndJ9KdSP7ZXpuC9MRZK2jdT/wKkySI12m7YEaedfI9Qcr77Jcuq/I8Jogt4xTKUzu7UGKtwmdINdRqqPUqVapf02QV6vjdF5ScLoj5JTGUluQtzLKbwvhs3xZLYI8qwXZqrtafVrlG2pB1h265Ltbqq8W95JpXSwsYiktyDrPEwQlYzG04kso1X3tlXDOgpxrM2sQSbud6OdluqUylVwschhEkEWdWgS3xcUi59LR4mJhIVe/GsuMNGEYQS5ZkHMEeRoLco4gt75B0gQ5Z63dVnbVVyyC3OLfr99CljAvgizd1pKuarFkz+JikSDjT/W9Rv3X0m1xsbDGYes5fW0aF4uUVouLxRALspSfndWCnCPIlvV7s7inJwEy/FbGy9vSN1oIcjPuKgTZUlBJWddQUhTakiQ74ETHjK/plmPPTjV0R9geLha5Dpvy2WJBtuK2XCyk1bCl0w91sSj5mErU8lBzsWgmyMoPquX1fE0+cwOk5d+W8tlqQa4NvlkXC8NXsIVoWvXfQpC3in+d5xSnRSBLb2hqLhbaqtiqR3NvjpaTV/4y7hxBrvWfTZnribzWoF9VJ7T4ILcQ5JxemcaCrH2QZ3WxSMdJh6fzRSNMOp7FxWKIBXmeLhapDVL683ax0ATZsiCvU/8aLeOEJmStBEvLZGmMTm9CwJ5Ya4JsjREtfc9aE2TVQcsEbCjmxQ1bXSw2G+GXyoLcfZAVchZkjdIirlK8FkG2Zsipg7YQ5Jw1TGMagjxEwUkXixYLspwMJGzBXpijCUwJQwmyRSKsNq/lYW4EmXEFncozixWoRPq1bA1dpFdTRiUL8tCBO+disYK6MpMER9eHPp/WB7m0uFA/W0LJAtyi/HP+dRMuFkb/s6AtbDnkLMgtPsgti/RyK+Dn4YPc+tpevm2wyJt2o7NIdIpnGoKs30KWkMoyqwVZ6tSkq7TvtoVprJipTizXhHRcI8ilPC2q/xRv6yIvHXfKQ87FQqahj1tdLHJGARlGX7PqoOTmNy2GtnGubWqL9NL4mepGjqeDF+lh70q1mSknk3cVgpxDy0yihSDXXCwStKtCqdF2FhcLaUFuSSuVTVqFlmKRXs3FQsfZakHSKC0igGEEWXbwVJ6SDMyySK+08KllgZ11TfuH5cLrZ1ssHENcLCxyYhHkkl9laRFnzcViWh/kVC9DCPK0LhYyvtwA2mpBloO59QoYZnOxWAqCPC8fZG2trRHkaS3IQwjyUliQtX4d6oNcg64Ty4CU8pAzxCyHMZcWq921TLZaIPV40upi0UKQ9fOQd7Gw5Kpk+IH6IuhpMJQbtryBtQiynoDKdKdZpGe5r96CPdGp4q5CkFtdLKyKm4eLRcIQC/IdwsXC8FW1rADzWKS3jvF2rFmQdZzz2sViyP0WglyyAk3rYrGMPEltdbGwrsnXpCU/Zu0yMWSbK4kWH1nZfjUXi1af/3SsrRta3ptdLOKreev1XyJkrS4W2i8vl76Mbx4E2Zo0SHmouViUFunlCLKuk2kW6c3VxQJ7INfH22uR3lK4WOg0LMziYpHqwqq/VhcLazJhvaIf4mKhy7TULhZDCHLJNSzlZ96YF0G2JtGyrbSVXI8b83CxWN/47AR2SoLsnLunc+4rzrmznHNnOOdeNmOUg/ZBVoPgEAuyVJ6WEtEW5J3NxaK2i4U1s9dKp5UgT2NBlnsOW/WxFBbk2pZaJeuoHnSGEuQaObSsG5B3sUgyP60FWb/+kpDlkAtRrbAWci4W1nVdVk/ZxcJaUKPR6oNsKewW+V2BbUFOA2WLBXkV8TPBKsyEi4WKr+RiMYsFuWWRXkqjZEHWHwRJyBJkY2FcwhYVtuZiofu/zp/2N18qgjzko0lL6WKh07Awq4tFbheWlJ9c/ClP2t0F8gR5WheLaXaxGOpi0UqQa9gZCPIQF4tSOpogT+tioQnyncrFYgvwx977o4GfAl4avxk/LVoJsuV/NY0Pcu45vV3aEBeL7WFBnmYXCy201muyeS3Sy726SihZkGsEuWUGbMU7xMVirXE8i4uFbHstszpeuT+rznOrBblkFdY+yKuMsK7wkZqcP15txfkywodILJ8+7WIh81hapFdysZB5sgbqHJaL8JogW+1l5XM1oQ/UyqnzNIsF+XbGLXFSdmS8syzSy1mQtQyW+ndCqoOkYy3LlDSEWBNky8Wi5IOs23PIOoWElsVxOr2lJMjzdrHIyQ1MEuRaunqyArO7WOQI8jxcLKy1DLm+J6+1WurvaC4Wcswtvemd1y4W2sWieZFe0/eod/QPOB54UiXMKYXvi98AvAn4AaNvwm8BXhqPP8b4N9XPEccXqbjk758I3w4/y7h3vXHtsfH/04U40++7wG8D/wr8L3BBaK6Jsp3dEJcXz74N+Lpx/5OMfzc9/S4V+bZ+78nk53fV9V9V57eLsBuAk4AbC+mcA1yurt0sjn8x89xWox0/LI7fLcJ9UT37L8C/NbRTU/0DLxHHb2Akm2my9vEY5sex/m4bELf8XSnKlX6PifVshX8d8E7gEcBXCf3tm0Y4mZ8TY7h0/h/iWLdT+t1E6GvWPStvX8uEPVedXw9cE4+3xLKke28Ebs3kJd1/PPAJce8KcfyTwJni/NPA6VO0ySbgbzL3rmNSLj8LfAH4VDz/tfh/oyir9ft+rONjxbUXFsL/XEPerwZ+KR4viOunEWRW1reWO0+Q5aQnPo+tZ6zfbxfufYDQT6Qu+y1G8vWg+P8R4CGZOJ4FfDQeP09c/1Nx/O34f3zM98Xx/ORY7lNUnO9lNMa8JOrcizPpy9/mhjA1XTTLT5fj0kr4Px4Y/6v1tVg3f07QV54w0S3F8ULg9wifLPfAeWK8vyxe+zFwYTy+gJEcyDiSHnuiuJ7TWacQ+uDh2Hpkkzg+P/6/0wj3AFW+n8qk9y1x/ITGur16QDtcSSCaDwVeTtD9Vjipz88j9POPDkjH+n0EeL84X8/kGHeeOL5I3ftbI85nxTiPAx4JPNmou6Qj/kBc2wi8FjgEeGuWV+5o8ttAjg8BLgF2N+69iCDApwAXFQiyRVY9obPVGrWkKKzBIP1uNq69KP6fxiQZ1ORM/yyCfHElf2O/+OxNreFF+Y8dGH4L8HYr/zP8LiN0qFwd/7LxzOtjXtL5PxhhNlXSzQ1Kiez8GnBCPP4l4CmFuP7OOE5lSr7BknDnCK38XU6YpV+lrt9EIH2fjeePw1bwHvhO/H95IZ0XM04Udb39p/HMxxhNAOb5O0+dX8GIZC5gD1Cl37sYJ8hywHkvgai/oRJHGvxyE7Vpf8cb127AnsDI3wfE8W+I4zNUuNeL4/cV4kvyujhFGV4a61hffzrw9/FY923P5CR7yO/R4vh/CuGS3H5VXJNtfWLmuPTbNhEaQJB39O8MJvvV0N8rjWtvi/+vI4xxP1Z1o8P/QWx3S87SOP6nwI8QYz52P7kYeJhx/TTgWuCvB5TtVdgyKn+XEkjXfxj39GT/EQ1pPrkhjGd8Qp/Llzy/F/VJqqXPT6g8czF5A0jpl8aVq4B/L4STBoQvE3hhOl8kjF9p/P3p+H86wQiSi/NPibJo/XZWFwsAnHO7EhryD7z3t+j73vv3ee8f7L1/MGGAzMHnkjCulT6JqVGqP2tjeel3+ml1/4uFuMDO61kMd7EY+nrMWhR0YyH8OuBUJl/ZzSpra8nv5wp2ub6orv9f/JevwGr5kq9qzhLHV8T/jYQODvAZ7/1nC3HpD8bApF9qbUGGxnqCzJ6jrq8gWBNPjefpNbcF/RpZY4Gg4HOvlcF+3ftVkf76TNzTQNfLAqO8yTL+qDE++coUbBeGUrveTLA0QngTM0/ktp4sfeIcxvWCfM15ngon++n3xfHnVbicv3XN7Sk9M+Hm4b3/NGGQg2At15jmVX6C9ZU4C5aLRc7F7sL4fwllTONisaOxlpEMT4vjjWvHESbrKwn98UwjjMQnCOTsZnX9x+J4NUGvyLbZwqQMJRcL3R4O+BzDFm5pHWFhHfA9bJemloW1GvNysbjUyEvNb7nVfed6cXwyozF2CD4X/3/AZD19L/5vYLz+f6jCJTcKvebgdMZlZxB2WoLsnFtJ6Fwf9t5/YsbocgTZKn/piz8tzyfozreJ8a299MCi0zXTUj6cCwwnyENXIHvjmZLCX0d4bbKLuj6rrO1CmRRYg6AOn+q8tthPIue7lBTMVnFcUzolgqwXoEBbna3MpJtIVLqXFrPl4oD8BxvkHrYyfgnLP2wTozrbmIl7GuiBSi4C9eJ+aUIlUdqCKp2X2jZZMLaZxeaI3O4eNdnIEWTdJySRlPWl9VGOTNyeuS5RmpylvFl9exYfW6l/WnS4rM+1xn0Y5bGmq3NfsYSdlyyvoW2yU4LVhmn3klWM68rc1zpTeN1mkqCuJowx2iddp59857UeWBGfz+k7qw+3+Pmui3lo+Z5Cy+SvVf6H7rQ0LUG2+pGs82kXC5a+hrpB/Mt7OmzaqcJaRzb1IsadkiDHjvN+4Czv/dvmEGVOKbVsmTLtYgXLyiUtyEMJsrUae4G2r9uFDIV6HWqV8cYzJYFbQxg0NXGfVdZWM6kAZR3XvvQFo8FcDuo1q0COGMgvuLUS5NJewZYVt8WCvCqTbhoYUh2U6j/JkJ7UJMgtunKwFOoCo3K1ktUW1AiyTL8FtT7fMqAsxUpysGWgZfcJ2f9kP9DtkNp+K+P11UqQWy3I0xDkqbZmipDlH2pBXmPch1HdNRkzBO4IBHktsxNkq48n3bESRZCxdUaOIEsZXsVo8WiCRZBXxJ9FnG8nv99yjujXsIZQB5a85XaeKWGpCPIK6oS/dWcj2ebTLhaUBFnXnSTI8p4Om3aq0Dxpm/FiGuyUBJngbP084AnOuVPj7ykzxLdULhZDtg6pWZBrwmWtxq4paiuOeRDkmpLfwLBV0a3Qimtl5jgh9xW8IfVm7cYA4wR5K4D3vlYvlgU5IdWPHJxbCbIlO2lgSHWwnHy7JbnM7SYgdyAo5UNDDhZDZbUEa/KZ0km+ZSn9FtQIcm1A2Vq5Pwv0wJr6Y60/5d4s5SzIWxivLx0uR1Zvq+QDyrKX6s16wzALQW51sbD0au7ZVD+1iVeJIC+VnMyKpSLIW+IvWZBl+WX7bjbCSySf5PScJkzLmdQxOQvycuwxKsGSxVaSJXWRTrN0bmEFbXqzJlP6fu6tow6jYfVHWbdDiKgs14L4L1mQZZ3pek4WZL3Di9y9aTCm2fB7yeG9/yZDtuKYHi0W5FIdtXx6OWFWgmxtAzSUdLTueyox1MUCwqB5d3VtHpMx3Tayw1ptofM5zUwyR1hbrcYSJQtyqmNZjpY+kFN2jkkLcm6imOQytx/tLARZbw4/D+h8SB9kWcZprdbWHuQ1F4ulIj5arjeR/zS3RG4LQF0nKf5FyoNdzhjQ6mKRq7903WqrWT6EkSu/hmVBXmfch9FAXuvzd0SCnEjnLKi5WKRjCCRUE+SVIkzpreUqbBeLVoJcc7HIEf0WSJ2n86LzUEMiyDVL8lALcu6tow7Tck22+ZAxXpZLEuRdVbici4Um08mCbO0RfqezIM8bQ1wsNIkozfSGEORZXSxSWnoWNQQtHUNjGguy5WIxDwuytdgiwXIP0PnUn6FtQe5V7Vb134IWC7JMbxYXCwjKusUHudWCXKq3movFUFktYd4uFiXrTnJLavJBXgLofrQ55qk2wObktkSQZX3pOr4ju1iUxrkhLhYpj7V+WdKXSyUn88BSWZCli0XSwRsYJ1xy8mHVkbY8t7pY5CzI07hYtOjjnItFy6JmjZWZvGjUyLtlWGo1yOnnNGTdDhlXLXcuy/re6mKRW6QH5T5XbNO7CkEe4mKhsRQW5GkIcvrUsp5FDcFqxl9VtcD6AENNyW9g/j7IOl1dX+uMazqf0t2gFTmiIRfptWIoQW6ps5yLBbQt0ttKnSC3+CDXXCyWkiDndrFotSCvUHFam9eXBpTtSZAl4Wh9rjSpzrlYbC+CnOp1KQlyaZHlkEV6qX5aP39une+sFmRYOgvyFiZ9kDeQcbHIuKrpRXqaMOUW6a0g72LR6oaU0m95o5FzsdA8oiUuiyDn6qYELXOJB5SQXGL0cxrzIMhy8Wuri8UWda5dLKQPcqnPFQ0Nd3WC3FL+UqM3L5BjdheLFMcsLhbJ2jhEScvXFgktPsha+czDZUZ2av1qd61xLedisaMsyC0uFkNR8idrcbGQCm4WFwuLsEn3nHm5WFhE3VKs0E6QSz696Q3KjnKx0P1ILnpqfa7kYpF0mHax0HU8q4tFzYK81C4WuQlacv8YQpBr40ap7u60FuQCsbV2sbgdmyDXXHHA/uR6ycXCIs4bGOZiYS0czD3b4mLRItuWD3IubyVM42JhjStWnls+N29B6svWRXraKlxysWi1IBfb4a5OkFuIUonYTetiAZOC3jLA6tnpNBbkZIEqQSq6lUzW0zQEed4uFnpg3sW4lnOxGNKRc0RjqVwspkH6GIqGdLFYXgiTMO9FeildmJ8FeTOTdSeV9HJGfXaIi0Wu/pOLxc5iQU4T3NoAO6uLhUZpj+waWhbpWQP/PF0scpOltLirZZFeq4uF7idz8YfcDmiZ7AyFdrFIOmgjeReLXDy1RXpDtnkrLdKzZKX1res8XSysid00/tE67y0uFtabSas/yrinHcOkD3Kri4V2+dMuFnKRXqnPFXXMXU/iFsMAACAASURBVJ0gtxClUuUO2YNYE+TcDgsl6NnpUKtcerVSU9KyE8qtUxJaFuktBUEuWZDXGde2hwV5iMuK7Iya4MxiLcv5x7W4WGwvgjwvC/JmJi0/su9Il6BWMpK2gyrd31l8kFNaNXmRslaaVKf4tQVZy1Muvdbtr2qWQYtoz9OCnCPIyfKYsyCXrO853FEtyC17lQ/d51sv0ktIi00TLIIs+7W8nnyQndhL2bIgg913a7tYWO3cOma0uFi0vAFKz8zDgqzR6mLRQpBLH1gqQT4nfZBzLhba59wz3s9yu1hAtyBXkevU+zc8W2r0gwbkQbpYwKTwtRCIBcYXow21yu1BEJYawdWkaS91v2WRnl6NOvSDJhZKBPnuxrV5EGRZDt1BE1rdR6S8HajuDXHX0cjJt3SxWIdNgKUM6XZOSAS51IY59wy9UnlWeCMfsi8tZ9RmrW4P8hmNNbQR5Hm7WKT0rMWnaxkmLyWSd2j81/sg67EhZ2lpGZwPZjoXi5xMtWA/cVxysdgr5mEXdS3hXuK41cViW76dc/sw3u92Zh/klj46dB/nNN7spp5dYCR72+JVH9rRixtTv9+DUVvs5pzbndB/rfzvgb0It0SQrbH4gExYjZyLxT3F8QJwRENcezBZpmn2aNZtdjB1gr6PEW9N5wx5MyvHTOmDrOtZWpC1jpblWk/Ic3pehi31uX1LmbyrE+QXxP9rpox3COnTBHkROEOctxLkN4jzi2I8lzbm4TsEYXlPPP/fQjoJy4E3q/sti/TmjeuBD4rzw9T9pwFHqWs5K32NIF9H+Na7xjvEsf7UpcT7jDQhDNqXxd++wLXi3q9U8mQhff743sC/Gvc3ASfG4w8yOSDcDFytrn3IiCdZgUouRXvG//TJ91sJnzVO8cm2uIjp+5xFmh4T/z3BIvDceN6yRy/ArwEPF+fyk8vPI0xsai4WnwK+Ia7N+rr6HYV7W6godoG3ED4hnHSEJKJyMP8goU3SJ9RPBi4XYSVBlte/W0n/dODZ5GUn1av1meOniuPSp74t/Iw4XgbcmAn3EwTZlURYb1GZoF0sTsmE+3VxfA3jVqo0qF+VebaGG5nfZ9vfo84vM8K8V53XdL/+sNctwE8Svm2wlVHd/QB4dyVeWW/rGBG0n2LUFjfH3wOxyeOvMZJpGPmyDrUg/1UmrPXsf1TCrAVe2RDXX9DmYvGvmeeT/tP852+B3zfCSx6xjnpbX8j4WPcF4KTKMwlSxybucwWT4/qFhDHlXIIcJTjG+esFwAOAV8Xz18X/0tu99YzGChNZguycW+Oce6lz7qPOuc875z4Sz4f43e4skOWUxOft8f+dwF/KB7z3qSMnUiYHyHcDz6ikeaI6X2C8Qy56748R5yn+c4y40vfrNwF7MxpMTvberwC+JcL+Zvz/eCZfi977l8fyfUBc/wVxnDrhO9Wz58b/pOR/Nsbz1nj+p/H/lkzaqV6twVDjJeL4Xd77vb33Mr9ywP5w/E9t9nWVz/TqcJsF2XvvRBtrPNJ7/yTgWeLaG7z3f5Pi9d7LdhpTQN77FzOSs7fGdJK15GXAa+Lxi8VjlnX3e8a1RCxPBJ4v0vxATOdjIuyC9/50RvUjcR/v/Z6EgQrg7BjP8+TzhMnRto+hRGi5SPL3V8AfxXh2895f7r3/i3jPAUne3w0808iThSQrj81ch9AnYFwRPo/JSedumTaXsnSS9/5BwJ+oMJaSTcrYe+8/471/jLj3PsYHnETQfmzEY+HNjCZQmty9T51fJOT5n8T113nvX+G9/x6jgScNuCd579cQB1Hv/Wu89zcBz4n3T/Pe30PEJSf3ciLwceDJhXI8Ov7XLNCnF+LAe//UzC1rDEvymPr9CsJg+JB4/vxYV8foBykP8GMWZO/9Qwph/0id/3z8T7rieRlZXCSQvRx+6L1Pk0Q5AfxHHVDpuGRYeZy4/7uIfuS9Pyse/nf8/znv/e8wLlOWIec5KR3v/R/Hax+J6d8qwm3zG/Xe/x6BAObiTROij8T/1M6nxX+LKMpJ6UMI7e+B98f8HUtoX7lI70rCZF5ikWBMglFdJBxDIIISp6YD7/1i0sUxzUeosK8EbhDnJzDJJc4Ux3qiLY1PD47pfFC08z/H/1/w3icras5A+Grg38W5Jqc1l6IHee8/Spzsee/f7r3/EfCLIsw34/8RjE8yPs7I2pt0wIWMjHFpjPmy934fJjmD7vcl/WHp7pWESVsRJQvyvxOE9hXArxIadoHxCr2jQJbT2qqr5bWXfH2whfqrJu2buonx13g6zXRuxSud2Hdj1GlS2JYvAsp8yTwlrDeu6zhSeVK6udntPCwc+rW5hlSoOj29gC7dT2WvvQrKlS+HFhcL6WOXyiYnEtbbCEtBybQsWZGvzjYVwqVrJWt6+tiIJshaLkp+pDKu9FzLQtEU9nZ1jroOI7mUYSx/tiGvh1s+MlPqs05dX67+a5Dp6fh1Ped8NaX8bFXX0rmu19zi09z+3LVdcVJec31uUf0PgnolLxeAwajfJxcZuW4A7P5Vavch+6i3untpeCOsxLSf9k110vKmUstGbW9xK7+5LSVzC0ZzMp1kTbeZ1XbShzptW7g747o37Y2c9kHWW6fKvGLcs8pf+8qmDqvdG3Scsn9pv3BJkK10LZ2fI8iL2OtqdFw55PiHte+3/oqidOnSrjcQ8+y9b+VoubzmvqRXW5QMlAny/t7793nvL/He3xz//5lx3647CmYhyHqgS+FbtlaR8VouFhJJcZUI8ibqBDl16FyZdJ4S5Cxa+gRJaIKshXJ7EmQ5ACWimfKr85ny0zrAlQZQaCPEOoycdKT4ZT1ZBLlGOC1ZsfxNLVltnSxYBFnLRU4eJORq4paFopoglxarSCUs7w/dvxtG7ZbbAcW6Zg1ATl1P9TwNQdb5Lu2AoycJIYOjLbjSs9akQqal08wR5JouTOkVfR4V0Z0WKY4kM6l/LWM8n6WdM0rt3tpnYLLvti7KrtWDjFfGUdNJ0xDklGeZp9bFtlY59NZc1l64MqwVX2nfbEkeEwHajXHduzLGtZHR9oNWe6b0dH8dukjOmhjJ9JIRAnUtQU+0ap92thY75mRqbC9hY5u+GoHMldsypsgt/tK5Hp9kXWh51mnlxtemfEZ9U110W+roX3fOfQT4HMHHZw/gpxmZzO9IkARZW4Kh3un1tkqbscmJ/HziFnWuV7fmCHLJUpVmxLersEMIsoxfdgCpXJLg5AhyjkCm+LIuFgMg81/b43a9uGatXtUW5NpgUrMg6+ctBaQnn1IZpPjTpKS2AM5KK/f5XmsAmtaC7BnthCHTyslFjdBL8lUjAmm3ilaCvELFaRHkIRZkXbdWXZf0hpYR6wtPrenXLDstFuQUj26j3GRHp6m/LijTy7al934xbjSQK/c8iLGOSxPknAW5ZcGT3FYw3SuR/QXsfWZT2tYHbSRa+oV1XFtPlHsraEFPkmoWZEuHtFiQc2XJpS2v11wsFhkZlKTuXS3upWulPqnLNnSRnEX09P7NQwhyaeIs82e9WdGolb1GkJMM59pIHusxRLaB7BspzZpxQ8t7Lq8lH+TpCbL3/tXOufsRfMjuQfCDe1P0abyjoWZBrhHkzYwT5C3YJEsSNG1B1mkMcbGQCn03RtYAy4Kc0s+VKTeAWsc70sVC722rIfOWiGbuq0OJsKdOWrPitVhEJSxZsL72lvKQ0k/xp09z17ZS0/HvLC4WtUE/xSVdLGpEoOZisVmFXa3S3x4uFqW3PrO6WOjXkRIlkqsnCRLSajPUxUJCE+QW5EjlPD4glKAJcur3s7hYWJOPEkFO+/vqeHR/y5W7xXUvQbZ7qwW5hSBr2bBegUvkPhJkxau/hpZQGx8TSm1nuVjszbjuXSXupTxZyLlYDN2HWLeLdrFwTNaptQWadc9K19LruTJaY6EXaSy1i4U2WEkLsh4HdVmHWJBz7bOt3p1zznqLVbRmeO/PAM5wzh3kvb+8FHYnh95QPKHVv0ULae7LXVLQF9VzNYtUC0HexLhVTVslEPnKEeSci4X1uqs2eOYsyNuDIEuk+tACbrlYzEqQpQIpQYeRZEp/PCMR5NvI70VsxV9zsZjVgpziqBHklj09pcVbkpUcUn3lBnZNkGG+FuRZXSz0vtPz9EHWcpnr69aEUVuYWi3IEtN8OnnaL0UOQcpzzsVCE78WgpzbWzeHjYS3fDWCnENt4mj5RMPSEORWF4uSD6++lnuLWnOxSCi5WGgL8gJhvJQGn9XiXi6fMD8XixZXAR2n7F+lNzmldGWbNLlYiPS0ASeH2uQipZGujek0772Pb5fkRz1SmjUL8li9eu+3jrbEnkCLBdn8GFSrteok59yDGsPujJiHi4VEy6dtk4tFQo0gl6xRWqFvKISd1sXCsiAP9UFOac5jm7eai4WltHMEWVqQhwwQlhK2lE3OB3UUYDQ7lR+y0BZkXW+lwXKID3ILQc6VK1mQS4PkULeBFhcLLUs6zVrbTBDkgX6uOYIjkZM7Kz9JHobUle5vCSUXi1YL8iwEWaLVgrwjXCxqFuSWBWdDCXKuz7X0t9L1hJzVtUaQczrdwjwIcosFeQhBrrn3waQPsl7QJ10sauNAjiDPw8VC3y8RUWsP55Z0Wwiy5WIhw5beYslruXE3pZGu5Sb9KQ/Smq65ac0HuYRWgjyBVoL8CuCLzrlf0jecc89wzn3LeGZnwqy7WFjuEDWCrDth7RVBum81plYKJR9k6QNtYYiLRc1Nw+zY3vshq6tzqC3Sa3FrsHyQWwb0YvmmzEuC/GpbjSCXlEDuE5rSmtsiU1I5WWlsAhYVuZyGIGsXixpSmNziIr1XN0ySw5Z8lQaPUaBQ/pxVuWWRXkKrBXkrkyv4E0oE2RXCSdIwdJGexM7qYpGQ80EeK5tYIS+h28yS1ZqLxbY0BFr6m5W+xqwW5BaCrMfFmg9yyxukFK/+olwu3tx4WbL+awOVRZBXAVuEPqtN3MbuZ8a2oS4W+n7JB1nnzzLwWZBt0rqLhYZ8zjJ6WfxDXpfHmg/JMLJP5Bbp1fhTCSULus7DGJqsGd77DzvnLgCOc84dSdh8/rmEfW9XAn/fntcdgnm7WGg/ogTtYpETCJ0Peb/mgwyTPshDXCxy/mTTuFjM6+toFoa4WORgLYZrHdAh/wq2ZWKZ68DLsV0s9gZuGpC3qgVZDALzcLGQ2B4uFlrGcm9cwCbIuU++amzE/mBArh9a7gUtLhYJTbIsXj9aeakttMuFs1wspvFBLr0CzmF7uFjktnnLuVhYqA3MUHexgLoFOYelJsgt7VWyILfWx1AXi9wivVy8lszLNNMCYxgfz1arZ2sEuaW/zmpB1v1U9i+tW7eHi4WFiS/ZFd7INblYiOOZXSymgdKxZjs3Ky3v/Xecc08ibLT9csJHI14H/LexPcjOhhWZ41lcLCxSMMTFIieYLS4WpW3eahZk2flmXaTXamGdBkNcLLxxDUb53ADbOkSL9TLV5ywuFjkSLQlyqr+NBAvylQ3xyvgtWbHkch4uFhLTEOShu1jonTFKJHEWgpz2Q9XIEWRZ1pKLRc6CPIQo7qwuFtv0jRpkSsjJyDxdLFKfS2WquVhYyK0dkGixIG9vF4vapD2VuWVyXyLItbdWCUMX6bW6WKSPtFhyl1u4pV0s5GK+mlzOSpBrrgK1XSymJcitFuSSi4VEyW1yVheLlNdZdrGYFdMTZOfcfsAfAi8ifKVokbDt21fuAOQYxnegsF7x1Hy5WhfpaReLEkHOrbCvLdKDNoKcI/2WjyrYi/d2JEGuzfKdcZxbTat902rQr/Mkqv7GlTxtc7EQCwsWCQS5tJp5Iv7MINFKkLVPbMnFokaQZRy5PE9LkHO++ZZ86ElTi34bIsM5K/ZSEWRrT2brlWxOfy05QR6A7eFikfR8Klt6czRvggz5+qn5IM/TxWKID3KKt2Uyq/1950mQcy4WNQtyiw+/zkfOxULGXSPILf113j7IrS4WS02QS9vNSbTuYpELY7lY1AjwvF2zzHZuZeHnAwcDx3rvfxp4KnAyYfHefeeTvyVFrqFlB0rH+rOum5jc1zd9wlJDhtugzmuWyyRItxn30jX5Sh5GQiZnxIsqjMYacbytY6rXJWlg0UorEU299dYQ31IZTwmlTeTB/rBJuqbrR4a9uSHtBMsdZb26vpXJrx3JPOi8W/sypr1WS19N0tdy7WvlxRrMtRVbf241XbMIcm5P4s3GPZkv6RNdk5Uk8zmCLOsm1YV+rdjiAqTloSSbOmwqt9VnF5is002V+DWSi4As+20i3XRfpiPr37LKpWspH1q3lQiy3llExltDy64684Y2WLQQZN2vLB2+mbweSW5SFiHYzOT6EY0bKvmz9n+HuqynvOsx39Ij2o9atre1Q5ElK7n85N5a6j6UzlPaSV5LE1o5zss1A3J8Ws54/VpvjzYa6UvoPmz1/wS9DkbnfyOTdVVqV9nXLTmx9kHO1dkik+WTactylr5toPVcjiDrcTNBTshSXmvGotYP1ljjl4WZXCx+wnt/QTqJZOoPnXM/Br7mnHuu9/4LjXFtLxxDqJxdgPsRLN5fJSi2Iwl7O3+MQP6/A3wN+DKhYVKneQDh++Br4/N7EYjMtwgNdg5wHfAEgsvJj4D7xjQuJJDRYwjWwdOAa4CvAw8CvhHTuC9wP+/9tc65xxG+w74vwSf1HgSFexbwIeAi4AzguFi2ROZ/B3h3DP9J4H+AHxK+EX858GDgsljuM1IFee83Oucey0j4fiqW9bvx9ymC0N5C6ASnAfsQXAGOEaT6nwjfSv88Yd9sgMfE/B0M3BM4W+T3ObFe7h3LdAHhC43rgINi2U4mtNt+Md2Eh8T6+SHwRODSWJcO+Arhe/I/AO4TLbTPAr4U6wLg8Yx/lOPw+Esff3He+/Rt+Wtim2wQ9fZARp3pMQRZ+H6sK4lnAz9DaKuERxFclJYD34vXfpHQvo8HTmF8u7eTCG0HwSJwYCzjLowG6J8nyFrC0wkyJSdC/0yQqwuIysh7f22893xCHV9PkPFUrsNjWlcT3h4B/FxM+0sEmftKLMvNwLHAxwnycomqi/sB13rvF5xzz47P3RTraCWh/x1CkIekUD9NkMdvA98X/eM2Qv/5CKHP3oPQBvclDPa7E2T4EuAPgL8D7qbyc2zM92EE2XkUQb5PJfRngM8CL43HV8T/hwGPI7TLQwn64igmydIDCXplHXB0vHYJI8v5SkIdnx7zv3+MazVwf0aD1GMJ7XgYoT02Al8k9MfnEuTmgYzL2HsIcrQ7QR9JPBO4KqZxVbz2XEKfTjgf+I0YN8B9CH3r8Yxk72LgvYzk5cSY11WEMeVggqylQewYghwdFMvqCf0Wgk5+TDw+PD57SLx/BON648GxXGsIZCfJ/aMJbbwPgWCeTNDHXyfoqn0JMnYF8OsE/ZDwGIJefjxBJj9HkPNvx3SuZaTDvxzDX8ZITo+Kx/eMv88AT45pP4ygx/cmtMV9CDrmkFhnEPpGevayWE9nEPrGapHWVoJOOE08dy1wAHB3gg76EEEWjyHob1nGbxHa6FzgGYzq/9kxfHLveiSjsePceO3NBLnYAPwf8LSYr0MJbfzfjOOpiHEmxv9owvjweUZf4/0Ood7vRZDhT4hn/oqgT84H/oEwjj2FML49IIZ5HKH+NxP6xknxGrE8fwV8WIxTlwMvJNQxwM/GZy8ltMnBwHmM+s2rCXV8NEFfJJ36CsKYt4ogc58EPoC9huQ7hHq/mKBnPkOQAw88HPiC935L1G3JeLKeIM/HEGTuLQSdtoHQvgcDezJJWh9KqPcvEOSBWGdnAW8jyNCehPH1kTHuE2IZ9o7hH0zowwcSxqhfIrT1mTH/LtbRPUW6j2V8ovFD4MWxHm8nyMwGgk7/ZYJcfyeGfURM55x4bQ2hj34K+McUYRyLnxXzfmVM4zRCu50dgx0V8+0JbbYF+K9YZ48T+ZOE+WkEHWpuTetm/cKnc+6JwEe89/vOFNGMcM6d4r1/cD1kR0dHR0dHR0dHRx4zOzp777/MyGrY0dHR0dHR0dHRcYfGXFYCeu/Profq6Ojo6Ojo6Ojo2Pkx760yOjo6Ojo6Ojo6Ou7Q6AS5o6Ojo6Ojo6OjQ6AT5I6Ojo6Ojo6Ojg6BTpA7Ojo6Ojo6Ojo6BDpB7ujo6Ojo6Ojo6BDoBLmjo6Ojo6Ojo6NDoBPkjo6Ojo6Ojo6ODoFOkDs6Ojo6Ojo6OjoEOkHu6Ojo6Ojo6OjoEOgEuaOjo6Ojo6Ojo0OgE+SOjo6Ojo6Ojo4OgU6QOzo6Ojo6Ojo6OgQ6Qe7o6Ojo6Ojo6OgQ6AS5o6Ojo6Ojo6OjQ6AT5I6Ojo6Ojo6Ojg6BTpA7Ojo6Ojo6Ojo6BDpB7ujo6Ojo6Ojo6BDoBLmjo6Ojo6Ojo6NDYKcjyM65v3XO/dg59yPn3Cedc3vu6Dx1dHR0dHR0dHTcdbDTEWTgS8Ax3vufAM4B/mwH56ejo6Ojo6Ojo+MuhJ2OIHvvv+i93xJPTwTusSPz09HR0dHR0dHRcdfCTkeQFV4AfC530zn3IufcKc65U4A12y9bHR0dHR0dHR0dd1Y47/32T9S5LwP7G7de5b0/PoZ5FfBg4Bf9jshkR0dHR0dHR0fHXRI7hCDX4Jz7DeB3gGO99xt2dH46Ojo6Ojo6OjruOlixozOg4Zz7GeAVwGM7Oe7o6Ojo6Ojo6Nje2OksyM6584DVwPXx0one+9/ZgVnq6Ojo6Ojo6Oi4C2GnI8gdHR0dHR0dHR0dOxI7+y4WHR0dHR0dHR0dHdsVnSB3dHR0dHR0dHR0CHSC3NHR0dHR0dHR0SHQCXJHR0dHR0dHR0eHQCfIHR0dHR0dHR0dHQKdIHd0dHR0dHR0dHQIdILc0dHR0dHR0dHRIdAJckdHR0dHR0dHR4dAJ8gdHR0dHR0dHR0dAp0gd3R0dHR0dHR0dAh0gtzR0dHR0dHR0dEhcKchyM65z+/oPHR0dHR0dHR0dNwJ4L2/U/yAU9T5+wEPfBJ4KvA84L3AS+J1D7wuhn1TPP9RPP834JnAmnj9fcDPx+M3AkeksDH8K0ScHvh4vP584F3AmfH6PeP184FHAxcA/yGe+3r83xLzcAnwgvjMbwEfjccPT/mN8fxXzN+5wKNEHH8N3EfE/23gDODzwKnx2rNiWC/yshk4Mqb1e/GZrwDXAv8d6+YTwM8ALwD+EfgV4H+Ndnkk8CXgphj3NcADVZh7AWcDrwdeDvwm8GPgQ/GZt8Z0U/4eHfP1EWABOCPGczGwb0xjV8ABtwL/AzwJeDpwAnAQcG585ndjnC8FrgI2xjo8F1gfw9wthvlizN9m4M+BQ+P174q68bF9PXD/GP9bYzw/Ag6L9w+I7f22eO8jwM8BnwGOjde+BfxkPP5t4CPx+J2x3n8a+BSwHLg0pvmuWDdvAX4IvC6m62OY38r0ny8T5OryGPY1US7+CHgH8KIYLrXBWuB6FcdHGcnlqcA3jfvPiMdPieV/GfAvhL6wvwh7dIzr2tguDwPWAdfFtr0AODSGPZKRjP+8iGM9cB7wWnH/wvj/Q4JcS33wNOAG4Lh47oDdgKsJcnWBiPt44AOxbjzwLXHvU8D3gW+La4fEcH8OvDke313c/yngNEI/88A74/XvAUfF4y3A7bFcHjhB1e8ehP6wIMp0Wvw/MIZ5HHAFoX8ti9d+Q4T3Ir5jgJOiTPw88LmY9u2ibrz6pXTeAvwDcKUoU9KpNxDk7RnARfG6B65S5fmXeP24WKbFWAePJMjNGzOyfG2UlTF9I+riT4C/VM9cAewJPJmR/nxmLO/5BD36RwSdehBBjl6nyv55gi7ewrhefxrwnJjO74h8vJsgzx74VLz/JIKe/l2C3ns58J7YBr9I6MMLwO7AjTGMJ+iCFxJ08csIOupDsa6/T5DTr8Wwb4xpPTre+yJB91wS68YD9yboxFSGM2Nan4zP/g/wxNi2D4vtnMK+PIa5nJFOWAOcxWh8uorQbw9KbRyfuYggFycA1xP0zBsZjUuPY9RnPxTr+YexjfaP7bhJtcvPAN+Mx0fEdP481v+FwJ5SbuLxLxPG4BPjc78PnBPjfw1RF8ew741hLhJpnge8O97/Y4LcJB5wWbz+npj/4xnJudaprwT+gjAe3QO4DNgr3vOMxtUPqj7z2lj/vxKv/z1BZ76T0HfPAB5C4EW6D79epP/38drPxrR+mdE496FYP/9FkJukdw42+qQDbo3Hb2VybJA6fBNwt3j9QwS5Pz62x3+m+ov3D4zPnEuQwxPEc5sJffgGI/xrgfsC3y3yyhrxvKP8mCTIssE/DHwnHl8s7+mw4vx/gf3EvbeI42ensDH8hVrI4vXvq+sPEfH/tSGY1u8d8ZnPiHj/Jt7bSiBKHvhC/P8z9fxvVOL/eub6b8S0vmXc+3T8/zeCcvJEJWG0yxuN539JhXm6uHcbQXGV8vw2gqKw2i1NHg4FVogw7xV5+WnxzFfitUtF2D9U8f5/4p5Uvo+inM+fI8qbyN8vx/9Hx/+zxb1Pxf9/Etf+0Gh/T5CtD8TjXVS6V6rjzeL89Ez/8cAbjDLcGP/PUn3lnrq9rTow7n8iHr8qnl8twj9AhH2yius5hEmFJ0yoPPCYGFbK+BvitWXi2okYeWNS/l+r7i1nNAl6pCxPvLbRKmvm2i8YaT9E3H+uVXeM98Va/R5phYm/J8Qw/yCurU26M5NnSZD+T8W3kmAo0Ok8IJdXAsHeR5yfoOu9Jk/x90YCmZnQN+K5e4jwv6LiW59J62jgn0W4r4rjYxn1hYcy3jdqvz9jNBH+ci5cvP/yeH5h/L9dhPkLcXxv9fwHGBHv69W9rcDJ4vzkmNZvi2tfjP+3xP9fV+W35DLV1etVmPVG+6Wx9GXi2pOIuljFK+voABXPO1C6X/wel7n+QdmOMZ1Fce0IkfZB8fhLQbGolwAAIABJREFUKg6pUy9N+a3IaSrTzYU6NJ8RccvJbqqrBxAIZynOJJt/aaSVxsVnEYw72TyIa6+O/xZfuJpxOX260SdXx3vLiAYbdf83VZz3F+l/ppC/B4nrrzXq4Ysq/LHi3ot1PvTvTuNiUcGW+JtnfBJbM+G8Ol+eOS4hhdNxAWwQ91cPjDdhVeZ6KuPmwj15nEvXqvdaHldX7i/Hro9aOla6Vjzb0nfOucxzufh0PDrMFvW/2Bifbodk9a89t5ow6CWU6m2I7NTaqJaGJRerjXDyfFHdS+EteZRyvaKQH1kfOk/LM/lM2FC4NxSucK9Vd5XCefUPo/rLyYSMT4dZbVyDsgytwNaVQ3VWC2R9tspqaZyQspDiax0/l2PLai0vGqsL92VbaHmX4wSMdIkMl+KTOsXS/RK5fmXlPdVVyxhYq6Np9THY7bA86nkY18c55Mb7pUCub66sPJf0n1UnkiuUdKMFHX7RiKcku8sZrjdL7SrvWeluBXDOLTPCVPviXYUgL9Im+BKOcSUrj4fGlSDru1UwS8IhFd8aI40W5AhyKqMlROmeE/dz5bHqalaCXKo72U7L1XXruRRe1psmavI5GX+trlcbaep6lffTsSV3uh1KBFk+v4pgMUsoEWSZl5qM5+SmhpRGKk+OyOi6lZOiJOslgizjaiVIusySlFttXSK1IcBIMZu3G+NqJVWlgbs4EcxA1kcrQS6Vd6W6n8o8lCBr3Wwh159luuFknBxtyYSTsjCUIC8Tz7SOHbX+oetenmvytAFbz5QI9wrjmkZKR7eF9ZxF2JYbz8JkHenznP5vGVNNgmw8W5KvoQS5qicKkO3qxH+t75YMZvJejWhr6PALDCfIizDW7yzIe6V2rRHkFE+SPylL1b7YCXIZuQZsjUt3JFnfQy3IVqecB0HOdZBWgpyOhxDkmiKrka+cJaqWTqnOV2WOV6h4lmWOc3HqNFN9JOtM61uFEkHW5dTkoJUgy/RrMr4GqgSwlIaV9xpBTtfWqfDzIshWmkkHTGsxL8ly62SrlSCXBpxU37LfrDKuSZQI8irjGtQJsiXjQ61YtXQ0avrEsq7qNFYwSZBbsQx7gC7BCpfTUVAnyGvE+Sr1D7YFuSZ3qd10W2xxzul2TnUm2zqn72TZHfbE1ULLmJrKLMu2Qly3jBQaS2pBVsQx18da3rLKfwlZ1ta+l/KkZWuzkYYlu5IgJ3kpkfPWcbFGzFNa1gS1E+SIaV0schbf1ri0cE9DkFO6ORcLbQ2YF0FucbFYxuRr71xYiaV0sfAqnLzeSpC1BVlbohNaLMg55WHVm+VOk451O2ymzYK8guAfpuOzUJuNSySSOtT6l8KnussN+rpuV4hra1V4WTde3YNxclCC7gsTaaqBv8XNpyTLrZOtzRVrS0KpLbaXi0WpHLkBeagMeTIERkzYShZkqywpfyULsnbfabUMSkLTOnYk/WC1l8wDRjjLxWKtOF+t/iUksaq5WOQsyJuNuC1S3uKiYRH1ebhYyLJJFxitnywMNba16AmJnI5Jx472N3hWHdcsyFb5tCU2YbORRmlyJ3VASTfKdFpdLCx51eOMzFt3sYiY1oIsK182Zmtc8yDIrT7ISQHKNFo6Zs3FwhI6S8harAEJpbK3vD4qEWT5GirnYmENbEtFkGtW7JpFJaVnEeRkySgRZAgLCxNK1o8hFuR5EeScpdfyQU7XShZk7Z8sw9eg5U5aO3aN/6sESR4yINdQsyC3DIil/KR2H0KQay4WFqaxIE/jg5wjpymu3JsJ61lJGDZnwlkuFtMQ5FlcLEoW5FK/3sB4H7AIsu6PQ3yQLRcLXedWmlq3Juh1Ga0W5BZrqGVBXi6u5+Keh4tlK2QeZLsOcbGw4kqQZR3q6qnTXWAyjZoFOYWXMpzrk1TyWCPIuXxDtyBvwzwIsmzM5PhdU5ClRXpDBXOaRXotZd4RLha1AbHFxaKF/A9xsZAdSFpbtNUr5+NsYZuLhbBspbKtVP+1+Ia4WJQI8rxcLNKAO/T1uCaX83axsIh3iSDnJsHpXrq/uwhTssBptLpY1Nq+Ja2WxYiy/VcZ1yRqLhbW+FF7HTovF4saQZb9qqZPJGGwZAlsF4shi/Tm4WJRchsq9euNjPcBy5qr622Ii4VuC89knecIslwQneKbliAPmbBqgqzHT12moYanWVB7SzUrQZZvTFrf6Fhv/MAmyFa/sAjyPCzIQ10shqyzuUsS5CEO87XBu6Z4d4SLxSABoF6GEkGe1sWiNpAvxS4WHvuVoDOuSYIsBzeNIS4WKQ7tHtA6U/aQXY1bsyAvVPJppb9UFuSc3yK0u1iktC0fWqtvyvbUKL22lmnuJsKsJuyvXZPT9ZUwRRcLYaneauTNQktbTGtB1vlbbVyzwknMy8UC8no8xS8J8rQuFvrtTqqPWVwsav0qxakt/usZdxUa4ge9mbqLhdXfWhfp6WctApdzsbDe3Ok2aF2kN62LxQomx09rgp7gYMLdap7IlW97uVhYsAwPYPsgW2nWXCxKb6haXSxKBNl6Q1BdLHhXIsg1VwALOetSywwItq+LRVKeUuBnIcgp3tZdLOblYlHKk3x+rD6EkEsFp5Wa1UmsziwHojErh8IQF4sURyJ3qZ3MmbJQvikNvVhsC3cOFwuJaS3IlttLK4HIudboNHcTYVYR/LprdVQjyDV3HUnEWsozbxcLCZ2/nAV5Z3Sx0Pqk1cViuTrWC0CHEORWUq23G0vn6xknuUNcLLScWpPz0q4xOeR8SWV5UWGyFmTxjLYgt/ogt5C9VhcL3U5aFmRc88bO6GKRMwouMil7Jat1zsUiFx5mc7GwXIf0vWw+dkqC7Jy7p3PuK865s5xzZzjnXjZjlFuYnP23IOdi0dpBJgiyQeRa82B1FIsgWyuTS8gplZK/rvSPG3OxMGZjS+GDbO1iYb0i1HVsWdmttLSLxbQEWe5iYRHkTeRnytriojuzXKS3FC4WrYv0pnWxqBFkLSNSsWqCbA1erQNI6bW1JMjaxWIT4/VqYT2z7WIhyzcvFwtrF4ucTOR2b0l5m5UgD9WFLenUXHcsSMKQI8iWi8U0FuRaWVO5dJvcgu1HnFDq11oHp2dLb2yWUy9f0rV6Eawlry0EOR1vVWF0/nP5aukjlgW5xcWitk3ePFFzsWjZxQKCa800LhYWcmXeSpsLjCbIeuzT9T2Ni4VlEdbjgbXm545FkAmD8x97748mfIL1pc65+84Qn3SxGEKQc0q2tYNYFuSWLU6sPFjb+MgVpNYq01l8kEtExvJBzr1us1DrlNO4WOhXq9qCLF03StYlmK+LBYy/IpfuAZtgzFps5Uv7O0oFn9vFQuerlSDfUV0sLFeF1n5eWviUc7FIbddCkOdhQbYschZqE08YZkG2Jh7y2RaCrF9lW0RjKVwsSgS55GKh85swi4uFRcBy0PUnXSxqBLllNxKA1ZFE1Fwsavot1Y8myBaBa3GxsPqz5WKRQ8mVSqcxdJu3dH1BHC+VBVnKXc4HuSVtvf91QqqnIRbkIQS5xcViA+UyFF0sBAkuWcjl/dLb46yOnmbmvuTw3l9J+LQj3vv1zrmzCN9sP3PKKBcJn6eFkSUIAOfck9X5w+PhUYTPlSYcIo6XizCXWwk659LncCWOYPjs837OuX1T+nGicJ94L33FRuLR4vhuwGGV+HNCem/n3OHA4ca9RELvD1wTjw+O/w91zi0ysp4dbTx/sHPu0YQ2voHw+dmWPCU8hDA7lkj1cG+RH6nkHsHIF3c/AOfcYdjt8BhxvDvhk9IW7lfJ5xHxf5HwGeCULwh1uBjz+NR4bVfx/4h4nAazFFfK790ZDeb3VOnqfi19kFc65x4W0079KfUJ2dYpzj3TBeec7A9Jyf6sc+5bZCzOzrndgD0YtenhzrldgAON4EfGZ/aJz0jcm1EfTpPlI6NP9hhBds49kFA/LThAHGtZOBLYOx4ngvxk4AeEOh3z7Y665BJxaSOj9nsEk1jjnHsiQYfoNoQop4S2z/qRO+cOIgw4D8uFAR7rnLtOhTnKOfcVYF8V36OAmxjJHEzqgT2xicuxzrlTxPntjPTFChVnqu9t6TvnHgF8J30vNoPdGG275wifA9+LoHN+Iob5KRH+UCW7yYd0L4J+TG38SOAnRThplFnOSP4OEuVpwf6E3U8OLT3jnDuCUb86RKWxnvEyHaUez259x2Q7bSWU+z7i2iNVmCOwdb9E0mn3V9cPZDyvMCqPjHM54+PVMeJ6wsMYHw90PiV0mgkPF8cPcc7tzXh/259Rva+LHOChKo4kq1KeV4uFhSaccz+ZuV567gDgqngs+0Fqr0cyGitknPupS7cDRxhvdZMuuxeFSUWsJ5229YZYT5COdM7dAHyHUFf7Maq/gwjtu5UwFp7inLsb8EAVx66Rf8DkWAChT1+EPYm/l7iWxoZDgW+o8Ikr3Ae4zkiD7Deod5YfoWNdAuxu3HsRcEr8XaTuefF7hzqXvwsK96zfOYRvmKfzhwLnG+HOAL5mXH9o/P/fAWlOfMs9/l4HvHlg/nf2322Mf/e+9bdHQ5jPTRHvGVOW4xJxLL9Tf3H8fyZhclGL523A08T54VPk5cGZ688BPtoYx1kEYpjO/7bxuS/H524U115ghLsBuNzou7Xfs4BnGPn6vynqqdQn5b1PA6eqNvZGe34ZeCJBOVtxvqmQ3o3An4lzUw6nqC/9+88pn9tUuPdqcXy1OF6vwv0w8/zBA8r1tMr9C4DTgfeLaxumKO/7p3hG56NWb6Xfayr33wGclrn3HEYy9a5Y/qumLcscZC793hL/N6r8fGxO8evfRca1zer8W5U4riKQKU/QxX/SkK41fv9RrY5jPV8/Q3lTWR5DkL+FWNcvrDz3g5h2Sz/5QeHeQQSO4oFfFdcvJ+jP98Z0zjOevboh7ecCvybOf72Qv3+PaT3DiivHP3dWFwsAnHO7AscBf+C9v0Xf996/z3v/YO/9g8nNAAL0DOf6+P9C4N+N8M/OxPMaQifLvb47SxwfTKh8Dfmq1sLrjWu7G9deSFhJ32rF+K/GcNPgjDnHV7OuW+lVXzl57382c+uZhccOrcVrYCuB3CRYO06sou3V4WqCdUyeD4L3/hSCvGgsx7Zc5pBm5q27KkCwhhxKsDieG6/tYoT7P4Kf5VDsRbASHE8YrLQbhsQHCvF8iXKZ5L1dsbeO/Ko6X2C0qM/CWvJ7zZ7JeN/eDXhFIX/T4mBxvHc21CRKdSXdtnI+vTqcROuHXcCWJYnvE4iYTKvmGvFvwD9k0vmhEf4xxjUN7fd7AvDxhucSPky5f1hjDYSJ3fHx+Afe+5cQSHqyNtZ2uDmtOYcBVw8Iuxtwjvd+DfBOcd0a014zMB8QjBEST1fnLyAYTSRq+lC6NS5n/E1Vrg0stL7hGhKnxpfi/y7AZcCTCDK0W/aJgPRWvMVlJfmL32rcW0mwzsOkpfdTjMqmx9i/R73VymCPGNd/EeS4tO2kXNB+vBHOxE5LkJ1zKwnk+MPe+0/MGJ0mFVJBWn6EOaWRFsXlVvvr18yWcCehyxGd1i25NmG7WORQ2/R9FrTmuQUt/lVWerP4g20o3JtmIYZjXK6kjKT4VtJGkOVCv2nzo/OQoGW5FYn4taar/dktxbtpyrykMmyNP8sHVaaRQ61M8t467K9z6vg3Mdl+Os7bMvf0AiZrNf8sSHmVacwrflneMfceFS5HkIfIeMu2aVpP1uRMf2QoXQNbV7TUm+XfPoT81HRsbhcL6SOa8inltKT7SvHmMGQsWCvCl+QE6vm0oNtF583yn20Ze2bxnR+KWT5rLcubfOgXqBPkIeVK+bPaXY4v2vfX2j85oba2Q6eR4iqtiZD5aNZzOyVBjj4z7wfO8t6/bQ5Rlj4UYDVGroFuZ5JUbGFya54SkiUiNwi0CsdCTLtVmJfy+/FDBLoFtQHSSm+WFcUl5TttH5EKwyLIQyzIud1UhsBKawXDlGGS82kJchpYrP64ienWRCTFmCy6yfqYI+E5WJ/HldAE2bIg60EirdTOlWs1458Bl9C7pwxZrNSClFeZxrzil+XNLXqDvCwP6cstg92iSrtloVyuzSxd0dqPJYYS5JqOzcUlSWD6l3I6b4I8xBCzC6NyyfJZcpHrJyXodtF1aPXhmuxtZtynvgXWG4vWBZ6zWJBTedNXZBfjNeuNtMSQMaH0xV05vuj+V9L3QyZZKxgZV6x86/QH6dGdkiATnNCfBzzBOXdq/D1lhvhKBNlqjJIFWa/EXswcg61c9BZVrWlrJAvyLJ10XpinBbk0OJXSWyqCPC1qFuRV2BYdDU2wpi2nRSSGrGKWSJbR1nS1xcXqjyWLQglptX2yICeCbKVRUow10i/Luwv24KrbMcVZsiDnZE9bkJeKIA/dFrIFOQuyRk6GhkwCW+pEGxJq4578LL2GRdSmIcjWTjwlLDCdDrcI8lJakC2ilKufdYzko0aQp9HRtQnsVowdPipxLjC+laj10amdBdqCvIU2C/KQMaFmQbas7dLqa2GoBTl9VdZ682BZkJv16M66i8U3ma+w6cFSKiZLAeQa6DbsmUqKb4iLRW4QaBWOoS4WS/k6aJ4W5Jbt76z0lsrFYhp48gQ55VO6WJTI2c7kYpHkWe9hWcJWJmfxS2FBTgR522r0gfFspn3boXm5WKwiL3t6C6zt4WKxFBbkEkHeHi4WKcwQ2bJcLNLzlu6ZxsUiuQW1Iqdj0wQ0F9ei935r3Mgg9d8hFuShMpHi3sqInFhfW4PQV1O5ZJ6sfphzRSqhNoHVLhZbMmlLyIlKq+60eEDr5GiWN7+yvIkYbiIQZGm40NgeLhYll7ohfGIFo+9cWPpEt1UK34Sd1YI8b+jB0toTVGKIi0XOHzkXv97DtTVtjQXunAS5RSZ3doLsGFcYVofUBDkHbYGcJ0Ee4mIhZXkB+6tXOehZfI4gz8MHuUSQS4OSLJMFWe9rmY+LRYkgL7UFeSkJsmzH0iv37eliMdSVSIcvyfs0JGYaH2QrfLJol1wsUGG2hw/yFuOaxjqRF5kni+hM42JRm8BqgpzG9xK0y5Cs9yHtuT2szantVjLpYlFq93kR5FYXCz3mD3kjnYh/jiDr9AdZkO+qBFnCEuohi/S0P3It7nm6WAzxQb6jEOSW+LanD/K0qH3eeSUjedF7OktIguwZtsJfYt4uFqvFcQukJXmeBDm5WCQlmQhyywpsiaEuFpYFWffdebpYrGaJXSy89/Nap9DqYpGzIM/7AwwtlkEJy8UitcVSTCKqiG1jkaokP1uxx5vaG9J5W5ATgZTPlQiy5WKxvRbpLaowLWnoXVmWmujO4y1/eoslXSzmRZBLPsg5C/JSuFhsod3FoluQFYa+bs01kOWDLDuJVkbTEOShLhatHeiORJDXV+7f0XyQc19Ja7Egy1f0tzNclhNqLhYtA2GS8yEEWS5gTa/W5ulioX2Q14rrQzBkkZ60WkhMs4tFq4vFoFeDDbAsyPNCq4vFPCzILXptcWCclgU5PT9PP+15TEiS/HhssmalIdukZpmd1gd50bimIS3INReLefgg63xoC3JLGtqvtwWz8Kx5TBbTJF26WJTKOo0Pco4g53yQh7pY5MaZZBlfxK4rTZDvFIv05o2SD7KFnFK3XCzkawQd71K6WGxm53GxmOciPbD3VJSwBqlZFMm8Cb5nvE5yn95sdbFIz8+bIEvZHWIpku4IrW2fZHWB+SzSk/taWov0hmKIDzK0E+RZXSykDlnqXSzmhVYXi9z4MyRPLYN5bvDMYaiLxTQYukiPTPhpLMCbMscW5uFiUSLIrYv0pnGxGMu78XXGWQlyq5vMLFbgeRDkVYyI4bwtyKmOLTnKuVh4yj7QQzZOkMaKEkHuLhYF6NettdciOaWRFhvo2VBOoCwBmJeLRRKyVmFeygWZ8yaYJZcDsAnyLAP9PIkHTPogW6/7p3GxmIUg51wslhfua1iL9Fq3n0qyWrIgD1HMKb85H+ShGOJikdLfHi4WpV1yiJ/angaJtCzFK+JWF4scWkmBdNspYQvDLchL7WIx1AcZ6i4WFmouFvMmyENdLFp9kKcZY2o6Te9isVQuFpaMtvbblkXrNSQdtIU2C/I0BHmIi0VaVDcPC3LNxUKn310sDNS+tqSRXRGM7WJRshBp1AjyEIV0Z3WxqA2q1iA1NUGek++lrgM5+FmEUFqQS/W31C4WKwr3NeQ+yEm2W9t+3i4WKb85H+ShGEqQt5eLRZEgF+KuYd6TQoncPsitaO3LnqVxsVhmxJvafym2wpsF0rLa6oO8kDm2MFROUv3oRb0aW8kTZGvcnGaMqeVd9+FpCHILrHCtk8B5yIl2sagt0ptGDw9xsUj1PitB9nQXi7kgNwu7BbjJuJ5T6qlRZcN+gdFnO+Vz64BHG3E8O/7nZp6tFpeNMewvNIa/vB5katQsvhI19wkIn/ItwZrwfGxAHpYC2m+69mWolzHqqKVBV76i3wL81cB8XWrkJ+H1wIHxuKY07g3cTYQ9Jh5fUXnuoeKZ5YQ+knOxWOWcO6USX0LK7/OAZ9BmQb6+cG8zZWuQ1pV70EaQSy4W9yM/SOwPPJZx2djCJOF5f+b5Gi6a8rkWPFccT0OQX+2cK33+PWE58N+VMFcznYuF/mTy/eK/JUND9F/C5czHBznpnbXA/Y37Mg25hiCh1j4TeXTOfbYQPo2n8jPPlu65hqAX0z1J9C19OY9t3mphWsamlN/NwG8y/vn3CzLPWDzrD0uJOOduHaALc7g5/r+U8OnmBUZGltI6n4Odc7V+lZDk4xrj3gnAk+PxX4vr6SNnT3bOlXZmkbD62D8BBxDacC/sT74vI7TVY5xzlwNvZSkJsnPu14c+s4NwXvy/L+Eb5A8HzlVhPgH8J3CIuPZJ731q7Evi/2cI3wtPlrNVwNuB88VzhwFXxePTmBxs5Tftf1TI99XAz8Xjo4HDgcfF8xfF/3O99+cy+ta6xu/F/yR8DwB+CzgqE/67hfwQ8/Nt4/pTCJOAr8ZzS0E/APgooW4OB/5fvH6hCPMnjMoGoS4Pi8fnMt65Hs/kt9tfEv8/bKT/qpjH9E343zbCEOO8VJx/itDGCQ9R4d+kzv9JnnjvrwRqCi4pWw88LR5r5SBf0f+vEcfphfh/E/jJeHwy8C4jzCsJg74exD5LIMWJgK0AziC0y4vjtXcyIuwfAF6u4jhDnaf9oXMEGeBB4loq2+uAb2XCfxl4FOME2VKAbwf+jtDXjyikL2FNcBMOIO9i8SqCvNVcLGDyq1afY9RPvwr8UNxbJEzGDxfXnse4HnpkIa2Ecwn9QBoH/lIcv1scv5lgSAB4YCa+zxTS0vV6E6F8/6Kuy7o+AHgD4zoC4FhsGS7hjwjtVHvzIgm5I+ipA+L5DeLef6jnnh11scSvVtLah6A7JTk4AZBfjf0x8G/x+OnxP43XX4v/RxP05nsZTXQ1JMFNzyeC/FTGOcDj4v/LMs8n/GwmLYBPx/8niGuvJEz2jiC084PjuczL6eJZvY7ghd77awmT8v0IuvowJnFc/L9X/F8gTGwOyISXrnDPYHyy/zvx/xeA+4jr8tPYup2fwHi5W2GNy7swrgst/Jg8BwA4nmCgeAnwRAK3eA2BD/0mcGPmuV0Y7w8lbCXo1A/E8+cXwv47od0fT56k/jbwDXH+0fh/HKH/X6vCH0Foi+MJevHfGB93ljFqs9RHpE4q1nGWIDvn7mv87sdocNzZ8RUA7/1Z3vsve+9PZDRb9vGe995v9d7L2a4cbE6O/xd67y9i9Mp0FcECkBriOu+9VOZaYcJoNgdlQroo8nC19/4C731SiBfF/0tj/jdiW8C/K8N770/13i8yOeAkaPKhcTXjBH9bOvGjLonUna8DeO9PJRCwK7z3FzCqB2mh+RKB6MjnUl4vBr4jbp3PZOdKz1ok/jTv/Te99yk9c5Yf21cOWJuAb4pzXXdfE8fnMG59SPFcFv91p5ZppPBpQnemCpPkTcYncWImboCTvPc3AnjvN2O38xcJeiDlJSnNc7335zFeB2d771NfALiS0cz+m6IMCbIfJP/jRWyyYlmy0luP25i0eKb8nkYYUOUiPcs6crn3frP3/mLv/YScYhDkKNs5RW4t9kh5+kGUt5qLBca92xhN1L7N+ER70Xt/XexHEl8Vx+dRt7ZdHHWHlCdZJ1LWL4lx4r3/QSVeC7pdz/fen02QHQltsYVQv5Kc/gg4aUjisZw5mZOQ+s1572/33ieDR5ogbGTSkmXJ0teMazJP13nvb2Fc39zOuP46n1HdnR3/05uIm2I8P/beXxHD5mRMymgKk2T9fMbfbpwprie0WrnH+kIsX8Il3vuve+/Pj7r4e4zaf1MMv8io/Pot0EkxzBne+2u89xep8Tbh4hhum6HDe3+m9/6qTHjHqM9+nfEJb+IEp6gJ0Gb1vw3e+0vIj7EWLovPnV0LKCBJ7VWU315s8d5/13v/Je/9NyLfuSzyoeuB7w1IN4fEn1J9WP044ZooB98nr1cvjmNVQpLFjd77E5jU07sR2vBsgtxcyjhfSG8tJVKbb43PZd1NSr4mJxJeX2lL6MGFZ+4oKL1KtRpO+l6ujr/0miBdr0G+Niq93pCvUbWFKuUjt41S7atKueu5V/xp66DaHps1V4FNIqxVV5vUdXlsfXRDt9GC+rfuJZRer+jPhspnc2kmyAGq9UtLKQ4n4tedNcmblSaUX5FaG+NrJOvaDeJcxlva8F+SRKvt5bU1BGWeIytWu6Tntxppp/MNBBKaCPIqgpLe08hrCbWFuRolgiz/Sy4WVr7kDigL6tlc/1qvwtQWfyX5lPFZH5RIYWoLkYYsJJJtKmHJdno9mmDJQQtafNNlv8uVN03yJKw+1UoqdTtpPafHl9yOM1vJt4HMS3o+lUH7gcqv4OXymEOKa+hWcwtGOF3QtpEyAAAgAElEQVSWVr/vaRY9WrtoyHzptDer+xpD3GamcT9qfmaO+5qXoLe4LbWVXqjXghQu6UFdpt0IbbFAkBt9fxmTkwg9rmf1c0lxnwX8aZxpbINzznrNuzNiaGdJKBGoNOCtZmQNS9drkHVdIsiLTBLPBO1wrtPeTOWzo5nrOWGVq8StODU5ysUvCbJVVwvqujx26ry0OKrFub+1Y+p09XP63OpLQ0hZik9b/yRBtpRjiTDoe7k2TPKczmV+5DO6LuWKYKvtZX5XE94e5HYUKLXLViPtFF7mO+XB6l+1hSe5PpzLl7UvsR70W1wsdL68935L/DTwIuNkIde/blFhchOhlJbcm9qKW28tp0mPJlYlgmw9i5FHXf+O8dej6dlpdzOQr+03M5nnVoJc6lPJBW8agqw/Ty8NAel6bseZ0vaGMi/6c9l6FyStA4YgfYzFqjsrPunLm5Abs1vz07LNqoQkyLkJuE67tCjNCl/CPAjytDxnXkj9KMdZJPRCvRakcLmtdHcnyK20CkvoSTZM8omsfi75ID8J4/W99/6phWfuDCgpt6QAE6FI9deiEKVCLq0gLRFkyzJpWV5NC6axD6RMs4RllC3IW2P8uXpYoEyQN6nrskzLmBTo3KcppVXfiis9n1AiZTULsi6r1claSZkX8Wsf5CRvYCvUWS3IKV09IKR4S1t2yRXBJQuwfD4na9Z12b9y7SitXql8tzCJVmu+Rq5+Wy3IQ10sdD+TMpSru/UqjNVXZTmWibAJQyzI2iJTkvNWgtxqQZ7HbgaWC4rWORa0LtLIDdJgy1HNgqxl3JrYpPRyFnLLgiz7uvU2UuardZ1SylOTBVmMRaVPNedIag7TWJBzY5e1XR2MypLTC0OsttO+DdmZoC27pfK36DKNGkGWFmQrfYsga8PAchctEhpZ4ffe3xL9gnDOHZQLtxNj2v09s50s1kfanmbohw1avy411MXCWpFshdNp5M5zglsiyC37Sg9xsSi5M1h7P0tCosumBzQZd8l/y7JcS7QQ5Hm4WGxmtGvHkA3Uod3FQobdov5zbyvSvZKLhTVzz8mXJUOSINcsyJIgWxbkaV0scpMoiyDr17XTuFhooion1rO4WNQmMFszx5YFWdfVEIKcc7GwtknUFttZXCwkLANF7c1S7m2hLF+JIFv1r3eY0LpcyzjYLmZDCbLpYiFIouUuVkOSuVYXi1IcCVon1Z7T6dTyXrpvuZjJNObhYjGNLA8t41JDW5BL5Z+Hi4VFkEsWZOutz7Y4osx7Mly4dXZ4knOutqLyzoLaLDTtI7iJ6QlySYikBTnXGXKkpWhBFtBWSv2aUMPRvsemBWk5zLlY5JSFRVRnIchbCvdK6eYUZcI0BLnFxWKB0U4HQwlyi/+1bhdNeGsEueRiYbVFiXBqSEtnbqIzL4Kcq8dSfnOyJt9ozNOCnOtv2sWiRpAtS2TOgmwR5HlYkHPWd/mcdrGY1oJce6uk81NyE8gZLWS8NTKckCOEKR1LZy4aeSj5WMsxXluQcx+aku05lIDNkyC3WpAta3QLSmWruVhsDx/kWfzbtxf0Pvrb28UCxgmy5ZZam4hk3SxaCfIrgC86535J33DOPcM5V9sFYUdgWt+cls9Qp1lLqdE0pCWoFH7bgGS4RMzkYiFQIshWp825WCRhbJlUFF0sCu4flouFLpfsnDr/JZJYsyBve9Z4Bac7YmmgyZXNcrHQ1q1NBHmD4S4WrT7IMqx2sSi9+ZBW1FldLEoE2bIc6gVM0ge51cVC71piYYiLRQqrLchDCLKGrP+cvm4hyNZr85wPskTJxSKVdx4+yDkXm3n4IOu4rUmPDGPV8xYo6mQoW5BrxEZ/nj73Vs8iyCULsmwby4JsTW5qBLm0hmYpLMgtLoAt8WnovFofNxnqYjHEBaJG3FoszDvaB3lHu1jAcBcLKw1TDzd9McV7/2Hn3AXAcc65I4G3EDaD/1NCB/z7lnjuIGghe4kg60UvJUhFVQpfWjU+LxeL/7+99w6366gO9t+Rrorl3m1kgwvYYIMxxgQIiTG9hBZaILQEEgIPXz5K8lF+TnFIIeDQQ0hIAqGZajoYU2KbZgzGDRtX2XKVJVtyka0uze+PmdFZd92Z2bPPOVf3Slrv85xn77P37KlrZtZee+3ZfRXkLgtyHxeL3ASn09SrSWjLyqRyee99dCHymbjG5WKh0R2x9pJeqX5ke7UoyLlBpdj5M0p9HxeLnA9y7tG6tKzpOujjYlGrP/0CEyKeVgtyLv6ccqMp1W/ui0y6LltcLPQ53UY5BUeztbze+y2Fxfflsa5VLLpcLFK/uY+wWkhNQdbKS9bFQvRhmd/p8kHOLdEl02990UyHrSnILU/g9Fg+N+VNHO/rYiHbRr+kV1IMuuaq1QzGJE0ufKsVulQfLY/jZf9vRedL/t8WLhZditsGpr58OdMuFZphXSxaFeSuVSyg+yW9rhuN3Nw1KdFOvPfnOeeeQliT8K2ENU5PBb68jZYT2VZ0lSUpLKP4INfIvYSWaFnFohROUlOQc+V3heN9XCyKA0vFepzS1lakWr33cbGoKchdL+SMw8VCT3wwVUFOTywgPzj28WOrWZBbXCxyFuTWVSxSGn1cLKQFvs9LejPlYqGXgBq3i0Wnghzp6qt9XSz0eKQV5HG8pJcjpyAP85JSqZ1K9FGQZd2UrFilYzUXi9LygvJJiYy7tIpFTn5GdbGofXEuN3e1Pqke5SW90pOTGrV8DfuSXp88dIXNycxs+/pxHwuylLW+MtHqYpFzSx3agtyUSefcgc65fyZ84eSn8bceOHsHU45h+lws5KDT5WLRRZeLRS6cpKYglywANatUHxcLrcTn0NaurRNHlLeawjEuF4tcXJIWBbnLxQJxvsWCnGubPksFjepiocvR5WKRs9z1cbGQaetyjvslvVK++rhYlCzI41KQS4qodilptSC3KMi5G4RUvuQvP10Ksn7BxtNfCZJpJroskrl+1mLF7PuSXtcqFiUFuY+LRU5BHtXFYpjPPrdQqo8WWRlGQa6lX3Kp6bIg72wM62LRbJyNDOtiAd1tNbIP8hLCB0Ke5L1/GuETlb8gvLx3TGMcOwryJb30eKHlsUfriw+5R5r6utLHA1pdLLRiWHpBpeoi0GH5lchH62nbOqlqC3LtWumqkMi90CLzJZH9oWQ1z8Wj86Trv0U+Unz65iXJWymePjeoNSVWW0z0o60cfZd5cwy+CpiLS1NbAzhn+S7dZJTib6G2DnKLgrwbg0/fluIp4cg/ItfUfEJL8ULbI8+cBTmVL8lqHx/krvQSe8R45XsA6cNFfSnJTgmdxpzKNTkXi1o/q6VddSUT1+fKM6yLRVe/63tTPoqLhSb1p5Z5ZpgnCzUXi9K4qsfLUehTLyndrg/ebGvSeN4i36MoyLXwtZf0oO7CCWNwsThOft40DlRvds5dCZzrnHu59/6sxri2FV8kfLdd8l7gOMLnIPdX594PvJnBZ5o/F38Lga+IcD8iTAzL4vnHEXyyAU4HXkn4HvhS4C1xfyXhs5InEL4n/0PCZzV/yeTv3q+JPoTLmPxdeAiftb4oprVUHP8ZcAywL/Bh4LEE95frgP9gqkJyK3BazPu34rXp861nE75pvj/hG+ebgEcTPsf4VeANwFmE781LQVwi8nQK8I/Au4H94rFrGHyy+J5YHx8C/o7wmeZEEtS/j///nfC0Ik2SF8bte4H/JHzbPaV7JXAZ8NFYvmsJ7a+VpZWEz4g+APgn4J3i3IcJ32vfO5b3bkJbp/XAlwKHEer2duA7wLExP9cCh8Q8pMH1A8Dx8dxpwLuAFxM+8fkKQtv9B0GmNhI+9XoR4ROiBwHvY7Dm9hHAxTHejTEva+M1l8e83B/4A8InedPScJKbCG1xfszjAoI16FrCDe+6mH9PeFoE4TPeP47HLhRxfQX4Uqyba2Pc1xPa6nKC1fssgjycQ1B4ziUoG3sQvty3LNbjyYTPg34FeL5I41+B/0No2zRJriP0ydOAgwnyfHOsh5sJn6f+DaFvrSHIz7HAGaou3kFQEF8Z6+1agoweSmiP1G/eT2ijhQR5u5HBsoR3qDjvIMh3GpBXEWTliYRPGT8MuAT4LmHcuCTm8wnAq2Lcp8drz47h1sa6fBGhXRMfi2k9k/D52STTEPrPowmydgXwbcLXBZ8HHAl8JIb7KbA4lvXGeOx8QnudAbwgpvmxeB3ApwljxE0E2Xg0QWY+QGijL8Q6BVhBGP/2IoxLKxiMNVcS2kouIfpOQt/781i2JYS6P5ZBH7wp1olj4FawPqZ7JEFGn86gP0FwCbg2bo8ntONRwJ4xf0fFcLcRZFTKyocIMnYvoX8Ty3sRoQ8vicc+Tvhs+8OjP/OPgd8lyNJjgA8S2vD0QdScQRhnVwJfi2lcRbip+hpBFmX9/DNBxi8BHiyOX0MYG46P//+LIHPLgDPjsfcyGGuviXWzCfg34FGE8RSCPJ4Xy/gggvw/kSAzjwZOjHE+jMGTxRWxfHsTxrQ0TnwAeBNT+0ni3Fhnif+NcW0k9N0PxF/pSd/tBNn6J4K8/IQgZxDa+BuZa35GqN/jgAsI9Z3mpi8R6vvxhLFffuZ8CUG+LiO0wfcJbXA7oU7OjuHWENrxVkK/PTgefzvBJXUOg7HlQ6JsX4z7cwjyux9hfnx/LMvlhHFyKfBcwpj8tXjNWkLbf5sw572AQX+u8TGC7J0cy/FQwhx1JGHsuJCgH8g8Sy4n9B/i9dcR2u+qmLe3EeTmDTHMp8S1N6i4/jaW9/L4/6PA6+P/LxL0FQjjfpLVKwhtuYxgJLglpn0F8FTCuH4xQc4OJ7TH3oS2+isGOsylFG6IXLsRMI9z7snA6d77A0aKaESccxd470+cyTwYhmEYhmEY2z8jO3x7739AuFM2DMMwDMMwjO2esbwR6b2/ahzxGIZhGIZhGMZMM9uWDDEMwzAMwzCMGcUUZMMwDMMwDMMQmIJsGIZhGIZhGAJTkA3DMAzDMAxDYAqyYRiGYRiGYQhMQTYMwzAMwzAMgSnIhmEYhmEYhiEwBdkwDMMwDMMwBKYgG4ZhGIZhGIbAFGTDMAzDMAzDEJiCbBiGYRiGYRgCU5ANwzAMwzAMQ2AKsmEYhmEYhmEITEE2DMMwDMMwDIEpyIZhGIZhGIYhMAXZMAzDMAzDMASmIBuGYRiGYRiGwBRkwzAMwzAMwxDMOgXZOXeac+5K59ylzrmvOuf2muk8GYZhGIZhGDsPs05BBr4PPNR7fxxwNfCOGc6PYRiGYRiGsRMx6xRk7/33vPeb4t+fA4fMZH4MwzAMwzCMnYtZpyArXg2cWTrpnHutc+4C59wFwMJtly3DMAzDMAxjR8V577d9os79ADgoc+oU7/3XY5hTgBOB5/uZyKRhGIZhGIaxUzIjCnIXzrlXAa8DnuS9XzPT+TEMwzAMwzB2HiZmOgMa59zTgbcBjzfl2DAMwzAMw9jWzDoLsnPuWmABsDIe+rn3/nUzmCXDMAzDMAxjJ2LWKciGYRiGYRiGMZPM9lUsDMMwDMMwDGObYgqyYRiGYRiGYQhMQTYMwzAMwzAMgSnIhmEYhmEYhiEwBdkwDMMwDMMwBKYgG4ZhGIZhGIbAFGTDMAzDMAzDEJiCbBiGYRiGYRgCU5ANwzAMwzAMQ2AKsmEYhmEYhmEITEE2DMMwDMMwDMEOoyA7574703kwDMMwDMMwtn8mZjoDY2Q/fcA5dxxwi/d+pXPuZOBQ4LZ4+nDgR8BmYH/v/c+cc78PnO+9v9U5d3wM8zXgZcA3gHuBVwC7AWcBi4FVwD6Em407gGXe+zuccw54OXA3cCGwO/DbwFLv/Q+dc0fF+FYDRwNLgPsDy4HnAR44B1gLPAE4A3gh8Bnv/Sbn3G7AC4A1wDXAwfHaY4FlwPxYztXAefGao4HDgAOBi2Od7RnL+AfAxd77K51zjwN+EfOz0Xt/o6jTJwCXAIcA+3jvz3HO3Q/YzXt/tXPuMOAZMV/nAw8A5gIrgOtiGywHHgecBzwHONd7f4VzbiHwEuBGYAvgUp0CR8a4rgeuAB4Wz22JdbXZe3+Dc25X4Fjv/S9ifvcFFnvvL3XOnQTcBTwCuBPYEOvugcD62K7LgXXArTH93wO+4r1f7Zz77Vj2PwRuiPLz8li+/wX28N7/KsravcAeDPgp8FvABcAJ3vufprwCm2J7eWBTjOPxBNnaL7bZ7TFfR8a6vSmemwP8ELhfrONjCTJ/VSz/U4CjCHL0ReAYUTfHx7jPJ8jcOcABhD6xPNbPrsBJwNe998vidSfHdj855uVy7/19QkbmAy8F5sU6vAK4DHgxcFHMz7eBh8c07gSeDFztvf+ec26XGPYsYP9Y7kXA3jHdQ2J+NwKf9N6vi+k+HviR997H/0/w3p8d++KLgV2A5d77M6OcutjOj4x1vZnQH3bz3p8jyrOYIKc3AXvHOlkCLCTI5NeAvYDHAr8EHgJ8lyBrL4lt+/nY/ucRxoHdYpqLgZ9475eL9A6K6RwQ8/igWM4NCJxzewHPBb7pvV8ljh8Sy+qBI733Z8XjuxLa/5fOuRfEul0R8/SYmPejgJsJY8QvCP0UgjyviXmfD6zw3n/ROXdwLO9NMb8XxvqcC/w45m8hoZ/NjW22BDiBMBacoWTn8cCPvfdbnHN7ACeKIif5viTmZ5cY3xHAtfH/YlGuVTFfxwHnAo8njB8Pi22zAng0cA9woff+ppiHJ3jvzxZ5coQ+sCmW7yXAzd7776Nwzu0PvIgwNqwkjAFrCG14SKzbcwljzj3e+2XOuX1inCu991+I6T0+yvpcwvwD8GVCn1lAGPsOAe703p/vnDsgnjsS+HSqU+fcMwhjxCrg0lh/i2LcjyDImQN+HuvpIoIsEMMcTRhj9xbjxgsJffVSXf54/iTgJ8DTYpnSdSfHut4LOAa4yXv/9djmcwnj/npCH9yHIE8HEfrHxWJOXUEYtz5FkI/Up+YS5tk9YlnXEmTs9lj+5xLG6YMJff2W2A5HxfAXAs8HfkYYbyZifidiOncSxrIHeu/Pcs49J57fM6azKbbRgwhj1p5RDn7Xe3+uc+6JMY/3EfrQrwhz+H3e+y/F+jkA+LX3/gpRZ8cQZOhTMa+bgT299xfEMCcQ+tTRiLHYObeAMA5/hiAXq2N7ryDMFzcS+s7VBLlYSZjzD4vx7UqQsWuA3xD61TLgKcC+wFWEMf5GUU9HE/rYPt77nyGIZTmXIOv7xLa+LrbvhigHywnjx+mE/ooai3+LMO8dAVznvf+OSuMYgsw4go7jgGfFfC4h9NuracV7v0P8gAsyxzxBYA+I+8WfCP9Wse8JAuUJnf1kcfzvC3F9I16/lzi2pJDWZcB74v5n4vZPVHw3x20K98B4/Xsyaa8u5Ol5qkz6d3gmb6+I21szdfptFf5ysX9vJZ3Pxu2b4/bXcfv9eO2jCtd9m6BwpP//qM5vBFbFOP425SX+/6Iq1201ORC/L4lyniau/3DcXg78eea6hYX43hC33xH5STJ0A0FRXEfowLW2yv2+F7c/ke2Siee/CufeWoh3FfCDuH9BvGZu/H+QCHeqkhEtw1vTJgz0HvjLXJrx+rfH/+cVzv+DOPYoVZ5Hx30n2uOgTByrCRPonxXKvquIN9fO8vd3mWPPI0w66f/r4/aFmbB/rurvfHFufdwelxnf/jOeO10dvw7R38TxU0X5Zfpvi9tr1fHXUyl3jOdX6viZYv+x6lwaG74jjp2UGV9OivsfrKR/A5PlaXkhXMrPUXH7gUK4d2m5EXk6XoT7pix/pk3+SIRNdXOzSuupcXthvOaFsc2SUeBYUb/PFtd9K5PvtTHcOeLYyYX+L+esvdW5d8ZtGqemyEn8P69WfnHNk9R1czJ5X5HJ400M+v1aFce+KuxvExS34wptKn9/Hbe/roR5n/r/nUyYrX0q/r9RnX8ZA6ONJ9xg5vqcjn/KGJW55smVMB+J278Rx0+Ixx4ct5fGbZovPhW3722ov9Qm38yc+wmZeVXJRJo3Fmeuf02mrA8V+7sW6mOKDAL/Lc5/OZffktzmfjuMi0WFXQiN08oW9T9Z2ecTBgcICtl88iyIW1m3iyp5mxD7KR0dJhfvAqayWyGdrvLPyxxL+dqa92jNmHQsIi2lu1Am5Tmll65L+S7V6W6EOqcQbkLEpc/psu1dyZ9kAYNyyjh3ISgt88m7KLlCfFPqk0F97BnzuYBwY9WXdE2t7mvnS0+SFhEUTBjUY6oLKVNaFnPylOIpybkkxbewcF7mV7fBfBVmHlP7NASZWkg+rzC5HXP1s6Hj/Bx1PO3n+q1GtlOuvhO7FuLU/WpSXNESJ0l1uIc6XpWnOB7oMDJNXS8pv7IP5PpQKnOp/WGQ15R+aYzdPW69Cq9JcjCh/us8dj11ledTWruqMFq+5zBQpucyua1lPnJ9JsWxuzhWGu9rspfKWBq/anmoxVf6D/l8zmdQXzqtXF+f25in1C66LXR8XfnT8rMuE4esw9rcK2W2a+zuimtBJsx8tU0yosfg0hgoSXKWk6GF1OsVBm3XkpYMD4O+24LM30La5bUzEzsqju5OL9mk/suJLcWzlu6JrrVuk+KX4tbxpvzMUdtxUhNaKZylDiU7pa6/XFwpfIqnVHaZv642LA0eOj+tN0u+kOYEwWq1IBM3hWtK51N91OqshZJyoCnJTinPnkHe0jZ3A9jSv/QgV2uHYnwV5S6RZGqB2OYUZAhlKg2+Mt5cXuV1ufzOKRzP9TWdh1yecnko1eHcwnnd/7ri6+orC6i3a6kd5fGcTOpxIUfrRJvCbY7bUpn0GCTHIlnGSW4uGeSEXJKteer8nJi/9UytU7lfGydkfZTKWJPZjWpbouUGL0ergryJQTl1/ek4FsRjLXlK5a0pTF3pyXgSemzReakpdzKuLgWzi9xcomVZ9yuvti3kxtIumYFBXSZ9SvajnFx3ja8ldL8daW41BTkFci41nBYAaTmTCnLXnUnXBJuYDQpyriwpP7I+Ut5yFtzEZsqkuLSVpkVBrilkJQUol59xKcjzyQ8MXUqoyxyr1VkLrQpyqeylPHumTpyp7fsqyDrMUAoyUxXPFgV5UnxCyd5MeXKYW9hPTKeCnJPnXB5K1sx0vFVBTvnU8XVZS3MKsrxmNijISQ66xpiagizbo0tBLinWkpT3FO+cuJ8U5DmwVU5lHdTGiRYFuVbvs0VB3signOs74hhGQa6FHUZBzuVJUpubZFz66U1fUlzDKMi1PGpyMriR7jlAW5ClnHXNo310Hln/jhHn1p1BQS5NVJrcxC+Py4l2Hf0syDVlOgl06Q5XWz5muwW5JpAprr4K8gT1ctfS7OogpUks+QNq5jGwIPdRkGvnR1WQWx7PldKGsiK0hakT57AWZE1NQa7Vob5Oh9WuDAsqYTZTnhy6FGR5XS6/cwrHWxS7nEzm2qhUhyUFWd+gJlI++1qQ5zO1/uQ1pXbsmvwmKucSrQqydlEr9RXtujYOC3JJtnIW5C0x7vlMfTSeqI0Tsk1bjABaBvSTohLDPrKutbNEKsi6rnNz85zGPLUoyLq9igqyc67kMqDzUrPOyvh3L4bqh5QRqbvA1H6VytvHgpyTQS0zObnvqyDLftpH5+nTZzrZGRRkaCtnzocHJluk+rhY1Hw0JV0W5NTApUlsHOTyl3v8MsWCHAeKVgtyikt33K7HXxNMLrfu0LU0uwb8ksWkZEGex6D9c3F3Pd7MxTmqi0Xr47lSP6jlueRi0WIprDHsCjoTTG5/nXf5zkDa6jDpXM3FIuc/LOmaVLqUV4lul3G5WOi0ShbkkkvGdLlYdKXRIhutMqfHrK6nLTnlVJaxj4W1S7Zke0gLssyDjKNVQW6pP13v021BbpVf6WKhLcg6/IJ4bLpcLHL50/O0lift0tWqfE6HgqxlvzQe9FGQc2E3quO1eTHrYiFuOBJSQe6j85iLRU8cbRWcs4zB5MFqWBeLSR1Y+VFqC/JMuFjkrCr6MQzkXSzm0M9tQV7f+vhTW5D15FjrBF13kLVrc5PwXAYuFrlr+7hYJKbFxUK8VJlo9T2VaAU5N9iO24Jci2+uOj+MBTmdq9V7lwVZ0sfFYpwKckkRKim8pbhyL6bV4k/kxsAWS+Y4XCygbfLTFuGSgtzqgzwOBVIryNIHeb7KQ4tFXsYJbeOxDtNqQd4WPsitFuRx+yBrai4WpRsuPS94yI7FMi4Y3cUi0cfFIjGqD/ImFWcuvpoFeRNT21AafczFYhppVeD6uFj0fUlPC6SciLpcLLryNw5qj+i7XCx0/dYm1RSXVoz7+iBrRnGxKE0INReLdQwei2pK+dS+sZJRFeSSfHe9BZ4YxsViOhXkUVwscj7INQV5NrhYtCjIfVwsSk+bSi4WKU/DWJBrLhYlN4hxuFhA28tB2sWipCDPBheLZEGWeZDx1dqjxQdZMt0uFi2rWMzJKI5SQe7yQR7GxaI2VjW7WFC3IE9RkMnncUd1sSiNhzIvMp7cqmBdK92UMBeLnjjaHjmVLMhywk3nRl3FQjZiGuS1ACVS3heqcOMkt5xSzcVCK8itj/e0gizjgPJApxXkPi4WXR2k5mJRUnCStSc3EZXap7Z01agKcgldz6XJYVQXi2FksiYntUlsgroFUi9Hl1uOL52rvaTXx8VipizINUVoSyatkotFqd+N6mJRSr9LQR6nBTn1ty4XC22gmJ85B90vNA3jYiF9kKWCLK3J8rocckwexsVi3Bbkkp+7ZDNTjTMbKbtYjGJBbhmjWl7S0/N0Lk9yTinNeTBZrraFi8V0rmIh45iASX7aMHWO1zcRun6G9UEuuagOxaxUkJ1zhzrnznbOXeGcu9w598ZRoqOfi0Vp8tAuFn18kEtpOaYOSCXlcRf1vw9dE03NxUJ2iNzkodft7Jq09fUyrdnkYlFbxWITYTJrsUM/twUAACAASURBVAYmcpapxLgUZJ1fnVapbUqWvrS4Okxtu1G/wtniYlFycak9du7rYjHsKhaSUVexKFl6a2Gg3gabMteUFORS+7e4WNRWsdDx5tKvWZC7xq0WC/I4XCz6vJA6zCoW0gdZvqTXx4I8qotFi4U15amFlqcRm5naHn1e0kt9u48FuUaLgpyYT37cLrnejUNBbimDTFvKkRxThlnForbi0maVt7Sfe6qR6kHmM9eG43CxSHkbmlmpIBMq7y+89w8hfPbyDfETgsPQqiD3dbGoLWKfi0ciG1G/pFdarHwX9X+ctLpYlCzIsnPU8le6m25RkNMkkmOUl/T6KsjSgpyrt1L5U9mk3OhHXeOm1cWiNMFIK7q2nEgZGMbForYKQZcPck0ZyCnIuZd7oP6SXpeC3KXkzS0cH9aC3MfFAoKMlhRkHdd0WZBLCnKXMjdOBTmR2rz0QmtNQW71A4a2dZBrPsjaxaKUj1KctXAy71oGOldJihbBVheLLlcoyCvI0p+16yW99ALudFmQu17SW5M5ry3I+kNgpTyNakHOjQ9SjuQ8N24Lcqmf5m4ycy4WuTZcpM5nyayLv+O7WHjvl3nvL4z7qwnfP188ZHTjcrHQFuSut6FbXCykha70pS3dwYZps64OkOu8uWtKL+nBQBC71rCV8SRaVrGYQ6j3XN6my8WiZEGuKch9XCySbI2rH+p6KT2N0PRRkEt+6H2pTbS5F0QTekWTmXKx6HITKL370KIg5+jrYrE5k9a4XSxyFuTajUWrBXmcLhaJVMbSy1A1F4txW5Bz7gfSgizH2fmV60pxpkfctXdfdNu0uPBpl48aLS4Wm8gryClv43SxaNEB+rhYzCevIGsLcqrznL4g27blJb0p8iTaOOf6JuWopiC3ULM2zynEletDcuyV54Z1sSg9HRwPfb5LPRM/4DDC98736Ah3gfr/LAYKaMvv8WJ/Y0fY/+g4f0/H+ZvE/pmZ8/K75pfF7YVxe1LcfqZn+W6tnLtA7K+L239RYZ4D/F7m2p+L/Ts68vD5uF3bM++e8CnWUrtcGbf7Af8Y9+8D/hM4DcL31wvXXtOQ9geBM0RdfRVYUgj7Nx1x3TtE2fvUUdr/LPDDQrifAEvF/5Is3QF8Me5/Ltbh8zPhPhzj+4P4/+4RynBTarOev5Vxuwq4HPhc/P+1IfPxcODVlfPrxf5HRmy31Lf/KG5/mgnzIiHDq4C3i3NnxHPPFMeWx3rwwHdUXL9R//uOJcP+NhTST7/Xi/2PbaM8pd9/MJB1+XtZR3kOBo5nqkx44Bcdaa4T+x8CfgTczECWW3/nqf9/BryzI70T1Ln/L25fKI69ToVZrf6/gaB4rSSM6e8S517SmPeLKue+J/Yvpjyv/nVDOh/uWaddv7OA6wvn5PEnxe2JmXDXdqTx2I7zLyCM5R74ejoex4KzgLvGWN5aO32F/Ly2OG7Pzpy7WOy/NXP+n8X+UZW0zwW+HcOsYTDGFH+xft4T/x9e0ytnpQU54ZzbjaCYvMl7f0/m/Gudcxc45y4gKEeSZ/dMrvVlCMi/yXy22JePS36UCXuI2D8hc/6Pxf4lcatdQA6N2+tF2IOA/8rEB2Egz/EhJuc31cPxKtyDyN+dPVrs7xu3P1VhXklQWNPddJoIc5SsQouATxTOXRW3+6jwf1JJJyGtLCsq4Z4ft/OYvFan5uUd6WnZ+l7c3tJxXeLLwHcL52RZ/hB4IkFJ0pwIvF/8r1mQ5xJu0m6Mx3J9wwEPINQ3lK0hjykcB3hN3B7CZKvADcArCLJdI7X9CYSB+UDgfxnIZBergEeI/3NjuiW0xe6cxnRyY0dKN6WXk1mZ3t7AQwmKueSBYv8SBvLwDBXuIXE7j3BDUmr/fyscP4ugHPWltIpG4kli/0+HiH8YVsXtXOBFcf9Qcf41lJlHMOA8IP5P9fhRgjz0eaFvC+GmdjGhfhO3A3tS7vMwtV/NBf4iE67kYnExg7xLy/IxhJvkxG5xm8as18Tw+xAs0G9XeWjheIKi+IHMOWlBPpbJ85SU/Raroc7Ph4H/F/ef0nC95qmEGw7JD+NWzg3yyfAVKvwiwlz4xUIaJ3Xk4bnA4+K+dvl8KkFuvt4Rh+YzheO5Jyfnx62Uq9eJ/VT2kzPXJgvyrwjzEYQx636Em2Npca+5s55EMAwcTLA651z3Ts0cS23/4Ercs1dBds7NIyjHn/XefyUXxnv/Me/9id77E5nckYehj2k+N8ndmDkG4c6qRm5yWiv29Rqlc9TxrTcO3vvlDelpbinkQSuA6fHaqkxYzWr1/3ZCmVIZbqH8qLK0jNJCJrexDFf6chgpnczjRggWaXnN3YW0pcKSfJBLrhtdPnpaOVgWt63yu5l+bXxf5thcgqUqUXtJbw6hPZPc1fzyutxZSvULk8ukX/hYGmW7E+/9UgarASyhfaKeS1DGE103yXLs1Gsz16iVI8lZ6eVEyQKmjjm1l2enJub9JgZresNAFhO3FS5dT7BO9SWVr+/LotNJkkmZp1K5S+g+fzehDbtuziVbGIzld4p8LYvGoVw/zrGBsuxKhU6XN+fuNZ/JBpjEGvIuPJI+L/HeR77O5RivxzxpMOt6HyiXn1WEm0MI9T0M2gVkC1PdtuSHi3T4XQj9aIrxr5Hckm6avv30pu4gW0n1Jl0s5BhSG3+SfrGCQd5Xe++XEWRfulgMsyqLROsj0Pjez6xUkKMy89/AFd77922jZPssIJ7zW835I8HUTqHJTQrymtTw+g4/tZ1WKPs6pa+h7VPF6Y3qnLBpcp+eTP51UK+TUv53YfKNg3byl1uJ9qHVacnjazNhYLLCknyQUxm1FaFrktd5THLTJSeSPm2ci3euOt7lgyz9AkdRkFtfptTLuPV9iTG9/LOa9s9wz1V56PMybKcyKqj5zaY4Wla6yPlA6he6WvK0WaSnx5KaTA7zharZqCCnMso89R1DtXFlTYyvj4Isx5TNDNoibVvrewPl+i35h6dPXMPk8bD0IhoMXigs0af/rCdvGFlf2IfJY3WLgqzzI40cpXG/C53ntCqVlGO5TKxuw10J5eoz9ktyS7ppSu1XomUO1MekgUCmV5OPVBdyNaj1Yitfpm3RzVqUcUlTH5+VCjLhscErgCc65y6Ov2dOc5p9LMi5yi0JYp+F5XPXaAVZW/J05+o7uLe8cAiDN6pb7na1QKYBv0VBLilDiyh33lQXuTvNico5vTxNy0CZlnlL9awV5D43WjC42WodJHNLAyZyE3JO/nQcXQryRqY+udDxwWgKsjw3LgX5HtpkGwY3Pok+VmG9DGGNmqKjP5OdO5dYwFR51Qpyi+VFKshaBmurRIzydngpXzOhIKf+sTVPyUkx0iIDeu5YS/+5NVkfYfASMGLbWt9JQe5ag1vuyw81aAW5ZLlOT2lK9GnLDeTHv5qCLMfdlpvg3AujoyrIuTxvZnL/lQqybsN5hLJ36QgltqWCXDOMSJmR8lIbe9OYLmVP3hTKa1vm1NpYV1qaDjr696hrmU4L3vufMNzSUZK+10+XgjyqBXmCyXdZWlHRnUtOwFIpLbGGtjvw5GLRYkHW9ZMsyKWJWIfNsZDJg2JuWaPam/65c3qtWK3s5kguFimfuv77KsilNT9LpCWhcuRkPlfX2oe65mKRLKs1F4t0btgl9aCsIE/QX0FOb8evprysl0ava9pnbCwt6Zaj5fPWORnKuVjULMh6tY8SmyjfuI5bQe7yQe7bd8ZBzoLcB8fUfKcvbfapI6kgb2JQV+lYqzW69AEjqFuQc19TnE9ZYZJPBHP0acuSFXVDYR+VrxYFObeiS6rjlnE/R27MljecMt2cggzjsyCX6ruv8l+qi1YFWaZXU5BT3qWCLG8KZZu23Gx1reijaXoiM1styDNBnw6dq9xhLcg5tIvFRqYqyC0W5JZ1QuXLczVqLha6E2qFRrtY1Oqk9nnWtep/IveCSYqr5p+s14ptudtOlsZ0nZ64+lrBSl+NqjGqi4X2oW5xsahZkFvz1epiof0gR3GxaLUgp3Im+rpYjFNBzslQbu1iLa/aB7nVglzql6OsL56jy8ViJhTkKRbkIShZkPv6IEsXC02rfK2nXBZZ79qCnPNBHsXFoq8FWZd5De0uFsNYkLcwdYnSvpSMDyUFOddnSu4lLcj4ptuCXFueUsqMTK829qa+kXPx0i4WoyrItbGq2q92ZAW5z+AE/SzIssK7HtMMc3eoXSzkXZZ2J6gpyC2TWKvPUc3FQj+G03KVPqPaYkGuDValvKYBUndiqciO4mKhX7oYp4KcyjsOF4scJSuHrOdSnpPiJ10spssHuWRBLn2xqiud5GLR6oMMkxXxPgpyHxeLYRXkmgXZi2MyfF8f5D7uWsMoFbPRB7krT1116Jmq2A+jIMs+mVufu1Uek4tFTh5lnDK+kovFfLaNi0Vu7NMK8qgW5JyLRZoThv1QU8m3Nbd2dWkcK7mXtJB1sVAvpLe+3JnooyBLC3KSm1YLcpLFLUwdf7aFi0WSh6retyMryNvKxSI1dOkusEX4dRj5P/kpzRP/ofxYdFNhv0TpDlMPcDUXCx1HTkEexcUihS913l3JfzlMHssN2K0uFlKW0jJv6Tqd376WqL4uFo5u5US2e66ut6gwpQFoHm0v6bVaYmryWHpJbx7DuVgsJMhqi/sQMMX3dLpe0quVpepioSa+LheL1jxJi5eWlZqCN9MK8rBKRYlhFWRH3oLc9yU97YOs56/WcSW5WHR90r7FxWIhdQvyOF0sNGlN21IYeW5YBbk0hrdSUpDnMchvzQcZpsfFouXF8xKlvOR0RfmSXkpfPrWuKcjp2i0MZHUUF4vaOJ9rp9pYu5UdWUHuS58O3UdBblF8tBDrFQbkACY/fZ2Lf3NhXyKFuDQA6gG25mKh48gpqq0uFrk8p/opdd5F5H3v5FJEpQlj2FUsShbkvvS1INd8G1Neao8mU7icD5gmKchdL+m1fvlsGAvyMApyiqvFX77EdPkg1+Sl6yU9Kd85BVlbrkZ1sZguBXkcPsjDvlhVopSnrjosKcijvKRXm9C7qLlYlHzs5bsqMp1dqCvINcWlT1vm5oMuFwspm8Ms8yYV5GFdLEovf0l3wBYFuTQf9hlPS99x6ONioQ0nki4f5Fxdtri35cafYVaxaPF3ltT0gq2YgjxAf0O9hhSinFIiaVF8tOVSdpj5Kl9JWNIdVm7FiNy+RF5T6kBSKNcxcLFoUZD1YNTHxSKnDKXBpjSQ7EJ+/U9p+RxFQdZvf0vFe1QFWS530/caTRqwai+3JORkXJro5tP2kt6Cyrlcml3n9MQwEwrydLlY1OQlpZmziGmLcE55GbeLRS2vM+2DPG4FeVgLcrKeybpLCnKfm6wuH+S+LhY5Sj728iZZjgV6aU2dTo2+TwO0rGkLcs0QNFMW5NrLX2lOlze9uT5Tc7Hoeqpd8kHu+16NzEuJLheLRF8FeRwuFus60qr59JuC3MgC2pUUKZipc42iINcsyDpf+tvuutO1uFi0KMgLVJj5tFuQcwpy6zrINQW5dANTsyDXHqVoF4vSZKCX7ZHXbWsLcsnFQh7rsiDDQAa6FOQWH+SFlXO5NLvOaQW5r4UnxTXsAvwwfS/ptSjIucFeK7y7Mz4Xi1K/rCkO02FB7qNUzSYFWS+Hllax6PtUUrpYJLrqTFNbxaLkYiFvkrSCPM7VmUq0+CDX/OOHfUlvunyQYSCfo6xi0VWukovFsApyrU1bFWRZJ7X813yQ+7pYrKGuINfmHXOxaGQhZQVZT2rT6mIRv3CVOJyBYriFwWdNk0DoTjcuC/LDVP72iMdaVrHIDUabCJ9RhXqd5BSIFgXZAy8EniWOLyB8ox2mfm4XwmOc3cT/0qR7sNhPLg6zzcViC4M267Ig785kC/L9K+kdHMOc7Jw7iamfIIfBp9MfljknabUgH6vOzYQF+Sgmf3q6xsFMzXOJFgU5xwnAw8X/3RnI6wOdc/cDHivOH0Tbo+c5DNp/un2Q947bUjkP7RHXsEtzlShNsDl5l7yI8CldOXasJcjDibkLCozTxeKhhXPyE/BPU2mna54tjh9K+SWvrvHqhI7zkhYXi9zHpxKHN6RRc7EYpwU5KXZJHtKY+FTKy3CW5sOndqT/aLEvy/dksT8uBXnfzLGkP+4vjsk66cp/IvV76WIh++PTqLMReH7l/KR2cs7JceZw59yrnHNZZb6oIDvn5jrnnu+ce55zbkIcf1Hpmu2E3DfqIQi2VMC+JfZT53xV3GoF+X+AqwvxSqFbQ/7b6NcTvkkueVfc7s7kBbT/SoS5kfCpRoD0xcGcdVuTynkukz9FeRHwnUz4xcDvEL57nutwnwROF//PUee3ID5t7L3fArxR5PksETYnk2kyvIXJn0j+oNjfF/gT4DhxbFcGSs6/AP/O5E/96rJqBfm8uNUfqdlEt4vF0sJxyS9oX+ZtSdzOBf5LHE9tPE/k6SBx/jrCR3fOUPElGe6yUhwZ83gYQV5ekgnzyLg9KnMu8S0GZV2qzn0lHjst/v8ddT6V8dtx+8l4jeyjsv5S2eTnafVnlCHfFxP/xGSF4j3AHxPk/Csq7O2VeDRaXn4j9muWkhcAPxP/P0Xou5sJivM1hD7wp8A7CeMGwPmF+JI8fCNulwEfz+T1/eL/lWK/xcXijYS66rL29qm/xNKO89+tnHs/oS1PFcceo8KckrnuWrGfZPL1hDHnYnFOKjybgK9W8nKRiC/nYpHGyA8CV1XiSfwGeHrcPxf4cCHcH4v9LQxuck8Sx3NLCa4kzE1nAN+v5ONk9T/3NCfV2XrCHJA+nf4jgiyeB7w3Hrt58qWT5FrfPPw5cJk6llOQvw18gDYF+ZrMMS0zpzIYez9FkIOkMzwOeDBhLE55+zyhD6ex60MqvjR3lWS5pIDK8Um23906oOID6v9yyvPSm8X+A+P2fCbL7hMqaV0FfAI4QhxLaf0G+AKD8e6FlXgADmRwM/oWcfyCuN0E/CNwZvz/f4Gfxv03E/Q3OdYP8N5nf8BngX8gNPrPgQfG4/9bumYmf8AF6v/HCJ1A/n4Uz63MnPs04Tvk6b8T+6vjdq+4/RNx7t4Y56Hi2HVi/0/F/ieAP8ik/RGCEuqBt4kypPM/jtu71XULgXfE/YPiNa8R56/KpOUJg40HHhCv2Uh8iT/+/4vCdZ6gIHmR7idUfs8E/kxd8zDCoO2BN4rwj0rpAl+O52/JtVvcHhjDniXaKC2JdKe65sU6HpHuD+Oxo1WYN8btXXH7QHHu12L/rwg3Jrqt5e9LBEWuVI+eMIm8Oe7/tTp3g/r/srj9rqjrdQRFTse7VuwflZEnT1BmPWEQz+Xt6WL/gx3lqP2SrD1S5OHj4vwZIn/zCnEcEc+fqOTgX1WbJFlK/WUOQanxhJvQq1W8so/7TB15wiTogceq8UWGOalHfZwv9q9iMD5cRJCp/2mI41qRj+eI4x+Jxw4Sx46R9SPq5uGqzl9FmGhkOq9ksFzZ34tyf51gIZRhXwis0vUZr3mrOP4cppbn99X/0yplT/l/YyWMV2mm33dkvpSsTMl3PJ/G/vOAs+P+WuBWdd0pYv9BYv8PGYzt38rk6SFx+xcEhcgTJvAbdF5ifr6hrv+R+v/suP1NQVbl711x+3eVMM8W+3eovOza0Qbpt4SgjHoG84YnWDo9cKqS5QNEGkmWf484T8XfnExdbG0/4KPi2BaCsiXDvUmkMSGOn5mJ8xWiHt+iypX2z1N1vTdT59/rYph/km0by6bl5rEEo5kH/qixns/NHHuI2H9m3K4Tx76j6u254txLGcz38rc6hv2JOn6MqktP0G1yef2XGMc54thbM/L+C3H++o7y/zBe8774/9i4fYqI7/8Sbhq/RrhB29peOb2y5td0P+/9ywCcc58EPuGcO7USfnugZvWY5GLhvfdiVaX1hEfx6e7Ii+vSfsm1QVoTtpB/LDNPHK+t4qBdDOQC61syYUouCake5DVSFmrWzFSePj5myQdZplkiF28q/6QyqjbSslwrQ+mlJP0yoMyrfKQr/fykLJTSKSFdNbRsltpOllP7UMt4E6V6SGFKT5Fk2Yd5IUvHU3oJT5az9Nhe9420lfHIdnAA3vstzjkZdlJbKfkp0eIC0+cFSy0vKf7kR3cv3cg4cn6auWPJkpRkPPc4P+di4cW+RLeV/PCCpq9PZK2uU367rNKjvOiWi8cxebUWHb/Mj+w7nkF5cnlaI87V5oCE7ou6HpJbUYvLVipPbUyWbko6X61uYaW5Me3r8VbGK49tfXIX+3Zt7NVjg/Y1ldfK8ucGBN2eiVo7bWFqvZaeOqby63E7jY21ckpq8oWIT/bTYVYeyn0gBEKeW2UklUnOZyXdqHZekuLSy47q8TC9fH6fOj6Fmg/yAufcAgDv/fWEO8m/pOzftD1Qm+i1i4UkCXDuep85V5p0Sgqy/JxuLo2knE2aiH1wVdAKcp+X9Epp6glf1ote37Hl8VRaxaIlfO6mLZU/dxOQ0JNfyxu5pcXnpc+3zkO6rsvFQr4EUkIquK0KshwwpKuHjjfRtYpFSWkoTQp9qcn1pONRnmtxaKWupCDrmwgdtg8tq4z0WcdU12UqW1KQW+KSZcn5m+fWj00TZZLjzTAwGzH4pP2kvIrzOt+6PT3lOtZr7nbR8qXNLh/knLwN87W8VgVZ9letcOUUoIQcF+WLsyX0OV0PSaFtqeeWl9SkglxbManGZpFG7sZbG09yCvIGpo6JtXzrsUGvVpAzcunrcumMoiCXfJ5TebXe0Ncw0fWF3yQTsow1HTBXBnm9rqsNYryAwfKuNfR8psmN5SVS/aZ85cbu9IGbCSbfXPZWkN/C4KUKvPerCeb3txSvmP3UlnGrKcjaApCbmEt3ybqz5xpZrvXax4IMU5XdjZlzXdfocCXLqjzXZ5mzkgU5Nxi1WJBbXmIZxoKcJpucgqzvQnVn1Hj6WZBrE65kngozrAW5a7AZ9qtymlz/6JMPmRfto1lSkPUb+hDGumGU5BYLch8FWcu/VJBdz7h02jkLcpoctAVZ17v8uEGipDjkFMRa/cr2aClfyyo3fSzIKb7aWq4lUj3JZdtyL8rK/7KNZb3WlgXTHwopoccFXQ/3FsLlGMmCrJShGpsYyJJMS/etFEY/dU1hcjdlmnRsjjpWVJBVObROtImyglwbu2oKss53Tj420P/mvrRKRiLJhO7LFP57+inIuZVGutZ47rIQ97Eg6zm5ZEFeEMNuvXnw3mfjLirI3vufe+9vA3DOLU6ReO8/05HJ2UyXBblrJYpcJY7DxUJakGsKcumzwSluaLMgawWwy4Kcm3D7KsijWJCzLhYd1w1jQV6jjre4WJTwmTzVwuh2L+V/3C4WtbwlWla7Kcla16TfR0FudbHIKcjDMt0uFlJBbo2r5GKxAdCr4HS5WCQmMpNErW9PuZ7yRK4/StFFzlqYGEZBTmmO4mIBdWtWSUGeYFCWnCzK8buPi0Vqm9oSoV20WJDlY+hh+9IW6gpyap85MOVJkrQgt4wVpae8NReLGusoK8i1OGouFpqSi0VfC3LtCQXkFe6a8t1XQdZ9exPd8tjlYiHPd7VZCqsVZP1ELedikaV1mbfznXOP7A426xlVQc4JSx8XC+lnJpkQx3N5bFGQc9eXJhk9YOd8m3NpwFQXi74WZBlX7tqaglyro9ydf4mURpcPssxrycWiZkFueaRbcrFoVZBHdbHoyhe0WTBKvqW1Gz9os3SVZLyvi8UwriLjdrGQeCb7ILfGVXKxyF2bjq1T25yCm8tfaV/La01BHsaCXJKnlO8uBTk3BneVsZZel4uFTG+SUi0Uvtx8KxXkPi4WqR11PSR5aJH10s25pLbUWivSl12mpV0sck/c5A1qi4tFzkra5WIh0TK8lvKcVbvhys31fV0s+vog59pHjg85w4Iur+7nOdnoY0HelgpyycVCGxFyLhZZWhXktwHfc85NWW7DOfcc59xPM9fMRmqT8cLKee2vl3Pwb7Ugb0sXiz4v6Ul0B84pXH0syPLR8TgsyKWBWsZda+t5hTB6oJJlK1mQS32oxcUC+rtYTKgwXRbkTt9fhW5fCmloSoNNznIkaVGQW1wsSi4h0sViGKbTxUL+76Mgl9LOXbtBnUv1nVNwNbW+quV1HttGQW71QW51sehiHC4WiVz6Uqb7uFiUFOQ+8tPiYpFbPrEv0oKc8+HNjTny2pQPPVbk5p7ci2hbmKogl8qsx4m1Kmyr61kfF4ucQab2FKXElPYpWOO3lQW55mIxzEt6fRXkZheLEk0vLXjvP+ucuw44wzl3NGFN0JcD/49QgPfXrp9FDGtBrl3X1we5JAQ1BTnlK9dhpuMlvVIaMJwFWb6o0vJSn6blJT0I+ZxTCCPLOA+yqxj0UZBLg0RiuhRk/VJDVUGu+AmWJrv0CKprYtd0yVApH31cLPRW+xkmcgrysC/pbXcuFpMChrf95aPOkrtYTlb7uFjMo20Vi1YXi9IN1zBj1iguFvIJhLQgt7pYdPWjYV0s9BOBxLgV5JwFsi/SgizRfSsngzUXi1ycpadLrS4WepyouVh0Kcg6jT4+yONysZDkyjyMgpxdxSLjotXiYtH1kl4fBbm0isXQLhbNb/V6789zzj2FsI7nWwkLZ58KfLny9vlsY9iX9HTD5x7tlh6xjWMVCzlIlPLW5yW9Lh/k2qd+9ePKlrbvY0HO0eKDDCGf88S+PpcoyX3tZZqSpa40wGyppCNJYVoGf5j6kl4ujZaJTN/QaUVdxttifR1mcIZ+CnKIKK/0l1wspII8jJKce0ynGdcqFq1xyXJ0WZDTcW1BHlVBbvWv1OdaLchdFuKuybLVxaILKT81a5dMT/sg5/Z1PK0uFqn9UplKFuQWWW95CjguBTlnvdR9q8uCPIqCPKyLRU1BrslTblWXUn13QExH6QAAEYhJREFUrWLROm4NY6QYZhWLVmouFqlMfVwsuvKib1hyY7e0IHe6WDQNGM65AwkfNHgt4Qskm4E9gbO3I+UYui3IrQqyxMNWS00uvB5gSkuZ1CzIuTuhhH7s3OclvZpPryTn89jXxaL2omMXLT7I+rhuyxYFuZbHkqWu1Qd5C/nBqGRBbnnhqWRBbhlQtZzoeGQ6fePLMTYFWdDnJb1hLcgh8sJbzpFtbUEupV17h0IvAdfiYtHHZ7vVB7nVglwKN1dtS4zLgtyqIJcsyF2uSsNakLVvuT7fgra4TUE9ZZsuC3LNxUKGGVZBdkyt+1YFWX5rQF9XlKdYb7o8zS4W3vvN8clPH7rap+8Y2NfFIpefrv4+nT7IOb1pA4OnCZ0uFq1+eUuABwBP8t4/jfDll18QXt47pjGObU3N3yvHLrQvidX1JmvpJb2ai0VtcKxZTmsuFsP6IJceDclr+nwoZNwW5BYFuWbhKeU9dyev8yDDQX2Q6Hp8BNOjILcoAjI92f6p7fu6WAxrQe7zkp6Oo8XFYtSX9DqNCB3K85Tg6n+6to8FueRi0WJBzrkPwegKcquLRasFuRQu5bNlCUWd5rhcLOTxXHqyHqr9SBmY+ijIqd/otfFzvr4l5qltF6O8pJfb7+Ni0dcHWY6f85jqi9+qIK+nbEHukiddnj4uFjCeD4VIcv2zSwfMxVn6UIim5mKRm2e6XCy6aP1QSLIgj20Vi+O89y/13l8EoRN6798MvBs41zn3tMZ4tiWvzhy7IW6vAJapcxOEG4EcV6j/d1TOQfi8bUI2wkbyjw5vYPJAoEmde3XmXIovCdyd4pwuY0JbZK9U51ep/7I8KS+3xO3NKuxy4PZMeqmzy0FOliddk8vz3TBp8Jf5u4yQ/1uAy0X8UqG9jfDZz8TVhE/FalJbpfqQk4/M1xoGsnR1Jh6AGwmfoYZQzl9nwtwr4tXtruNdRfgUsWyLqxjU/23i+DWFPOW+Wncrk9s/lfkucUy3cY7bCsdTXqTc38RAIWyJO+VV9x0pBzL9pYTPycOgvq4j31a5fMs+VLOA3NHzOEyWu2tE/HfHbcuX5mT7SrkpXbuawfq4KYy+UV2RuW6l2Jfj2A1MldeVwG/Iy54ss67Pe5g63txL+YuC14kwNaSspL5/LVPrKDcOSNK1NzGQn6vi/1J6UqmQY6Hsu5qNTFbirmIgE5Ib4zb12VI9dJVLxtXqIlQaVxKl+WYToU/C5HpK+6lNtBzAYF7bwNR5Ss8zEGQQJrfPhEgjtUHuWgifM5bcy+T6kdddw6Ctr2MqKe93MJinYGo9lRTk1Cdr44lMewN1ZTr1YTnmLlVpyzZYRX78k/2pxhWU5TPVwdUiP7ly5nSPtE1tcZMKm+LbDFMMGPcBRwJHkZe3Sbj2tb4LETj3ZOB07/0BI0U0Is65C7z3J4r/jyQIWPLlmUf4lvxm59wiwh3ELoSO84D4/3JgP2CT936lc26fdB2wn/d+uXPuAELDHBCv3ey9XxPTvB+h099L+MjKeu/9XdHKvoAgyKsJ30dfSWjAjcBa7/36+ALkdd77jTG+/Qk3MWuABxI672EE4drivb/dOTcfONx7v1UBdM4dFq+7PYa/O+ZrLrBXyr/3/jcx/AJgoff+bhHHEQRl9yDCYLsY2Oi9vyHWy2pgD+CuJIDOufvHtO4B9k9xee9XxPNHAUu99xtEOgd471c453YH9iEIbWqfibh/HXCY9/7qeM0i4GDv/RLn3K4M/EuTD/Ke3vsbY3prYvtv8t7fIa6f671fHdtzaz7j/zuB3b33q5xzh8a2vjjKxn6Ejr8I2DWWdc+YxpxYBgiddSKeS0sFzQHuH/OE9/76+Bhuz1ifh8Ww8wkD174MuJ34uXPv/Rrn3F4M3rDePV6zZ8zPXTHtXVLdx3KnfC6M8n1AzFO6c5+I9TcR0z8wlufK2J57xfCrYrhU/r0INyiHxjytiPW0iiDfuwsZ2JcgIwfEfF8jrWjOucPj7tpYnrlJTuP5A733y+P+bjGdlOb+sQ33BeZ775fF/nFkrL97RXssFHK3BVgU+9NesT4OA27x3t+ZZFS0Rcrn7bGOb491uZHQT5bGulkv6mkuoY3XxzArY91tJPTt64CHAZeKPB5EUOBdrK9FMa/Xe++33gAKGb0krYEc8+PimHVg3B5J6Mu7K7nYD7gzjo0HEMbFCe/9knj+SOBW7/1a59zewH3e+w3R9W4fQn9ZHvPnYnm9aPMk43Njne8X09gM3Ou9vyfGBWGCv4Mg+3K5pmRJugPYV/TVrcWI1yZ5vhs4IubtbgZPCOd57+8RZd+LQf/xwD1pnIjnFwKHx3ZYH8PeF9tzMeFmYRGhzx0d62lVzJsHVkb3Ozlv7EkYj9dG2dk6LjrnHkwYO+bpvMb8zIn5uYU4/hIm+1ti+BXOuUNivd4Vrzk81s9qgrxtJKzatDq21ToGfSSNYWtjHKme1wPrvPeTlOk4R+0Sy3QjYZ7bM+Z/JWHcWBnbLdXdg4CbvPd3x7nxylhHjtiHVRppjlhAmFd3jWO/7P+7Efr3PVFO58X0JmKYjbGu1hD61XXyXYZYxvRy6K7A/Qiys57JfSO14W6EeXherMu74hy+D2FsuTV+P2JvBgYw572/N7bhvt7722X6om/Mi2PXrjGtpbHNfczf3kyW6Q2xnm+LxxbF8172E7HvY553iXnbK7bt3aIuUvi5BH2FWPa9gVXx3MLY3ovjsfTdjMNjPu8WedsvXr+B0HdSnS4iyNwi3e4xrv1jGvfFPO9LkLOFMY19CfK1SLT9BEEHWKnH7ihjDyf0h0ti2W7PpQ1jUJBjokdLBW0m0AqyYRiGYRiGYQzDsGuDTmKmlWPDMAzDMAzDGBdjUZANwzAMwzAMY0fBFGTDMAzDMAzDEJiCbBiGYRiGYRgCU5ANwzAMwzAMQ2AKsmEYhmEYhmEITEE2DMMwDMMwDIEpyIZhGIZhGIYhMAXZMAzDMAzDMASmIBuGYRiGYRiGwBRkwzAMwzAMwxCYgmwYhmEYhmEYAlOQDcMwDMMwDENgCrJhGIZhGIZhCExBNgzDMAzDMAyBKciGYRiGYRiGITAF2TAMwzAMwzAEpiAbhmEYhmEYhsAUZMMwDMMwDMMQmIJsGIZhGIZhGIJZpyA7505zzl3pnLvUOfdV59xeM50nwzAMwzAMY+dh1inIwPeBh3rvjwOuBt4xw/kxDMMwDMMwdiJmnYLsvf+e935T/Ptz4JCZzI9hGIZhGIaxczHrFGTFq4EzSyedc691zl3gnLsAWLjtsmUYhmEYhmHsqDjv/bZP1LkfAAdlTp3ivf96DHMKcCLwfD8TmTQMwzAMwzB2SmZEQe7COfcq4HXAk7z3a2Y6P4ZhGIZhGMbOw8RMZ0DjnHs68Dbg8aYcG4ZhGIZhGNuaWWdBds5dCywAVsZDP/fev24Gs2QYhmEYhmHsRMw6BXmcOOcuA9bNdD62c/YD7pjpTGznWB2OB6vH0bE6HA9Wj6NjdTgerB5H5w7v/dP1wVnnYjFm1nnvT5zpTGzPOOcusDocDavD8WD1ODpWh+PB6nF0rA7Hg9Xj9DHbl3kzDMMwDMMwjG2KKciGYRiGYRiGIdjRFeSPzXQGdgCsDkfH6nA8WD2OjtXheLB6HB2rw/Fg9ThN7NAv6RmGYRiGYRhGX3Z0C7JhGIZhGIZh9MIUZMMwDMMwDMMQ7JAKsnPu6c65q5xz1zrn3j7T+ZmtOOcOdc6d7Zy7wjl3uXPujfH4qc65W5xzF8ffM8U174j1epVz7mkzl/vZhXNuqXPu17G+LojH9nHOfd85d03c7i3CWz0KnHNHC3m72Dl3j3PuTSaL3TjnPu6cWxHXfU/Hesuec+6RUYavdc59yDnntnVZZopCHZ7mnLvSOXepc+6rzrm94vHDnHNrhUz+u7jG6nByHfbuvztzHUKxHr8g6nCpc+7ieNxkcTrx3u9QP2AusAQ4ApgPXAIcM9P5mo0/4GDghLi/O3A1cAxwKvCXmfDHxPpcABwe63nuTJdjNvyApcB+6th7gLfH/bcD77Z6bKrLucBtwANMFpvq6yTgBOAycay37AG/AB4LOOBM4BkzXbYZrsOnAhNx/92iDg+T4VQ8VoeT67B3/92Z67BUj+r8e4G/ifsmi9P42xEtyL8FXOu9v857vwH4PPDcGc7TrMR7v8x7f2HcXw1cASyuXPJc4PPe+/Xe++uBawn1beR5LvDJuP9J4HniuNVjmScBS7z3N1TCWB1GvPc/Alapw71kzzl3MLCH9/48H2bXT4lrdnhydei9/573flP8+3PgkFocVodZOSxhcligVo/RCvxi4HO1OKwex8OOqCAvBm4S/2+mrvQZhEc1wCOA8+Oh/xMfLX5cPJ61ui3jge85537lnHttPHag934ZhJsR4IB43OqxzkuYPAGYLPanr+wtjvv6uBF4NcEKlzjcOXeRc+5c59zvxmNWh3n69F+rwzq/Cyz33l8jjpksThM7ooKc87OxtewqOOd2A84A3uS9vwf4KHAkcDywjPBIB6xuazzOe38C8AzgDc65kyphrR4LOOfmA88BvhQPmSyOl1K9WX0WcM6dAmwCPhsPLQPu771/BPAW4HTn3B5YHebo23+tDuu8lMnGA5PFaWRHVJBvBg4V/w8Bbp2hvMx6nHPzCMrxZ733XwHw3i/33m/23m8B/pPBo2ur2wLe+1vjdgXwVUKdLY+PutIjrxUxuNVjmWcAF3rvl4PJ4gj0lb2bmexCYPUJOOdeBTwLeFl8VE10C1gZ939F8J89CqvDKQzRf60OCzjnJoDnA19Ix0wWp5cdUUH+JfAg59zh0Rr1EuAbM5ynWUn0Z/pv4Arv/fvE8YNFsN8H0tu03wBe4pxb4Jw7HHgQ4UWAnRrn3K7Oud3TPuHlnssI9fWqGOxVwNfjvtVjmUkWEpPFoekle9ENY7Vz7jFxXHiluGanxDn3dOBtwHO892vE8f2dc3Pj/hGEOrzO6nAqffuv1WGVJwNXeu+3uk6YLE4zM/2W4HT8gGcSVmRYApwy0/mZrT/gdwiPXS4FLo6/ZwKfBn4dj38DOFhcc0qs16uwt2JTnRxBeCP7EuDyJHPAvsAPgWvidh+rx2o9LgJWAnuKYyaL3fX2OcKj1o0Ey9FrhpE94ESCArME+Ffil1Z3hl+hDq8l+MmmsfHfY9gXxH5+CXAh8Gyrw2Id9u6/O3MdluoxHv8f4HUqrMniNP7sU9OGYRiGYRiGIdgRXSwMwzAMwzAMY2hMQTYMwzAMwzAMgSnIhmEYhmEYhiEwBdkwDMMwDMMwBKYgG4ZhGIZhGIbAFGTDMIwdAOfc/Z1z96Z1UQ3DMIzhMQXZMAxjO8U5t9Q592QA7/2N3vvdvPebZzpfhmEY2zumIBuGYRiGYRiGwBRkwzCM7RDn3KeB+wPfjK4Vb3XOeefcRDx/jnPuH5xzP4vnv+mc29c591nn3D3OuV865w4T8T3YOfd959wq59xVzrkXz0zJDMMwZh5TkA3DMLZDvPevAG4kfF52N+CLmWAvAV4BLAaOBM4DPgHsA1wB/C2Ac25X4PvA6cABwEuBf3POHTvNxTAMw5iVmIJsGIax4/IJ7/0S7/3dwJnAEu/9D7z3m4AvAY+I4Z4FLPXef8J7v8l7fyFwBvDCmcm2YRjGzDIx0xkwDMMwpo3lYn9t5v9ucf8BwKOdc3eJ8xPAp6c3e4ZhGLMTU5ANwzC2X/yY4rkJONd7/5QxxWcYhrFdYy4WhmEY2y/LgSPGEM+3gKOcc69wzs2Lv0c55x4yhrgNwzC2O0xBNgzD2H55F/BX0TViaH9h7/1q4KmEl/puBW4D3g0sGEcmDcMwtjec9+N6QmcYhmEYhmEY2z9mQTYMwzAMwzAMgSnIhmEYhmEYhiEwBdkwDMMwDMMwBKYgG4ZhGIZhGIbAFGTDMAzDMAzDEJiCbBiGYRiGYRgCU5ANwzAMwzAMQ2AKsmEYhmEYhmEI/n/zRk5z1Q4LSgAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -1271,7 +1269,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -1288,7 +1286,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ diff --git a/tutorials/tigramite_tutorial_causal_effects_mediation.ipynb b/tutorials/tigramite_tutorial_causal_effects_mediation.ipynb index 8f8f097b..4ba84983 100644 --- a/tutorials/tigramite_tutorial_causal_effects_mediation.ipynb +++ b/tutorials/tigramite_tutorial_causal_effects_mediation.ipynb @@ -172,7 +172,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -184,7 +184,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/tutorials/tigramite_tutorial_missing_masking.ipynb b/tutorials/tigramite_tutorial_missing_masking.ipynb index 4e94abc2..9510a3c6 100644 --- a/tutorials/tigramite_tutorial_missing_masking.ipynb +++ b/tutorials/tigramite_tutorial_missing_masking.ipynb @@ -24,7 +24,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -56,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -127,7 +127,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^0$ has 4 parent(s):\n", + " Variable $X^0$ has 4 link(s):\n", " ($X^0$ -1): max_pval = 0.00000, min_val = 0.682\n", " ($X^0$ -2): max_pval = 0.00002, min_val = 0.532\n", " ($X^1$ -1): max_pval = 0.00419, min_val = 0.371\n", @@ -160,7 +160,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^0$ has 1 parent(s):\n", + " Variable $X^0$ has 1 link(s):\n", " ($X^0$ -1): max_pval = 0.00006, min_val = 0.507\n", "\n", "Algorithm converged for variable $X^0$\n", @@ -208,7 +208,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^1$ has 5 parent(s):\n", + " Variable $X^1$ has 5 link(s):\n", " ($X^0$ -1): max_pval = 0.00000, min_val = 0.800\n", " ($X^1$ -1): max_pval = 0.00000, min_val = 0.734\n", " ($X^0$ -2): max_pval = 0.00000, min_val = 0.720\n", @@ -247,7 +247,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^1$ has 4 parent(s):\n", + " Variable $X^1$ has 4 link(s):\n", " ($X^0$ -1): max_pval = 0.00000, min_val = 0.680\n", " ($X^1$ -1): max_pval = 0.00001, min_val = 0.557\n", " ($X^1$ -2): max_pval = 0.00762, min_val = 0.350\n", @@ -280,7 +280,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^1$ has 2 parent(s):\n", + " Variable $X^1$ has 2 link(s):\n", " ($X^0$ -1): max_pval = 0.00000, min_val = 0.680\n", " ($X^1$ -1): max_pval = 0.00032, min_val = 0.463\n", "\n", @@ -329,7 +329,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^2$ has 6 parent(s):\n", + " Variable $X^2$ has 6 link(s):\n", " ($X^1$ -2): max_pval = 0.00000, min_val = 0.773\n", " ($X^1$ -1): max_pval = 0.00000, min_val = 0.771\n", " ($X^2$ -1): max_pval = 0.00000, min_val = 0.737\n", @@ -374,7 +374,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^2$ has 5 parent(s):\n", + " Variable $X^2$ has 5 link(s):\n", " ($X^1$ -2): max_pval = 0.00004, min_val = 0.518\n", " ($X^1$ -1): max_pval = 0.00005, min_val = 0.513\n", " ($X^2$ -2): max_pval = 0.00065, min_val = 0.438\n", @@ -413,7 +413,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^2$ has 4 parent(s):\n", + " Variable $X^2$ has 4 link(s):\n", " ($X^1$ -1): max_pval = 0.00005, min_val = 0.513\n", " ($X^2$ -2): max_pval = 0.00065, min_val = 0.438\n", " ($X^2$ -1): max_pval = 0.00836, min_val = 0.346\n", @@ -446,7 +446,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^2$ has 2 parent(s):\n", + " Variable $X^2$ has 2 link(s):\n", " ($X^1$ -1): max_pval = 0.00005, min_val = 0.513\n", " ($X^2$ -2): max_pval = 0.00065, min_val = 0.438\n", "\n", @@ -454,14 +454,14 @@ "\n", "## Resulting lagged parent (super)sets:\n", "\n", - " Variable $X^0$ has 1 parent(s):\n", + " Variable $X^0$ has 1 link(s):\n", " ($X^0$ -1): max_pval = 0.00006, min_val = 0.507\n", "\n", - " Variable $X^1$ has 2 parent(s):\n", + " Variable $X^1$ has 2 link(s):\n", " ($X^0$ -1): max_pval = 0.00000, min_val = 0.680\n", " ($X^1$ -1): max_pval = 0.00032, min_val = 0.463\n", "\n", - " Variable $X^2$ has 2 parent(s):\n", + " Variable $X^2$ has 2 link(s):\n", " ($X^1$ -1): max_pval = 0.00005, min_val = 0.513\n", " ($X^2$ -2): max_pval = 0.00065, min_val = 0.438\n", "\n", @@ -624,7 +624,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -722,12 +722,12 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -765,7 +765,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -783,12 +783,12 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAANgAAACUCAYAAADxuuf6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAP+ElEQVR4nO3de5hU9X3H8fd3ZnZmF4TlJncUpdGAGBCMjXmqkkRMQloVa6umGjU2PEQebZKa1jYmzRPTG6bkMZqgaFNomgqaeoNYsHh9VJQIrHhFdF0EgrDIZbns7sw58+0f5wiz617mcn7LYfm+nmeec+bMmd/vN3POZ87tNzOiqhhj3Egc6QYY05tZwIxxyAJmjEMWMGMcsoAZ45AFzBiHUke4frtGYOJMKi3AtmDGOGQBM8YhC5gxDlnAjHHIAmaMQxYwYxyygBnjkAXMGIcsYMY4ZAEzxiELmDEOWcCMccgCZoxDFjBjHLKAGeOQBcwYhyxgxjhkATPGIQuYMQ5ZwIxxyAJmjEMWMGMcsoAZ45AFzBiHLGDGOGQBM8YhC5gxDlnAjHHIAmaMQxYwYxyygBnj0JH+f7CKaN6HXZvRDzZCYz14rZBMweATkeGnwJCxSLLqSDfTOKB+DvZsQT+sh6ZtkPcglYGBJyKDxkL/4Ygc+e2HqB7R/8Arq3LN+2j9aqhbCnk/eHPz/uEZJAGpNKjCxOnIKeciqXRUbTZHkHpZdNMqaFgFJMDP0mY1kiQkkpCsQk6dDsMnIlL2/+hV/Ad8R13AtKkRfWo+tO4HL9v9E5JVkEoj530DGTK2jCaauNBdDWjdA+GHaq77JySrINMfmfpVpGZAOVUeWwHT7RvRZ+4Ng1Viu5NV8IdXkBg7pbTnmVjIb1kLb60I9lZKIsEH7JSvIgNGl1rtsfMXsrqjHn16QXCcVc6epZ+Dl+4j37A28rYZt4JwPV5GuAAUvFZ0zX+hTdsib1t3joqA6cG96DMLgpBUIgyZ7v59NA0zzumereGWq/Jlr2t+jWYPRtOwIh0dAXt+UXHHW8Xwc+iz9wRnIE2sqe+hdUvK3HJ1wMuirz0STVlFin3A9IO3YdcW0Hx0hbYeQOt/F115xgnd/HJ4ljCqAn3Y1YDu7bk9mFgHTFXRNQ9G+yZDsDWsezS4lmJiSb1WePfZyg8L2st76Fsroi2zC7EOGDvfgwO73JSd9+D9V9yUbSq37dVo91oK7duO7tvupux2Yh0wbVgDnqOtjJcNLlabWNKtdZWf2Oi0cB/94HU3ZbcT24CpKmyqo8zOHsVprEdzre7KN2XR7EHYt8NhBflgC9kD4tsXcf/Oio696nfs5Z8eXs3eg1ke+NZXOp4pmYIPG2D4qWXXYxzYvSno7uSXfqb3QEuWOXcsI51Kct6ksfzF5yd1PGP2ANp6AMn0rbCxXYvtFoymHcGb3IX5K9cz5z+ePHT/+/e/wNd+ERzAnjy0lntnTe+6Dt+DvQ4/KU1Z9MDOLk9uzF+6mjl3LD10//sLV/K1uf8DwIPPvcGfnjOBBd++iKWrNnReSSIFB3ZG1uZOq3FeQ7matnd7Bunqc8azbO177DnQyrK19TxW18Ddf/mF4uvIe+juLRU21ERu7za6OjS4evpklr24gT37m1n24gYeW/02d//VhQBs3dnEmONrAUgmuujplM/3SMBiu4uoe7e37SHfgT6ZKi4/+1Ruuf8Flr/SwIq/m0lNusSX1GRbsNhp3t3lw32q01z+udO5ZeETLP/dRlb889XUZIKvJY0a0p8tjU1MHjeCfFf9bPM5tHlP5Z0NuxHfLViRx1/XTpvA/JXrmXfVeYwbdrjH9If7mvnmvz9B3aZG/uWRLi4q27Ww+Cmi58a1F0xh/tLVzJv9ZcaNHHRo+iV/NIEHn3uD63+2lD/+TDfH1lFfX+1AbLdgxXZkvvXBlzi+fw1evu01k8H9aph/XRG7i+V/V8g40/0yufXXT3N8bV88v+1y71ud5pc3zYysnkrFdwtWVd3tLPN+u5aWnM/iG2Zwx/K68uqxL2LGT7Lrz/15v3melpzH4u/9OXc8vKr8enpg2cc2YFI7PDjT04knX9/MwmffYOHsC5g2YTRNzVnqGhpLr6h2RAWtNE70HdLpQ0/W1bPw8XUsvOkSpk06iaaDrdS9W8bXUJJVSJ/BFTSyOLENGP2HdfpJ9v7OJmbds5IlN86gX03wKXTDFydz+/J1pdWRrEIGjqy0pSZi0n9E8NX/dt7fsYdZP32EJbdcRr8+GQBuuPhsbn+ojK2YJKCv+4DF9hvNenAP+uiPo/uqQkdS1ci0byBDx7mrw5RMGzei6x8C32EvG0ki076DdH0o0nu/0Sx9BkD1cW4rUR8Gn+i2DlO6gSe6/WAF6DOwu3BFIrYBA+CkT3e4qxCZkeORbg6oTc+TVBoGnuCugkQKRk52V35hVT1SS5nkxCmQcNTEVAY56Sw3ZZuKyahJkHR3lk+Gj3dWdqF4B2zACBgyFifXKzJ9YdSE6Ms10Rg2IfglsKhJAoaMK/dn3EoW64AByJSZ3V4XKVkqjUy9JBa//Go6Jolk8MOhUYdMEsgp50dbZhdiv4bJwJEw+vToQiYJqB0Oo06LpjzjzvDToHoAke3BJFIwchLSZ1D380Yk9gEDkLMug8xxRPJGp9LIOV+v5OeUTQ8RSSBnXBbNVkwEqvsjp15QeVklODoCVpVBPj8HqjJUFLJkGpk2K7gEYI4K0mcgMvnPuuzV030hElzznHplj581ju2F5g5n3teIPvFzaNnX7VdZ2pBEcNbwc7ORIXbd62ikuzah6xaH334oYbWRZLDlOvMqpKa21GqPrd+mh+D3GvS5RcHfFRXzVZNUGvoNRc69Duk7sJw2mpjQAx+idfdDy97iln0iBYPHIadfhKQy5VR57AXs0BMb30PXPgS7t0KiCryWww+mMsEW7rhByBkXBxeU7ZirV1BV2LEBfXsltDYFW6jC73UlM8GvUdWOQj75xaBfY/mO3YAdKiB7EHbUo7s2Q6452BUcMAKGfgKp6RdFG01Macs+2N2A7m8MtmipaqR2JAw8odwtVnsWMGMc6r2dfY3pDSxgxjhkATPGIQuYMQ5ZwIxxyAJmjEMWMGMcsoAZ45AFzBiHLGDGOGQBM8YhC5gxDlnAjHHIAmaMQxYwYxyygBnjkAXMGIcsYMY4ZAEzxiELmDEOWcCMccgCZoxDFjBjHLKAGeOQBcwYhyxgxjhkATPGIQuYMQ5ZwIxxyAJmjEOV/WFtc6OiXvBnd+pD3kPVp/20Q8PCm3rox6blg6HvQz4flOHn242Hj/l+cPM8yHnB0PPQgvE20738oVveV9TX4P5HQy9P3tNw6JPPeeRzHn44PDze9jE/5+N5Pn4uj+/5eDm/zdDP+fh+Ht/Pk4Mub144/IGjv5Sq/vRskpkaUukakunqgvGacDxDqioZ3NJJUlWJj41n0klq0kn6pJOkU0lqqoLxmoJbdSpJdSpBJpUgk0wcGq9OJcgkk6RTQlVCSCUKhwTDZHA/4efAzyF+FvGykPeDcT8LXjBdsy1oa0swzLagrc0F4y34ra34LVm8lnDYnG17vyWL1+LhNXvkwqHX4uFn/Y+ma67Vp9nP0+xreAvGW/L5Q/d/nm/o9G+OevYfoU2xXP0dp/0fWw+zXURjHLKAGeOQBcwYhyxgxjhkATPGIQuYMQ5ZwIxxSVXLvgGzKnl+lLe4tCUu7TiS7Y9LGXFoS6VbsFkVPj9KcWlLXNpRrijaH5cyoiqn7DJsF9EYhyxgxjhUacAWRNKKaMSlLXFpR7miaH9cyoiqnLLLkPAgzhjjgO0iGuNQUQETkS+JyAYReUdEbu7g8YyILAkff0lExkbd0GLaUTDfpSKiInKmi3YU0xYROUFEnhKRdSKyXkRmuGpLJURkkIj8n4hsDIcDO5lvroi8LiJvisjPRERKLSOct7+IbBWRO8P7Fa9bUa0XTpZpEdcAksC7wMlAGngFmNBunuuBu8Lxy4ElDq7PdNuOcL5+wLPAi8CZUbejhPdkAfDNcHwC0OCiLRG8lrnAzeH4zcC/djDPZ4Hnw9edBFYB00opo2De24H/Bu6MYt2Kar1wtUyL2YKdBbyjqvWqmgUWAxe1m+ciYFE4/hvgC4WfcBEpph0AtxIs8JaI6y+1LQr0D8drgd87bE8lCpfdIuDiDuZRoJpgxcsAVcD2EstARKYCw4DHw0lRrFtRrRdOlmkxARsFbC64vyWc1uE8quoBe4HBRZRdim7bISJnAGNUdVnEdZfcFuCHwJUisgV4DLjBcZvKNUxVtwGEw6HtZ1DVVcBTwLbwtkJV3yylDBFJAP8GfLdgchTrVlTrhZNlWkzAOtoStT/1WMw8leqyjnAB/hT464jrLbktoSuAhao6GpgB/CpsY48TkZUi8loHt44+6Tt6/h8A1xB8Ym8Fvi0i9aWUQbCr95iqFq7EUaxbUa0XTpZpMb/JsQUYU3B/NB/fNH40zxYRSRFsPncVUXYpumtHP2Ai8HS4BzEceFRELlTVl3u4LQDXAV+CYAsgItXAEGBHxG3plqqe39ljIrJdREao6jYRGUHH7ZsJ3K6qt4bP+QHQoqpzSyjjbOAcEbkeOI5gd7M/wS7jR8pZt6JaL9ws0yIOglNAPXAShw/+Tms3zxzaHoje7+BgvNt2tJv/adyd5CjmPflf4JpwfHy4sMRFeyp8LbfR9gTF3A7muQxYGb7uKuAJ4E9KKaNdedcQnOSoeN2Kar1wtUyLXQgzgLcJzrJ8L5z2I+DCcLwaeAB4B1gNnOxoZeiyHcW8kT3VFoKzTM+HC6oOuMB1WMp8HYPDwGwMh4PC6WcC94bjSeBu4E3gDWBeqWW0m/8a4M6o1q2o1gsXy9R6chjjkPXkMMYhC5gxDvWKgInIxSIyoYznqYj8quB+SkQaRWRZwbQvi8jLYReht0TkJ+H0H4rITdG8gmPPsfLe94qAEfQcKDlgwAFgoojUhPenE1znAUBEJhKc7bpSVccTnO6tr7CtJnBMvPexDZiIPCwia8IOprPCafsLHr9URBaKyGeBC4HbRKRORMaJyGQReTHskPlQV51PCU69fiUcvwK4r+CxvwH+UVXfgqAngar+IsrXeYzr9e99bAMGfF1VpxKc6r1RRDrseqWqLwCPAt9V1cmq+i7wn8DfquqngFeBf+iinsXA5eFFw08BLxU8NhFYU/lLMZ3o9e99nAN2o4i8QtD7eQzwiWKeJCK1wABVfSactAg4t7P5VXU9MJbgE/SxShpsSnMsvPexDJiITAPOB85W1UnAOoILjoUX7apLLHNMuAtZJyKz2z38KPAT2u6iALwOTC2lHlOyXv3exzJgBP3NdqvqQRH5JPCZcPp2ERkfdrCcWTD/PoI+Z6jqXmC3iJwTPnYV8Iyqbg53ISer6l3t6vsl8CNVfbXd9NuAvxeRUyDoOCoi34nsVRro5e99XP+AbzkwW0TWAxsIdhMh6Oe2jOBrBa8RdBqFYF/+HhG5EbgUuBq4S0T6EJx5urarylR1C8EXAdtPXy8i3wLuC8tS4LcVvjZToLe/99ZVyhiH4rqLaEyvYAEzxiELmDEOWcCMccgCZoxDFjBjHLKAGeOQBcwYh/4f2x+N5/hw2ToAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -807,12 +807,12 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -831,12 +831,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAANgAAACUCAYAAADxuuf6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAUYElEQVR4nO2deZQdVZ3HP7+39Z50J+lAlmYLBCIhEAKEcQPHqEAQEPGAiig4h0EZcOQIMoqCMs4B9HAExgkoQhAVRFmEDBNghpEhsigkIYtk6wBJZ+t0p7fX/V6/V1V3/qhKp7vTy1vqJo/k9zmnTt26det3f1V1v1X33rpVJcYYFEWxQ2R/O6AoBzIqMEWxiApMUSyiAlMUi6jAFMUiKjBFsUhsP+evzwiUUkaKNaB3MEWxiApMUSyiAlMUi6jAFMUiKjBFsYgKTFEsogJTFIuowBTFIiowRbGICkxRLKICUxSLqMAUxSIqMEWxiApMUSyiAlMUi6jAFMUiKjBFsYgKTFEsogJTFIuowBTFIiowRbGICkxRLKICUxSLqMAUxSIqMEWxiApMUSyiAlMUi6jAFMUiKjBFsYgKTFEsogJTFIvs7/+DFYUxBlItmI4m6GoCpxciUaiYgIw9DGomIdHE/nZTsYDxXOjciml9FzqawM1CNA5jpyLjDoexU5BIdH+7iRizX/+BV1Dmxhhoa8RsetkXlfHAuAMTRRJ+3CGzkMmnIrGyMPxV9jPGczFblkHjS2AMeI5//ncjEYjEQASO+igy9eRihFb0D/jedwIz2R7M2qch3Q5edvQNJAoSQaZ9Cqk7shAflRLBJJsxSx8Ft9e/Y41GJA6xBDL7EqTmkEKyPLgEZnpaMGueAied76b+VW3yXGTSbESKPm7KPsa0bMCsfDI3YQ0mEkdOuACpPybfLQ+eX8iaVBvmb38AJ0VBNUvPga2vY7a9Gbpvil1M60bMiicKExeAl8WsfBLTsiFcx3LgfSEw42Ywa5/KrUo4Ep4DW/6KaX8vHMcU65ieNsyKx/1zVwye44usZ1c4juXI+0Ng770E2VRIxhxM42KM0xuOPcUaxhhfXG6R4tqN62De+gP7sllU8gIzqTZoXb93L2ExeK5WFd8P7FwHqTYK7GweAgPpDmheG5K90Sl9gW1eMrAbNhSjLux4C5PtCdeuEhrGeJh1LxTe7hoON4tZ9wLGC7lMDUNJC8z0dkHHZsK7gvU3bjA7VoZvVwmH1ncgm7Zj2+mF1n3T4VHaAtvVSAg9pcMYd6F1jR3bStGYbSvBzdgx7mYw21bZsT2IkhYYLW+DCamBOxSZbky6w559pSCM50HLeruZtDT6w60sU7JjEY3nQKq14O03bmnh3x58no5kit/f9tWhE4lAZxOUjy04H8UCyWYKrbl0pzJcfc/TJGJRzjjxSL748ZOGTigCXTtg7OTC/cyB0r2DpTv80RcjsODxl7n6jsf6lr937yIuu/lXABw1ZQL33/SFkfPwHEyqpWhXlZDpGfnCuuCZ17n67j/2LX/vwRe47LbfA/DEktV89iPH8/PrPsMzr47SBOgu/AKeKyUssLZRk3x5/lwWvbyK9q4eFi1ZxbN/Xs19/3JJfvl07yzQQcUWJtk8Yvvry5+YzaLX1tKeTLHotTU8+/pa7vvmBQBsaemkod6vkUQjI9wF3QymuzlUv4eiZKuI9HbCKHXkyvIEl3xyDjctWMTiV9/muXu+TkV5nq+nZLqKcFKxwih3lsryBJd8bBY3PfACi/+6juduv5yKsjgAUyaMoamlk5OOnow32gPlg/oO5rnA6M8qLv/06Sx4fAl3fvNCpk2t74tv7ejma7f9juXrmrht4fOj5KOUFDkMi7r8U3NY8Mzr3Pm1+UybPL4v/sIPH88TL6/m63f9kXNPP25kI2E/YxuC0r2D5djGvfWXi6mvq8ZxB4px/NgqFtx4cXgZKSXFrb9+kfraqr3Oe1VFggeu/2xuRvbBWxWleweLxP13uUbgzt+8SDqT5dEfXc49v/tTgfns/7delUGM8hb6nb9fQjrj8OhNl3DPk69YyycMSldgZWNHFNiLb6xj4aLXWfj9SzlzzjF0dqdZvq4p/3y0i74k2Nqe4rG/buLa3yzl7OfGcPHyWfy5be9z8+KyRhY+/yYLb7iIM088is6eXpZv2FpAjgJV9aMnK5LSrSJW1DHcEKlN23dx5Y8e4Zk7/5GaqnIArrn4TO569E88+P1L88uncuKwq7KuR2cqS2cqS0fKoTOdpbMnS0c62xffmXZwPY8TptZy8WkNxCKle80qJTxj+NvWTl5et5Ml61tobE4OWN9BOTevP5rfnbSC8Qm/rbSpuZ0r73ySZ/71Mmoq/U9AXPOZD3LXE6/w4A0X5edANI5UTwhlX0aiZN9oNsbDvLEg/IG+/YnEkSPORCbsaQw7rsc//XopK5ra8fI8NBfOmcoNZ4/SsD5I8YyhsTnJ0vfaWPpeG8s2tdOZGr2T4WcfeJvZYyz09EYTyClfGu1TAkU30kr2DiYSwVQdCslCbv85YjwY0zAg6tZn/sbyze0FmXtu1TauP+tY/SQB4HqGDc1dLHuvnaXvtbF8Uxud6fyGvVVGXY6sCOk9wMGIQPXwtZewKFmBAUj9DEzPzuLfZB6O8jokUTUgavWWwscmTqgu22/i2rRpE6+++irr16+nvr6eK664gng8vs/ydz3D+h1dLNvUFgiqna48BdWfKVWG6xs2UBu3MRZVYOKMfXKuSlpg1B4J7/7Jjm2JQf2MvaKnTaymqa2wq2ZZLMovXmpk1tRaZk4dS1XZvjm8S5Ys4bzzzuOMM85gxowZ3H333TQ0NHDOOedYya8jlaWxOcnGnUkam5NsaPbnPZninikee2gNH5lez4ePmcD08g5YvhxsPKaMxpBJMy0Y3puSFpjEKzATjgtG1YfcFotEkPrj94q+5fyZfP6+V9nekf+7SOt2dLFuh99eiIgv1umH1NAwrrJvmjqugspEuId9w4YNnHbaacybN4+5c+eyceNGOjs7i7abcTzeben2RRSIqbE5yc6ucD63UB6PMPuwuj5RTRxT3rfOmBpM5Xjo2h5KXgOoqIPahtHThUBJCwxApszFtK4NV2CRGEyZi0T3rkJVJKI8fvWHuPO5tTz+ZgHd/gGegfU7kqzfkdxr3fjqBA11ewS3W3yTxlZQWRYlkmfVZf78+SxevJg77riDW2+9Nadteh2X1q4MO5O9tCZ72dnVS2syQ0tXLzuTvTR3pmnalcINsROsIh5lVsNYTj68jpMPr+O4SWOIR4fudRUROPYTmKWPFP/Bm/5E4sixn9xnVfnSF1iiCnPobNi+LLwDHStHJp4w7OpoRLj+7OOYMXkMtz/7Nlk33J7W1mSG1mRmyM4UAarLY1SVxagOpqpyf14zKF5EcDwPxzXMv/Y2NrVf12dn8cptbK1bS9b1cDxDxvHY1Z2hNdlLS1dv3h0OhVCZiDKroZaTD9stqBpiwwhqKKS2AVN3OOx6N5xvskgUaqcidYcVbytHSl5gADLlNP9Taz0t5DI+cUQiMWT6uTl9TvncEydz2LhKvv2HFbR1Dz26e3x1gnTGpbvI9sduDNCVdgrqIGjcvqc7+8/rW1hTsTkUn3KlMhHlxIZaTj68jtmH13HcofkJaihk5nmYV+6DML6fEksgM88v3k4+We7T3ApEJALHnodZ9Ujw+bYCRRaJwZHzkMrcn+DPaqjlwStO4/rHlg9Z3WtNZrjlguM5ZmINKza3s6KpnRWbO9jSbql7eRiM52H6VaM9z8EYY6UqFBWhYXwl0yZWM62+iqMnVjNtYjWTaivyrt6OhsQr4OQvYN54qLjBudE4MvvzSKIyPOdyoGQfNA+ZONvjfzo73Z5/lSESQ44+G6k9Ir/tAlIZlx8+vZr/XbP3O0Rf+dARXPWxowfEtSZ7WbOti827emhq6/Hnu1Js60jl/QB7NLLdHay4+woiTpoHHniAxYsX89hjj1F11ClM/+IPirJdX1PmC2liNUfX+/PDJ1RSFtu3YzhNcifmzd/4n03Pqz0egXg5MucLSP7PvQ6ub9OD/ykB886LsKsxENkoJiJxiFcgx8xHKosbGuMZwy//byO/fPmdAfH3XjaHkw6ry8lG1vXY2p6iaVeKzbt6+gkwxa7uXtLZ/O/One+upHzpw9x///19calUio9+/JOcetMfh9wmIjC+uozx1QkmVJf5U00ZE6oTwbyMSbUVjK3Yd8/SRsP0Jv3v03duz+3ZaCQONYcgsy5EyqoLyfLgE1jfhj2tmE1L/P+CRWID34CNxP2rXKwCafggjJ8ealXplQ0tPPzKu2Rcj8+d0sBZJ0wKzbbjenT3OiR7/XbY7nAyPWje67fR4tEIxunlt7d/i7YdW0FAEERg7sfO4nP/8A3i0QixiFBbmWB8dYL6mjJqKxMjv/Fbwphd7/nfTOxu2fvcRxP+O35V45Hp85BxRxST1cErsD4DbhaS2zDJ7X0/4JPyOhgzFSmrCcNHpUQxmR5o34Tp2gFOxh9fWHMI1B0WVltLBaYoFjl4fl+kKO9HVGCKYhEVmKJYRAWmKBZRgSmKRVRgimIRFZiiWEQFpigWUYEpikVUYIpiERWYolhEBaYoFlGBKYpFVGCKYhEVmKJYRAWmKBZRgSmKRVRgimIRFZiiWEQFpigWUYEpikVUYIpiERWYolhEBaYoFlGBKYpFVGCKYhEVmKJYRAWmKBZRgSmKRVRgimKR4v7RnNppMI7/wzPjgudgjMvgOIwXxA2cTF/YHbjedcHz/HjXGxQO1rmuPzkOZB1/7vjbmv7LQdg4LsYxGNfDOB6eYzCOh3GDeb84z3Hxsg5e1sEN5nvCe9Z5jovruLhZF8dxcbNeMPfjnf5z1yMLI05OMPeAWyz8Vqr81KuIllUQS1QQTZT3C1cE4TJi8SiRWIRYPEosHiGWiO4Jx6MkElEqElEqE1EqEjEq4rvDe6byWJTyWISyWISyaKQvXB6LUBaNkogJ8YgQiwhRwQ9H98TFI0LEuIibRdwMOJm+sL/sh00mjelN+/NMGtOb6hdO4/b24qYzOGl/7macYDmDm+7FSWdwUlmctIOTcsgGcyft7I4z2V6XlOuRck0w+eG05/UtuwbuNe8O+auj98VP0A9SbPx+Uv/Hto/RKqKiWEQFpigWUYEpikVUYIpiERWYolhEBaYoFlGBKYpNjDEFT8CVxWwf5lQqvpSKH/vT/1KxUQq+FHsHu7LI7cOkVHwpFT8KJQz/S8VGWHYKtqFVREWxiApMUSxSrMB+HooX4VAqvpSKH4UShv+lYiMsOwXbkKARpyiKBbSKqCgWyUlgInKWiKwVkQ0icuMQ60VE7g7WrxCRk8N3dXQ/+qU7VURcEbnIhh+5+CIiY0XkGRF5S0RWi8jltnwpBhEZJyIviMj6YF43TLpvBvuxSkQeEZHyfG0EaaMiskxEFgXLRZetsMqFlXOawzOAKNAIHAUkgLeADwxKcw7wX/jvMJ0OvG7h+cyofvRL9yLwLHBR2H7kcUy+A9wehOuBXUDChj9F7ssdwI1B+MbdPg9KMwV4B6gIlh8DvpKPjX5prwN+CywKo2yFVS5sndNc7mCnARuMMRuNMRngUeD8QWnOB35lfF4DakVkUg628yEXPwCuAR4HmkPOP19fDFAjIgJU458Mx6JPhXI+8FAQfgi4YJh0MaBCRGJAJbA1XxsiMhWYD9wfRIVRtsIqF1bOaS4CmwJs7rfcFMTlm6ZYRs1DRKYAnwHuDTnvvH0B/h2YgV8QVwLfMMZ4lv0qhEOMMdsAgvnEwQmMMVuAnwCbgG1AhzHm+XxsBPwUuAH/qwgQTtkKq1xYOae5fDJgqFfXB3c95pKmWHLJ46fAt40xrn+RsUYuvnwKWA78PTANeEFEXjbGdNp0bChE5L+BQ4dY9d0ct68DbsYvgC7waRHZDHTkYeNcoNkY86aInLk7eoik+ZatsMqFlXOai8CagIZ+y1MZWD3INU2x5JLHKcCjwUGcAJwjIo4x5qn94MvlwG3Gr7BvEJF3gOOAv4Tsy6gYY+YNt05EdojIJGPMtqDqNVQVah7wpDHmq8E2lwGnG2O+noeNDwHnicg5QDkwBr/89S/YhZStsMqFnXOaQyM4BmwEjmRP4+/4QWnmM7Ah+hcLjfFR/RiUfiH2OjlyOSYLgFuC8CHAFmCCDX+K3JcfM7CD4o4h0swFVuO3vQS/nXVNPjYG2TsTv5Oj6LIVVrmwdU5zPQnnAOvwe1m+G8RdBVwVhAX4WbB+JXCKpcIwoh+5HMh95QswGXg+OB6rgEv3hWAK2I/xwP8A64P5uH7+P9sv3Q+ANcG+PAyU5WujX/ozgUVhla2wyoWNc6ojORTFIjqSQ1EsogJTFIscEAITkQtE5AMFbGdE5OF+yzER2bl7GE8Qd7aIvCEib4vIGhH5SRB/i4h8K5w9OPg4WI79ASEw/JEDeQsM6AZmikhFsPwJ/J4hAERkJv7DxUuNMTOAmfg9TUrxHBTHvmQFJiJPicibwaDKK4O4ZL/1F4nIQhH5IHAe8GMRWS4i00TkJBF5LRgc+uRIg0/xu4DnB+HPA4/0W3cD8CNjzBoAY4xjjPmPMPfzIOeAP/YlKzDgCmPMHPyHhNeKyPihEhljXgGeBq43xpxkjGkEfoX/5H4WfpfqzSPk8yhwSTA6fBbwer91M4E3i98VZRgO+GNfygK7VkTeAl7Df8J+TC4bichYoNYY81IQ9RDw0eHSG2NWAEfgX0GfLcZhJT8OhmNfkgILxqrNA/7OGHMisAx/eE3/h3blQ2w6ks2GoAq5XESuGrT6afzBrI8Mil8NzMknHyVvDuhjX5ICA8YCbcaYHhE5Dn+IDMAOEZkhIhH80dG76QJqAIwxHUCbiHwkWPcl4CVjzOagCnmSMWbwqOoHgB8aY1YOiv8x8B0RmQ4gIhERuS60vVTgAD/2pfoDvsXAVSKyAliLX00Ef5zbIvxR3avw38kBvy7/CxG5FrgI+DJwr4hU4vc8jfjmqTGmCbhriPgVIvLPwCOBLQP8Z5H7pvTjQD/2OlRKUSxSqlVERTkgUIEpikVUYIpiERWYolhEBaYoFlGBKYpFVGCKYhEVmKJY5P8BQmXicSUT1A4AAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -863,7 +863,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -875,7 +875,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ diff --git a/tutorials/tigramite_tutorial_pcmci_fullci.ipynb b/tutorials/tigramite_tutorial_pcmci_fullci.ipynb index 7f7d4de5..9dd0aecc 100644 --- a/tutorials/tigramite_tutorial_pcmci_fullci.ipynb +++ b/tutorials/tigramite_tutorial_pcmci_fullci.ipynb @@ -162,7 +162,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaMAAAD+CAYAAACX8mppAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3deZyT1b3H8c+ZhZ0RZARxRSuuQamio1OJDrUtEq0LLrUpdWnxaqneaW9vF3v7am+tbW9t67RKa8VaK6ZFLYpKlKISjZo6WkUhCqJ1wRYUKeCwDzN57h/nCWRCMsyS5Jkk3/frNa+Q85w885sweX5zznMW4zgOIiIiXqrwOgARERElIxER8ZySkYiIeE7JSEREPKdkJCIinlMyEhERzykZiYiI55SMRETEc0pGIiLiOSUjERHxnJKRiIh4TslIREQ8p2QkIiKeUzISERHPVXkdgEgpWT21fhjgB450i5YD0dFzYxu8i0qk7zPaz0ik91ZPrd8f+AlwMbANGOge2goMAO4BvjN6buxf3kQo0rcpGYn00uqp9ZOAeUB/oF+Waq3AduDc0XNjiwoVm0ix0D0jkV5YPbX+LOBhYCjZExHusaHAw+5rRCSFWkYiPbR6av3BwKvA4G6+dDNwzOi5sXdzH5VIcVLLSKQHVk+tN9j7QP178PL+wBz3HCKCkpFIT50MHEPPRqRWAT6gLqcRiRQxJSORnvkcu0bM9cQA9xwigu4ZiXSb2732AbBPL0+1Bth39NyYPoRS9tQyEum+j5OlVfTHt97nO4vf2vn8/15dyTUvvJHtPIOB8TmPTqQIKRmJdN9pQHWmAxcetA8L31/PR61tPLZ6PY+/v56fHX9otvNUuecSKXtaDkik+/Yiyyi6QVWVnHtALT99bSWR9zcw59SjGVhZme08/dxziZQ9JSOR7hvW2cHPjRnJaY+9zB9OPoIxQwZkrbe8Zox54KBJU5c2RauApUAcWBFp9LflNlyRvk/JSKT7Nnd28KZl7zGifxXtnQwOSmC48ZjL2Fo1YBwwLuVQa0NTdBk2MS1NeXwv0ujXQAcpWUpGIt3XArSR4fNz6xur2J5w+N1Jh/PzZe8xZf8RGU/gYBjUtpWtVbu1nPoBx7lfqdY2NEWfAZJfiyON/tZe/hwifYaGdot00+qp9ZOxqy/UpJY/s+YjvrfkbR4+bRxDqiv51BOvcNMJh+Eblnm1oA/7D9v466OCD/1j6IFDsZNgs450yGAr0Myu5PRcpNH/UU9+HpG+QMlIpJtWT63vB6wHBiXL/rllOxdEX2V2/ZGMrbHF97y7hr992ELThMOynWoLMHz03FgrQENTdAh2VQcftusu+TiyC2E5wBLgaWxyejbS6P9nD348EU8oGYn0wOqp9X8Bzgd6ur6cA8wdPTd24Z4qNjRF9wVOAU51v46na13s77Cr5fQMsCzS6E/0MF6RvFIyEumB1VPrzwFmY7eF6IkWYNroubGHuvvChqboYOAkdiWnemBIF166HogA9wPz1a0nfYmSkUgPLLvkM2MrncRS4zj9B7dt6UnzaA1w8Oi5sW29jaXBDg0fx67kNBEYvYeX7QAexyamByON/g97G4dIbygZiXRTPBjYD3tv5lCAwTs2M6C9WwPbtgCB0XNjT+Y8OKChKWqAMexKTqcCR3fykgQQxSamB3SvSbygZCTSDfFgoBZ4ipSLe832lq3VTntXV/DeDNw8em7sO/mIL5uGpugI7NJD5wKfpfOVH5qxien+SKP/zQKEJ6JkJNJV8WCgBlgEnLCz0HG+OmL7hv2ARlJG12WxBWgC/sfLlbobmqL9gAbsAIxz6Xy03hLcxATENfFW8kXJSKQL4sHAIGAB9n5M0nW+UPgnsHNAw2+wAxqGsGuUXQLbGtoIfGX03NiDBQu6CxqaopXAJ7CJ6XzgwE6qv4FNSvdFGv0vFiA8KSNKRiJ7EA8G+gEPApNTin/qC4U7dLWtnlpfDZwJTMFuMwGwGHgEeHT03NiOAoTbY+69pgnYpDQVGNtJ9b8DM4F7Io3+rQUIT0qckpFIJ+LBQBUwB3txTvoN8FVfKFyyHx43MR3DrsR0bJaq64DfA7+NNPrfLlB4UoKUjESyiAcDlcAdwBdTimcDl/lC4QRAtK7+YuwGeTf6m2PrCh9lYTQ0RQ8DzsNulX58hioO8Ci2tbRAk2ulu5SMRDJwu+buBlJXSHgAuMgXCrcBROvq7wAud4+1AHv7m2PtBQ3UAw1N0ROBGdjElGlfp7eA3wJ3RBr9JZugJbeUjETSuIMV/oK9/5O0EPisLxTeDhCtq78AuC/tpSf7m2PNhYnSew1N0VrgCuBq7LymdNuAPwMzNeBB9kTJSCSFO3z7YcCfUvwg8DlfKLwNIFpXfzLwJLu3Ck7zN8eihYizL3FH5J2JbS1NzlKtGduFd1+k0d/rVSek9CgZibjiwcAI7PDtCSnFIeByXyi8AyBaV38o8BywT4ZTTPY3x/6a90D7MPfe0tXYFlOmHXHXArcDv4o0+t8vZGzStykZiQDxYGA08Bh2BFnSrcCMlMEKw4EYcGSW01zob479Ja+BFomGpugg4BJsa+njGapsAX4F3Bhp9K8vZGzSN1V4HYCI1+LBwCHYLRZSE9HPgK+kJKJ+2Amf2RIR9HwF75ITafRviTT6f49dreIU7GCQ1AX8BgHfAd5uaIpeN+bTl44yxvzKGPOKMabVGLPKGNPZenpSYpSMpKzFg4EjSVn01HWdLxT+Vto8opuB0/dwuq5s41BWIo1+J9Lofy7S6J+GXd3hf7BbWSTtBdwwePQhr59yyinXPv/888d+9NFH1Zdffvlo7NYYUiaUjKRsxYOB47GJaP+U4muSS/wkRevq9wW+3IVTqmXUiUijf02k0X8DNvH/CLtMEgD9h4/a68033+S8884jFApRUaFLU7nR/7iUpXgw8AnsRnO1blECO5n1lgzVNwJdmT+kZNQFkUb/hkij/3vYpNQEtO415hjGXPFzWmvHkryPvc/4hhMamqK6RpUJ/UdL2YkHA5/GzhuqcYt2ABf6QuE/Zqrvb45txq4+EHFfl4266brBbSl9DbsG3u8H7zumvXrIrp0thh8x4SrghYam6GR3eSIpYUpGUlbiwcB52HlEye0etgJn+0Lh+zt7nb85FvY3xyYBr3dSbVluoiwvkUb/ykij/8vAMa0t69L3Tzoeu8zQUw1N0VMLH50UipKRlI14MPBF7KoJ/dyiFuDTvlC4O3ODGtKeXw88j53QeUevgyxjT37ttJPXLn26Jfl87dJnWLf8heTTicDTDU3RcENT9DhPApS80jwjKXnxYKAC+C7ww5TitcBnfKHwS109T7Sufh9gTUpR2axHl2/GmMNHjx79+tVXX82UKVNYvXo1ixcv5gfX/ygx8f8WVhjToZcuAfwS+H6k0b/Fm4gl16q8DkAkn+LBwFDgLuyOpkmrgDN8oXB3u9X8ac+jSkQ5s2Xr1q0sXryYxYsX7yx02nZ8iJO4FFP5Y3atFl4BfAM4v6EpemWk0f+EB/FKjqllJCUrHgwcDswDjkopXgac5QuF3+ru+aJ19bdgVxRI+oa/OfaL3kUpScaY8XSc7wXwkuM477gDGKYCvwAOSqtzB/ANreRQ3JSMpCTFg4EAdl25vVKK5wGX+kLhlsyv6ly0rj5Ox1UaTvA3x7rczSe919AUHQLcAFzDrq3dAT4AvgrMjTT6dVErQkpGUlLc+0PXYe8PJS9WDvB94Ibk8j7dFa2rH4m94CVtAGrVTeeNhqboydgFV49JOzQPmBFp9K8qfFTSG0pGUjLc+0N/xM4JSmoBgr5QeH5vzh2tq78QuDel6CF/c+yc3pxTeqehKdoPu77dd4HqlEMtwH8Dt2vH2eKhod1SEuLBwFjs1g6piWg5cFJvE5Hr9LTnT+bgnNILkUZ/a6TR/7/Ybd//lnKoBvgd8ERDU3SsJ8FJtykZSdGLBwNTgBeA1FWeHwTqfKFwZ5NUuyN9flEkR+eVXoo0+l/DzkO6BtiUcuh0YElDU/RbDU3R6kyvlb5D3XRStOLBgMHeH7qejjezvw/8qKf3h9JF6+pHAakbwa3H3i9SF1Af09AUPQi7D9WZaYcWA1+ONPo14KSPUjKSouTeH7oTOD+lOCf3h9JF6+ovAu5JKZrnb46dl62+eMsdBn4JdvO+2pRD7djVwq+PNPo18KSPUTedFJ2U+0OpiSiX94fSpXfRPZmH7yE54u6h9Cfs/LK7Uw5VYlvN4Yam6AhPgpOs1DKSouF2y10C/IaO84ceBL7Y0/lDexKtq19Gxx1ej/M3x5bk43tJ7jU0Rc/EDmg4MKV4JTA10uj/uzdRSTolIykK8WBgFPBbOo6WgxzfH0oXrauvBT5MKfo3MFL3i4pLQ1N0b2A2MCWluBU76GGWJsp6T8lI+jS3NXQRdlXs1K6Vj4BpvlD44Xx+/2hdvR94KqXoUX9zbEq2+tJ3uRv1fRf4XzoOeLkT+Eqk0b/Vi7jE0j0j6bPiwcBI7JYPc+iYiB4Fjsl3InIdnfb8tQJ8T8mDSKM/EWn0X48dabcu5dBlQKyhKZq+Lp4UkJKR9EnxYOBC4FXs4phJLcCXgIAvFP5XgUI5Ku25NtArcpFG/1+xK4Cn3i8aD7zY0BQ9y5uoRN100qfEg4F9sF1yF6YdWgh82RcKv1fIeKJ19QuBT6UU1fubY3/LVl+KR0NTtD92+Pd/pB26AbtXkoZ/F5BaRtJnxIOBqdjWUGoi2ghMByYXOhG50rvp1DIqEZFG//ZIo/8q4HJgW8qh7wKPNjRFazO/UvJBLSPxXDwYqAVuBj6Xduhx4Eu+UHhl4aOCaF19DXagRNL7/ubYaC9ikfxqaIqOB+bScT+l94ALIo3+572JqryoZSSeigcD52FbQ6mJaBNwFfBprxKR68i05xq8UKIijf6XgQlA6qTpA4GnG5qiV7mrOkgeKRlJzhljLjHGPGWMcdyvecaYI1LrxIOBEfFgIATcD4xMObQIGOcLhX/nC4W9brari66MuDvFngP8D3YPLIB+2Pltv3aHhkue6M2VnDLG1AwaNOhP8+fP9y9fvpzly5fzy1/+8pyKioqnjTF7x4OB6ngw8FXs8j2fT3npZuArwKd8ofA7XsSegUbSlRl3+PcNwGewE5yTvgrcpdW/80fJSHLNARLXX389Rx55JMceeywTJkzgvPPO2ycwZr/vY7vkbqbjApZPYltDv83XSgo9pDlGZSrS6H8MO/z7lZTiIPBAQ1N0oDdRlTYlI8kpx3E2btmy5dzm5uazgarW1taFK1asYO+99+a42mHXAqmbnW3ELsfySV8o/LYnAXdOLaMyFmn0r8TuifRMSnEAWNDQFN0r44ukxzSaTvJm/yGDfjXq8COvvffeeznxxBP508TjOHDoYIA2bD/89b5Q+MPOz+KNaF39QOxAiuQfbBuAvf3NMX1gykxDU3QQdiWQ1GWgFgOTI43+Nd5EVXrUMpKciwcDtVMPO+jZmgMPvvbuu+/m/PPP54ox+yYT0VzgaF8ofG1fTUSuw+n4+VimRFSeIo3+LcC5wJ9Tij+OHWl3sDdRlR4lI8mZeDAwMB4MfPuO1/7x3tKKAfVz585l2rRprHx9OYOrq1as3Li5wRcKX+ALhd/wOtYuSO+i0/2iMhZp9O8AvoDdviTpcOCZhqZo+u+K9ICSkfRaPBioiAcDlwIrNmxv/ckf3n5/QCQSIRaLcfzxx3PhFy8l3N7v8MDDT43zOtZu0P0i6SDS6E9gR9X9KKX4AGwLaYI3UZUOJSPplXgw8CngJewy/AfYW5AOP/vZz1i6dCmDBg1i0KBBVFdXQ3H9vn0s7flyT6KQPsXdRfZ7wNdSikcAkYamaPqOwNINGsAg3ebuMXQ68G3g02mHt93zxrsP3PzKilc+at2Rut7XRuAex3E2FyjMXonW1S/AzjVJmuBvjr3oVTzS9zQ0RS8Ffo/dzhxgO/C5SKN/nndRFS8lI+myeDDQH7vtdyNwXNphB7gL+J5HC5rmVLSu/nngxJSiQ/zNsXc8Ckf6qIam6DnAPUB/tygBfCnS6L/Ts6CKlJKR7JG7yd3V2BUSRmao8hjw375Q+JUMx4pStK7+H3RcNLPG3xzb6FU80ne53XMPAUNSir8eafTf5B4fBmyKNPrbvIivWCgZSVbxYOBYbCsoiF2jK5UDPAzc5AuFnyxwaHkXravfACQnNu4A+mtot2TjDmBYQMcdia8D3sH2GHwAnBRp9K8qfHTFQclIOogHAxXYyX1fAyZlqLIZuAO4uUiGaHdbtK6+CpuAkj7wN8f29SoeKQ7uEO+F2BF2SYuxc5IAbow0+r9Z8MCKhJKRABAPBoYAlwL/Sccle5JWAr8Gfu8LhTcUMrZCi9bV7wOkzqx/zd8cO8areKR4NDRFD8KutXhIhsOrgYPUXZdZldcBiLfiwcBB2LkT04FhGarEgCbgAV8oXC4fohFpz/+dsZbI7tZgk9G+QPqCqqOxW9g/WuCYioKSURmKBwMDgTOxWzicy66hqUnt2LW4bvKFwuW4y6WSkfTUhdhtzLO5DCWjjJSMykQ8GBiAnTdzEfBZOo78SVoP3Abc4guF/1nA8PqavdOer/MkCilGb2GHd2eb4H1eQ1N0uLuRn6RQMspiw/TJFcBQoG3YrAVFMVEzXTwY6IedlHoRdgfLmixVV2C74u7yhcJF+bPmmFpG0iORRv+zDU3RScD1wMQMVaqBbwDfzXaOtdMmDcZemzfWzl7Ul/b3yislozQbpk8+A/vLcip2OLPZMH3yOmzT+sfDZi1Y4WV8exIPBqqBTwIXY7vgMt0HArslwv3YCXuP97FN7bymZCQ9Fmn0PwX4G5qifuB7wBlpVS4jLRmtnTbpcOxQ8DOxLXMHaF07bdIzwI21sxc9ke+4vaZk5NowffI+2Ivzx4HBaYdHYufaXLRh+uTfA18bNmtBn7mZHw8GqoAGbAvofHbvZkpqAR4A7sUmoNbCRFh0lIyk1yKN/ijwqYam6MnYkajJFT3eTNZZO21SFXAT8CVsqyn1mlyN7Vo/de20SS8B59fOXrS2ELF7QckI2DB98seAp7EXofTJnUlV7tcVgG/D9MlThs1asLVAIe7GbQFNxCagqXTcxjvVJuBBbAtooS8U3l6YCIua7hlJzkQa/c8BJ7ndd8cAMwHWTps0EHgEOIndR96lGgzUAUvWTps0sXb2on/kOWRPlH0y2jB98lAgAoyia6tKD8L+YtyNTQIF4Q5AOAnwA6cB9W4smWzGro5wL7DAFwp7ljSLlFpGknORRv8iYBHA2mmTDPYaUkfniSipH/YaFVk7bdLRtbMXbcpboB4p+2QE3IJtVXRne4OBwGc2TJ988bBZC+7JR1DuJNRT2JV86sjeagPYCoSxLaBHfKHwlnzEVSaUjCTfLsZ2wXUlESVVAPtgr1mX5SEmT5X1Cgwbpk+eADxF9hbGnrQAI4fNWtBp11c8GDgA+B/swpvf8oXCizPUGQ58gl3J5wR2n/+Tbit2Pax7gfm+ULjk/lryQoYVuw/2N8dWehWPlJa10yb1x06OzTa6dU+2AKfVzl7099xF5b1ybxl9gc5bG10xiSyT2NwtF76GTUTJQRFbgHPdlbAnYhOPHzgWMHv4Xi3AM0AUm0Rf0iCEvEgfWVhMmwJK3/fJXr6+H3ZAlZJRKdgwfbLB7s3Tm/dgKPaXYrdkFA8GzgR+xe7rvB0eDwbeAQ7uwvnXYhNP8muJLxRu70W8sgfGmKF3+o6r3H/AAPpV7MxBe2qhinTHF7DXjp6qAi5ZO23S12tnLyqZrq2yTUbYzeHSh3Dz+vpNXPTXl1h88UQqjCHhOFyw4EUuOmw0nxu7f3p1A5yzYfrkquRQ73gwMB57YzLbwppHdRLTKmyLJ5l8lvlC4ZL5ZevLjDFnAzcOHDjwiP/d3EL7myu4a9xxGGOgvD8nkkPuUO6zydILck1sGUvX7+ptX7O1lR2JBG9ctNv82SHY3pSS2UOsnD9k55Ohi+6I4UMYO2wwC1Z+yJSDR/LDF97gsL0GZ0pESQnsQIOn3e0XmjOdN4u36Zh83lLy8cyVt9122xENDQ0ceuihDBgwgDbHodomI7WMJFfq2b0beKeb63f9rfrupq2cvXAxv6zL+PdrP+w1TMmoBHwMO6lsN1/xHcxv4u/SlkjQ/MF6HgqcmKlakmHX/iUm2zlTvIudfb3IFwqv7mbMkj8vXXvttWdt27aNjRt329BVyUhy5QD2fG+Yddt3cPETr/BfvoOZfGDGKYTVdNyJuOiV843ZbMvkMOmAWlZt3sYPX3iDP3xyPNUVnb5NlbijYtz7OdcC7wHZRtgdDOyvRNS3OI7z/W3btg3FztFKV85/tElu1bCHP262trUTjCzhnINHcunhWXtkAIbnNDKPlfOHrNO/Tk4aNYxjR9Sw76D+3TqXLxS+BbjF7bI7GrvG3Sfcr0OwKyIs6mnQkj+O42xy7xGlU8tIcsXQybWnPeEw/elXOaxmEN8Zv8eGzx5bWMWknJNRp7uVvr5+E8HO/ypJascOue7AXXg07n7dChAPBmqBbZoPVHTK+XMiudUCZF3X8pvPr2CH43DTyUd05VwlteNyOX/I3sH+UmR8D5Zv2MRRwzNt+bMbB3i/KxV9oXDJLnJY7Iwxh2Png+2cEf/jt97k86P3Z+zgwWoZSa6sxl4zdnPjkrd5Zd1G5n1qPFWd3xoAe+16N9fBeamc7xk9CGzLdOCfm7ayV79qhlR3KVdXYSeiSnGbftlll0277777KgYOHMicOXM4Jvh55n6wGtRNJ7nzDBkGOa3ctJWfLXmH9dt3cNbCxZwefoHTwy/w5adfzXaebcC8fAZaaGW7HJC7ed5aencT0AEeGDZrQcEWTJX8MMb8x6hRo24dPnzXr0NLSwtTKiqZtt8Bn/Q3x3SfT3Ji7bRJ92P3GuvNPZ91wD6ltPle2baMhs1akMCu6dabFQ02ArNzE5F4yXGc333wwQdjli9ffvRXTeVD36nuzy9qR/GF0fuDWkaSW7Ox146eagfuLaVEBGWcjFx3k6WrrouqgL/mKBbxmOM47zqOs2zc0Jp1YwYOYr8BA7QCg+TDX+nd79Q27LWrpJR1Mho2a8EzwONknxPUmc3YHV+1V1DpSR/tpJaR5Ezt7EVbgK+TeU7bnmwHHqudvejZ3EblvbJORq4rsMMtu3PzbDvwHDArLxGJ19K7bpWMJNduw15DuvOHsIO9Vn0pLxF5rOyT0bBZC9YBZ2DH7Hfl/tFWYBlw/rBZC5x4MFAVDwaujgcDvnzGKQWVfoHYbUFdkd5wV9ueir2WdKV3pQ17jfpk7exF6/IZm1fKPhkBDJu1YAkwHliBXSEhEwe7F9HDwCnDZi1ITnR9DvgNsDQeDDwUDwYOz3e8knfp88ZGexKFlLTa2Ys+wi6y/DD22pKtd2YT8AYwvnb2oqUFCq/glIxcw2YtWAn4gOnAy0Ar9pdgM/YXZSHQMGzWgouHzVqQOughdV+is4Fl8WDgT2opFbX0dQOVjCQvamcv2lY7e9HF2E06F2KvNZux155W7LVoOuCrnb2opHcbLtt5RnuyYfrkgcB+2K6794bNWpCxCy8eDPwSu5trJg8A3/GFwq/nJ0rJh2hd/Wew27kn/cnfHAt6FY+Uj7XTJlUCB2LvU66qnb2obAZIKRn1krt9+Cqy3+ReC+znC4V3FC4q6Y1oXX36pmURf3NsklfxiJQDddP1ki8UXgOEO6kyAOjS0t/SZ6ibTqTAlIxy449ZytcAF2uV7qLzbzrONdrPq0BEyoWSUW7Mx17A0o0Evh8PBvYqcDzSC/7mWIKOI+pqonX1g7yKR6QcKBnlgC8UbgX+lFL0QMq/TwKejAcDowoblfSSuupECkjJKHf+F3gUu+7UlcB3U46NB56OBwMHZ3qh9Emr0p4rGYnkkRaAzBFfKPxvYEpK0Y/jwcBW4Jfu87HAs/Fg4NO+UPi1ggco3aWWkUgBqWWUR75Q+CbgciC51Pv+QDQeDJzoXVTSRUpGIgWkZJRnvlD4TuwaVK1u0QhgUTwYaPAsKOkKJSORAlIyKgBfKDwPOJNd694NAR6NBwPneheV7EF6MtLwbpE8UjIqEF8ovAi7/lRyCHh/YG48GLjMs6CkM2oZiRSQklEB+ULhFwA/8C+3qAL4QzwYyLa2nXhHyUikgLQ2nQfcId6PYUfYJd0AfM8XCus/pA+I1tVXYbd3Tq45uAnYy50QKyI5ppaRB3yh8LvAROzy8EnfBWbGgwH9n/QB/uZYG3YPmaQhdNwuRERySBc+j/hC4Q+A04GnU4qvBu6OBwPVngQl6V5Je36cJ1GIlAElIw/5QuGPgMl0XPX7EuBBrWfXJyxJe36sJ1GIlAElI4/5QuEtwHl0XNvuTOAF7RbrObWMRApEyagPcDfemwbcklI8FmiOBwOf9yYqQS0jkYLRaLo+JB4MGOwiq78G+qUcugX4L3d1cCmQaF29wc4LG+4WOUCNvzmm/alEckwtoz7EFwo7vlD4d8CpwHsph76K3YbiAG8iK0/+5phDx9aRAdR1KpIHSkZ9kDs59njsXKSkU4CX4sHAJG+iKlvp943UVSeSB0pGfZQvFF6LHcjwo5TifYDH4sHAt9wuPcm/9PtGGsQgkgdKRn2YLxRu94XC3wPOBja4xRXAT4H7Nfy7INQyEikAJaMi4AuF5wMn0HHFhnOBv8eDgXHeRFU2XmXXflQAx7oDG0Qkh5SMioQvFH4LqAfuTCk+DDv8+wueBFUG/M2xrcCKlKIatCyQSM4pGRURXyi8FbgC+A92bdY3EJgdDwZmxoOBfllfLL2h+0YieaZkVGTc4d+3YYd/r0w59BUgFg8GdE8j93TfSCTPlIyKlDv8+wRgYUrxCcCL8WDghngwMMCbyEqSWkYieaZkVMTc4d9TgB8C7W5xFXAd8HI8GJjoVWwlJr1ldIInUYiUMC0HVCLiwcDxwO+B8WmHfgt82xcKtxQ+qtLgjp5bBeybUvwxf3PsLY9CEik5ahmVCF8o/BJwEvAdYHvKoauB1+LBwNmeBFYC3GWBFqUVf9KLWERKlZJRCfGFwjt8ofBPsXryEi0AABFmSURBVDfYoymH9gceigcDc+LBwEhvoit6j6c9VzISySF105Uod/vyLwM3YufGJK0DvgbM9oXC+s/vomhd/UHAuylFHwL7+ptjiSwvEZFuUDIqcfFgYH9gJnBO2qGFwH/4QuF3Ch5UkYrW1b+BnWicNN7fHEsf3CAiPaBuuhLnC4X/hd1J9iJgTcqhTwOvxoOBxngwUJn6GmPMOGPM9caYOcaYu4wxVxtjBhYw7L5KXXUieaKWURmJBwN7Az8HLk879DxwjS8Ufh7AGLPxuuuuG+Lz+di+fTtz585l/vz5MeB0x3F2FDjsPiNaV38BcF9K0aP+5tgUr+IRKSVKRmUoHgycAdwGHJJ2aB7wvXF/eiQSDAZrlyxZwvDhw7n99tu5/PLLefbZZz/rOM7DhY+4b4jW1Y/A3itKLpS6Gdjb3xzTDrwivaRuujLkC4UfB8YBv6TjitTnAktumnj83x+6955Hly5d+nQ0GuXZZ5/l0EMPBSjrkXj+5ti/gcUpRYOxw+lFpJeUjMqULxTe7AuF/wuYACxIOWTOOHDfyf0rK8/8yU9+MnHOnDkMGTKEv/zlL9Bx59ly9UTa8zM8iUKkxCgZlTlfKLzYFwqfCZwGPJssHz6gH/Pnz2fevHkcccQRHHfccQBaXkiDGETyQslIAPCFwlFssgkseHfVW9/4+JFcMaCNVdEnuP3227nooos4Zd/aGfFgYKjXsXrsGXZt3wFwcrSufohXwYiUCg1gkA6MMYeNGDHijREjRrBixQpGjBjBnDlzuPvuuxm59Hm+eOQhHwI/Bm71hcLbvI7XC9G6+iexLcmkgL859ohH4YiUBLWMJF31gAEDaGpqIh6P88gjj7Bw4UIeve8ePnvI/gD7ADcBK+LBwJfiwUCVt+F6Ql11IjmmlpF0YIwxwAzsRNkjgdVVFea52Z865QPfiGHXYJNRqhXA9cB9vlB4O2UgWld/ChBLKVrib45pjyORXlAyki5z7xf9J/DfdFzvDuzqDrOA3/lC4fcKHVshRevqq7Br/KXeP9vX3xz7wKOQRIqekpF0WzwYGAF8E7gWSN9RNgE8iF0Pb1GpLsYarat/EPhsStF0f3Psdq/iESl2umck3eYLhf/tC4W/BXwMuyr4upTDFdguvsex+yhdEw8G0ltRpeChtOdTPYlCpESoZSS9Fg8GBgIXY+81TchQZTMwG5jpC4XjhYwtX6J19fsA77PrD7odwEh/c2yDd1GJFC8lI8mpeDBwEjYpfQ7ol6FKFLgFmOcLhYt60dVoXf0ioCGl6Iv+5thsr+IRKWZKRpIX8WBgH+AK7LbnB2eosgq7WOttvlB4dSFjy5VoXf0MbGJNetDfHDvXq3hEipmSkeSVu1fSFGxr6TMZqrRhVwu/F3jUFwpvKmB4vRKtq98P+FdK0TZgH39zrGh+BpG+QslICiYeDIzFtpQuB4ZlqLIN+CtwP/CwLxReX8DweiRaV/8sUJ9SdJG/OXZftvoikpmSkRRcPBgYDFyCbS2Nz1KtDViETUwP+kLh9wsUXrdE6+q/Dvwi+by62jx+zHHDngGOd4tewq52/reamaU5zF0kF5SMxDPxYMAAdcCFwPnAmCxVHewCpfcDD/hC4XcLEmAXROvqxwBvJ58PHFSZOOLomnag2i3aAWwHVgJX1cwMP13wIEWKgJKR9AluYvo4NilNxS5FlM3fsYnpfl8o/HoBwuvUCw0TX9i6pX0CwKjRAxi9/8BsVbcA366ZGb65YMGJFAklI+mT4sHAUdjEdD67urwyeRWbmOYBL/tC4UQndXOuZUbgG4mE84OWj3YMrqgwDK2pwi7vl9UW4Ps1M8M/L1CIIkVByUj6vHgwcAh2VYfzsYMFsl3tN2AXMH3G/Xohn9tctMwInAQ8CWRtCmWxFTitZmb4hZwHJVKklIykqMSDgdHAudjE1ABUdlK9Fdull0xOMV8o/O9cxNEyI9APeAM4kOzJMRsHeA8YWzMz3LqnyiLlQMlIipa7YOvZ2HtMpwNd2XH1NXYlp2eAd3qymGvLjMCZwBx2X728y6cALq6ZGV7Qw9eLlBQlIykJ7iZ/44BT3a+JwOguvHQVHZPTEl8o3L6nF7XMCNwNfJ7ut4qSHCBUMzM8rYevFykpSkZSktzReWPYlZxOBY7uwks3A3H3a2ny0RcKr0lWaJkRqALW07WWWGc2AnvXzAy39fI8IkVPyUjKhtutV8+u5HQiu+YD7cka3MQ0oIrW2sFcVWF2ba6XcBzG/P4xVn750wAsWdvCxHuf4cXP+zls2BA27Whjwp+e4u+fP40h1Tt3at8InFMzMxzJzU8oUryq9lxFpDS4gxcedr+SW19MYFdy+gSwV5aXjwQmAZO2tcGaTTijhkByFHeFMTiA4zgYY/jDqysZPbg/La220XPfilWcOWZUaiICuzHhBEDJSMqekpGULV8ovBV42v0iHgxUAIdi7z353MdxwFjSRu21JXa/VzSoqpItbe04wN9Wr+OsQ/Zl0w57++mPr73HzQ3j0l9STcety0XKlpKRiMudMPum+/VAsjweDAzArggxDvD1r+KsvfpzdPrc1qH9qti0o51H3v6A8w8bTWu7w8bWNl758COqKwzjajMOvFMyEkHJSGSP3ImzL7tftMwIbCfDYIih/arY1NrG3cv/SWjy8cxZ8S82tbbxh1dXcvkxB2U7fUveAhcpIhV7riIiaT7CTqjtYGi/Kp7617/Zb/AA9h08gCHVVby/ZTtPvLeW8w7LOMq8FSUjEUDJSKQnYmRKRtVVzHzlba5wW0FDq6u4a9l7nHXIKAZWZVwoYjvwbF4jFSkSSkYi3deM3Rqig736V5FwHE4/YAQAQ/pV8eaGzZ110bUBz+ctSpEionlGIj3QMiPwO+BLdL42XmfagdtrZoavyl1UIsVLLSORnvkzdjuIntrinkNEUDIS6amnsbu39mT/pIT72mdyGpFIEVMyEumBmpnhduAC7CCE7toGTHXPISIoGYn0WM3M8HLgSrrXXbcFuLJmpvfbpYv0JRrAINJLLTMCU4G7gP5kH9DQjm0RfbFmZvj+QsUmUizUMhLppZqZ4bnYBU8fx24pvinl8Ca37HHgRCUikczUMhLJoZYZgTHY1b19blEcWFQzM/yOVzGJFAMlIxER8Zy66URExHNKRiIi4jklIxER8ZySkYiIeE7JSEREPKdkJCIinuvdtuPb1jo4DjjtgANOAvs84T5vt89xcNLLdj5Pvib9HO0dyxNpj047Tno9x+n8NYlESp2U75VIfY6tt7M+Het1OA/23I4D7e32eHvK85RyJ2N5AtoT9vypjwkHx43JaXfct9D+u0OZW8/WpcPxjPXaEziOg9Nm37tEm40l4T5PljtuvE7CIeHGn2hP4CQS9hw7H+1xJ3nccWjfWe7Y79GeIJFyPOEeb0/GknZsZ13sZj+pj+3YFUa785j6+gTwA8cxvfqdL6D+J0x3TEUlFVX9MJWVVFb1wz6vto/V9rmpSD3Wr8OxyqoqTIWhsrKi42NVBaaCzOXGUFllOpT3q6qgssJQWWHo7/67X1Wl+1hBpbGPVSl1d3usrKDCGKorDZXGUF1hqKhwH42hurKCSgPVlRVUGGydSvdYRQWVFVBZYajAUFkBxq2TrNvxOfbnMNjnFQaD++g4mESb/bwl2jGO+9lLtEEi4R5LrdNm67S3g5PYWe607YBEO86OVkgkcNrSHne02uPJesnH9nZo24GTaCexow2nPbHzsX3Hjp3PE+0JEq1tOAn7mEgkSLTu2PV85+sc2ne0k2h3SLTax/Yd7Tjt7meqNUGiPUH7Dvu5bW+1n+H21l3PE45Da8KhfecjaY+7ync4merZf9/qvNPjz5daRiIi4jklIxER8ZySkYiIeE7JSEREPKdkJCIinlMyEhERzykZiYiI55SMRETEc0pGIiLiOSUjERHxnJKRiIh4TslIREQ8p2QkIiKeUzISERHPKRmJiIjnlIxERMRzxnGcnr/YmCsdx7kth/EUPb0nu9N70jN63/JH721+9OZ97W3L6Mpevr4U6T3Znd6TntH7lj96b/Ojx++ruulERMRzSkYiIuK53iYj9bnuTu/J7vSe9Izet/zRe5sfPX5fezWAQUREJBfUTSciIp7rUjIyxkw2xrxujHnTGPPtDMeNMebX7vElxpjjcx9q37Kn9ySl3onGmHZjzAWFjM8LXfg92csY87Ax5hVjzKvGmMu9iLOvMsbsbYx5zBjzhvs4vJO6lcaYxcaY+YWMsZjoupU/+bj+7TEZGWMqgZnAmcDRwCXGmKPTqp0JjHW/rgR+u6fzFrMuvifJev8H/LWwERZeF9+TGcBrjuMcB5wO/MIY06+ggfZt3waecBxnLPCE+zyb/wSWFSSqIqTrVv7k6/rXlZbRScCbjuO85ThOKzAHOCetzjnAXY71HDDMGDO6KwEUqa68JwDXAHOBNYUMziNdeU8cYKgxxgBDgHVAW2HD7NPOAf7o/vuPwLmZKhljDgACwO0FiqsY6bqVP3m5/nUlGe0PvJfy/J9uWXfrlJI9/rzGmP2B84BbCxiXl7ryO3ALcBSwClgK/KfjOInChFcURjmOsxrAfRyZpV4T8E1A7112um7lT16uf1VdqGMylKUPwetKnVLSlZ+3CfiW4zjttiFQ8rrynnwGeBmYBHwMeMwY87TjOC35Dq6vMMY8Duyb4dB3u/j6s4A1juO8aIw5PZexlRhdt/InL9e/riSjfwIHpjw/APuXbXfrlJKu/LwTgDnuf0QtMMUY0+Y4zrzChFhwXXlPLgd+6tj5BG8aY94GjgSeL0yI3nMc54xsx4wxHxhjRjuOs9rtLsrUvfEJ4LPGmCnAAKDGGHO34zhfyFPIxUrXrfzJz/XPcZxOv7AJ6y3gEKAf8ApwTFqdAPAoNmOeDDy/p/MW81dX3pO0+ncCF3gdt9fvCfYG8Q/cf48C/gXUeh17X/kCbgS+7f7728DP9lD/dGC+13H3xS9dt7x9b9Pqd+n6t8eWkeM4bcaYr2JHRFQCdziO86ox5ir3+K3AI8AU4E1gC/Yv4JLVxfekrHTxPbkeuNMYsxR7AfiW4zhrPQu67/kpcK8x5kvASuBCAGPMfsDtjuNM8TK4YqLrVv7k6/qnFRhERMRzWoFBREQ8p2QkIiKeUzIqMGPMuZlmK3fhdY4xZnbK8ypjzIepy8EYY840xvzdGLPMGLPcGPNzt/wHxphv5OYnEOnb9FkpTkpGhXcudgmN7toM+IwxA93nn8KORgPAGOPDTir9guM4RwE+7IgXkXKjz0oRUjLKAWPMPGPMi+7in1e6ZZtSjl9gjLnTGFMPfBa40RjzsjHmY8aY8caY59yFGh/obHFM7DDUgPvvS4A/pxz7JnCD4zjLwY54cRznN7n8OUWKiD4rRUbJKDeucBznBOxEr2uNMSMyVXIcJwY8BPy34zjjHcf5B3AXdojzsdglcr7fyfeZA3zOGDMAOBZoTjnmA17s/Y8iUhL0WSkySka5ca0x5hXgOezM5LFdeZExZi9gmOM4T7lFfwT82eo7jrMEGIP9S++R3gQsUsr0WSk+Ska95K4PdgZwimO3RliMXaYldQLXgG6e80C3G+/l5ESyFA8BP6djtwPAq8AJ3fk+IiVOn5UiomTUe3sB6x3H2WKMORK7rAjAB8aYo4wxFdjVa5M2AkMBHMf5CFhvjJnoHpsGPOU4zntuN974DLOZ7wB+6DjO0rTyG4HrjDGHAxhjKowxX8/ZTylSfPRZKSJdWShVOrcAuMoYswR4HdtVB3ZtsfnYpdbj2P17wPZlzzLGXAtcAFwK3GqMGYQd0dPpkiSO4/wT+FWG8iXGmEbgz+65HCDcy59NpGjps1JctByQiIh4Tt10IiLiOSUjERHxnJKRiIh4TslIREQ8p2QkIiKeUzISERHPKRmJiIjnlIxERMRz/w+6LEDc1ue8XgAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -174,7 +174,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaMAAAD+CAYAAACX8mppAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3deXxU1f3/8ddJQgAJIrKpEXcxIip1gxjjRLFVqUrcv/i1djElxdrayFer/fbbmPZXrVpMW7U0bWot1WJxC9biCswYY9QqVtzGpYrLuKQsIntI5v7+OHfIJWTPzNzMzPv5eMxj5p67zIchcz9zzj33HOM4DiIiIn7K8jsAERERJSMREfGdkpGIiPhOyUhERHynZCQiIr5TMhIREd8pGYmIiO+UjERExHdKRiIi4jslIxER8Z2SkYiI+E7JSEREfKdkJCIivlMyEhER3+X4HYBIOmmaGdgNOBEocIvCwFNjF4Q+9y8qkYHPaD4jkf5rmhnIB24ALgS2AEPdVZuBIcDfgGvHLghF/IlQZGBTMhLpp6aZgZOBOmAwkNvJZs3AVqB07ILQ0mTFJpIqdM1IpB+aZgbOAP4ODKfzRIS7bjjwd3cfEfFQzUikj5pmBvYFXgOG9XLXjcBhYxeE3o9/VCKpSTUjkT5omhkw2OtAg/uw+2DgHvcYIoKSkUhfTQUOo289UnOAScCUuEYkksKUjET65r9o6zHXF0PcY4gIumYk0mtu89pnwJj+HgrYY+yCkL6EkvFUMxLpvS/RSa3ozrc/5ocvvL19+YYV7/HdxnBnxxkGTI57dCIpSMlIpPcCwKCOVlyw/zgej6xmXXMLj0dW8+THa/jlsQd3dpwc91giGU/DAYn03gg66UW3S042Z+87lhtWvMeST9Zyb8nhDM3J7uw4ue6xRDKekpFI7+3W1cqZB+zBCYtf4M/Fh7Hf8M77OHw4dIyp27P4tPrq0OfAq8ArwYpAU5xjFUkJSkYivbexq5VzX32fUYMH0Rrtul/CLQf9F5GhY6Ziu4kDUFIdasJNTJ7n14IVgQ39jlpkAFMyEum9L4AWOvj+zAt/xNZolD8cfyg3v/o+Xx0/utODDGvZ7ADtb3wdC5zsPrYrqQ69CTwN1LvP7wYrAuqFJ2lDXbtFeqlpZuA07OgLu3rL6z9by/8u/zeLT5lM3qAcpj36Ir+ecgiTRuZ1eJxNWblfzD145t2vjDhwMHA49ibaXXoYxqfYpBR7vBysCLT08Z8k4jslI5FeapoZyAXW4kkcH23cwtlLV3D3iZOYMMIW3/PupzzTtI7fTD2ks0NtAkaOXRBqBiipDmUB+2MT0yTP8yFAp70gXBuBRtqS03Nq2pNUomQk0gdNMwP3AeewczNbTznA/WMXhM7vbsOS6tBQ4FjgBPdRRLtaWQdagZfw1J6CFYHP+hirSMIpGYn0QdPMwAzgL9hpIfriC+BrYxeEHurtjiXVoWxsk14sORUDe/dg13eAJcADwLJgRWBbb99bJFGUjET6oGlmYIiTk/MR0egoE4326RDAvmMXhLbEI56S6tA+tCWnE7DNe13V2j4HHgLuB54IVgQ2xyMOkb5SMhLpg0hV+Sk4zmKam3MGvfdeb5vqNgFfHbsgFExAaACUVIdGAsfTlpyOo/PJ/zYC/8DWmBYHKwLrExWXSGeUjER6KVJVfjzwBLCL2bhxec6HHx5CzyfY2wjcOnZB6NqEBdiBkurQEOyUFWdjr3WN72TTrcDj2MT092BFYHVyIpRMp2Qk0guRqvIvAcuww/g8yJYtFwxaubIK+AHdd8veBPwK+LGfI3WXVIcMcDRwrvvobPC8Vuy/9QHgwWBF4NPkRCiZSMlIpIciVeWHAk8Bo7G1h7PyK2u2wvYODb/FdmjIo+16TRRbG1oPXDZ2QWhRsuPuipuYDsPWls4BjuxkUwd4BnuN6f5gReCD5EQomULJSKQHIlXl+2NHP8jHdpU+Lb+yZodhgZpmBgYBpwPTsdNMgO1evRh4ZOyC0IDvvVZSHTqItqa8qZ1s5mD/TbcBjwcrAn3qwSHipWQk0o1IVfle2ER0ALAcODm/smadv1ElXkl1aG+gFNuUdyIdTznzDjAP+FOwIrA2ieFJmlEyEulCpKp8NBACJgJvACfmV9asAqgvLDLA3cBXgPnFjQ1X+hZogpVUh8YAZwEXAl/uYJPNwF+B24MVgZeSGZukByUjkU5Eqsr3xPaaOwx4DyjOr6yJxNbXFxZVYzsuxOxV3NjwSXKjTL6S6tDBwGzgm3Q8nUYjcDtwX7AisDWZsUnqUjIS6YB7jehJbNPcSmzT3Hux9fWFRecB97bb7bjixoZ/Ji1In5VUh3YBLgK+S8fTp/8H+ANQow4P0h0lI5F2IlXlE7E1or2wTXNfblcjmort8jyk3a5FxY0NzyQt0AHC7ZFXiE1K57PzlOxR7GgPtwNLNPWFdETJSMQjUlV+NPAYMArbWeG0/Mqa/8TW1xcWHQA8C4zpYPfTihsbHktKoANUSXVoHFAGfIeOx8t7E9sF/o/BikCXkxRKZlEyEnFFqsqLgYexI2LXA2d6e83VFxaNxN5rU9DJIc4vbmy4L+GBpoCS6lAOcCa2tjStg00+A/4f8AddVxLouKumSMaJVJWfhq0R7Qo8iq0Rte++/Xs6T0Rgb3YVIFgRaAlWBB4MVgROAQ4FbsXe+Bszzi17s6Q69I2RE47ZxRjzc2PMM8aYNcaY94wxh/sRu/hDyUgyXqSq/HzsNY2h2E4JM/IrazZ5t3G7cZ/ezaH6Op1EWgtWBMLBisD3sTcMXw585Fm9L/Cn/BNK35g8efKPli1bVtjU1DTy29/+9n5AwIdwxSdKRpLRIlXl3wLuwV50vwOYmV9Z09x+u+LGBgd7cyfYKb87omTUhWBFYH2wInA7diy8K4FVsXWDR47bJxKJMGvWLO6++25yczsbYFzSlZKRZKxIVfkPgD9ivwe/Ar6dX1nT2sUuV2MHSH3bU+atQa2Je5BpKFgR2BKsCFQDBwKVwPrhe09g/Neu5/NhexN154fadf/D9/czTkkudWCQjBOpKjfAT4Dr3KLrgJ/mV9Z0+2WoLyzaBTsxXaz78p3YwUXfBS4tbmxI+2GC4q2kOjQKuAa4/J1Ftw+58qypvPvuuzz2cTb5xec8DPw4WBF42ecwJcFy/A5AJJncRHQLbSMnVORX1vyqF4c4nh3vo7mzuLEhFK/4MpE7Z9JVJdWhX21d8+li4AjP6jOAM0qqQwuAymBF4O0ODyIpT810kjEiVeXZQC02EUWBS3uZiABKPK+3AM/FJzoJXVkyZdUr9Rtiy2ve/Cdr314eW5wJvFFSHfq9O4CrpBklI8kIkaryXYC/Ad8CtgH/lV9Zc0cfDnWS53VjcWPDlnjEl+mMMeNHjx59/7XXXnv8lClTOPXUUymfUUL4jv9tjba2xDbLBr4NhEuqQ1eUVIey/YtY4k3JSNKeO87cM9ipELZgu263H1euW/WFRXnAcZ6iZfGJUIBtzc3NvP/++/z2t7/lnnvu4f333yfaum1D69bNJ7DjZz0M2+GkoaQ6dJg/4Uq8qQODpLVIVfmXsV23dwciwDn5lTXP9+VY9YVFX8HeGBtTXNzY8HT/oxQAY8yxwIR2xS85jvO6O/7dNGwS8iagbcANwPUaySG1KRlJWnI7KlyFPVFlYacLvyC/suazvh6zvrDoBmyvL7Dz94wsbmzQCTCJSqpDudj/gx+zY0eS14GyYEWg0ZfApN+UjCTtRKrK87D3D13gFt0KzMmvrOnXtN/1hUWNtE3F/WRxY0NHk8xJEpRUhyZiO6MUeood7FToPwpWBDZ0uKMMWLpmJGklUlV+EHZytwuw14e+nl9Z8/04JKLhwLGeomB/jif9E6wIvA4UA98HYqN/G+B7wGsl1aHT/IpN+kY1I0kbkary07FTX+8GfIC9PvRiPI5dX1h0OrDYU5SRcxcNRCXVoX2A37Hz2IF3ARXBisCqnfeSgUY1I0l5kapyE6kq/xHwD2wiWgYcE69E5CrxvN4EvBDHY0s/uLPIfhW4GFjtWXUx9t6ki9wOEDKAKRlJSotUlQ8H7gN+jm2muQX4indCvDjx3l/0dHFjw06DqYp/ghUBJ1gRuBs7XcXdnlWj3eWH3RqUDFBqppOUFakqPwR4EHsC2gyU5VfW/DXe71NfWDQCOwhq7MfbtcWNDb+I9/tI/JRUh6Zjm+7Ge4o3AFcEKwJ9udlZEkw1I0lJkaryM4HnsYloJXB8IhKR6wR2/K4EE/Q+EifBisBi7P1It2F72YGd/PCPJdWhP5ZUh4b6Fpx0SDUjSSnu+HL/h516AOAJ7BxEqzvfq3/qC4t+CcxxFzcAuxc3NvSrd54kT0l16HhsV3/vLL3LgfOCFYH3/IlK2lPNSFJGpKr8UKCBtkR0EzA9kYnI5e3S3aBElFqCFYFngKOxvetijgJeLKkOdTd7rySJakYy4EWqynOwNZMqYDC2x1R5fmXN/cl4//rCov9gL4QD3Fjc2HBNV9vLwOT2qJuNHVIoNnqDA/wU+GmwIhD1KzZRMpIBLlJVPhH4E20DlN4PXJZfWdOUjPevLywaA3jf6+vFjQ3zk/Hekhgl1aGpwL2AdyqKR4GL3bmVxAdqppMBKVJVnhOpKr8GeAmbiFYBF+ZX1pyXrETkOrTd8htJfG9JgGBF4FlsM90ST/Fp2Ga7o/2JSpSMZMCJVJUfhp3y4QYgF3sf0WH5lTULfQhnYrvlsA8xSJwFKwL/AU7F/o3F7IudlqLMn6gym5rpZMBwrw1dBVyHTUKrsE1yvZ57KF7qC4t+gx3vDOCD4saGff2KRRKjpDo0A5gP7OopvgO4PFgR2OxPVJlHNSMZENzaUCNwPTYR3QtM9DMRubzNdK/7FoUkTLAisAjb226Fp/hb2FrS/v5ElXmUjMRX7rWhH2Hv+zgG+A923qELEjCkT194m+l0vShNBSsC72Cno/iLp/hL2OtI0/2JKrMoGUlcGWOGGGOuNcY8a4xpNsasMMZcbYwZ1H7bSFX5JOBZ7LhyucBC7LUhv2tDwPZhgPbyFKlmlMaCFYFNwNeBy7AzyAKMxI5rN6fTHSUudM1I4soY882pU6fecf311zNu3DjWrVvHj3/8Y5YuXXq74ziXA0SqyncB/oe22Tr/g702dJ+Poe+kvrBoKrbpMEbTRmSIkurQFGzHGW/37xuA/w1WBHTSTADVjCTecrZs2cKsWbM47LDDuPzyy1m4cCE5OTnfPWXCvkMjVeWXAm9jb2AdBPwNe21oQCUiV/uedGqmyxDBisBz2O7fT3mKrwXmlVSHsv2JKr2pZiRxZYwZAXwH+yV+Mysra/WqVas44IADWFp2Rnhs3i6x8cHeAq7Kr6x5yLdgu9FuTLpPixsb9vQzHkk+d0DVvwFneooXAl8LVgQ0jUgcqWYkceU4zjrHcW4EXgYenDNnDo888gj7DM3BTUSfYYdkmTSQE5FLPekynNu1+1x27NhwAfBQSXVomD9RpSclI4k7Y8yQYbk5j1188cUnnnXWWcyaNYvrzzhhM/b+oYPyK2t+l19ZkwqDjXqb6ZSMMlSwIrAN+AZwq6f4VOCJkurQSF+CSkNqppO4uufrZ+z1s8canznipK/se8UVV3DqqafypTG7vpGTlXX5k2+9v9Tv+HqqvrBoGHa6iJjLihsb5vkVj/jPHWj1J9gfVTGvAKcGKwKf+BJUGlEykrhwe8hdcdcLb/zf0uahQxcuXMjVV1/NmjVrAHj00UfZsGHDWMdxBsK9Q92qLyw6CnjRU3RScWND0KdwZAApqQ59D/iNp+hd4MvBisC7PoWUFtRMJ/0SqSrPjlSVfwvbIeH65tbWoZs2beKWW25hjz32YOLEiUycOJHBgweDvZcoVezTbvltX6KQASdYEbgV+BrQ6hYdADxdUh063L+oUp9qRtInkapyA5wO3AhMcovfemfV51Un3bZwnLPjOF8ArzuOMyBuZu2J+sKiS4FaT9Hg4sYG9Z6S7UqqQ2die9YNcYs+B6YHKwKNne8lnVEykl6JVJUPAf4LuAKY7BY3YWdf/WOKdEzoVn1h0Q+BX7iLG4obG4b7GY8MTCXVoROBv9P242sTcHawIvC4f1GlJjXTSY9Eqsr3iFSVXwe8j53sbjLwBXaWzFTqIddTozyvNeGadChYEXgKOAk7igjALtjhg873L6rUlON3ADKwRarKj8LWgmbSNlXzv4FfA3fmV9as9yu2BPMmo1W+RSEDXrAisLykOnQC8AT2WuMg4G/uDbN/wY4AvjtQHawItPgX6cCmZCQ7cecVmgH8ADjBs2oJ8CtgcX5lTdSP2JJINSPpsWBF4C03IT0OFAAG24JwILY7OMBwz2tpR9eMZLtIVfluQBlwOXbWS4Ct2F93v8mvrHnFr9iSrb6wqJ62RLyguLHhIj/jkdRQUh0aDTwJHOkWtdD2o/9TYLxqRx1TzUiIVJUfAnwfO3x+bIiTj4HfAr8fIPMKJZtqRtJrwYrAqpLqUClQjx3x23uO3QP4MvCIH7ENdEpGGSpSVZ4FnIJtijvds+qf2Ka4+/IrazK5K7OSkfRVDTtOPeH1DZSMOqRklEHcBDQFON99xL4wrdi5W34NPJtfWZPRbbf1hUUGJSPpu7FdrCstqQ6NDFYE1iYtmhShZNSJdbOnZ2EvOLaMmLd4o9/x9JV7c+px2JGGzwfGe1avxt7YeXt+Zc2HPoQ3UI0AvHPWqDed9MZM4A/s2PknJhd7TfZnne28+pJpw7Dn5vWj5i9J945C26kDQzvrZk8/BTsL6QnYPxwDrMFWra8fMW/xWz6G1yNuAjqWtgTkHdpmLfAA9s7xZWl2b1Bc1BcWHQi84yk6tbixQTcxSq+4N8T+H7Y53OvTYEVgh7mxVl8ybQLwI2yT+e6AAzQDTwM3j5q/ZEniI/aXkpFr3ezpY7An6S/RdhHfqwXYBvwRqBgxb/GA6hHjJqBjsMnnAtp6w4FNQA8C9wJLlIC6Vl9YdBzwnKfomOLGhhc7216kKyXVoanAXOB4t+jtYEVgAsDqS6blANXApdj7kzpqrdoILAfOGTV/SdrW0pWMgHWzpx+I7f0yiu4H89wEPA9MHzFv8eZEx9YVNwEdTVsC2s+z+nN2TECZ3BmhV+oLi04HFnuK9i9ubFjpUziSJkqqQycB04FfBCsCq1dfMm0o9u/sOOzIDV1pxjarF4+av+TfiY3UHxl/zWjd7OnDgWXAOHo2PNIu2E4Ad2FngEyqSFV5HlCIrfqfD+zvWb0OqMM2wT2pBNRno9otqwOD9FuwIrAMe65h9SXTDPYcMgUY2oPdc7HnqGWrL5k2cdT8JRu62yHVZHwyAm4DRtO7cfqGAqeumz39whHzFv8tMWFZkary3bHXr04EirE1Ie/F9S/YMQFtTWQ8GcKbjJrZcZI9kXi4EDtbbE8SUUwWMAZ7zvpGAmLyVUY3062bPf0YIET3VeTOfAGMHTFvcdwSQKSqfC9s0okln47mSAljmxUfAp5QAoqv+sKia4Hr3cW1xY0Nu/sZj6SX1ZdMG4wd6b79NCs9tQkIjJq/5IX4ReW/TK8ZXUz/J3w7mT7exOZe89mftuRzInBQu80c4F/Y5PMU8HR+Zc1nfY5WeqLV8zq7061E+mZaP/fPBf4bUDJKB+tmTzfY+wH68xkMx/5R7JSMIlXl04HrgMb8ypor3LIhwKHYduJY8slvt+s27CgIseTzTH5lzef9iFF6yBiTAxw6e599Dzx51GjG2dlplYwk3i7Gnjv6KgeYufqSaVeOmr8kbZq2MjYZYQcy3KkL95trN3D+4hf410UBsowh6jic+49/csHB+cw8pH3ewAAz1s2enhPr6h2pKj8Q21XzTHeb3SJV5Xtim9sOZueT22agEZt4ngKey6+s2RSnf6P0kDFmpjHmrxMmTOCdffZhQX099x4xmcFZWUpGEjduV+4zseeOnXzvmdd5ZU3bJcqmzc00R6O8c+GJ7TfNA44AXk5QqEmXycnoHDpoojtkZB4TdhvGo+83MX2/cfz0ubc4aLe8jhJRTBTbu60+UlX+Z+Br7PiHdrD7iPkYeIm25LNcvd4GhLNuvfVWJk6cyNSpUxk/fjybW1uVjCTejseeMzp06/ETt79+f/1mznh8ObdOPbSjTXOx5zAlozRwIG2Txe3gsiP247crVrIt6vDcp2t56MzjujqOoW2MtwvYMRG1AB9ghwZpBF7Jr6xZ0+/IJRH+cfnll58EjIlEIt6elUpGEk9700mtyGvN1m1csPRl5hy+H6ePH9PRJoOAA+IdnJ8yedrx3TpbcfL4MXy8cQs/fe5N/vTlyQzK7vJjyqatV8yXgflAEHvPTw72D+bV/MqakBLRwOU4zl2O4+wBtO8ckuUOnCoSD7vSzQ+czS2tXLT0ZUr3Hcs3JnTaIgMwMq6R+SyTa0ZdnmCOGzeSI0bvyh7DhvT4WPmVNU9jx5KKjZA9EfdGtf6FKj7LYscediJ9Zeji3NMadSirf42DR+zCtZO7rfik1Y+kTE5GXfZQe3PtBv67oMtfJTGt2PuNduBOy/2q+5DUlo2SkcTHF9jm+w5d9fybtESjVE8t6Mmx0qqXbSY3062kiz+KN9Zu4NDde9T70sFOJywpzBhzhDHmaTxz0cx543WeWbsGdN1I4ucT7DljJze9/B4vr17PH0+cRE5Wt6fmFuD9eAfnp0xORouALR2t+GjDZkbk5pA3qEcVxxzcpjlJaefOnj276KWXXsoeO3YswWCQy37+/3i4qQmUjCR+nqaDjlMfbNjMTSveY+3WbZzx2HJKHn6ekoef59KnOm1Y2YIdBixtZOxwQO7keavo30VAB3hwxLzFSR8wVeLLGPOVrKysx4xpa4Z3HIfLx+/LeXvuuVtxY8M6H8OTNLL6kmkPAKX075rPGmBMOk2+l7HXjEbMWxxdN3v6QqCMvv/yXQ/8JX5RiV8cx3ncHYHBPHbslHMHZWXdY4Bsm5xUM5J4+gt2SKC+jk3XCixMp0QEmd1MB3YI9w6b6nooB3gsTrGIzxzHaXUcp2Vodva2HGNiiQiUjCS+HqN/FYEt2HNXWsnoZDRi3uKngSeBvox6vRE746uvE+xJQrTvOadkJHEzav6STcCV2HNIb20Fnhg1f0lDfKPyX0YnI9e3sN0te3PxbCvwLHZkBUk/SkaSaL/HnkN680PYwZ6rLk1IRD7L+GQ0Yt7iNdhZUz+nZ/eSbAbeAM4ZMW+xEy4rnRwuK/1duKz0iETGKUnVvrbbnxGWRXbijrZ9LvZc0pPWlRbsOWraqPlL0nIkl4xPRgAj5i1eAUwG3qLzWT0d7KRWfwcKR8xbHLvR9SmgHHg5XFZ6T7isdEKi45WEa3/f2B6+RCFpbdT8Jeuwgyz/HXtu6ax1ZgPwNjB51PwlryQpvKRTMnKNmLf4A2AS8G3sZHax6aY3Yv9QHgdOGjFv8YUj5i32dnrw3jh7IfBGuKz0r+Gy0knJiVwSQMlIkmLU/CVbRs1fciF2ks7HseeajdhzTzP2XPRtYNKo+Us+8C3QJMjY+4y6s2729KHAXtimuw9HzFvcYRNeuKz0J0BVJ4e5Bfifgto6fcgpxB0YdQttU4xcWdzYUO1jSJIhVl8yLRsYj71O+fGo+UsypoOUklE/hctKxwIROu+quUtBbV3G/EGli/rCoveBfdzFm4sbG672Mx6RdKdmun4qqK1rAhZ3sGoN8Av6dx+T+MfbVLenb1GIZAglo/j4s+d1bNbW3YEJqFtwqvrE81rXjEQSTMkoPh4GVruvvT3yzgHuDJeVZuywSynMm4xUMxJJMCWjOCiorWsG/ht4AvghcAZtzXP/DdwXLivt0Sx9MmComU4kidSBIUHCZaWnYod4jyWhZcCMgtq69f5FJT1VX1g0C6jxFA0pbmzoy7BRItIDqhklSEFt3WPAl4HY1AMnAUvDZaWj/YtKeuGTdsvjfIlCJEMoGSVQQW3d00AJ0OQWHQPUh8tKx/sWlPRU+2SkpjqRBFIySrCC2rp/ASfQNkVwAfC0hg0a8NqPwqBkJJJASkZJUFBb9zY2Ib3hFu2DTUhf8i8q6cZn7DhWmLp3iySQklGSFNTWfQScCPzTLRoDBMNlpcX+RSWdKW5s2Iadlj5GNSORBFIySqKC2rpV2OmGl7pFuwKPh8tKv+pfVNIFde8WSRIloyRzu3Z/FdvtG2zX77pwWelF/kUlnYh4Xu/nVxAimUDJyAcFtXVbgPOBO92iHOCucFnpZb4FJR153fNakyeKJJCSkU8KautasNMHx6YmMMDt4bLSH4fLSo1/kYnHCs/rcfWFRbrXSCRBlIx8VFBbFwXmAD/2FP8M+E24rHSQP1GJx4p2y4f7EoVIBlAy8llBbZ1TUFv3c+C7tHUlvhxYEi4r1UVzf72OnVwxRk11IgmiZDRAFNTW/Ra4iLYBVouB5er67R93LLqwp0jJSCRBlIwGkILaunuA44H33KI9gGXhstIKXUfyjbepTslIJEGUjAaYgtq6l4CjaZs9Nhu4BbgnXFY63LfAMpc3GR1WX1ikualEEkDJaAAqqK1bC5wJ/IS260gXAM+Fy0oP9S2wzORNRrnAIX4FIpLOlIwGqILaumhBbd3PgNOBNW7xocDz4bLS8/yLLOO071GnpjqRBFAyGuDceZGOBl50i/KAe8NlpXPV/TspIrT9GAAlI5GEUDJKAQW1dSuxo37/wVN8Jbb7t0aTTqDixgYHdWIQSTgloxRRUFu3paC2bhbwLSA2/XUx8FK4rPQE/yLLCEpGIgmmZJRiCmrr/oTt/r3SLYp1//6Bun8njDcZ7V1fWLS7b5GIpCkloxRUUFu3nB27f+dgx7irC5eV5vsWWPrSsEAiCaZklKIKauvWYLt/V9LW/fss4PVwWemscFmp/m/j5zUg6lk+0q9ARNKVTlgpzO3+/VPgNNrm3tkVqMF2bjjIt+DSSHFjwybgbU/R0X7FIpKulIzSQEFt3ePAYcDvPMUlwCvhstKrw2WlGjWg/573vD6pvrBI1+dE4kjJKE0U1NatK6itmw0EgLfc4iHAjdiRGyb7Flx6WOJ5PR5QrVMkjpSM0kxBbd1T2LY8hZQAABFzSURBVGsaN9A2/cFRwAvhstIbwmWlQ30LLrUtabd8ii9RiKQpJaM05N6T9CPgGGC5W5wNXAO8HC4rPdG34FJUcWPDR7TVOAGm+RWLSDpSMkpjBbV1/wKmAFfTNk/SwUAoXFY6L1xWuqtvwaWmJz2vT6ovLNL3RyRO9GVKcwW1dS0FtXU3Y0cOCHpWfQfbDfzM9vsYY042xvzOGPOkMWaRMeZ/jDHDkhTyQOZtqtsd0HU4kTgxjuN0v5WkBffeo0uBX2K7gMf8Dbi6oLbuA2NMbk5OztZbbrmFQw45hI0bN3LXXXfxwAMPPAMEHMdp8SP2gcAdeWEVEOtJ98PixoabfAxJJG0oGWWgcFnpXsDtQKmnuBmY93LTmpu/9uizb0ybNm34ihUrGDduHPfddx/nn38+y5cvP8lxnKAvQQ8Q9YVFL9B2n9HjxY0Np/oZj0i6UDNdBiqorfsYOAc4H/jMLc4Frjhy7O5v3lR85MIljz/+0Mcffxx66aWXeP311xk3bhzASJ9CHki8TXXF9YVFg32LRCSNKBllqILaOqegtu4+YAJQBWxwVw07db+9LnVwzpo/f35g6dKlNDU18dhjjwEs8yveAcTbiWEoMNWvQETSiZJRhiuorfuioLbuOmB/4Bbc6Sny83bh5ptvZu7cuUyZMoWjjjoK4CT/Ih0wGrBNmjG630gkDpSMBICC2rpVBbV1c5o2bZnwm+Xhp344ZVL02n1347MXn2XhwoWcfvrpTNlz9MWZPgCrO07dM54i3W8kEgcZfWKRnQUWPJb/j9WbT/zjmpassqUvsmn3cZx99tk8//zznDNhn3OAf4XLSs/M8LmTvNeNjqsvLNL9WiL9pGQk7UWzs7O56qqrWLZsGTfddBM33ngjH7zwLF/Zby+wc/k8BDSEy0pLfI3UP95klA1oRAuRflLXbtmBMSYL+AZ2rqTx2Ptqgg+WlrxYMGrE/2GnOvd6HNsBorGgti4j/pjqC4tygDXAcLfo18WNDT/wMSSRlKdkJD3mNs2dClwPfKnd6peA24B7CmrrNiU7tmSrLyx6CJuwAV4rbmyY5Gc8IqlOyUh6ze3EcC7w/7Bdw73WAncA8wpq6/6d7NiSpb6w6PvArz1FBxY3NrzrVzwiqU7JSPrMnbTvPOC7wAntVjvAI9iRHh4tqK2LkkbqC4v2A97zFF1V3NjwS5/CEUl5SkYSF+Gy0iOBy4CLgV3arX4XmAfcUVBbtybZsSVKfWHRi9i5ogCeLW5sKPQzHpFUpmQkcRUuK90N2wHiMux0FV5bgL8CtxfU1i0nxdUXFv0I+LmnaLw775GI9JKSkSSEe13pFOBy4AzaRrqOeRbb4eG+gtq6rUkOLy7qC4sOAcKeou8VNzbc5lc8IqlMyUgSLlxWuh92/qQyYFS71f/Bdni4F1ieat3D6wuLXgUOcxeDxY0NGjJJpA+UjCRpwmWlQ4ALsR0eju1gk5XAA+6jMRU6PdQXFlUBP3EXo8AexY0N//ExJJGUpGQkvgiXlR6HTUoXAh1Nw/Ap8CBwPxAqqK0bkJP61RcWHQn8K7act+ugGw+eNGIzbR0blgNPAI15cxfpyybSCSUj8VW4rHR37M2j5wJfoePEtAZYhE1MTw6ka0z1hUUGeBs4EGDMnkO27b1/HsAgd5Nt2JHQPwC+kzd3Ub0fcYoMdEpGMmCEy0qHA9OxiWk6MKyDzdYDD2Ob8h4pqK3bmLwIO/bmuafc2fTx5q8bAwcdNoK8XQd1tukm4Jq8uYtuTWJ4IilByUgGpHBZ6VBsTekc4Cxgtw422wI8iq0xPVxQW/d58iK0NsyZ8T/Addu2RYdlGcjO6Xbs4U1AZd7cRbpBVsRDyUgGvHBZaS5Qgq0xlQJjO9isFXvt5unYo6C27tNExrVhzozjgCB2xtfe2AwE8uYu+mfcgxJJUUpGklLCZaXZQBE2MZ0D7N3F5u/gSU7AW/HqOr5hzoxc7LWi8ex8D1V3HOBD4OC8uYuau9tYJBMoGUnKckcRPxabmE7GjiSe3cUuq9gxOS0vqK3b1pf33jBnxunAPUBfJ9b7Argwb+6iR/u4v0haUTKStOF2gJiCHbT1BKCQncfJ89qMHQkilpyeLait+6In77Vhzoy7gIvofa0oxgHuzpu76Gt93F8krSgZSdoKl5UOAo6kLTkV0/H1ppgo8Aqwwn1+1X2OeJv3NsyZkYOdKiOvnyGuB3bPm7toQN5DJZJMSkaSMdxmvYNoS04nsPN8TB35nLbE9OrwwY7ZdTA3GLN9pleijsM+v32Ej747HYAVTesouivE8m+ezMEj89jQ3MJRf1rK8m+eTF5uTmy39cCMvLmLlsXtHymSonK630QkPbi1m7fdx58AwmWlY7EdImI1pyOB3Ha77kZb8mL9VkPUcaIjPX3osozBccBxHIwx3LFiJXsOG8L6rbbSszD8EdMPHOdNRABDgGMAJSPJeEpGktEKauuasMMOPQjbm/YOAg73PCYBB+C5PtTSyk43FO0yKJtNLa04DjwTWcOZB+3BhmabjP78ygfc9pUj2+8yCNpqVyKZTMlIxMPtXfeG+1gYKw+XlQ7Djs49aViu883hg3ea2ZbhuYPY0NzCP/79KeceshfNrQ5fNG/j5aZ15GQZDh8zoqO3VDISQclIpEfcYYeeB57fMGfGfuw8zTq75uawvrmFv7z6IQvOOpYFb3zIhuYW7lixkm8dsW9nh+5R7z2RdNft2CUispN1wE43qw4fnMNTH64if/gQ9sgbwvDcHD7duJUnVzZxzoT8jo7TjJKRCKBkJNIXz9BRMsrN4dYX/82lR+wHQN6gHP786vucedCeDB3U4b24W4GGRAYqkiqUjER67zns1BA72HXwIBwHSvYZDUBebg7vrN3INztvomvBNv2JZDzdZyTSBxvmzKgBLqXr4Ye60grU5s1d9J34RSWSulQzEumbBdjpIPpqk3sMEUHJSKSv6rGzt0b7sG/U3ffpuEYkksKUjET6IG/uolbgPGwnhN7aApzrHkNEUDIS6bO8uYvCwCx611y3CZiVN3fRm4mJSiQ1qQODSD9tmDPjXGA+MJjOOzS0YmtEl+TNXfRAsmITSRWqGYn0U97cRfdjBzx9EjtH0gbP6g1u2ZPAsUpEIh1TzUgkjtyhgk7GDq4KduqJpXlzF630KyaRVKBkJCIivlMznYiI+E7JSEREfKdkJCIivlMyEhER3ykZiYiI75SMRETEd/2bdnzLKgfHAacVcMCJYpej7nKrXcbBaV+2fTm2T/tjtO5YHm337LTitN/OcbreJxr1bON5r6h3Gbvd9u3ZcbsdjoM9tuNAa6td3+pZ9pQ7HZZHoTVqj+99jjo4bkxOq+N+hPb1DmXudnZbdljf4XatURzHwWmxn120xcYSdZdj5Y4brxN1iLrxR1ujONGoPcb2Z7veia13HFq3lzv2PVqjRD3ro+761lgs7dZt3xY72Y/3uRU7wmhvnr37R4HrHMf0628+iQYf/W3HZGWTlZOLyc4mOycXuzzIPg+yyybLuy53h3XZOTmYLEN2dtaOzzlZmCw6LjeG7ByzQ3luThbZWYbsLMNg93VuTrb7nEW2sc85nm13es7OIssYBmUbso1hUJYhK8t9NoZB2VlkGxiUnUWWwW6T7a7LyiI7C7KzDFkYsrPAuNvEtt1xGfvvMNjlLIPBfXYcTLTFft+irRjH/e5FWyAaddd5t2mx27S2ghPdXu60bINoK862ZohGcVraPW9rtutj28WeW1uhZRtOtJXothac1uj259Zt27YvR1ujRJtbcKL2ORqNEm3e1ra8fT+H1m2tRFsdos32uXVbK06r+51qjhJtjdK6zX5vW5vtd7i1uW056jg0Rx1atz/T7rmtfJvT0Xb29e+clX3+fqlmJCIivlMyEhER3ykZiYiI75SMRETEd0pGIiLiOyUjERHxnZKRiIj4TslIRER8p2QkIiK+UzISERHfKRmJiIjvlIxERMR3SkYiIuI7JSMREfGdkpGIiPhOyUhERHxnHMfp+87GzHIc5/dxjCfl6TPZmT6TvtHnljj6bBOjP59rf2tGs/q5fzrSZ7IzfSZ9o88tcfTZJkafP1c104mIiO+UjERExHf9TUZqc92ZPpOd6TPpG31uiaPPNjH6/Ln2qwODiIhIPKiZTkREfNejZGSMOc0Y86Yx5h1jzDUdrDfGmN+461cYY46Kf6gDS3efiWe7Y40xrcaY85IZnx968Hcywhjzd2PMy8aY14wx3/QjzoHKGLO7MeYJY8zb7vPILrbNNsa8ZIx5OJkxphKdtxInEee/bpORMSYbuB04HZgIzDTGTGy32enAwe5jFjCvu+Omsh5+JrHtbgQeS26EydfDz+S7wOuO4xwJlABzjTG5SQ10YLsGWOI4zsHAEne5M1cAbyQlqhSk81biJOr815Oa0XHAO47jvOs4TjNwDzCj3TYzgPmO9SywmzFmz54EkKJ68pkAfA+4H2hKZnA+6cln4gDDjTEGyAPWAC3JDXNAmwH82X39Z6C0o42MMXsDXwVqkxRXKtJ5K3EScv7rSTLKBz70LH/klvV2m3TS7b/XGJMPnA38Lolx+aknfwO3AYcCHwOvAFc4jhNNTngpYZzjOJ8AuM9jO9nuV8DVgD67zum8lTgJOf/l9GAb00FZ+y54PdkmnfTk3/sr4IeO47TaikDa68lncirwL+Bk4EDgCWNMveM4XyQ6uIHCGPMksEcHq/63h/ufATQ5jvOiMaYknrGlGZ23Eich57+eJKOPgPGe5b2xv2x7u0066cm/9xjgHvc/YjQw3RjT4jhOXXJCTLqefCbfBH7h2PsJ3jHGvAcUAM8nJ0T/OY5zSmfrjDGfGWP2dBznE7e5qKPmjSLgLGPMdGAIsKsx5i7HcS5OUMipSuetxEnM+c9xnC4f2IT1LrA/kAu8DBzWbpuvAo9gM+ZU4PnujpvKj558Ju22vxM4z++4/f5MsBeIr3NfjwMiwGi/Yx8oD+Bm4Br39TXATd1sXwI87HfcA/Gh85a/n2277Xt0/uu2ZuQ4Tosx5nJsj4hs4A7HcV4zxnzHXf87YDEwHXgH2IT9BZy2eviZZJQefiY/A+40xryCPQH80HGcVb4FPfD8AlhojLkU+AA4H8AYsxdQ6zjOdD+DSyU6byVOos5/GoFBRER8pxEYRETEd0pGIiLiOyWjBDLGlHZ0Z3IP9ms1xvzL89ivm+1XGmNGu683eMonGGMWu0N2vGGMWWiMGWeMKdEwMpIu9H1JDz3p2i19Vwo8DLzey/02O44zuT9vbIwZAvwDuNJxnL+7ZScBY/pzXJEBSN+XNKCaUS8ZY+qMMS+6A33Ocsu8v67OM8bcaYw5HjgLuNn9tXagMWayMeZZd1DGB7saCLOD9/2GMeY2z/LD3dz0eBHQGPtiATiOs8xxnFd78c8VSUn6vqQeJaPe+5bjOEdjb+r6vjFmVEcbOY7zDPAQcJXjOJMdx/k3MB/bnfkI7HA4lZ28x1BPk8ODfYxzEvBiH/cVSSX6vqQBNdP13veNMWe7r8djR/ztljFmBLCb4zght+jPwL2dbN7vZgeRDKLvSxpQzagX3Gr+KUChY6dBeAk7JIv3Zq0hvTzmeM+vuu90sWkLO/5/dfc+rwFH9yYWkTSi70uKUTLqnRHAWsdxNhljCrBDiAB8Zow51BiThR2pNmY9MBzAcZx1wFpjTLG77mtAyHGcD91mvMnd3Lm8EphsjMkyxozHDuPelb8CxxtjvhorMHZCrMN7+G8VSWUr0fclpSgZ9c6jQI4xZgV2aJtn3fJrsL3mlgKfeLa/B7jK2Bk5DwS+ju3QsAKYDPy0F+/dALyHvdb0S2B5Vxs7jrMZOAP4nrEzh74OfIPMmFtJRN+XFKPhgERExHeqGYmIiO+UjERExHdKRiIi4jslIxER8Z2SkYiI+E7JSEREfKdkJCIivlMyEhER3/1/mlMo4yX2z7MAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -276,7 +276,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZsAAAD+CAYAAADs1qilAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOydeXhTxf643zlpkzRNmtIWKEILiOw7CCqLLCKyIyCCyiKUi+ACCF6U5aIigqAoKsh+q+ACCsqOshQQRC1bWWQHodBSWlqSJk2TNMn8/jgpFiiLfsV778/zPk+eQs7MnDknyXzOZx0hpURDQ0NDQ+NOovynJ6ChoaGh8f8/mrDR0NDQ0LjjaMJGQ0NDQ+OOowkbDQ0NDY07jiZsNDQ0NDTuOJqw0dDQ0NC442jCRkNDQ0PjjqMJGw0NDQ2NO44mbDQ0NDQ07jiasNHQ0NDQuONowkZDQ0ND446jCRsNDQ0NjTuOJmw0NDQ0NO44mrDR0NDQ0LjjhPynJ6ChoXFz7EM7mIFmQE3U32wqsNU6e92F/+jENDR+B0Lbz0ZD478T+9AOpYGJQH/AAxhRrREuwAAkAyOss9ft/Y9NUkPjNtGEjcb/DEKIUEBKKX3/6bncaexDO7QAVqEKGP0NmgVQhdBrwNvW2eu0H7PGfy2az0bjvx4hxFAhxPmQkBCvTqcrEEKkCCEevs2+g4QQF4UQ54QQnW7SLkwI8YYQ4vtg+6NCiCp/3lXcPvahHToD64EIbixoQP39hgETgA/+gqlpaPxhNGGj8b/AhI0bN5bdvXs3hw4dYu3atXUtFssGIUT1m3USQlQJDw+fv3///lLvvvtuOaDrTZo/3LBhw/GbNm1qnp6eXqpPnz5VgRZ/6lXcBvahHaoCX6AKkdslHBhoH9rh6TsyKQ2NPwEtQEDjf4E9nTt37uh2u08DdycmJpKQkMCMGTM6AUeK6yCEUIAlkydP5uDBg5jN5ivHbPPGhgAmIBRVc9B3ql/FtCc9nRdeeIFhw4ZhNBppVb1iFdu8sfcCdsAG2CMHT/beqYu0D+0ggE/5fYKmEBMw0z60wxrr7HWX/tyZaWj839GEjcb/Ap3dbvc7wEi9Xk9kZCRpaWkAjqKNbPPGCqAEcFfrGhWHeKPK1rdYLGzcuJGmTZvS7d7qj9rmje0MlAJE0b6LnunO7l/Tef+7n/D7/QB0bVjtJeCla87hJih4+E0IZQOngJPAieDfrMjBk+U1fR8G+gFTIgdPPlzMdbYFqvPHLQ46VJPasD/YX0PjjqEJG43/eqSUUgjReeXKlTRt2pTdu3fzzTff8PzD912yzRvbD6gH1A3+jUq9ZGPn6QtsmPMJjz76KJ07dwYgKzcvRkqJEEICTqAA8AJeIYS30d1lCyxGfUkgGsDmcp9EFWiRgDX4MgKxwdfNcNjmjS0qfE4C7YDHgZ62eWPHAjMiB08OFOnzCqpJ7I9iBP5hH9rhJevsdXdMA9PQ+CNo0Wga//XY5o01PfzWJzMOnLvY1y8xfvTRR6SlpZG5Yx1Tel0XJ+AcmrjaV719z8hAIMCXX35Jt27dqF+/PiNGjMDvtL9zZNoLYyMHTy4o7lxCiFkzZ858NiUlhQULFgyWUs4vPGYIDYkP04e01wmlockQGvrPjk1X9WtWLx8oDVQCKgP3BP9a870FrNhzhO3HUsnN93BP6SgSWjSQcdHWQq3qONArcvDkFPvQDiYg50yuy/DFsTSOXnYikdSMsjCoZnmiw24WJ6ByJtfF7ANnvNvTs9ccznGOl1LeyMQYAvwTKFvkbTcwU0p55pYn0tD4A2iajcYNcU/oYQLKAX4g1ThxebEL9J+Nbd5YHdAQaBOQ8uHnP1n7YM2ypZTBre9lzb5jbN++nTZt2vDdZxn59706L/+S0xVoV/ueBbOe7jQLSFvy06FPR9zf5sn77ruPCRMmULFiRUqWLEm3bt2YOXNmnxLPTOnEM1PygN5SypOF5xVCdAPqF/5fp4j2NUpHnfvuH92S5/x4MEIJCf21U7ce1K1blz179vCvr77xdosv82ph9ysvAaFmU1Sz6Z9+WLFOwxa9BrxAVFQUP//8M/dN/FAkvdyXanfFAFQBNgExQGvAMzTpgKFO18d5olUrFEVhy5Yt3PfxQow6hQNPtUQRgoCU9Fi7i8crl+WJqqq88AUCdFuzi85PD9I3zc/vfnj+fA/w5A1ucZPq1atPfvbZZ6+8sWPHDpYuXaoDXvwTPkINjevQhI3GVbgn9AgB+gAjgWqoeRwAoe4JPXYDbwAbjBOX/2kqcdDXUgloE3y1RvW9cMHmYPOpi7z00kts3rOHuAfaMHLkSIYMGcLPp87v6tix44MjO3dmyJAh1T7beeA8AM9MmT5jxowAagBAxf79+zdu2rQpM2fORBHi4pS33qq7f/9+snfveOnc+IQUoHRKWlaVUqVKPdmvXz/q169P6dKliYyM7Db3w/e7SSnpUrMiCw6dpW7dusTExNCyZUtCjqcMBgZfd0ESChwuyppN1KxZkyVLlpCens6ECRN4c/Jk3l2ykLkDOiGlDPhcHt+58Qnf6iKi4nW+ggih03H+/HkmTZqEoijMmDEDv99P0tJP+fZsJh0qlGbiz8e5J9J8RdAAzNp/hkqNmzB48GCOHz/O/PnzbxZkEBYXF0flypV56623AEhPTwfQAgs07hiasNG4gntCj+rAOtQn7cLwrdAiTZoCy4H97gk9uhonLv/Di1NQe2kF9ER1jFe4psmvwEZgW05OzmfJyclUr14du91Ohw4dOHbs2CrgcJ06dR48cOAAsRZT+rnxCc2B0qnjBpYO9i/95f7jgdk7dnDixAmG3F+7YNOJ1LqNGjVi4cKFvHlfrWcKTxZjDsPn85GVlcW8efOuTCJEUX31d0WYGVgznmUfTqdmmw40btz46tkqOggNReiNCLMVYY7g6W4Glu/YwVNNG5NeJpKZM2cybdo0Fs94m7xsF9LvU/D7S4N4xB9qwB9q4M3OLViY/AsZthwOXcjm22+/pUKFClSJLcm84xk4DWZ2ZjlY1rMlbgGKDHAq2860Q+dZs2YOb7zxBr169bqtz+DixYscPHiQ7OxsgB+B927389PQ+L1oPhsNANwTerQEVqM6qMXNW+NFjcBqbpy4/NTtniOowdwHPAH0QvV1FHIZ2IwqYDZFDp58uvCAEKIk8AhQqbTZFOhWu5LjlZb3it6frX++YtNWdy9fvpyfn+1BdPj1D/P+QIAtp87j8vpofU8c989cSrdeT7D3uzWsGdgFERKKUrYCulLl+OnoSe+p9AyPD9x+idsvyb+3Tq3LDWtUywvORM76/Mu7zrl91Rs3bsy6L784v+CNf6l+kUDAL30FBXjcHumwOQKXsxwBhy0fv8+fluc2dXrvk/5vvTejxIkTJzjyw/dn5o19MZ1AwApEIGWE78zRiEDGOQHQ+9P1NOn5FPXq1eOuu+6id+/evPtQfd7YlIzX7+fLPh0obTFdub5O/17FM+NeY926deh0OhISEnh3wthLq+fM2BoaXzkrJKpkfpHPVM6bv6D8mvXf9nj33XfJyckhLi6OF154gVy77ccN69eNOnnq1J5adeuXRA2MOC6lvKn5NOgDqoHqA8oGUqSUNw1QEELoUQM6Cs9x5mbtr+lbBogCTkkp3bfbT+M/iyZsNHBP6FEF2MNv2sztEADSgFrGictzb9bQNm9sTVT/QW/g7iKHTqImMK4C9kUOnuwvPHBufIIZtfBk7SKvWkDJwjansu0sP3CCZhXL0qRCmeJPbgizhVSq4VRiyngI0TtXbNsR8sP+Q8aEJx4/WrNmrUxC9ZfIz9vhO3N0S+yj/RzFD/IbQoiBAwYMWNi4cWOGDh06V0o55BbtrcCWUaNG1W/RogXdu3f3+ny+ilLK9Kvu0dAOqxGiU0AoDN60j2P6EpQrV46xY8cyf/58rMd2c9lTQK3S0fRpWB0Z1LiWphxnpR0GDx7MgP79adehAwkJCXTv3p3Z3VvRsXpFgEzgQPB1cMHPh7Lf3LLnC7/fnw1k1axZs+HWrVuJjY2lXdu2izclJT1utVoNVquV0JCQs3t3/bwcyAd+ALYZwi2uItdXSlGU1KpVqxrKly9PRkYG+/fvz5JSPiql3HmDe/KUoiif1qlTh5iYGA4cOEBmZuZSoL+U0lNcnyJ9W1osli3lypXjyJEjB6SUdW/+iWn8t6CZ0f7muCf0UIAVqEmBvwcFdeH/CNXHcxW2eWPLo2owT6IKikLSgaWoQma3I/ViCKqj/DHH+ISigqXirSZQKdoqR7dtciq0btPLulJlbRjDLguD0SGMJqcIC3cIkzlPhITmADuAY5Fmk/+Z1h15prjB6jUu7t2rCNZmiy7ylkUIEQ7chZo/kw3MKtQEhBARwMZhw4bVf/jhh+natSs+n683cEEI0RZopdfrkx2ZaYTc19rk/zmJH85n0r1iaUoYQ1l+4jATJ07kpZdeYnLCOs45XATy8zkXGUr1KAtSKBw+e44nho6madOm7E1JISIigqioKObMmcPMV8dx8pIdnSJK9WlQrU1kmKENQI/a9xCmDwk8WLGs16QPPXvv+1/U9fl8IVFRUaxdv/6BpKQkQ2xsLOHh4ZQvX14xhFtGefIcZqAlMNaT5yj8rsixr7x8eePmJMPYsWM5deoUderUwev1luzcufMyIUSclNLP9SQsXrwYvV5Peno68+bN48UXX+y1cuXKo6h13m50/8OFEJsTExPp1KkTRqOx2i0/NI3/GjRho9ETiOOPJRIage7uCT1qGCcuPxz0w7QHhgb/FppuLgPLAj7/13kXsguQ8l5gOKpQqcbN638VkoFQDobWb+rUVahWoESUyFCiSmUJvcGOqhmlRppNd1pN/zkuLq5+dHQ0FouFuLi4JzMzM7t5PJ6d/fr1e2jv3r0cOnToKPBtsP2MIUOGNBo4cCC9evWiVKlS+Hy+r60W849nU881HDd+vH7SpEky/cKFriV2b9tU4A80fWJDiqFuw3v5edPPmM1mZvzzKfbt20e228tZp4dWzR7hXxtXsbxjI4QM0LJMCf7xwvM8F1AvvWPHjiQkJDBkyBBCFMUd16Cx0e12o9t3zDm0SR0zwOyfDvKjS1He/mnzPQ6H457+Tw/AZrPhcdjpUatS+bZt2xIdHU1ycvKVCzeEW5zAmuALAE+eQ9e3z1MdvlmxMnXE8OFGY5jRe+zY8XKpqamUK1euzLlz5+KAM8Xcx6MJCQmt3G73NsC+du3aLmPGjGHlypVtuImwASY/9dRTyt69e+nU6YZl7jT+S9HMaH9z3BN6nOY2tIib4Je6kLWeMpWSUSOz4oPve2VAri3Iyz/ssTlMSJqghjPf6gHHCRwCDuqq1b+kb9giUokulaWYLHmARPXr7PsLBMt1CCEK1q1bd9X8hw8fzokTJ9i+fTsvvvgiu3fvflhKuSnY/of33nuvSdWqVa+0P3/+PM8//3y2Xq+PPn78OOXLl/cWFBSYLw97tFpBfv6PdyVuDv/kk0+oVasWLpeLzZs3M2nSJJ6uXJpFp7KYP38+i8aMYGmHe6+b36bULKZdUnjkkUd44403lgGuefPm9du+fTuLFy8eljpu4JdA7Sc/+3Z8xeYPtXjuuecwGo0cOnSIV199lYQqpenToBrpuU66frmN5ORk7q9VQ/48rNcGoPD1S9ykhVfdeyFEaZPJlF65cmWlTp06PP/88zRt2pS0s79+ZLVavwe+MoRbAkXa64CSUsoMIcQ7ffv2HdW5c2cef/zxb6WU7W9w75uWLl16x+eff0779u3Jzc3FaDR6pZSGP/hxavzFaMLmb4x7Qo9KwEH+WC2uK3hKlQ8U6PRKSuoFTl/MsUeGhJxvVDIqJERQ9SbdfMBRgoJFuav8GWOnfpWUyBivUJTCL+VRYF2k2fRfsaWAEGIEaqBCUVJDQ0MHz58/n6effjq1edMmd29au/IhoNOsufPLJy7+rNb5tLQLly/bCv1BErjYrFmzp2vVqsWnn30292xaxgYCAZTxT81Zf/J8yc+PpXH8spPw0BDqxEQwrG5F5h46S8mufVixYgWvlw+jTXxJrsVV4OelH474j4RGpmZcujTowoUL//7kk0/KJyQk4PP5oqSUl4PXUQ74F6rwD48w6i/0rlvl5/FtGvuB2hmOvMadl26NTU5O5oHaNfjphaui2y6gCp2NwKa4SQsvCiHqVqxYMWXixInUqFGDtWvXMmHCBOLj4ozHj/zSDOiCquVeAN4v9PkIIV6sXLnyu2vXrqVDhw6cPHmyi5RydTH33QicX7JkSfQ777zD3r17nS6Xy2w0GgEaSSl3/5HPU+OvRRM2f2PcE3oMB6ZQRNgEpOSut9eQMVot8bI/w8b985M48OzDVI624PT6qPPRBg482xazXn3I/9FGQae5q0MrV6/BPffcw6lTp7CnnubjXg9TMcpaOHQ6sB3YTkjoTvOwKfcIvaFQo5JADrA00mxy/iUX/yeiKMrSCIul5bTJE394us9T54HvgeV6a0yxPy6DwRhvMOjX6vV6w9wFiaNbPfTQqlCdkIGvZn/DT5vaoW6MdhXfns1k/M6jNCodyUetaiNE8QGDSq/ncnX3PRQBvBluCgPVbzZFSrngdq8nLDQk1hodcyE5OZkG1au69734ZAAw2fI9FPgDlDRf9WyS4gsENnT7eE3pQxezDQFJ7+TkZIYPH87OnTvboBZKzZNS2j15jnjgOcA4/MVR1TZs2tR2zZo1DBgwgOTk5LellKODkW13ARmFEW1CiIebNGmyYfbs2cydOxdFUXjvvfcYPnw4c+bMyQ0EAiWklAE0/qvRfDZ/b3pxjVajCIFEEqwhxsK9v1LGYiTXoyoXSw+do1OVMlcEDcCGA6dCnnnueVq1akVKSgojR45kz549DHz9Xxe3DOkxGthuHvl2htAbE1Aj3h4GVkeaTV/9ZVf6J+O1XwpHzbYv7b6cmQF00Vtjfr5ZnxyHqzpQ/cKlHICOURZTKoDDlR8JzBF1m86RP21qW1zfduVL0a58qVtNyxn4fs0wXaMWj4HIy72UteXyO/+cEj8lMe92r0sI0QIYU/iIkO1yi4qTE9e2uqfcyZ8zbK+EhoaKYQ0ry4GNawqA7b+m1Ru4dFO9hnGl6Fmnsm/ZwZMyEAgIRY2WmxATE/Ngfn6+TwjRQEp5EHhZCNGnfPnyw9auXcvgwYMLfUM1hRA9gVFxcXH3paWlnRRCVAsGGOSdP3+eWbNmARAcG5/PB+qDisb/AJpm8zfGPaHHOdRyNFdR8b11HHquLRJo8e+tNC8fQ7fqZWlRoSRNFyQxu1MD6sRGXmn/9ZEM+q9Ipky4MSM63PjTsct5j166dInIyEhOnj4zJsJqDQHpC/V7lobKgnzUgAADqqALQ42EK/xb+L4R9WHIjRrldSn414a6LbIn+CrQl4i9I19iEVQfZPBH4rVfikOtqGxADQX+UG+NOX+zMXIcror8VgLnSJTFdFW9Mocrvw3wFDDEYgrz2Id2eBMYwe+PDvSjmiTrW2evk/Yd345y7d05reDCOQXIAlaiRuX9CJyIn5JY7D0TQqx89dVXuzRv3pymTZuyefNmPvvsM7744ovM559/vlStWrUYNez5z478s98a4OEZ2/f1cNd6wNq2bVvS09OpX78+Z86cYdg/Eoi3mr2vzVmoX7hwIbuSNj593u78JHiO7zdu3Ni8UqVKHD6sFr9OT09n/Pjxl7Oyskrk5+cTFRWFy+WySCmdwc+hE6rGowghPsrPzydoRmsgpdz3O++Vxn8ATbP5e1NsheEIQwgOr4+1xy/wWI2yeP0Bcj0FpFywEapTrhI0AN2rx9KqyXMpJfqNTvpgXuJ9Cz9exKVLlwgJCfFHGwIlQ30OF2q025OovprCastu1EW78JUV/OsKHitAXXQLKzHfjVp5OWzw8y+2WLXu28ZGo8H3wdtT1nfp2P4ixSSjfrcpKWbI8FEdch0OUyAQUJBgNofnzpw+bWrXTu03AOeA3KICSwjRGxhLMGT77ooVLo5+cfiPA/v33QW8qrfGuK49T1FyHK67UJNXQY3G+ibKcn1Ag8OVPwbwWExhA4q8/VrAYHxE8bhrc3tReoU4Aw1b9C8x6GUJYF+7tHFITGnFUKUWnuO/lAQ5CBgUbJudOmbAj8DnwJJrBM+hjz76qEtiYuKVN+x2O0BE/fr1mTdvHnle3+q4SQuXAkveV5TZge0pPyUlJelKlSrF1KlTCXHa+HfPh+icuFofGxvLd999x/f/6Drv3PiETsAnOiEO9+nTp7nB8Ju1MFi9IbdmzZolvvnmGyIiIk7nZGbkwRVhvxquPAAMrVKlSm0gWRM0/ztoms3fGPeEHjbUxfsqmi3cwsePNmLgyl0s7Xk/nx88x11mIzvPZXNfuSj61C1/pa0UAn+1+/HHVjy75FTuxdGjRjROSkpiwoQJrFu37k0p5fg/e95CiEYxMTHJW7duZf78+bz//vuvSSlfv0Hbl4cMGfLWyJEj8XrVpPaJEydy4XzqtE1rvjmNulVABL+Ffst76tz7j3ffm2GuXr06oaGhHD16lH79+mG32+tKKQ9ce44ch0uHqr2URRV4GUBylMVUrB/B4co3AfOAORZT2I5rxooXX84KKLu3rAaqcuvgDT/qNghtfdOWJQDDoi0mb+qYAa2BzcJgxFilFu7jvyA9+cX1fyh+SmLSNfesLFc/iOYBc+vVq9c9JSUlC4gt6iMJ+lmqA1HlS1iyNg3uXloI2jZ4f+no+Er3KE3NgnEPNboymJQy83BmzqpdqRe/nrQ5+bDXHwDVHFYhNjZ2G0DHDu1fnPXB+zVQg0TeM4Rbij4MhKJqOWlSyv+K4BGNW6MJm78x7gk90lB/tFfR4dPtdK9els2nM/mi5/3M230ap9fH3N2nSRn6MAZTOIHaD0JIKEiJciyZ1f5S5wdNmlFu/fr1zJ07l02bN+/duvPnSVFR0UUXgwBqNnsGcLFkhOl377kihDAAqYsWLSplNptJSUlh4sSJNxU2o0ePfsvj8fD+++8Xvp0DPCil/EUI0SA0NPSxGtWqtouKijLc37hR2qLPPjc5nHlNc3NznYB5zpw5nD17ljMnj/348dxZP0pAIqIlogSIfJ/Q7fIp+q9KRJhTbzV/hyv/AeBZVLPZVb6UHIerJCCjLKZL9qEdjOjD5uLz9iTg16NujHYtTsLCT5Gf18U6e11qtsNlQPXDLY62mGTqmAHTULcSwFClFv7L2fiyLlw7Rtv4KYkbbzVvIYQJaAbskVJm36p9sE9c9VIlGi7v1ynKbAh9CrUW3rXa50HgE+CzuEkLM4QQ9VHXpb0AnjxHPdT7dRZ4yxBuKS5JVON/AM2M9jfDnpcfgVr4sptB9YFcJ2ws+lA++OkkM9rXC/4/hJnJJ+nc/H5Cm3Ul4HWjHNiK4lNlxf4Mm0z4/LNy69atIzExkU8//ZQSJUpENK5bq43dbn+ucNysXFcIapHPWKBGVq7rZmaifFShlAHklIy4oiWM7dq1a6kLFy7gcDiuOItvRf369enbty/JyckcO3ZsD5Cadupo+5CQkHVjxoyhatWq5OXl8fnnn9dIS7+wDpgEDFMUBYPBQHZ2NucvZh93hkR8HxzyKHDc7MuN0El/V4Pf+4L3slMhuM2ABE8AZZdbZzoqhRINCJ3CY4DJHyARuD/H4SrclgBUc6EFyMlxuATTlmGQ3kzPwd2Ddad/GSD3fF8Dr6eUkIEA4EZv2Bna+aldSqPWu43WqFSAaIvJk+1wfYsaarwSGIcajFHPc/wQoWXi0JevhPdssJydoqQRCNxWbTEppQs15Pm2kVKeQzVTAvz73PiEeNRqE/1Rq0aAaqp8B5h2bnzCd6njBn4SnDsAhnBLCjDYk+eoCszy5DkygYmGcIum0fyPoWk2fwPsefklUAWMEXUr4y2AyzC1z7+Al7nGNzB41W52nsvm4LNtCZSqwOpMP09M+oC9wztTPSL0uvHHbT7kiWj7pOHFF18kJSXlyvvdunVjx7atKyqUj88GdiqCdQazNeN25pyV6wpDLdRZBtVfI+bPmV3h7SmTPli9ejVt27Zl1KhRKIrC4k8/++bnfQdGAxklI64OnRZCjO7evfvUWrVq4ff7GTBgABMnTsSWnXVwzocz3qlYvc7cnj17Gg8cOEBsbCwLFiygffv2pKaeuzB37pwyDz30EMeOHeOhhx5i6jvvfth/wMAzhUPzm6AIFHlPRUpFJ33xOukvCwGP1BkaEPClK9J/XqIc8Sr6LQjFg2o+kqjJsGeDY0kgYJSeLn50AT+CgNDZKPBaCARC0RsKEAKj39XVqzMeDyCOgrgyB6netzABZ/0Xz9/l2//jsID9ki6QdgbFEEZIydJ4jh8qcpOU5cjAS/FTEs/wF3BufEJhQdZ+qPXySlzTxA58iarx7CyaROrJc8Sh+tNygX8Zwi3ajqT/I2jC5v9T7Hn5RlQBE4VaLmaDNTzsKqO9e0KPhsBWrinAKYXAX6clMsyCcuk8upN7b3quZUczCoauPxCi1+uvMpHYbLZTLVs/VOOrr78pFULgYR3yAaFW+Q0EECd9KAcDiCPAySiL6aZOd1AjpebMmdNl165dbNq0iWHDhqEoChMnTqRS5Sqj121M2n3ttSz57NOyUya9Pqh2rZr2MIOh8tlz5+O++OILmjVrZjv+a+pnn3+2uFLiwgU1XHl5+qNHjsSuWLGCBQsW8OuZMzt/OXSoSUhICO+//z42m41x48bNk1IWW1rtRjhc+QbURfN1iynsiPdyRijwANARNapNBhARArlEQJK+RKwfwJObEwr0AOINEVHTihvba8v8QOr0E4HqBkvk9qLHsh2uB4GL0RbTsdRXh74uLJETlDLxCJMZxRxxQWexlinISAMkSAkInxJValtIldpJitn6C5AUZTHdsjDp/5Vz4xMMqJFm/YEOXG8uPAUsAhbFTVp4pvBNT56jJPAmsM8Qbpl9p+ep8X9HEzb/H2HPyxfAg6jlZ9zARmt42A3t6/l5zsrs+Ho/P6wOEwQIlIjFX7UxAoly4HsUl/22zivh+49KPNjn4bZtxwkhQn/8ceecZwYlnAbsxbNY+LYAACAASURBVDlwPU57CNBASlpKiJOICL8qfI5IxA2fVKveXWHK6NH/rFFY/qXw75QpU1i2fHl6iE7nNZnC7es3bl4TFx8fi5TKkkX/fnDd+vUlW7ZsmXH46An799u2NNqwYQN169bNqVqt+k/Hjh2tle9ylXv77beVcuXKkZ+fT0JCAnHx8eviy1fYsOvnnxq3adPmyf79+9OjR49VUsqut3VTAIcrvywwA0iwmMKKrYyd43BVCA14swwBd1tUn4hqhhNKeWTgLZTQVgZr9NTi+nptmQOAI1KnL2OwRH5z7fFsh6s78H3e5OfsQDJqSX+AYYo5IsNQueZM9y97S0lvkULLQslXylX82tD+yV90MbGFn0XRRcKFqhmfuFEAxB/l3PiEUqhJqP0psmNqEb5HFdzL4iYtzAXw5DkeBAYACw3hlh3F9Lkpl/q2jkM1NbZADZa5ACQBm2IWJ13+I9ehUTyasPn/gKAW0xk1qmqbNTzs5M3a57vdoUCXQCDQVRGir/+XnQUy83yosGWiO/rTLTezuYY89+OvJAbK1zwWZTHNtDldOlTTXHlgRaTZtP5WA3icdiPq035TVFOfA3W75L0Gs/XKFzQ0NLSdEOJ5RVF0oaGhdUaMGHFXoWYTYbXmvPP221Gffvop9erWnTbtjQlWAQUlysQ/MGTo0Ibnz6vpMCNHjmT16tW8+eabXyiK8kRKSgp16tShdevWxMfH889//pOePXty7733YrPZiIyM5OWXX+a1114jLf3C4hXrvisuETWHoH+pZIQpD8Dhyr8f+Acw2GIKK9apneNwlQY8URaT7bp7Ys8eSKAgBkQrgTyKKoROAAv1JWLdAF5bpg6YLnX6rcAqgyXyqsU/W/UJ9QW+zpv8XAzwQfDePh8/JfHyhQ9fMxqr1lqQt3tHl4DDbrlmCn7UytzT4qckHiwy5wjgIdQHmit75KBG8/mBfcD2KIvp/+TIP6dWAO+H6uOJveZwPrAYmBE3aeERgOz1S+f60lNboNP1K/30yGRuwaW+rcsA01C1Rz+/acQS9R6FoG4mNzlmcdIttW6NW6MJm/9h7Hn5pVGrKxcAa6zhYbdURfLd7vpSyipevzQC1XUEauvmvvyAYs+41m5+O/iBZPfoxXMCkkmojt1RURY1yszmdPVGLUt/BPgw0nx7T8Iepz0CdXvohn5JuBedPoBIBVG4gHlaP9isdIhOGSuEYPfu3cOAD1JSUmjbti3zZ73/ZruH20zQW2MCQogVbdq06dq8eXMAfvjhBzZu3HhSSjn07rvv3jho0CDGjh2bjrqwTXjttdce9Pl8rFy5kieeeAKHw8HGjRvZvXv3D8DDUsqrTJFZuS6B6nOIDb7CQxSaKYK7vX4WX3NpPuAikKFAvhDooyym63xYntwcBfUJPxZ43xAR5QPwXs6ohSo8jMGm+0DcK0MMU4CyBkvkdYtsthqW3a/GPXefycy82AY1PPscsFhKeRwg7+ShpxybV7X1njnRg2Duld3t4fOU4+R5C8h2uU/sS8vaeSTr8l5g7o32nPnHM0P1gYB/oNPpfMRus5lbtm59cvCQZ0+hCodVURbTuWv7CCHuQzUplkf11XwLrC9MpD03PiEEVfPoBzxa5Nr58ewFVv1y+uSZy7nrP+7VtrMhRFdBGIx51p6DF+rj7n6xaPHPolzq27px8Dxmrt6J9lrygVTgoZjFSWk3aadxG2jC5n8Qe15+NVQt4CLwrTU87JaROflut0VK2dnrl+VRy/r/ACyINJsC7sVv9uLML/+mwHPbWeuBEqUJtOnnE7aLj4Q375pkc7piApLRqI7uyVEW05V8FJvT1QD1Kd8BvBZpvt4/k+NwKajaTRPUJ+bgF1NmGPFd0AmaoC40R4F1RktkHtCjQb26sZ99vKB6gwceHNizZ08WLVr0lZTy8cJxg/vNdEHdiE0Ch4GvgU5Vq1ZdZrfb0ev1pKamUqpUKVauXMlbb73FypUr/41atcAJ7EVdAG8pLB2u/JGA22IK++jaY1m5rlCgFOqWDjWC41+HEW8jL7rdYfgezMPwJnC5ZMTVSaHeyxlBJ7uYsfOnn3/du/9AVZvdvrJ5kwcmPdy5+1VahdFoHFS2bNn5vXr1oqCggJSUFHbs2IHb7R6PWjct4LVfalZwMc2cnTijETB8zs+Hon8WEbRo0YLc3FwuXLjADz/8QMvosC8mtr3/xfgpiRevnbcQYmGdOnUGNmvWjJiYGCZOnHhJSlkyx+EKB7pydeSj3L5ta06/p57497Bhw6hUqRI5OTkkJiZy6NChD6SUw68d/9z4BCvwOPDs6Wx7vY6Lv2X06NF89dVXjKhe2t62Snk1Z0zRnY8aNPqHkOjSnxvCLauKjnGpb+v7UM1kt/td96FqrnVjFifdVnCLRvFowuYvRAjxAGoZ/gaojvKFUsqJN2mvQ92rpR5gVBRFMRqNolnzB2d99+36cbd73jyX62GfpI+UXAIORJpNnxQe8zhspYD+8p1BLqR8m9urAC39PV8KyEr1dFKy2xIediVjz+Z09QlIuqNmzV/1ZG9zukoA/5ISo1TLztj4zR8ggd3cwgTjcdqrIWVHZKANMhAB/CjgFUNkyX6oQvRdKeUtF4XgxmbTq1SpMuijjz6iTJkyOBwOPv30U2bNmnVCStlASnnbRUEdrnwBTAeSLKawNTdqF0wAvTvKYjpxw2vMzXnKiX51GN4xeRjXoAZ5FHsZ32/eGPdk78dndu/enW3btvHBtDe/6NKxfRbq/VwLbDJElZnUr1+/sTt37sRqtXL//fcTEhLC9u3b2bt37w7gESmly2u/VAson/HWP7cO+GrTsgf7Dmq3YsUK0tPTadCgAYFAgIsH97Kqfyc/sB7Vf7I6fkqiJ3hPt77++ustfD4fY8aMwWQyuaWUxX6fchwu8f5701vMnvnhlkceeYRjx45xzz33MH36dGrXrk12dnY5KWWx2kTH6hWV70+nHX/z7XcqderUiVdeeYWWviw61yi6CSzHoga9PCukZJnawDBDuMV9qW/raOAYV2+AdzsUAPuB+2MWJ2l5Pn8QTdj8hQghUt588826jzzyCF6vlyZNmpyTUsbfpH3lChUqHE9KSsLlUpWBnTt3Mnjw4I1SymILNhbF6XLF+SVvS8lp4CsgEGk27S887nHYIoAXgKkGS6TPPaFHN+BTVHv1jXJgXIDL/0CXQbLF4+P8EjfQ1xoedrawgc3pqhaQvIG6bfQo1Aij3vxme5dAvoAaQhAA5kSaTYe4BV77JT3wBqoj9xOpCz2JaoKpTNBUAxws6ue5GcHM91Go0VBVUc1LScA0KWXW7YwB4HDlh6IuvG9ZTGHXVRgoJJhXU+3a+mjX4snNeSr4zx2GiKizN2oXLN2yaeLEia2fffZZ+vbtS9n48hMnT5u+BylFWMD9gA5/zc1btlpHvTL+nrT0dN3zzz9fKjc3FyklI0aMYOzYsXz99dejpJTvAnjtl8oBzY0lSlV79dVXJ0yePJmNGzdit9uJjY1lUJf2rH66c9FpXEb17SyqOPXj6IBkgKIojzmdzpsKmyLX8CSQgOrzabl7924GDRrE4KHPvd/riScLzW6bgf2FJX+EEC80a9bsg6effhqj0cjKlSuLEzYAF8Mf7NAgvGnbScBax5Cu7VDNkH9kD5w84LmYxUmf3LKlRrFowuYvRAjxffPmzZs7nU5WrFhB+fLlbypsGjVqXNdmu5yycOFCWrRoUfTQ81LKWTfql5vnCpUwG4ki1cKR1YHLkWbTlcABj8NmQl1o3zZYIq8k9rlPHegv1y5ox6X0bgLpAUXQsHUoe5J8EECWjJvre2zU95YycasAHHn5UwJQC3jUGq46wnMcrijgadSghVKovpw5hVWOixIMKHgedbG/DEyONJuuyqz32i+FAK+jPpG+prfGXO/ncNoLzWV1UM0eywxm6683ukd/Fg5XfilgNmogwE0z63McrmrAseLqpBXiyc2piboYtrlRyHMhQoi+9erVW/Tyyy9jMpmYM2cO69ev7yilXHdtW+/ljHrzEhe9+trkqQ8rii7c7XbTu3dvGjRowHsz3t+wI3nPzMK2igyYhgzs90KtOnWbpqamsmHDBqKioliwYAGPtX1Ibh/S40YxJBkF/sCGKtM/7fc7hE2pyMjIi6NHj6Zy5cqkpaUxYsQIAKOU0hM0r7ZF/Y7xw47tUY93f3TMd999x6OPPsqHH354M2ED8F7cpIUjXScPj3ZNGvE6fp+xuEa3SRYQF7M4qViflcbN0SoI/LU8sX379odKly59y6cje15+2xGjRtV97V/jiY6OZsCAAfz6669s27YtU0q5q7g+NqdLEfA6gmoCXoowm87anK4WwMlIs+mKScLjsIUDI4F3iwoaAFEq3lcwaOr60Lf69Aca0fufo0V81S6yZtMpntJ3H0DRhSqCuCvtBVMIyAUSfshxuL4unAowN8pietfmdLULSP4J7EF1tl5FpNnkB94Pzj8GeM3mdJmA3Qa/e5GOwDjUytST9NaYG5aDMZiteahP2F94nPYYoIfHaa+Aqq0sM5itmTe94X8Ahyu/AWqF5l4W0839ZjkOV1XUfKJbPd3VQy2QeVPNVQgRGxISsujdd9/lySefZO7cuTcd1BBVZj9wLjo6Orx27dpUrlyZ3r178/LLL2M1h+0sGWG6atOyHTt/sqxeu66plNLu9/v1UVFRYQBpDpdb37HPl4GL51sH7NllkVIhPw/pzEXm5cYqAU+/wjH0OkWfOmbABFST2574KYnF+bw8Xq+34IcffgjNyspi4MCBlCxZkqysrLtRq2QHUJ353wJ06dBu7dSpU5k5cyZut9tJMIrsuW+2cm+50j+ViQgPR00ELoFq/loK4Hr9+TD+2NbnV91GoHXwejR+J5pm8xcjhIgtXbr0heTk5GI1G3tefllUZ+rGSLNJli1b9sTo0aNJTU2lbdu2OJ1OHnvssTNSyipSygIAm9MlgOcENNMpJJpNpu+C77UDfow0/xZa63HYzKj7sEw3WCKvctR7HLYSEpoV6AxRFlPYJwAep70lcC/wnlvoVUevlFF+iQ/1hy4E6BUFC4gL1vCwd6+9ZpvTFR2QJAK/RFlMY251j7z2S4ofZRbQwitC90lFNyPSbCpWwN4Kj9MeDzyGqmH9AqwwmK3/52RFhyu/G2oww2iLKeymP6Ich+tuID3KYrplaZigCc0GXDBERN0wm1YI8dXYsWMfy8zMZMGCBVkrV64sGdRsdgPNpZTuIm0FML1Ro0YvRkZGYrVaqVOnDm3btuWVV17hXOqZQ32f6JX28ovDjiuKsl5fIna9ECJeCNHs4tmTgeZt2pU0GMM+WLBgAY0bN/YC7UJCQu6bOvblqCfKmmMKMi80ESZzVREeQZ7PT41h/8LpdFIiIoKDH7xBqE5h2U9789Mu52Z2bFD7+2olI7+TOZlb4sfNuIiayOlA/S5NS0xMrL5lyxYWLVr0Mr9VBV9ceD1CCF9WVpbu6NGjSCmpVq0a2dnZjBw5kgp3V1oyacrUvahRkl9HWUxnCu/Bpb6tj8JNd469HQJAYszipEG3bKlxHZqw+Yu5kbCx5+XrUBdFD7DSGh4mgwECC1EjYk7qdLrXjx49qu/SpQtHjhype9mRdxBIEHCvTmGfTlE+DjMaPTanKwT1R/xdpNl0ReX3OGwW1Cfx6wRN8PiTXkV/ACEMFlPYHgCP0/4gkJInQ2sDzYWgvpSk6gQbrWbTlVpZTlf+a35JKGqez3U1tGxOlwhIXgfuVwRdIs3XL7xe+yUBDEetlzVDb405aHO6FNRItjqokWFTigrP34PHaa+FKsgtqNF46w1m6++useVw5Q8DFIspbMat2uY4XPFAdpTFdFsbmHlyc55ErRrw1s3aCSFkTk4OX331FYFAgPbt23P48GHGjRvHvn37BqFGKh6RUp4SQjzdoEGDxDlz5tCvXz9Onz5NIBCgRYsWjBs3jl69eqHT6cjIyBiR8uO27OpVqzxQ9/4HuyohoWWPHFHdS7Vr1yYobBx6vd74wgsvhE6fPj07z5XfEOjkXL/04PCJbw5ZcezcEwaDgYyMDEqWLElBQQFdqsRxwKujZs2ayFOHeX/g4wiThdV7DzmmrEmy5ObmYrfbKVOmDFu2bKFfv34cPnzkVNOmTSplZmaSkpLSNxAIfBq87jUREREdC+/DggULWLt2LZ9//jkFBQX1pZQpOQ5XCNATNeoPmX3RL/+V8CY38NUkHk/jiM3JtMaqLJqccprzeW4+alqjuObZQMmYxUnawvk70cxofyFCiFhUB2UhFiFEvxeGj7j89fJl717MyMjz+Xwj5W9PAOVR8x5+As4EAoFcl8sVYzAYmD7j/W5A7xCFDJ2izAgzGo8C2JyuCNRM9NWR5t9MNsFggGHAOwZLZLG15gGBEA2AxTkOlxkYoKCrGUC0RN3SeaoiRFcEWxRBH64uzDhVJ5jql3S35+WfvjaxNDiXCTkOV/OAZGeOw/WPKItpD1wRMkNQNai5emvMjCL9AsDcItc2Nvj3EGpgwW1nsRvM1kPAIY/TLlBDx9/wOO25wGcGs/V2KjYLYCrwk8UU9vWt2uc4XGUB++8QNI1Qo56u29CuGE517NixUuF/atWqxebNm0lNTQVY8Mgjj7B161aPECIKqNeiRQu6dOlCXl4ed999N5mZmVSpUoWsrCwiIyPJysqiefPmM+o90GKdlLLj0eMnms+cObNseno6H3zwQdHzWgKBAJ07d2b69OmKKcx41pXv/sjcvlfHg6++c9dLL71Ehw4d2LdvHxs2bGDZsmXMen8GT/brz/3338/aGfuQF1KRQMH5Xy3ly5dn+vTpmM1m8vLyeOutt3CeOempHmWOHDBgAEuXLqVZtUpPXvhxW6wSHZuZnpG14MSvvy4G6PdEr+cOHz7c/Ny5c1SuUnX41p0/HwWIsph8qCZVAC4NH/ooqpZUrLDpdXcsD6z6mXH1Cvg5087GtGzWPdLgRvc9nOD2BrfxGWkUQdNs/kKEEIs7duzYp3bt2owePZrx48eza9cujhw5crZDhw7la9WqxYQJE/4tpUwIth/ZoUOH6eXKlSMjI4N27drRsGFDWrdu7dl/4OBzd91VJhNYG2Y0BgBsTlcZoEak2bS56Hk9Dls06mI+/VofTSFuhy3UjxjvJbSqVLPA84CPw0VBAyDFYLbmAtjz8q1Ay6DfZlZRE5LTld9YSuoHVH9Dn2trsRUSzEJfBWwMD7gyhGqOStRbY2673IjN6WqIWtZEh7oD5ZdB/8/vwuO0R6HulBmHKlDXGczWYsdxuPJnAostprCbbv8MV6oD+KIsptsqxw9XtBoD8K0hIuq6vQCKIoSwouYOAUxbsmRJ04ULF0Ig8O9NSUkDL1++THx8PLm5uVFAJdRs+Vb79+/H5XIRFhaG0+mkb9++VKlSBbfbzcSJE2nRokWylPI+IUQb1O0JHlqyZImuQYMGlChRgosXLzJx4kTS0tIwh5uSVi7/ah3BvKjERYurzZo9t2ue0+krKCjwAoSGhha48pyRY8aNj/nwww+ZMqBXRstaVaMISL0z383bS1eQtO8Ap9IvUrlsGR6+ty4vdOtAnYQXWfLVV3Tr1o2Ti2dhDgsreu0F6HTu7w8c9k/59KuwCIvFP/vVsRdK3lXGjy7UhyhM/hVSIGVB6ikhsy5WE1tW6UWg+GeT1/eeJM8XICk9m68eqkdFyw3jGhzAfTGLk24aUahxPZqw+QsRQizq0KFD3/Llf9t8bNeuXezevZupU6dy6NAhFi9e/IqUcmqwfe9KlSp90aNHD0qUKMGJEyf4/PPPGTx48LtvTZ06PcxoTC8cx+Z03Q2UjjSbfix6To/DVgU1KuwDgyWyoOixYChuV6BqKL7aPpR1ITpdmsUUtu1K/6AZrVDYANjz8vspgnNApsUU9kvRMZ2u/FcCknVSLW/f2xpevD/DY7/0hB/l1QJC0qQuZFCk2fSHIseCvqkWQDfURc+Dmqx67PeME9R2mqNWZLChajtXtnx2uPI/AD67TUETA+iiLKbrEh9vOgdV2JQ3RERN+T39hBAJwDRrRIRn1IgXNi1fuabv0KFDGTJkyAYp5SNF2o0DxlssFqPH48Hv958zmUyh+S5X1KiXXtIfP34coz50ZeKCed8TdKY/1e/pVsu/WdEh2F9KKYUQQsZERzk2rFo+sUa1qu/pS8RetYK78t3NUP0jX5jCjK7C+aEmxvZJHTOgcLO1hqjabEOCuWSFY4xY/T2bTp7j1Yca07NO5d9zO65GUdDd2xJ96+7w1TzEttXFNjthz6PJ6mQWt6hNu7iYm41oBx6OWZz0h3yIf2c0YfMXIoQoDXRteG+jihUqVii7asWK5IKCAjsweNCgQc0SExPx+/1WKWVusL0YkDDoOafT0X3v7j2pVapUdg8YMGBTz549lxUd1+Z0VQIiI82qWaoQj8PWDDUH5WODJVLC1QIm2GxtlMV0yOOw9fHqDDrUJ/cri8cNhE1fAUuEYKDFFHZVGJTTla8Hpvsls4FnrOFhV2WCe+2XuqHmxqzQW2PW5DhcI4E6imALsKio6e+PYHO6jKhaXMXgW2eA2cX5iG5EMJrtKdTSLlu9IrQtQnxlMYX9cKu+OQ5XJBAeZTH9LjOLJzdHAAOBcENE1Ae3al8cXlum+DF517KO3Xu19/v9YRPGjx0xcvgwgSo4FED6/X55Pi0tzBweXhAdHZ0GbAuLKNHOarXOd7lc9p279vZoWKfm5hueQzV5PgWsJeC7BzXEXQAz9SViDxe2c+W7w1Bzq06bwozbihurKEEBdBfq51bhmldFVM3zD0aTKegaNEO/7guEr3gX3TM7fuH7C5d5+76qdIovebPBcoGmMYuTbpkXpnE1mrD5CwlWZe4NnLeGh10pCS+EaIT6A14hpdwKVxbNsUCKIUQ5gloFd02Y0XhV9WCb01UBKHlttJbHYesOeAyWyLVBAfMo6oZVElXAXKWRuB22pwp0hpDCKLQr4xQvbGoA4YqgUXFlWZyu/FpAG7/kJFDFGh72rtd+qT1qAMS3emvMVcUscxyuXkBtRWABZvxRLac4bE5XVdSkQQPqta8Att2OUPM47cIrQpbopN+nQ+4DEg1m6w3NYjkOlwUoUVw+0S3PlZvTDDV6cJIhIurWUWuqJlYDtShmKIVFMX3eRy/l2H91edzJ8XFxW4EjtxMEIYSIAXIv5eZVAcpFW0zf3qhtUOD0AVbprTF27+UMHWqEYyVUX9rsQm3Hle+uhVqJ/EtTmLHY8jy3Q+qYAYVbQZdALTgbgZrcG3HNy4qakCwUc4TBWLV26cDl7PBA8veVQtz5xZao+ehwKslZdv5RtRxTD/zKqrY39NeAal6uGbM46YbJthrFowmbvwh7Xr4BNapqmTU87KblVGxOVy+gqk7wXohOaQ+cCjMa9xTTrhxQLtJs+qnwPY/DJoBnJOxxoY9D1WwA1lwrYIr0qeATSteAErrSYgo7c9Wx4oWNAPoqAgPwscUUVsA1OF35w4GkQMDfOyTgeyBE+v6tt8Z8eqNrznG4WgBNFIFErVLwUaTZ9KfuxhhMIO0J3B98Kxf4INJsKnYRdLjy3wI2WExhSR6n/S5UzUMPfGwwW09fM/8woEyUxXS6mKFuihCiVOeOHaanpafX3rsv5TCwC5gnpcwLbsfQBNXcVHSvFwkcBzYYzNYrwslry7xXIgYaIks++3vnUUi2w1UR1bS1PPoGeUFBgdMXVUO98t3wXs64F/U++YCp+hKxaa58d2GkpRtYZQoz3pFFx2vLbABUk0AApYJP6OpLJaRAOO2mwPql7Qu2rddzjc9me8Zlxu46wfp2DTCHhtBq7S4+eKAataOuLYJ9BRcQGbM46brvvMbN0YTNX4A9Lz8aeBJYaA0PcwkhygOP8FsF3m+klNk2p6siau20bwwhikA1HawKMxq9QohI1AWgInD2siPvEHB3pNl0xbTjdtgiC1A+9KFLS79wIW9wwgDnzh07zKj5AXuA72QxH7jHYXvKq+hDLeGmj687VoywCV5Tf0VwADBaTGE/XtvP5cgNEdL/kyL937l1pjCESLSGhx28tl1RchyuKqih3J8JwT+Aj681Df6Z2JyuaNRyPYUVr5OBJZFmk9/hyn8T2GoxhW0s2sfjtFtQAxPiga8MZuuuHIcrFCgfZTHddGuHGyGEcAwYMMDcqlUrhBCsXLmS7du/T0/euWNW6VKl3MF5/XijwIVr8dgyV6PTP2awRP7hTPdsh6skqqb1efQNatV57ZcU1GrMy/TWmKvqyHkvZ+iBMaglinYAn/uMkWVRqzx8awoz/m6hfN35bZnVgIYSFL/Q1fOJ0FIBRXdZh7xLIDNCCGwVsEfKQEeB+NC9dAEF234rrnA+z82jG/fxeas6VLGGA/DFqQv8cNHGzCbVb3Ta1TGLk7r8X+f+d0QTNncYe15+FVTHc6I1PCwghOgWFRX1dadOnahYsSLHjx9n2bJlvhkfzvzgyaf6nNLrxBdCiA5AcpjReAJACPFIeHj4tw0aNKBy5cqsW7eOZ59/of+/xo1dBOoiLQiMUCAugJhQwhK+TwjxU7t27e4rLKC4YcMG9u7d+y3QpTAZtBC3wzaoQGfItpjCrtuAq/fjPcd8s3LVA16v9zL/j733jm+q7P//n1fSJk2aNGlayt57yt5DZCjKEAEZAsoWEIVbQAFFBEXAAQhOUFAQxHUDRVkKCjIUZYOyQUFK6UhykpPV5Pr9cdJaKmUon9/3vm99PR59QJNzrnNOenLe1/V+v96vF0yRUp6PXlfbXTt3XkpJKXJX/dvqvBLtCeoONCtZokSTRg3qJS1YsOAxe5Fi9cOS2Whd8Q/bLWY32sPdH/W1vwLRVNQMYLpO0BPtYfVyQQmbW40o0aAV0F0ImiL5TcIhtA70nwum3aIrjp5SEFMjBwAAIABJREFU0jiCOKEX8i2jxXajFgo6NFJDQ4A4q332rFmzxGefaWzqxYsX89RTT7F27drhUspFN3stAWf6AkRMqtHm+EO/080gU6O/9wJWJhXSkBp0ZejRAs4qgy35qr4vwey09sB9gE/CjHCcvRma9NCHZlPcDa9eg870YhLaSURyWMQ0CwsdEV3sJZCxsUTS9EQOCQgCO40WW57xWcDj0ge+St0S/GxpCyKRgk6gNwxPnNUTmxMcVXLJ+oLWEf/gBvBPsPk/hMvrawYUs8X//hAXQrzw2GOPPZmUlMThw4fp3r07Op2OAQMGHHC6XBPQ8u/rTXG/pxqEEE8NGzZsRrt27WjatCkDBgxg//4Dd5y9cLEWyIQYImUMhFfHWe3r8+1zavLkyRXOnDmDyWRiypQpDBo0iG3btvWVUn6Y/zxVxf1qWB/7hNV8JVVZCFHRZDKdXLx4MZ9++imfffbZeCnly0KIscAIo9FYzWg04na75wI/16lT562+fftSpUoVnnnmGQ4fPtxK8arVgYNhyf5IJLLckWAx2my2LsFgMODz+TpIKa+wM4Y8u4EZwHKdwI2m4bbJbim8jnCroKi+p4H9VrMp1elRHWi+MhX43SgsAuwEPo9IgiCrm8kpKgT3oPn2fJA/rRWtrdRCW8nq+F3leifaQ1E2alB/mdForLNj1+5HgaGTJk3qb7VamTx58otSyok3ew1BZ3qSRLxhtBe5//pbXxuZ2qrtAWB10lVM3uCKgPOhwZZcWA8Xwew0C/A0YJdCvzxstFYHfjCb4q6qlKC4nGV0yGlSk59BIrxhXeyvCHE+lvD2GCK5lgUutM/yqis5j+oz5Wz89P6cz959nRu3FrgCaYmlWdbucRDinBS6jnO61Dz+Z8b5O+Ofps7/I7i8vrsBT/5AE8WW+fPn9zMajRuGDB1W4qGHHurscrkIhUJ1VFU9lORwXK2es2bRokWdFi1aVHPz5s02gKnPTu8VS85cA5FewHNGq72gMdW4mTNnDkabQTYoV66cqWXLlmzbtu0KHmlAcZaVQu+5SqDRAStmzJhBxYoVqVy5MvxuNPXcrl274suVK8eZM2do0aJF8+5dOxfNdLr56aefaNeuHcnJybnbLwbm6QWHmjRq+H3Dhg3nfPvtt0yYMMG4YMGCemi9LQAoqk8PxMfqRRLwVTgipwjI1OnELxEpe7u86kQB3wghPFzpEvlXINACCGjF9kuAV1F9/9LrhA+NBr0aOAdkRyLSL7VVyXQgBUS2X8QKIC2WnNMxyDlRiZx9aPl90GTt5xVWqP9265engKVxtiSn0Wjsf//99zNmzBjQUp83DYM9JTPgvBz/Z/YtiCSrOZSpqO8BfTIV9Zskq/m3gtsYbMnhoCtjGTAw6MpYYbAlX3UVZEgs5gGeCGan6YQMPxrjd9aI6GLNXimbhSLSD9TQRUIldDJiAxDgzBExs6ROf8hECKAe5OT2DeQAa66n8O1RfQakHBfb4d7qORs/+gGvpyV/gtWmi4R9Uuji0FLgOyamHrlnTpea13UE/Qe/459g838Al9fXFbhgizf94WEhpdzs9KhPApVSHHZnu3btOu/duxcp5alCAg2Zbm86sKl18ybl0dg2XL7wy1kDkXbAHKPV/oeHmJRyrRBiUu/evZuWL1+eFi1aMHjwYNB83PMQQdwfEfrVVznssCZNmjROTk5m06Y/ZGOOdu7cuVHZsmVZuHAh1atWrfrE4+PmN2l9x2FgUL9+/SoD9O3Xr4rUGEqu06dOfXH69Kk269evZ+VKrbm77wMPtFVUXwzaA1+gPUC8aOrPv+p1YkIoLDuFw/Kyw2p+2elRbRLGI2UGt4AmnR+K6nsCeNdqNn0a/V2H5u1jR6udNQXsOp0wAzopZUQn+ElIadYTqQuyVgTxYAghIgiXgIdAqhF08xBioy3+mmSHanG2pI/1ev3h5cuX8/HHH/Ptt9/uAj79C5d0PuBMv81oTzlw/U2vjShJYGWmonbNVNSfk6zmP8zqDbbknGjA6R90ZbxvsCX/oc7j9KgG4A5iE9qiES28MTm+jvqgUtWIcAmh26iT4WcN9pSfAQIelyGWSAuIdIsOsd9osRWqF1cQHtVXBhl5OCYSOi/gQbyeamjki5te3aS4flPi/e7BXpNtCZAMbJ2YeqTHnC41/89X2/8r+CfY3GK4vL57gXO2eNO+gu85PWplNKbOJ80bN2xQoUKFx+fOnUv37t1Bk9DPQzSV9CBaCiFLwN4jhw8fjf7O+QsXLhut9iXXOx+dTkdMTAw2m42kpCTOnTtXDsjre5CICgjxUv59hBBljEbjm7Nnz6ZHjx489tjvrTKK6ku6cDFtwVtvvtl6XeraoQBhKSPVGzQt7vaqgXp1aufVLRITEy3AuzOff875wbJl+ydPnszixYtp2LAhACs/+GDriuXLr9dT8m6Woj6Qpah3O6zmL4CnnR61BTDf6VHfye/P82ehqL7xwLncQAMQ7TXyRn8uoEkG4VdctghM0IFTaGurX4AXCqZwFNWnF5FwEz2RF6UUE11eNQ1NIBJ+dyKVRKT3p0NHa8XGxu5funQpx48f54UXXvADQ6SUf56Np9M/SSRnMdDjT49RAElW89pMRb0jU1Hjk6zmvPs7Wu+yoTdXQsrEWBn6VPWop6Jv504kQKun7DCEfXNiZPjO6Ot7gC+Q4XpSRkZGdPqX/IrrQyHwcpX6y43Co/puF5Hw3XqZsynOav8SwLhsy9GstR8uibUnjgh8tCgGV9aNDqcC9zxzf/MfJqYeOQ+kok1CUiemHhkwp0vND6+9+z+Af4LNLYXL6+sOnLHFm/bnfz0qJjkO8Br0YnrPHj3eCgaDA9auXUv//v35+eef50gplwshkmrUrNVz5OhH6vfrP+BXYLnDaj7r9Kj3GGRoQ+lSpfLEGVd8uOrUBys/RAhRDbgN2COlzGP4CCHKA4+vXLmyDnD3uXPnuowbN44BAwbciWb0haL6YvUQzi85o6g+nSMp6fV/jRvH22+/TWbmFW0lLyx49dWEcaOG72hYu3rJdama465bUdxWs6b2fOrUqTuJNoy+/tpre19buDB71syZ/WrXrl3ntttu49lnn80LNpUqVR4qhHj9eg9Vh9X8QZai9s9S1LscVvMGu8W8w+lRvwMGOz1qL2C+3WK+YbOz/FBU3zjgotVsuuoDI+BxmdAovnYp0UXAqIMX4qy2axIWrGZTGK0u0yLgcZVFhocD6cAio8WmgkbFjg37Znbudm/Td955JyYSiRB1DY1TVfXo1GnPnnh8woQLUYfVc2hBbxdabch9rZWdMcGRHXCmm4POdJ3BnnLD+nG5iNo8lAEao9WsrIBOL5BSUjRbUfVCkJtSk2g08rMI8YUuEllnDqvlDbbkjbnjBZ3plYEmaL0wLYFVBntKGCDgcZVFW7GvIJyTKMKBB0F4kOG+xsRiN9yMC+BRfXqkHKyXORV1MvKa0WrP64dRVF8rU/sudwqIIRIOB9556XpkgdwJR7fkZVt+AJjTpea3E1OPtEKzPCgJLJ+YesQ7p0vNq0sT/IM8/BNsroHIrnlxaL0Nqq7Z2GumbFxe333ASVv8lU6NTo/aGq04/KoxRldx3Nixz/z8888D1q1bx5AhQ/jxxx8BJpYoUaJljZq1EosXK1p9xrSpjBn1cC0p5VmnR229atlSwxOTJme4XC57vqG/EULMio2NHdOtW7f4Tz755DxRlVshhMVoNB41GAxxiqIcBWrUq1ePCxcuAGQqWpd/UyKR4VKIoKL6Hs83roxEItXr169P165deeKJJyhWrBiRSARFUfjgvSX913z6cYfvf/jxUL169QAwGo1GRfUZE+LNpdBmfLmoIYTYDTw+b948UlNTue+++6hSpQqJiYls2rSpdu8+fReidfxfEw6reXmWoj6YpagdHFbz5mgPzttRq+lHnR41C3jLbjEHo59BDWAJmnT9m1LKBQXHVFTfmPRLl9yVKpSvimY/UAM437pVyz2rViz/IdFuD6P1hizzylgfUNpxlRTS9WC02M4BUwIeVwXgqYDHdR54126x+Z2XsssriuJISUkB4J133gFg/fr1zHh22pcTJk58FEFDKWVzoIjUqNrJQJzLq0okmVKjz+fw+woCQMYKQyxEtqoe9YcCpyQLbJsfuasuP/Ab8B2a+d0VwS1TUWsiqQys+WMvjpmgK8MadKbfjWZpLYBTBnvKcsgjTdSLBhmJFkjz11+W+BRnLRFmQyD70q8COc6QWOy6DaEe1VcEGRkXE8m5JJCTjVZ7XpBVVF8ZHZEuAp4A7sv5ccdqSpabx4WzNqKeOPkQAXzEGg4TCg5IXrblCgvvOV1qHp6YeqQlWr2xFPDxxNQjneZ0qbn1euf4d8Y/bLQCiOyaVwOYiCYmWRTtxvOjSdIvAL4oGHiigea4Ld6UJ2ERTS1MBI4bY3Tb0HoWdptNprEzZsx4pH///ng8v7cmNG3aFK/Xe2Hv3r0lhwwZwr59+1q63G5TDJE2g4cMNbg93olz5swhISEBn8/HyZMn6dy5szclJSX+0KFDFC1a1COltIImi+NwONK2bNmClBKz2czBgwcZMmQI815dMLdnr15ngR/04dAgPZHhuVI2uRBCPAaMR6Mox0+fPh2v18vs2bMRQiiTJk2yrlmzhmAwyHvvvUf79u29DkfSdlX13lWlShXmzZvHsmXL2LlzJ/v27dsCWEeNGtUoShrgrrvuwul0MnPmTCpWrrJu/oKFC23xpo3cALIUdRDwi8N6pdio06NWA0YAX97essXGAwf2n5w7d27ZKlWqcM899xyTUlbLv72i+kYBvoR4s2zRosWSl156iYSEBILBIE8//TTr1q1bKqUcFD2mFUhxWM2nuAUIeFxVgMFIeQ4ZaRVnSzoItC2wmR+YJqX8Qzo23zXo0cQ4W6PVl35Pz8G3seFAii4c7Gywpwy/FeddEJmKmojWN7M2yWrOBgg60+1oWnwAxRC6Dw225F8DHpcBbUVji57fvmgQviZUr/ceXUgdLWT4jIAnoiSDP8DjVWsIGXlUL3M+jrPar7g3FNUXB3JsDFKazPGzAVxen0FGInN1a5f+FtzwaS10uhaxHe5LDG3+LI1I5Etdz6GH9e27X7bFmz4q7Nwmph6phlYDLYJmf9HuH9JA4fgn2EQRXcW8CdyPVry82hLbA5wAuuuajT0Heayz3/KnzpwetQowFHjZGKOri/YQ2GiKi5NCiPZ6vX5xTGxs0ZxQKCYcDufm8b+xWCwdP/30Uzp16vTb5bTf3jLGmUIxRF6MS0gsjrZsr4i2rDehBcFT3bp1q1O1alUWLFjw7qWMzJ1AYjgcpnevnp2++frrZpFIxBQKhUALlk/lyuEoqq9ZTDjYwmS1XVGvKYiWzZu9l5xSdGAgEGDDhg3jgOcOHjwY37VrV8aOHUvfvn1JTU3llVdewWQyMWLEiLx9MzIymDx58k9o9OFu0c/hrpdeeqnpuXPnWLBgwVngNqdHnQp8ZIs33dAXNUtRhwCnHVbzH2aSTo/aaczokZPT09Jajho1imrVqlGtWrXjUso84yxF9d2HjNQzyBxl/BNPNtz6zfZeTqeTCxcuhKpVqxa7a9cuihUrRiAQsGS6vQYgwWE133J5koA761mgMTr9SmD5jfbpXA/RIHSHiIT7ikhOjkBawzFx+4HTwFqr2XTLbI0zFVUQifQwSX+FGCK/oakipxrsKZGAx5VIJGcSQv8jQiho9Zeb9iJSff4EIuEH9SFvCyEjF4AphnzpNa/Xe5+QkQ56GX7KaLVfkffVbCHkqBhkaQHT4szxfgCX1/eokJHdRnKsRovtq4DH9QjaZHKM0WJbGFU3fwB40xZvKvTvMjH1SD3ga7T0YDbQek6Xmv/opl0F/wQbILJrXhLwFZp22DU909GKvArQUakzwgREbPGmPGl8p0cdCFiMMbr1aDIjm0xxcZchT5KlFZABLHLk68wWQhhjYmJO6PX60mNGj3x7yrTnPrNb4/8w24+ypJoAzZa8+26FKZOeHB4KhcSadZ9Pad68+btWs+mKdIMQwgCECioHKKpviCEcUI1W+0oKQdCVMfrEqdP3NG/b/pzbrXiBxRaL5aeJEycye/Zsatasmbft6dOnycjIoH379vzwww84nc4NwHngIyllXhe+EGJ0mTJlFgYCAS5fvtwlHA6vA3B5fYuBWQV9cApDlqKOAI46rOYr+nSEENWtVuvR1NRUxowZw8cff0y1atWO+xVnNaBdGHF3ROgbxsqc14CP46x2EzAIrcv9vE6nu5zr9dJ/4EM1npk+w+W4Ct33ViDgzpoKnESnP4n2YPvUaLFtu85uNz6+4qwO5IhwcELAYB2Bdn/fhTaZyoUCfFLwvrkegs50gaaQ7QByPMJ0Rur0ReMJHRSCutHNnEQiu4UM9wHeN9iS/1IwVX3+xoRzmutDnppC+w5NDcVanhJIn9livarZnKL6esQQKSFgV5w5Pi+d6PL6Xo2TwfXAVqPF5g94XHrgNWB0rlJDNGOxzxZvuqZWXzSltgnt2ZEGtJzTpeYtWQX/L+FvH2wiu+bFohVy63Dll/CakOjcvgp3j7QUrbQCwOlRLcBTwKfGGF1p4JIpLm5HlFU2FM2WeLfDav6y4FgBxWkHeqo+X9yyD1Z+MnDYww3tFvM6AEX1VQY6o620cntC9gLbrGZTWAhhAnIKqgJcC4rqqyMi4dKxMsdrtNq/Lvh+0JVhBhYB70h9bA5RuZqovfAbQCXgbbRcOwBffbNtQrs2rSu0bdu23tatW48D1a4mjRMdo9arCxbWHzR4cNBiNq2EPL21lcAYW7zphor9WYo6EjjosGqSPVEVg72vvfZanbVr13L8+HHWr19PgwYNQpd++/UZnU73XY7OMBzoW9DKWQgRD2yeNGlSs+rVqzNk6NADaRnZHR1Wc/qNnMvNIuDOugOtZmozJjg+jtYxeqIV5F83Wmx/WYw0oDhjgQ4iHEwC0gz2lM0Ft1FUny163KR8Lx8D1kVJDlcg6EyvjSYKGwY2yRhjBlAfKB2RWIPoy+Ug5idZ43/XS3Nl2ICOBQVY/wxUn98A9JahQIwgMklEcnbpZXhQQZuD6LW1EMiUGGTZOHP8Fa6qLq9vfpwMfm202PL64AIeVxejxZYanaAlfb5ho2zRstXttvirk0dyIYRIaNl/zENVW3R8yV6sTKxOrz+LFnCuqvwd/c7mr22GpEbnv9YxYtG+d1bgjJTyTxFi/l/in2Cza97zaFbJN8u9D6Mp3NZz1x7eDmgZq2ONTqerCqT6QpFIdFw9sNRhNZ8vOEBAcVZGs292AZ8G9UY1EpFPAX6dLtcAirPAaqvZdMtEKRXVN9gQDniBT4xW+xUPlKAroxnwCDDcYEv2FqaNVhAur2/ihytWnHx4+FALmgbbdb1cPKpvOvCWxWy6EB0jBvgY6FeY8VpBZCnqI8CPDqt5lxCiZ4sWLT6eMGECw4YNo1y5cqxcuZImTZpQtly541u/2ZYFtEuIN18hqyKEMANfDB48uM2AAQO4++67qVuv/u07d3x7XWn8P4voqmY3sM+Y4Mh7cAQ8rjhgJJoj5KvX+9yvexzF2dVota8NOtPfvtHajaKpdncil0QQiWQZcrzBKKPgqIwxHkJzOk3g9/rLLwCZ2uSqO3AsyWrOSycFXRkVgbIGW/KWv3I9AH7F2SYsYsah0+/Wh9RtukjoIbQA+YohsZiMXkMlkHVikQ2BZ+LM8XmTMZfX1wgp68YRSjdabGtyX58y6YmJM2fN6anX6xsVKVKEy5cvnz3z64WXShcv+trVziMaND4wmUzdq1evjtPpJMPjp/P4OZSsVvcnoPmcLjWdBfZJNhgMJxwOR16w8fv9OJ3OiVLKFws5ThedTre2UqVKJCQkcOLECVwu10o0evwNfU/+E/C3DjaRXfOKA6e4fuqsMHh8JVq+EUqqsccYo4sBjvhCkUto6s4B4FWH1XxFfjyqynw7cFsYcTmsi3WgzaSIRGRp4FObxfwHCZdbBUX1VQRKG8KBYkar/YoZW9CV8ShgM9iSZ+Sd7w0GG7fXV0LCBFu8adyNnotH9cUDM4GxluhKw+X1xQMfoBmv3RDtNUtRHzOQI8c+9tgdmdnObqNHjwbAbDZTt25d1qxZw8CBA8PFS5Q4aIg1pHTp1u3NZ56d/rzdYpZCiDhg3cCBA9sNGzaMTp06EQqFVgYCgYVSyp03ei03g4A7qzra6gBjgmPFVbfxuIqhMc9Oo6lM37QLKVwRbMYDGw32lGuKoeZH0JleHWgsEeag3uQQOlERrfs+APJFS7yl0JRnpqI2Riucf5HLVgu6MpoAqsGWfMPnUOBa9BIxJqyLKSWF7hmdECpaYNPp/c6TAkYD+wKGhJUI0TOWSBjYHWeOP5p/HJfX95JRBv8t4LTRYstzRK1SpfKXAwc+2O7BBx+kWLFilClThhdfmdutS9duv9niTQUZfQghmtWpU2fnJ598wvfff0+5cuXIyMjggQcHMfTtjRhM5k+A++d0qZlfeqpxo0aNvvv888/Zv18r837zzTc8//zzK6WU/a523UKIN6ZNm/bwbbfdhtvtplWrVjzxxBN8/PHHs6SUk/7MZ/n/An/3YPMqmsryVb3JbwRhvfFcTp1Bm32hyHw0scGMEkUcuwOBQFfy0UsbN2p0fOuWL+tKdJWlEKel0J1HKyiusppN6nvLPmjw3tIljbZu+coR3eU9KeUt9zlXVN9gYIkhHOiTW68JujJi0cgRHxtsyVd0RN9osAFweX1LbPGmQTdzPh7V1wyoaTGbFucbxwosA3rb4gsvZgc8rtpoKUYCUld02YqVGx55eMQQNBaduXz58s3Wr19PtWrVSCla9HDjRo1qNWnShLffXvTVwaM/HQLWOxIspe688853Pv74Y6ZMmYLL5QJgzZo1OJ3OElLKa9oz/xkE3FlPA88BfYwJjkJrZtFrrItmUJZqtNgKNTUrdP/fg40OeN1gT7kmzTy6XXfAJIXOgz5XoQgnWoE/qKi+XGO0ZLR7PLxzx47td3XsEEdUlVxK+XWmZo19F5pVgQcg6MroAuwx2ot4gPZANX5XJd9ytdRr9DpqfrYm9eEt32xPWLp0ydacnBwZ3e9Lr+qLoH33vtb7nUWk0L0I4m0M5tg4c/ybBcdyeX3zoim0K5Qz2rW9/d0f9u4b5Ha7OXv2LE2bNiUtLa2E06N2t8X/0bdJCFHBYrGc9Pv9Iicn52MhROc9e/aYxo0bR4k7B1GmTmOAEXO61Hw73z6NGzVq9N2UKVO49957c18+DgyWUl7VnE8IcQ8aeSEdKNamTZuyzz33HK1atdotpWx2tX3+E/G37bOJ7Jon0FhShQaacDhC48GvUKKIjdSXhl11G+moUhwYGqsnNhRmkMNqloFA4IdHHnmkQS7VF2DWrFnhLLf3TpvdPrFgvaBnr/ut61LX7mzTpo1h4sSJHD9+nNWrVxdHm9neMiiqrziQZjWbZEDRnuFBV0ZNYCow2mBL/tPmVgAC0l1eX1VbvOmGLZktZtMuj+pr61F9FSxm02kAW7xJcXl9A4EPXV5fn/wBJ+BxFUVTVtADPwOzjBabNAJ9+/X/V99+/Wc6rOZ9QogiWVlZ6XPmzKFEyZK//nbhwrr69evXSktL49dff9kVveZOo8c82u+7XTuZNm0asbGxuZpu6PV6+D/4fgTcWUmA05jgkAF31nVnekaLbX/A4xoHdAt4XC+j1XPyis9CiBJo6tHFgQNSyt0FhggEFKfRaE8JBJ3pWUFnelGDPeUPKc6gM72KhCYgyqKLOYlO50FL4R4oqD8W1dHLU6+Ii4u7SwjxXdOmTalcuTIbN26kcZMmjb7/7rsfMhV1OdAjU1EPJVnNPxlsyalBV8YAnU43sm3bts0aNGhAOBxm06ZNHDp0KFUIcV/BJt+A4uydlpGdMnTEw8N79uxp6Nev30CArKws1q1bt9FsirsLeMOr+tqFjLaBIDvH5PiWioCSHgwoXxgSixU0s7tqj9EXqWv+HWe1T0DTtSud762jLq+vbsFmbSnlaSFEJTSyglmn03UymUy43W6K5oQOotWB509MPbJjTpeaV3hJ1ahRg7feeosTJ07w1ltvVVEUxUEhkFJ+LoRw2Gy295OSkujatSs7duwATb3ivwZ/22CD1p9wzfTZqx9to1q5ori9hWdzdJcPhaUp6d8xSdWGgKyteNVuxYsXrzx69GhmzpyJ16s1modCIVfpkiW+vtrM7YH+A+75eusWQ9++fTEajVSvXp3Vq1cX6t70F3AXUfUAgKArYzBat38fgy35VixxT6NpiN1wsIniZeAlj+oba4kWpW3xJrfL63sQWKV4PAMMhB9Ca77LBF65mqilw2p+JUtRJ2Qpao6U8lCr1q0H62Nihv524cJQYFZ6ejrvvvsuaIZpEvjiu927tlWvWWtRRlZ2if379u47sH9/bm3tmJSyoLjprcAIYHb0/4U1Vl6B6MN+dcDjWg88EvC4IsDCOKv94aSkpFcbNWpEmTJlWLZsWUAIkSylzN+LcgyNhXYITRLpZbSaHAABZ3pHhLgDoXehj/kJeD+3/nKjCAQCjR9++GE6dOhAo0aNOHPmDJ27du2jqL62Br0A2BsMS3umonYGPrfCh/Hx8S+1aNGCs2fPYjKZiKppdNmxY8d9wEcAAcVZEugW0sWmnz73y29Go9EwZ84cXn755fyHzyP1RDSSw6wYmBuJMb0bEw6tBp6Leus8aUgsFnJ5faWR0k8hD2opZaYQouB34Qzafb3/KtufFkI4gC+feeYZy549ezhw4MDRFo9XuxeNyGMHVk1MPdJoTpeaPsB/8eJFJk2aRFpaGj179mTz5s00b978HSFEcSllYenSWj169KBv376ULVuW/v37g5aq/6/B3zaNFtk170lgGoWsbM6nOxmlSRAOAAAgAElEQVQ0YwWTHuzA3A+/LnRlAxA2Og4Fq3TPEchjOhlZb3UUefrQoUOVmjdvTnZ2nqzT3VLK9QX3dXrU2kB2ojV+JNCxb9++DTt27MigQYPek1I+9BcvMw+K6ksE2lrNps8C7uwKyMgcgfzIYEsutGkNbi6Npqi+IRGJRPPuuakby6P6bgNaW8ymvE7/gMfVMQItQ8R01xO+I96ScKMstSeADbF68RTQ22o2RYQQTdHsoddIKddFt4tF6106phPo0Fa6dYH37Bbzn6orXAsBd1YsMMGY4JgZcGeZgY7GBMfVRFCvPY7WFDq6YtUaVYcNH35n6dKl6dWrFxUrVuTy5ctFpZR5DLqA4tQBdxut9nUAQWf6Ain0L4AcDVgQugPo9J8aLTbXn70uIURdNHZi1S+//DJh2rRpfPvtt61z7SMULVXaSkppkpKKYcm8hnVq1AqFckafv3AhCDSYPn26yefz8cILL0yVUs4IKM7ugAzpjXHACWu8+UxiYmLm9u3bqVWrVu6hLwNtpZRHFNV3O+CNJeIH6keE/jDaim9VjN8Zh2ZZsc9nsBWNlaFTeuSygiu2fGy0c2fPni2TL43GxYsXEzIuXy7eslmTrwtcux3YOn78+LqtW7emR48ehEKhWlLKI6Pf/6aPMd66MsZgBHhzTpeaI6Nq6o+gkYLOCyE+O3nyZEL79u05c+ZMFTTVhmBBdmlUlupZoGydOnWa/Pvf/6ZixYqXpJTF/uzf7f9v/J1XNtW5Rgpt3Lx/M2t0FxT1+pMHfSCrWIwMlwUiRqs9kJOT82wgEGDz5s0kJSWxZs0aHn/88fdemPFsq389NsaDJr0fE0bY9EJfyyBzDvpdmau7398nSNRQq0L58iUC7qx70P5GuX+nAJo44Y3+m2NMcOR+oboBK4KujDIgloMcYLAl3+pegBNoLKpmaHTyG4bFbDrgUX3tPB5vvVhy2qKtOreaLLapQa/v5Rx0Swum1ApDrF7MiUh5ICcieyZazBGAaHopL8WUpahmoKTDav45+lIYWO70qKuAB6P9Up/YLebvbuY6roNHgIXR/7cH/kBFvhEYLbbjAY9r7MD+D8xeunRJzbNnz6V07NjxqrR9o9UeCShOEfC4yhOJNABikeFPQXQx2ov8pbRpLqSU+4HGQoivgDsKvh91ct0FoKg+M1JO3XfoaKmG9W4r06NHj2Lly5enVatWDB48mM53dzoTUJwjJKzN0Ru7ARstZtMZtH4eypcvz6FDh3C5XMyYMaPIxo0bJ0ddVeNjiewEngGeMpvipOrzHwR658TZM4HhMX5nK104OFovg6uMtiJ/mAx9+dUWR+d773sdrRaVi7l2i3mRwWBYERMTk6Kq6ptSypGQ18O2cezYsXXbtWvHvffeSygUOgYMFkJsNxqNS4VOJzuOeU5UbXnnwxNTj3yJ1tf0JFojaJrJZEpISEjIVROZZDKZBoVCoSwhRJ3cmq0QYhbQG1gHuDMzM5uYzWa4euP5fyz+zsGm0Bzpuh1HSEm00qBaab7ee/0eQ6k3mpGRgYAMuLOoXKmiu2nTpjI2JiYrlJOTtH79enr37l1k5+7dY//12Jh1aDpWobDQ1zfInJ1of4ccxeP12x3afZ6dne0GDgAhfte9MqAFyPz/2gp53QjEBNxZSIQjRoiSukhOUwlVEeIIiPYBd1Z7fpc3cQFZaKSFrOiPG91N3c9HdIJ2EUkxbjLYBDyuxjFgjqBbEEHcbbIk5K2kbPEml8vrewithtPbFm8KXme4mQIGScnDWYo6wVHA1jhLUR2AxWE1nyi4o91iDgGLnR41Bujh9Kj3ozX8rv8rlgYBd5YALMYER+51xRsTHH/afdRoscmZs+dMfObpKS8WLVnmFAV6xKJuoPWBUkQityPDdUHmMrYWgrxpJeUbRVQUo7cQ4s58LzuBt6SUCvBkpqIanU7nIbPZXMxqtRIfH4/NZsNgNNZPSC76y+23t1169tzZ1479/HNuv5Hq8Xi8FStWjE9LS6NevXrMmTOHnTt39qt3W52qp06e3D1xwoRejz06ZkqJUqUlgNkUFwKWqz5/RWBkTpx9bSQcOUDIHwlmp72DpkSQZ+vx4itz23br1u3BHj16kJyczMKFC9m1a1fvl19+uWXt2rVTlixZQrNmzfJfU4smTZo0njt3Lp988gmLFi0CqPrGG29U3bVrV/vx48cb7XY7y7/cnVm15Z1JwOL4xCLLhz/Uv3j16tX7ZmZmctddd7FkyRIuX778HVBt06ZNTJs2zfHVV1/VQBNeBbh3+fLl5dLT0x8Jh8Pcc889TJ8+HeAPmZL/ZPydg01sYW/sPHiG1G8Ps37XUfzBHNxePwOmLWfZtP5X3V6EA3pjguOt3N9PnDx1HMjxSfmtEGLuhg0bxtasWZMpU6b44mxJRQHr0mXLf+p2b/f3jFYtNRRtdqzXt4zmDZXtdAbibElpf0lmPgrFq44w5Kg2AacMtuSHA4qzb37lgIA7S4cWtBxoTK7K0f9biYSrAvUC7qz8hasctOX+r8AvuQ9Qq9mUqag+B5Dm8vqSbPGmK6RDCiLatT0MLde+P85ie86j+j5CE+ack3/bfAFn1bUCjqL6hgAHE+LNP2Yp6jE01lcePTRLUcsCXofVfM26RFToc5XTo36ENlt/yelRDwArowHpZjEQzRr7lsJosV12ud1utGY/tm/9snvA47oESMIhj5CRRInOJZDPGewpGgXZmT4fmABctev+r+Ly5cs0bdp09D333JP32vr169m5c6cLrVmY5IT4FOChffv3dz565PBDp0+fLj5u3DjGjx/fu2HDhiWaNWvKpk0bGxJtNpVS+oUQPdPS0n4Bftq3b9+ezp07Nxg3bhxVqlRpoChKg+XLlzPnxRdjgf75a6PxZtNpvT5m1x3t7phZtly525e+++6Xd7a/Y8FnK96bGsxOCwJPGRKLhUuWKJH+1davOXfuHK+88goA2kdL8dq1a/PBBx9QsWKlEy6vTxeVsLnw008/RerVq3eFGdu5c+cAKtSqVYs5c+bgwvQM8BJgbz1wbLNFi16gQYMGJCQksGTJEo4fP/4rsEmn0z1ttVrZvn07aPWeXKx57LHHJjZs2BCdTse8efO4cOHCRuAx/ovwdw42heaoZ47szMyRnQH4eu9JXl6xtdBAAyDB5/SoItq3UcxqtW612+0IIUhOTqZXr14899xzANVr1649rnTp0kx9asonD/Z/oFe+Yb4wm813xcXFERsbi9ls7hcIBO4WQlS+XnfxteDxKB0N4cB9AsYX1t9gTHBE0FY0f5jtXq1mE609lECToK8TcGflkRn0Qt8qVoa/zRGxLwTcWavQAtJZY4IjmG/MKmje9mFgidFiy2NHWcym4x7V5/aovoYW85W9DfkCzkqX19e3YMBRVF8roKTVbJoO4LCaPVmKuixLUcegKR9UBM45rOYblq2Prma+Ar5yetR6wAynR/0NWGK3mJUbHQcoY0xw5E9b3pJiacDjcsTFxcXl/p5gTahEOKcCMnxMwCWDPWVJQHG2k1p60wNgsKf8HHSmVww600VuAPorEEKUQUsJVgGIRCI0atSIcuXK8emnmkXQpUuXyD2+ECLeaDT+rNfrzZcuXvw1MysrpU/ffhw4cAC/31/iueeeo1mzZkyfPj1RUX1PAv6qlSqeSkhIWKsoClLK/UlJSXVzcnJIS0vjq6++omTJkqxevZoWLVr0O3v27Cw0QkQunipTpvT06tWqUaRIEbp06fLO559/PtvoKN4gkHVRDywJZqd98O6it7bHWe1vX7p0yQq80KBBgzvbt2/PiRMndAcPHuTYsWM0atx4GloKdJOU8rgQotT+/ftz6yavlylTpmnr1q3ZsWOH5fXXX2ffvn3ngdfRUl7za7Xr1sBevPR9K58cqADVkpKSFowcObJ0KBR6esWKFQwZMoRgMLhHSpk3UZNSPiGEeHXjxo23ofU5HZdS/tfZUt+0Per/EC5yi77wEYNNBaY7Pepzq1M/HxEfH8+HH37IkSNH2Lx5MytWrGDNmjUngD3t2rWjbdu2/HLuXMFZf+v169czYsQIKlWqxJYtW6hVq5ad6Bf4zyDgyugYEw49I6BzgUBzQyyowmBMcISMCY5zxgTHdmOCY4UxwfFW7k9Yb9gel+B4Iyz0OyOIdDQK6YCAO2tkQMl+J6Bkr0FGxhIJbyISfi1/oMmHt4GBHq2f4wrY4k0utEL/R9EGUAAU1VcMGJQbaHLhsJqPoulVDXFYzcduJtAUhN1i3me3mJ9EM8+a4PSok50etej19gu4s+4C/nLnfN54HleFgMfV/ZmnJk+Otyf96vf786RmbmvYePyAIcMsxBjryRhj7gThJFqgzY+5wJRbdEotOnXqVOXQoUNUq1aNvn37AnD06FHWrVvH6tWrOXXqVIgoywywWiwW83fffccX69eXPnr0qL5ChQrMmzeP2bNn8/zzzwMgpZRWs2kW8Hbnrl17t2nThhMnTrBnz5663333HU2bNmXp0qXZGZcvn1m9ejWHDx+mQoUKoE2E8qPx0KFDEUKwd+9eRo8ezdSpU5Nr1qr1YU6c/aIhsdhAoAwh/+hA1sXfokrbsY0aNcLlcpGYmEjfvn1p27YtX2/d2gaIcXl9RaLneFFKuS+6T5X58+fTs2dPPvjgA7Zv334GaBhdZb0R/TtQqkb9KRPWHt4C7KtatSrDhg0jNjaWe+65h2AwCPAHQVop5QUp5RdSynX/jYEG/t5stM5oneoJf3Uo4G1ds7EjAX5Lzyjet3evuSePH29z8eLFona7PcOakPCNTqd77OyZM28sXry469SpU/ntt98aSCnzlspCiMloRfz8OAcMkFLeNMUx6MqYFBa6SjkxpslWsynvgR5QnOWBkkar/dtr7J6Hm2GjASiqbxCwIiIxAHfHyeC/gUeBOOAjo8V2PLoSqorW0JfrJSLQ6lMngZ9C+jgjQjxkKRA8cuHy+kzAcmC0TnAZWAX0KSjrk6WopdHIEvcC3zvyOUz+VTg9ajJa4LMCy+2WPLLBFQi4s542JjhmFHjtfmOC45pMwLxttfpLAzSzLtCouAfjrPZpo0aNmjpy5Ehyi8xbtmxhzJgxqX7FeR9amsWHlEuBFkar/QpCQtCZ/jow0WBPuaps/40iurLZwu+q5PFjxoxh9OjR5OTk4PV6GTx4MEeOHBnid2evCYfDvarVrtvk1/Pn+5hMpji/34/FYslu2LBhYp8+fRg5ciRerxeTyRSSUhqixygGvC+E6GAymVBVlfr1G+w+evRIo2eeeUZftmxZ/H4/w4YNIxwO26WUrnznNxiYOHTYcBYvevuDOnXqTH///fepX7/+EcXjnQscM5vivg24s3qJcPBOYIfRUfwYWn2rLFB96NChjgYNGjBy5MjFTo86HOgPLM/PuhRCTALur1WrVt2lS5fSsGHDvVLKBrnvT0w90ovfA27fF7vW+rV58+bfjhs3jl698pIc+4COfyWb8Z+Kv3OwMaMVwf+0ekAU7kDxJs/mpNSdW7BZE8DpUZPQfDzqPT5u7O0rli9rlpKSsu7AkZ962aNMqVuJoCtDDyySiA+CsebiVrNpef73A4qzD/BxQU20wvAngk0LwG2IBM+H0C+OIbxHwEKjxXbdB1rAnWVAe2BVB1IiQt8UZJZORg6g5bCPGhMceeft8vr0wPtARCeYaDWb8rr9owKoVYBfHVazN/raDGCuw2q+YT/gG4HTo8aj0aaroc1KV+eauAXcWfWA8sYEx2f5rtMIdLoW7TmqkZarPxYBfjRabFfo6/Xve3+v1M83vOZVvfHhcMSFFrhVYJyUcmV0nAbAg0i512i1L82/f9CZHg+8ZLCnjPxrn8CVEELcZTQa1wcCATeQ8MADDzBq1Cg6dep0Lv38uYlo958ESE5Ojl/+wYoxPe7r/sKmTZvo3Lkzbrc7N9hQrXr1N386ejTv/DKdrl4/7Nlz7K6OHQ59v+f7Uh3adzjVvHnz2PLlyzNq1Cg6d+7M2bNnWxSUGgp4XDYlGHm3SJIjZsKECV0rV67M8OHDV0spu6s+f12gqS4ccMVZbCuD2WmdgfuTy1a233FHuy41atSgffv2jB07lkOHDg2SUi51eX3JQCNbvOmKIr0QonatWrUOFhJsBBojsjFwekG/FoPr16n59Zo1a7h8+TKZmZlMmDCB3bt3z5RS3qpV538M/rbBBiCya95WNJ2yvwK/WqVnZWlKao/2Rf8k6l//Bzg9agc058N2aBRnieYzs8VuMf/lBq2gKyMObbY/NhAb3wFYUdC7JKA4+xmt9hsuVN9ssFE97tsETNEhdwSI/VQKcZst3vT5zVxHLjyqTwCv6CKh2fpITmW0IJRLj8sGfgjo42pIxL+ASbZ40y7IMzsrDpxw5HORjAagl4HHHdZbH+ijhnmN0FZRXmC5KeJ/0JjguGJ1FnBn1QWCxgTHFZpdAY8rCY02HoNGX99xtc896EyviGaYdtJgT7mujl7A4zIh5TsIsdZosV2ph+dMn4zmP3PL+oqiq5A70WbxlRMSEg6cPXuWpKQkj5SyY/Tc9yhedSswrGnjxr7y5cu9/9Zbb3Hq1CmEELRs2ZLt27dz++23c3+fvgv37f0xMH7CxKO9+/TZZzWb9gkhdC/MfP69RYvfWXn69Gmh0+menTNnToMLFy7w088/r/zok08fyD/5y0pPu7frfb1mWizx1WfPnk3btm3Jzs5uKKX8EUD1+WNEJOcFqYv5Bvg8xu/Utbmry2FbYlK16tWr07dvX2bMmMG6deumSymfAXB5fS3RvKzy27EXGmwAJqYeuR3YCnB2387p61/811M5OTk6v9/PHXfcwbJlyyhXrhyhUMgktebT/xn8nQkCAC+gPRzir7dhIfCHSrU6GGtM6GQ0mxYpqs8CDFBUnwRWWs2mPNaS06NWB47bLWY38G/g31F6bXNgktOjGtGsiT+3W8w3TUsNujIcwGLgwUBsfDJwsRCTrFv+kAUIeFwNgU56+DUoYr+yxpvfMgIur+8ul9cnbrbJE8BiNkmP6psV0cU+arYkTEGz4dWO585yRBDNdchJsWH/+wGd4VmP4v4OKT9DxKZdzb7ZYTVHoqubaWhyNbcUUTLB98D3To+aKCLhkTnoWvg86j3ABrslj4JdCVgLEPC4KqLJmki0lfZGo8V2VbZb0JleFs3R85zBnrLkattcDUaLzRdQnCsBf8DjehGYabTYcu+xF9CkZx66ycu9Fl6rUaPGfceOHVsaiUQYOXIk33//PVLKY0Dq+PHjkxYsWJCTmZk5Jikpae2RI4eNx48fc1evXj0BNKmgixcv0rlzZ6SUwZ3fbn+kdevWvDhn9onuvXp3BpgwfvzEVxcs7B8KhfoDOBwO2rRpw9NPP0365cu7gSc14zTWJsSbj9ate9tEhyOp+osvvsidd95Jdnb2ACnlj0KIimgryMN+xbktTMxhYNTU2fN/3P39D4Nat2je4afDBx8cP/7His8//zzr1q1rL4T4EigHfOn0qG1dXt8vtvjCVdmFEEY0dXcd8MWEtYe/AO4uU6fJKEeFmpM6jppa0ZRgX7CgX4vtXq/XXrp0aU6fPl0arW/tfwZ/92CzGTiKlg//M2SJsNAbx0kZeSmguJoadLqhxnjre4rqiwF6K6ovFvjMaja5gVJ2i/mKnHmUXrsN2Ob0qMKZnV1r965dky9evFgiMTHxXIuWLRdXrlDu9FWOewW+27almpTypXETJz2067vvlYDqewB4q5DNdUIIG1AbrZZxREr5p/s9Ah7XnWhmbgeMFtsMgKDqG5Fvkx1oAfWqIoPXgzXeXLZVq1blf/nll23nzp37FZgupTxmTHBkKarvXrQufMWrqG/qhXhDEBkcL/1HA26/QGO7/Ygm4x8GcFjNWVmK+u8sRR3hsJoL+4z+EoQQFqDUF2s+S5n76mtdPlq9tjnwvNOjZoBcboIq6PT3BDwuiSbxs9posUkhhBUwFuweDzrTE9A8Z84b7ClLo8cwo9XBcuGXUl5hnVDwtIwW2+aAx/Wj2+1++qfvv9/epl3H1VJKGXSmrws603sa7CmfFHItFdAC4YXChDILIKFfv350794dKWWeJTkwz2QyLXviiSd49dVX9b/88svmsqVL/SalRAhRJBQKmQC9TqfL3L17dy7teEDdunVX3XvvvSxfvvwMYM5WvENKlChRPyUlhddffx273Y7P52Pp0qVs2LDhZ2Cx1WxSo8Hm3t59+ryedvFis/nz59OpUycuXrwIsEwI0RC4u3fv3pXXrl0bOXXqdJ8at9U7q/r8r8+bNy+jWLFijm07dv4GlJgwYQK//PILgDU5OXlb06ZNWbdu3Vdottj3Ap9E667P5/sc6gshsoAP69SpMzImJoa9e/dOQBO97fRj6vJkf9qZ2e+M7IzBbBnYoEGDOJvNxvnz50EzHvyfwt86jQYQ2TWvClo94GZXNyowWtds7NKA4ozWDkQFdLp7jPHWLMi1pOW+SETWA1bYLOajhQ0mhCgrhDhRqVKl2FKlSnH+/HnS0y+nv7N06Zp27TucBTYCe/M3Fgohqlsslo/8fn+tMmXKkJaW5n914cIB9/fuc8xqNv0hLSKEEDVrVN96+szZNnXr1iUUCrF//35ycnIGSCmXF9weCqE+a0ZffdBm6F8bLbYrUjmK6htuNZvylG5dXt8QW7zpnRv4TAuebwmbzXbh4Ycf5rbbbmPz5s0sWbLkRSnlREX1DQRUq9n0SVQNoBRwUq8TDwPY4k2vB9xZMWiNjfXQ0m8htJXHIa+I6woEHFbzLW2ME0K8FxcXN7BixYr4/X7OnDmjWCyWEekXfrkcgZJhdG2IRErm6GLnAF8nWuMlmqJvV7PZXEoIEfF6vQ9JKZdF3TB7o616PsqlKQsh7jCZTBvi4uLyesVUVSUQCLQsTDk4V/1ZCNEkNjZ2t8ViISWlyKkDP3xf22ix+YLO9CXA4HzHsAHLjEZjl8qVK3P58mUuXbq0F62H5afCrj+gOJu8+fbibk8+9XQDv9+f+7nvAV4E9K1atdrYrFkzFi9evDIzM7MwSf3piXZ7z7g442qh0xcfPnz4Q6mpqfz44489fF7Pv4HpJ3+9sGX44MGjf/xhT7VgMFgFbRWwCXghv1wPQIkSxQ+8+OJLdRo3bpzL9uLSpUu0a9cuXafTpVy+fJly5cqxef3nfZu0aPVh9Bzkzp07SUhIQKfTcfLkSUaMGEHbVs2P/ZaeWXXq1Knccccd30kpm7q8vjqAzm4xv/3hhx82qlOnDkajEZ/Px4wZM1i1apVv1qxZpqysLOYtfH32Yx/ufgwwbntvrmhYLI7HHnuMUChEIBBgwoQJfPXVVwuklI9e6z77r4SU8m//E945t3N451w1vHOuvMEfj3Lim02Zbu/+bMVbMnccvzt7iN+dfcSvuG7PfS1b8cZlK95Wbq96h9urDnR71VZXOwege4cOHeTatWvlggUL5K5du+TixYslcDBb8VqzFW/PbMU7M1vxzshWvB2zFa+hedPGi4cPHy7PnTsnnU6nvP322+XUadNmFXadgMNms8kTJ07Id999V3700Ufy4MGD0uFwSDRnzT/s41ecrf2KMyH6f+FXnMP8inOqX3HWKOw4bq86PP/vTo/a3OlRq9/s3wUoX6xYMTlmzBi5YMEC+corr0hgrturJrm96ptSSjLd3pRMt7dUgeP1dXrUKX+4Flemwe/KbOl3ZT7sd2WOUlzOFW6Xs7PflSlu1b0EyP3798tVq1bJTZs2yT179ki73S7btG51W+42Pldmn2zFe2e24p2Z+sWG+aVKlZI///yzzMzMlAsWLJDAwkD2pTaB7EuDAtmXEq5yjPGPP/64PH36tNy2bZvctm2bvO+++yQwsrDz8ruzu6CthJwrV66UbrdbCiE8fsX5ql9x1glkX6odyL40Od8xurRu3VoeP35crlq1Su7fv1++/vrrUghxHIi5yvgl/e7soX53dv1rfDYVbDbbb7GxsWeBUtf7LH3OjEcfHjlyAXAJjW4ufF7P/T6vp0nuNhlub/MMt/f+DLe3WCH3r+hzf6/5SUlJTrR2h8sxMTHZZrNZqVK16s/169eX8+fPl8Aav+Lsku9cR6EFMAnIokWLnk5OTu5RvHjxuZMnT5adOnWSQoi8z9vpUXvYbLax0WOko/WXXQYOAs61a9fKxMREaYy3Vpuw9vCJCWsPy8GvrZFlajfOVfCQaKuZyUDsrbof/5N+/vYrm1xEds1rjXZDGymcoRZBK9w+4641rCVCdJWSdYlWc5fcDQKKswrwGYhFRqttfpQU8GXuiiRq89wMLYX1ca71rhAiGfgcbSbojYmJaZ2RkUHJkiXxer15VE6nR40FWsZEgqM+/eSTaiNGPVIrEAiwYcMGZs2axY8//tjB7Xb/wXo6egyD2WzODIfDlkAgsBL4/9h77/Amjq5t/B5VS5YsuWFsbGxMjU1vNi2UADHFoWMwNQTTExI6AUIJNRAChBJKIBA6mOYQMD30GhI6GNPBGCyrrHYl2ZbO98dKjiA2JM/zfr88z/d7z3XNBfKeMzs7MzuzZ84594lbu3Zt9KlTp7BixYqhRPSnnB0ezQbiUUEZAKuVGt0b0ZA5wTZQq1YVHlG5Uz73+xe1m34AOg0ZMqR1uXLlsH79hr3HTpzIBfBRvpMiAOQGaNWm1+XMvC0BYvDdaJ2vitxQ/HUhwsGfIiJyWHJ9HJB9r0DBBSaOB+9wOE4FhEb4O53OqhAX5zsQ86wU673HGAsG0KBefFzJu5n3PrZauagA/wDD02fPSm3atEmyd+9erF+/3uPFxJROW89lazYc37xxQ3O7w1H1zu1bg+Vyubxbt26oWrUqfkrbc2Xbtm1LXVLFM/wRE1X4orZPbNuhVs0aHwIoREAuERJyZfHSZd+0fD+hSNQGKTnrNA5zq/UAACAASURBVG3WrGJk6dJd4+LiMGjQIPj7+9sMJks3GZztCMwsK7BXypP6rCaJ1DHvqzkVv124YK7VakXJ0NDT2c+f18/IyEBCQgIqVnqnyboNG38FwPu4HAwiOkKOUqtPe9NYWgVbNwC/atSqt8aJcIItmJGrl7zAlqHUBaUBgF3gSwFI8lH7zvfmNXACA9AIQAiAo4FadaHbsNsbL8fOFMN1vqoR3nIBAQHl8vLyfnU4HL5Lv1s+sVdSp+s+Gt0ebx43sgd4weYDoNuAAQOqbtu6ZShj7GlW5o3zvmr1VIV/yRtuz8jeADa8HmzMGFspl8v75+fnLyWioWPSrleAeKxciMHmcjrXzWtftc/b+uW/mf7/brMpJEm9T4+7j9SmQjSWOlyADwVVlrKca4IEUOTpy92VWx72lcYNvQirsBFACRdwzsAJgYFatQEAlFr9HQdnqgbQIRtnfhdMPtn76EurVmUAyHAnoOrutuvsJ6Isxlh3tVqdGRkZifj4eFy7dg2CIBBE8D4AInZXnjmnAoDj7bomd61QpXrtXsndN0CEmIFMLi/W9kREeWdP/DKy3rtNtkC0Z1wIDAyEwWAARO+poqgxROPmWqVGt877ghvBtjrE47QXAM5SER40Ol8VmXnbczNvC3V73dWECEPyBMA5egMkDxGtdqffbQ0AOr2u5rVr16ZUfCc2CsD9AK36T7JuO4P5o5QB15u9997PA/t/9A1jbGubNm10V65cwaNHj1oD2Kf0C7DznNC7ALK5AEb6kl3d7P02K6Kjo5MbNGgAlUqFCxcu4OLFi5cYY82J6JVNzR3/Ujs4OOiHatWqv+Pr64sSIWIw+Z49e9SxsbEoV64crly5gmGfDA8387YPAGBr6q6mY0ePXNe4cWPUqVgbEeGlsH///oLs7GwZAOQ7qcApkTMQndFr1H+Ktzh29EjFWjVroHXr1ggPD8eZM2ewffv2El07dTxKRA+L6sevZs6IvpeZ2XXe3Llo164dBg0aBKfT6dRp1HsA7HFYzc0hkbqUTqG5Ulti0JdTp6RNnzZ1H4DHSqWyBGMsQyqVwmazoUbNmkEAakrJ2TifSQOckB4DY7DztsTXbstDDKjNlgCNGMPvf3WjAdCFmGQBAxrnmXNCXXLVc4hxL1Ne53dnAj3u3nSaGkTsu0OB4kdIpFKju2Tn/5w9OTc39647PQC6de9eqoBc0zjBVgXAZq1alQmIgaVudhuANcu+W/7evHnzMiUSyWZfWYEBYgoDo86/5Dwzb9sIINnM29a54WzgriOFMTaM3PFyXyXG3hmTdr01RHutDwBIpNLCNNH/r9L/bjZeJFQb6Augmvr35UEA6jsjmgyiwIodmCZsu+TBgc+dpRp+y4c34wMB6DXqpyar0EACzHAB7QycsC7QvfC5Y1ia8px5q4ry1ju4vLpKrf6Vrx13Aqr1brtOAifYWvbq3Uf12+VfMWnSJFSuXBnLly8HEb0S7Z9nzhkH4KlCF7RcAaBendoXnjx+/BTuzWbylGm9TVYhDsBGvUb9CqqzgzMpalSvlgvxK/6nlJSUSj4+Pti1axcH4JWYD4fVnABRA3sMMRjzFRdcxlhZxtiJihUrhsbGxuLp06c4d+7cS8ZYGwtfpJ16//x5c2f6+vqOqV27NoKDg3H37l389ttvGYyxBCJ6qyMEANy8cSO0TcL7C0pHRvr9dvlycZvUkdq1a9e5fvUKrl+9ApVKldCtWzfMnTsXI0aMwJo1a0I9jAFatTOXE+YCmKD0C5h+6fJl2fDhw6FQKGC32/H999/j22+/rfXs2dM9Fiu/gsDsUrjeAeADSMkFdlcQbPply5Zh586dhTaB/fv3Y/Pmzbh58ybu3LmDK1eubPx24YJ7ALB127aOH374IeLi4nDp0iX07dsXAwYMkPXq1QstWrTAkcOHzkC00X3oDhy9DGCPXqP2dKzjzJkzuHPnDgoKCjB69GhUr1695Oeffz4PIgzQK8QYU/j4+Ixfvnw5Jk6cCIfD4YLoEKNhjEUS0UOlRnfIYTXfBElSHeacBKUuaD8RXWeMhdy/d+/gggULsHPnTjx69OjMyKEDbytcjngA65Ra/YPixsrM2zQAQhjQiQA/F8Fp5m3limC1QwxUfShh0Luf4TutWuXKM/PHINqtfABs8lH7FgvC6t50jhhEF/dmBo4P8AELsfM2BcQ5/yfy+tB56LCat+cxxU8AenCiFnZJq1a9krnWBWT4+fkdA9C5QGz3RJnd1DDP+HyDChhhU+hSAXQ387aN3h6Y9Fpg9leJsRfGpF3vCOBn95+KBQb+f4b+6XO8/6TC8UIXjhc2eX7bBEFuE4RlNkGQEhEEs2FujoXv5S1j5PiIXAs/KsfC93jt71WMHB9mt5ha2C3GDLvF2Pxt979242b1+Hr1fo6Mijojl8spIyODKlasSBAN3MFZ9+7Mc5hetvGWsfACKxMdfWP//v3UpEkTAtDUyPF+z7JfDjl78dKSZy9yOhs5Xk5EsFuMMVd/vVAXwP7k5GQ6deoUabVaAtDYU5/bRjPVzpne9fpdlN2gb/fu3enAgQM0bdo02r9/P6WmphJj7H6O0dTHwgvq12VatGz5Y/fu3Wnp0qU0efJkOn36NM2bN48A7CuuTyACgy4YMmQIzZ8/nzp37kw+Pj50+07GgDfIGLKzs2nlypU0cuRICg8Pp/3799PKlSvpww8/JIgpeAv5TVaBGSx861wLP2ns+M/HRkREnA0MDLqpVCpzExMTaefOnVSubNnfbebcuXazYYndbBhmNxsqeN3vbkZGBqnVau/z9ysAqEGDBhQeHk4Q3doDAMimfTHxC8YYVyI4+FSHD9pulkgkZDKZyM/Pj+bMmUMAFnvqrlatuuxp9suaRo7/wsjxs4wc33PYJ8PLQQQY7QJgcHh4OD169IgggqMyiCCzzKt9CfXr16fz589Thw4dKCkpiWw2G3Xo0IEgIgtL4LbD2C25crvxxSW7mE+mBIA7U6dOpc2bN5NMJnPs2r51vN1ibPA33qkyHC90ehOPySqoTFYhxmQVkkxWYZnJKnxgsgqJ7tLWajEPETjT3L/7Pts5U+tcC1fNYOEH5HL8qhwL7/MW/kTv3xZeiLfwwgQLLwyz8OIaYLIKhbYmXrBF8IJtCC/Yoh25WTJHbtYSR25WX5NVCDZZ3/zMnjJ6z7Wxo/dcuz96z7XGf4X/v7n8r2bzKjGInkEecgFI81G57SrAfikV9ATwo4dBr1E/NlmFZ4xgNHBCq8A/vJtC3Am4njl4riVcrh0OznQYwGhP9PQrN2asHWNsPREdVqvVV51OZ3x+fj7kcjkAfB0QENA0OraazWazLXQvIGCMaWNjY7c+fPCghFdVU/21voskEsnQ4ODgGMFma/zoaVZNk1WwKgFD9TrxrZOSkt4fPnw43n//fXAc5wDw0cL587SDBqTUBnBOqdFN/gt9dXvbtm3OTZs23QaQJpVKRz969EgSFhYW9VNaGjp26hQMEW6nkJ49ezbrxvUbNTZt2sQB0Cxbtqzy77//jlGjRtUucjAYk0gkkmt169YNi46ORlhYGJ48eQLGGJ5lZZULK1UqSqNWPShCVOJ0OpGSIia827FjB0aOHImPPxazbLfr0KG650jLQ1IJe+l0kXTM+Ak/zpk1M7h27dojK1asiF69emHJkiV48PDhTz5+/hOAQqSDxg5LbgsAUCgUfgBw4sQJWCwWfP/991i/fn14lSpVkJycjHfeeQfTpk2LOX78+FPGmPTps2er+ZdPR0ml0tNK/5CalSpVSjKZTLDZbFAqlQDQjDE2FgDJZLLZEaEhBpfLVcfI8Q8BvJOV9eyboKDg+jGxMVeuXb1qDA4OhiAIgHjUky6TyVo4nc4TjLHGJE4Wl9FoxN69e1G1alXIZDJIJBJUqVIFO3fuDJNIJM8kEkkJxtgUIpqWZ3oxJ/t5VsOSJUsu69+/f0jlypWRlJQEnZ/f/faduyohHn2+dYJYBZsWwPsateq7N/HpfFU2TrBlQ0TXHuodFG3lBTmTSBe4nAVGs1X4AOwVRZ9BtMHdeh1h3O0x6euv1fxu5m2lSPRQa27gBCWAy4Fa9Vs1aa1adRbAWU6wBQIYzQk2KYD9cLslq1U+jwWbfRmAVgU++voAhsvspg9UeeavHFL1LDOP1jpf1c/F3wH4KjF2Dv7I3ArTgFYlIULkFAC4rV+x79+CEvqPon96t/tPKhwvzOC8vshtgiC1CULrV3jMxsOvyxk5nhk5fnqOha+XY+FrGDm+jpHjdd48dqtFa7eY0u0W4067xfgnTy4Ac8aNG0cbN26kBQsW0NmzZ2n16tXkq9FkV6xQwXrq1CmP5vKeR6ZmzVoD6tevT6mpqZSdnU3Hjx+npUuXEoDnWq2W7HY7Ach3t9H/4oXzW0NCQig/P5+OHj1KqamplJqaSklJSdT43UYbi+qT4jQbd5u1EF/4xsHBwfT8+XPy9fWl3Wk/NbbwQp2iZD4bOWp+yZIlqXHjxjR//nxatGgRAbhUFO+un34OlMvlBStWrCDvEhYWRhGlS9fieOFbjhckRbTLkZ2dTR06dKCePXvS1KlTiTFW8N1339GHH35IOp3OBMDvteeU2CymOKOF21Glcuy+du3a0axZs+j06dPUpk0bArCwyP4xG5ivr+/VmJgYkslkVKlSJbp16xbFxMRQ1apVqX379rR3717q3LkztWnThpYsWUIt3mt2xWHMZgDaBwQE0G+//UbNmzenfv360fXr12nlypUUERFBAB6np6dTYmIiAWjn9Xynly5dSrNnz6aZM2dSZmYmde/enaLLlt0qvtJECoWCAPi4+WUymWxwfFzdjQCmK5VKslgsHg1sbkJCAh05coQAHPPcY+6MacdatWpF+fn5tHbtWlq5ciWtXLmSYmJiCGLWzbe9SxKOFz7heOGtnlVu78JhliLG0sZbB9t4azmH6WWww/TyldMBk1VgJqsQZLIKDd3akKckWjlLH4Ezhbr5RntrJDkWvmaOhe+UY+Hfy7HwUq85kPiWdkrMVmGMhRcmWnihifc1XrDpecE2kBdsNR25WVpHbtZawfhykMn6Kl9RxZiS4GtMSfjcmJLwxJiSYDemJJiMKQlmY0pCnjEl4XdjSkJHY0rC/5jH5D9V/lezeZVUGrXqTYFxQBFI0XqNmkxWYZGUoY+TcI0IGn+t+oI3j9JXyzl4rg2I1oBcnzo40y2lVu/tVXNw7ty5Y6pWrYqAgAAsWrQI9+/fv5mWuiWrXZfuzVQqFU6ePImLly+X4wTbbwCMg4cOjfps+CcYN25cYSX5+fkA4FetWjWsW7cOcKMN6zVqY4DWd29ubm7TmJgY70yEyM3NhcFg2P13OgoAiIhjjNVWKBTHNm3ahM8//xw8z69p2qxZJoBqRcls2bTxXvny5ZGcnIzq1atjxYoVgJhL54/2iIbesv4BAbb8/Hzjhg0bgm7duoXs7Gx77969fV6+fIn8/PxIAKuJ8LGZt52GF9KvWq02JiUlhRw/fhy3bt3C4cOHMX/+fGn9+vURHR2NjIwMXfUaNQ+UKlVq2pdTvgjo0b2bFQAxhosXLlyaMWT4Z4mDU/of3b17d5sqVaq8u3nzZuzdu7en2zPpdwCp5HYWUPoFEM/zvfr37T3qy5mzR92+ffvJ+vXrpR07dsSyZctw9epVdO7cGQAQERGBLVu2ICQo8IDSP6Stv7//zn379mHatGm4dOkSLBYL+vXrBwAep43wEiVK4MiRIwDgnW7h1KxZs+rVqiUioSxduhTPnz//6ePhn14+sH9fl507d8LXV5OZbXgsdY9TAYBlDs70xMfP/+f8/PyP3nvvvZIQYfjNsbGx2LJlC+AOvHVwJpnWz+/WhQsXGjds2PCV8Xv69CkguiK/jXoD2KDxQtEoitxaQ3cAS1+HebILfCwAh4/a9y7gizxzjjbPnOOj0AXZAdHxBKJm8wqorJm3SRkwJI8paubxNhnEoON7Zt5WHsCVQK36VwC/GjjBH8AHbhvPSc1bsNC1apXLzNs2EuGphKEZJ9gmQnSAWK1Vq0wAlgs2e/0CH30SgKEyu6mnMs/yoZlI0GnUf0JyBgDTgFYNIKJJKPFHrJ+3N2xVAGsBTDANaNVav2LfX+n7/0z6p3e7/6TC8cJ8799FaTZms3mjYDZUL0reyPHtjRzfJ8fCDynufNhutTC71bLQbjGNtFuMG+wWY5DnGkQjaF0ALVu1bNFAMDxP/WTIoBC1Wu2MjY0lABMtvMAsvJBo4YUlFl7oplargyACTnpKeQCdoqKiKDg4mAAUxiTYLcbkBvXr6X7avWPejm2bp7RN/CBu246dM0+dPb/EHffxpy/Lt2g2NeVyOe3Zs4dGjx5NEINjtVdv3FRu2rJ1LIBSr/EzACWaNntvD2Nsja+vL+Xk5HjsRiUAVP5y5uwyBgtf1mDhJQDqVKlShe7evUtjx46lsWPHks1mo0mTJpFaraZNW7d/9NPP+7c9fPKsickqeNso4gF0BHCpfv361LRpU2ratCmlpaXRV199RaVKlSIAFB8fTxqNhgCEeMmeUKlU5OPjc10ikVCbNm3oxIkTFBQURGq1mho2bEgALnjxB6pUKrtUKiUAR6VSKe3bt4/69OlDvr6+V1UqFa1fv546d+5MlStXJolE4kho2aKtTqejs2fPUrdu3TwaRg5EzKx67vaXUSqV+Q0aNCAA3xbRjxXdz9gRwDvuv7eOjo6mqKgo6tCx02dGjp9g5PgZRo7/3Mjx79osxg5uPn/3PTQAlpQuXZoYYwQgLzAw4H7H9u3W7dq+VXEgbcfcjwcN+AhA/Lw5s6cu/XbhfKVCUdo9zw5DDNb0lHS4Y2c4XmjN8UKxcVieYuGFgDdoNHIbb51l462F4+owvVQ4TC87vq1eO2eqZedMZT2/TVbha/e/OrcW1M6rJBo5PibHwjexWCyz3HE7xWoRJqsgN1mFkl7PEGHhhc/dxZ+IwAs2JS/Y+vKCrZkjN+sde+7zwxaz8U9akzEloYsxJUEwpiTQXyh5xpSEF8aUhPL/9Dr5r5b/jbPxIqtgm69R/+GLb7fZpADe91H9ce5qsPAfqeGopPILGF1UHSarsJYIw11ABwBrA4sBfHTw3JcgOg1ytQNwQqnVb/BcyzPnlAcwDUAvhS6ogDFWEeI57mEicnKCrRbEI6zrABLcYue1atVtoDA2oCEAgdxAgwDg4EyLwJgBwHylRlfoTm2yit47AFpAdGFer9eos4HigTgZY5Fyufza1q1bNRcvXvTkILkBceHJKFWq1HRBEGA0Gt8joiNumUkSiWSaTCY7EVaqlMJsMsXdu3cPoaGhcDgcFytUqFD7wYMHVofDUdJkFYS9aXtGDf942FctWrQovO+qVaswbNgwbNy4EYwxREREQKPR3j9+8mQFjVpVwBgLlUqlt5xOp8ndljZz5szxWbBgASZOnIjz58/jxx9/XOJyubpkZmaWaNmyJbokdesya8b07e42cr/88osGEDG6dDod+vbtC4PBALlcjn379qFcuXJPiCjCzR9TtmzZ6+np6bh//z6ioqJw6tQp9O/fnysTFbmDSaR9vvjiC+zatQtPnzw6/u38rx8nduryrHfvPqM///xzDwQKAKB169Z4/PhxOSLKdNddEyKS9E4i+rPv7mvkdkVvDfHoNN1rfDUAGsjI2aeASe8DsAD4BcBFf63vqGbNms2aPHkygoKCYDAYMGbMGJw9e3aGw5g9CWIajl4KfQmnw2quB6CdLijE3K1bt5lDhw4tvPesWbOwc+fOARwvXAQQoFGrDr+pre6Mrj0ALCkKuNYu8J8C2O6j9n0FtiXPnNMUwE2FLuj56zIecljNXZQa3TbPbzNv+1rnqxpZFK+Zt0kgIo1XlJIzvgCSTAIiXYRMiB5yZwJfSytu5m0ROl/VK7FmboiqwQD0AHZp1aqrgs3+DoAmINdOiYNb5GLSW2p90BcAYBrQqi7Ejwt1cc9RBLkgBo3G6Ffs+0vAuP9J9L+bjZusgk0JYKpGrSo8kypys+GE5ipydJWCBir9Al7pPJNVqAAxF3w7J2EhxEDIDYHaonPXO3huDoC9cDnDIAYgDmGugjIQ0xh/qNAF/UmOE2yhAJpp1aoNr/29PsSXpgAi8nTh8YXDaq4D4AMQ8Uqt/o2pgE1WIRRiro4gALtVyJeh6M1mSP/+/ZcsXrwY58//cUKQkpKC27dv31q3bl2lI0eO4IcffhhARCvdMjuWLVvWITw8HFarFbVq1cKiRYuwevXqwzabrX52draqevXqmL9wUUpCq9a5DOgboNPOdjqdUe7qVxmNRlWpUqUgCMLwmjVrLlyzZg3q1q2bmZNrXKZRq75mjNWvU6fOqeXLl+PGjRuIiYnBvXv3kJSUZHc6nQUQY5b6lihRIn316tVo27bt7Re5pp0KheKBzle1nDH2KWNsbkBAgMzpdMJutyM/Px9OpxM9e/b0HHEuIKLPAODF4/udqtSK+8SQm/tuiRIlYDAYUFBQcHb5t98cHjNhcouQkiXrTpw4Ebt27cL27dtnHz+c/vjAwcMB8xYsGme321+HSPodQF0iKta9998hB2dKVGr1aSaroIOIvFx7wtjR7S5cuFDtxYsXePjwIRo1aoTNmzcjPDzcQkT+DmN2KQCjFPoSwwHAYTVHDvl4+KbgkJL1nE4nlixZAkA8vm3StGnCzl27gzSvzc3XiRNsQfjj6OxPwbJ2ga8DoKyP2nfz69fyzDkMQJJCF/Sna+72lQPgp9ToCnNFvWmzeU02UanRpbmT8tUioigSNUgJEW4TsClQq3aYeVtpna+q2LTinGDrCvEj4YiUsdMAOgFwMgdXnoHq5303s6vr3u17+HOSt79CdgDb9Cv29f4XZP9R+t/Nxk1WwVYGQBuNWrXY87diNpsKUipop0LBI6VfwBbvOkxWoZleoz7iRg2QOAmXADQL1KqLTZLl4LlvAGyGy3kHRCtBrgAGeq+YjcYHQH+IX4NFDpw7SLQTADlzOV/I4awP4KpSo9vu4EzdlVr9pr/SHyarIAXQiYE6AfhOp/E96n2dMdbAx8fnsEqlegVtgeM4U0FBgd+JEyckrVu3BsdxZYjogVumM2NsW3R0NNRqNe7fv49S4eGXk3v0TF21Yvn0pUuXIjEx8SqAahZemANggVateuZ1z5/1en0rs9n8OxGtSUlJWaBQKLBkyZKvOSv/WEJOx907t8zvNmsxSy6XR0ZERCArKwvPnz+/CeAjIjrjridEpVLdVSgUGrPZ/AERpZl5W0eIG/7H7jxDlUNCQq789ttvePbsGc6ePYtJkyaB4zjk5+eXJKJshyWXAZiq9Av4gjGmABB889dzFaLLREX5h0WdUanVN+Pi4jw5SnD06FGcPXv2mdlsLgWIyNUA2kK0WT2EGGj6RhvHv0Oezcb9/wQApRYuXnJuztffdBs9Zqy5fsOGYS2bNf3UYDDA398fm7dtD+vY7oOsPNOLwQAeKPQl9gGAn5/fF0OGDJkaHh6OvXv34vLly8jJydl+78HDUwEBAQs1xcxNAOAEWwSANgBWFKPRqCBmEJ3ko/Ytsp48c05lAKyoNOevazXA399sXv+7mbcxIqpJYnJDOQAfBqQzxk7ofFXFgthygs0DUntJythlAO2pwM7BYv4yf8YnQSjI+1fR5m0AaupX7CsyWd9/Kv1XbjaMMV+IXxwWAPeI6C/B5jPG9BC9dcyvX7MKtnchqv+FwY3+en3F+Pj4j/enp18CsJWIeAMnqAB8qiE7lH4Bszy8X3+zsPqWzZvevXD+nBzAvTMXLtZ5npW1oFGTZkoA1QO16mKhPBw8txQu5zrmKhhNTHoEjFUBMFyp1RcGgpUsWVI1feasSdO/nLb74YMHnr/foiIi9t1un8MICM82crcPHjxY4uiRIydWL/u2dHGbjfvIZhBEm4EKIkzLvHt3bkq/W722TXZ2do0L5y/8euP6tXSI+dddjLFRcEf2e9EGABPKlClT5v79+/vcvw+YrILzyePHDfr17d07405GdYfDHuCn0+Vqtdq1GXfu7NBoNFcZYxKO4+ZHR0ff79GrV8svp05NJiKrVxsZRHuDGcCQqKioRc+ePcOBn3/qExdX92UBk38Axj7VqFUOxlgoxC/HbBSBVuwGmvQhokKDq5m3RQCYD2CsXqN+JpPJHkmlUn+Hw3EnLCwsZu/evWjbti2ePn3aBID5UcatZiVKBG9S+gVk5ZleSCFm7byo0Jf4lTFWNzo6+lzv3r2RmyvmasvLy8Pq1au5vLy8AHoNNcFhyY1y9yWl7f35cJfkXsEQ4VdCIC5wgKj5HH/9WYoZTxXEnDIMwCEi4hyc6QOIxmcNgANKrf6pmzcE4qY3Zfr06eGBgYGYMGHCpcyHj9dDRHqAskBolSdRjiOJ9Jy/1veTXr16TY+Li4PT6US7du3wySefYH96+hyH3T6uyAYB4ARbJYiL77riPpbsAj8OwGofte+Loq57KM+c0x3AZoUuiBhjcgCR48eOlk+eOCFEqdEd8+b13mzcsEXeR1e5RJQLvLrZuNMCVIEYG3WJiApdq01WobyTUEXCUAWAjAE3GWMWAL/pNWoDRJTzPABniKiAE2zxEI+o70mABMZYz4L9W+DaV6Ry9lfICWCrfsW+IoFM/1Ppv2qzcX89rlMoFEmVKlWCxWLBw4cPHxJRDyoG7ZYxJoUI6d3Oz88vmIiI47je9BrKsVWwJQO4rVGrLrnlAhljOb6+vlCpVDCZTNb8/PwyRJRj4IRpGrK/BLBO6RdgZox1USgUW9VqtScuBgCQl5/PmU2mEjkWvjSA0oFadZGYZQ6zQQ4gAxJpO6VW/7uDM+khLnqHPInOgoKCMsPCwqIlEhGNxul04tq1a+eJKO6VuqzmtgDijp84+X3L1m1XyGSyFuXKlYPZbEavHj2OcQio3QAAIABJREFUTJw6bQ2AI94ag/t5qXv37khLS0ONGjXg5+eHq1evIisry1S9enV9w4YNIZVKcezYMdy6deuS1WptBCB37969PjKZ6NRoMBiQnJz8CEBGWFjYe7Vq1UJeXh5u3rx5/sqNW6OjwsNKlS9ffuPs2bMREhKCJ0+eYNq0aTh9+vQPISEhfb1tM5mZmThz5swcInpl8XJYzRUAxBY4nZj91Vzdj+s3Hnrw8OET9xhGAeihUau8Yd7/FrnP8L/hef5sqZBg9l7zFjc2b9/RNliv7TpixIgqCxcuRFBQEEJCQvA8K+t59osXoXmmF1UgLjCrFfoS+e7+lAAYJpVKZ1auXLnwC9Zms+HOnTvbiehPkf4AEBgQ8C4vCL9Ur14dwcHByMzMRHZ2Ntq2bYtff/0V165d2w/RDfqNR22MsS316tXryhjDuXPnVvDGnNMQoYUmKbV67w28q0aj2aJQKJCUlIQOHTogMTERDoejFREVRs/zZmOklAqW2WW+v3Rs90Gns2dO1ylZsiTy8vIQGRmJZcuWoVq1ag+IqExR7eEEW00A0Vq16k9pDDxkF/jGAPQ+at+3ekbmmXNKAKii1AcfA/BLZGRkA5PJRBzHved0Ol/Rws28bb7OVzWCMdY3MDBwjV7/BzLM8+fPwfN8FSK65tlsGGPjZTLZzNjYWAQEBODo0aPXiKiKV32ROl/VQwAwcIIcYj6cQJfTGRVXq3rvAH//qoIg4MXLlzNyXr6c6NUHlejp/UG4fmmQ68B2JQr+rdNSDoBev2Lf/5X8VP9X6J/2UPg7BUCtSpUqUUZGBm3evJlOnjxJu3fvJrlcbgagK0amUlRUFGVkZFBOTg598803BGDB63wcL4zg+D988QFseOedd2jw4MGUn59PdevWLfTsyrHwU+1mg9xuNowmIvj7+y8JDw+nI0eO0NmzZ+nw4cN0+PBhCgkJoa2pO/q7ZarmWPg/RV47TC8lDtPLzXbTyyC71bLWbrWU8VyzW4yd7RbjWo7jPpBIJHaDwUDr16+n9evX0/LlywnA80JezlTJzpm+tHOmhp6+qly5Mj18+JDu3btHM2fOpPr14ne7vdmaW3ihh4UXelp4IdTN76hQoQKNGzeOvvvuO/rqq6/o9u3b1K9fP6pVqxZ99NFH1L9/f7p16xa1a9eOUgYMPAiAsrOzKSwsjMLCwqhkyZJUKjz8nFQqdRw/fpx2795NJ0+eJACnDBZe0uL9hO6hoaEUFhZGAKhRo0aUnZ1NUqk0r0mTJnT58uVCr7NWrVoRgPl2ziS1c6Z4O2fqYOdM7e2cKdbOmYr1FuJ4oS/HC385wr248lH/lGWRkZGk1+sJANWuXZvi4+Np+/btdPnyZbLZbATA7jBm93AYs5sUM/d0fn5+ZDab6ccff6Qff/yRZsyYQXAHRRYjMzw5OZnWrFlDs2bNogsXLtCcOXOodOnSlJmZSS1btiQAKW95T9qXL1+eHj9+TKmpqVQ2OvqC3WKU2S1/9ogCsLx06dKUkpJCR48eJbVaTY0bNyaIieoSIOZ8Wg9A4zBmJzmM2T0A7GzUqBFNmDCBEhMTqXTp0vTgwQNSq9W8keMnGzm+tzvWTEtEsPBCIwsvtHpTm228VWvjrVP/zhg5TC87+iiVY5o2bUp2u50GDx5MAIa8zufxRgMwb+7cuXTx4kXauXMn7dy5k+rVq0cAPnC/Q4luvotpaWl08OBBys3NJQDG1+orXVR7pFJpz6pVq1JOTg4tWbKE6jdocNrI8X3cXm8tTFahkjElYZrbs+xPHmfJFUpR5QBtYSmhUpBeKS/OO81iTEmI//9q7f2fKP9tcTYvnzx5QrGxsSwvL28nY6zl6dOnfd99912/w4cPx0N0v3ydsrKysizVqlXz69OnDypUqFBc3RKI6ikYY21KliyZLAgC2rZt+4oB3E2k9AvId+dLQf8BA6/PnTPbAsCvT58+uH37todvYbP3mutNVqFkoFZ9xcAJcQZOqOn28/cYO1cBmKDUBeU4eO5DAOsdPDdK6at9ptTqt3NW/oaMCuYCkDscDvTs2dNTtwvAcIfVLAcwFsBTpUY3yauNd2/evPksMjIybMSIEQgKEkNr3McXh4DCfDvNOcH2XnKPnj+k7dmjnD17dgyASJ1OVyItLQ0zZsxA48aNjZcuXboBIFapVOqbNWuGkSNHZkC0cSAiIgIGgwH37t3L02q1o5xO5wdtExP7VChfPnjBggVw23Uia9Souflg+v6XED3t6Pr16/UBgIjkAHD9+nXMmSMGU/vr9bePHky/AvF8/4JSoztb3MC9RmsBzLcKtt81atW/HH39/aqVF5s3b445c+bAx8cHL1++RN++fdG1a1cQEQRBgFQqlQL4WaEv8cbMqs+ePUOvXr0AAEqlgoMII18c7d24cWPnjRs3ygCEzJs3r8ytW7cwduxYLF68GC1atMCBAwdiihNmjPkzxnYuWLAAs2fPRrNmzZB5795jpVZf4OD+BI4NAKo6depgzpw5GDlyJFq3bu1up7Khw+GYOHfu3Aapqak4e/bsBoW+xJY804sVjLG48uXL49Qp8TBh5cqV2Lp1KyrHxmQpkb/YAbk/xBTeTc1WoSoAJwEPTFahNICbAG7qNeqXr7XjUwDfvKkfX6d3atS5JZFKUydNmoQNG97ok/AKzZ8/Hxs3FmZG3wR3LJoX7UxMTIxUq9VB7kRmbyXGWIhMJvtx3rx5+OabbxAWFoZzZ89ecRJugygEgL+EoRsUPvVYnl1eVB1LGhcqT3hoEdD6p3P4plHl4m7pA/Hd+KvvxT9O/0p2yn+MiOiR1Wotn5eXFwBgAAC7j48POI4DROj/omTMDocjVBCE8W+rHmIWSz2An7Kzs7Fo0SKMGDECLlexmup5uyW3yecTJ/0GEYYfn3/+OebOnYu4uDgAqHggff8SAB+brAIL1KrPAfAzcMI7bvn5ABYrdEGZAKD01boA9AKw0MFzQZxg84NE0lCl1bVxuVwShUKB1NRUrFq1CrVr15aUL1c2BcBEAF8rNbo1rz+30+mMADCmuMZr1SrSqlUHtWrV+u9WrBj09PnzjdWqVePCw8NLxMTEoH///khLSwMAa0JCQoOPP/5Y37lzZ6xZswYdO3e2A+IG0a9fP2zYsAHbt29XWK3WXQBmTJ8xc5XnPjabzRGgVd+fM2sGAVA3aNCg3tGjR+v//vvvGDBgAFwuFxhjeP/993H9+nX89NNPKBUeXrFpi/cDlRrdHqVGl/WWsSskt3H6qzc991+kHYcOHfquVq1aN2vWrJnfsWOn240aNzno768vPO93Op3Ot200AFCyZEns2rULS5cuRVRUGS1EJO0iiYjuApgSFBQUHxcXV+bTTz9FWloaAgIC0K5dO2zYsAGffTLM32HJ7e2w5Gq9ZR2cqXrl2Ni0IUOGYP/+/Xj4sEgA6NfpjtlsxsKFC1G6dGnExsYiNjYW7qPRBs2bN/cEcnpW3WEB/v5+HMchKSkJXbt2xbp16zB+/HjkGo1jJMBUFfLz9Rp1mlTC7kokbIFOo+4DEa35J4g2o+4mqzDNZBWmmqzCVM7Kb8h3IcLuYgkmq9DAZBUi3CnTiyXGmOTe/QdrZ8yYgXnz5nnWgGLJYTVLlUql+HHYvz/WrFmD3r17Q6lUNt/449qGbhf/6g6rOdHOmW7fvXl9rEdWLpfLHVZze4fV3NZhNbdSUH5Dh9XczGE1v+uwmhs4rOa44KCgzaNGjcLGjRuRnS2aAWUymUTD8s8FatW7NSz/kJScn8DlDHnbgOTa89B5/0WMqlEWrSNLFMcmh5ia+r+G/ts0GxBRptu4e2jcuHGBd+7cwYULFzLxhrTDRCS4DXhvIhdEY+rMmJgYxMXF4fz586+/sM0BnPP8UPoFHBYsxuUQDeu2xYsXIycnB6Ghodi6dSv69OmTkJzUtZuR47cDSIboBn3MwAmtbObcgVIgTaEL+tX7BkpfrdPBc90J2ApynQSTLHJfyurVq1fonTt3UKVKFaSlpaFRo0bv+Wj1k6iYGAwSjfh/6UxXq1YRY0yqVCqbtW/fHomJiYiJicG6deugVCpVGo0G/v7+UKvV8PPzw9bNm58C2NSsWbOKAH5jjCUdP37cNyEhIYDABqrVquIg029euHABSUlJaNCgAebOnYuDBw/i0qVLKFu2LDiOQ+fOnbFnzx6UK1fuS8bYAnpDLpmiSKNWZVkF21WrYGupUasOvI3fbderACAYIjDlPSIyQoybAACYedsn5HLV+/brOYf9g0t6y0YCeElFp2TOczgcBd26dZNlZGSgYcOGOHLkCKpUqTKJMbaKiIpzny0VExODfv36oVq1aliwYAGcTid8fHygUCjwzaLF52Z9OTUNQBeHJVcDsBwwpuz7UYrKwnENwsLCMHHiRERHRyMzMxMAOjDGqtktRe6Lyw4dOuQ4dOhQC51O16Js2bK4efMmbDbbCh8fnwE//PADHj9+vI+IrgKAQl8iLzSs5N69e/d23bZtGxhjiImJwYgRIzB37tzOAD4kYBbPW7PBpGlateoGAPhrfWMhvgPeH7iXbbz1IIDBdhdbCCACQGmIjg1hf95wKIcBnARU0LFDh2bPs7NrBwUFYf/+fWjZsiUAICIifPjLZ4/h5+dXOGcYZFUA9IuPqxu1Y8cObN++HXK5HNOnT0d4eHjwmHGf9+/Yvt0XEGNYfgVg37Rla+G9CwoKCiBqEFIAMhdYhASUDXH9lH7QsXPLwKCgJg0bNkTbtm3Rv39/AIDD4Ug5cepUZqMGDUwAyiqZi9kK8lXFjDkAwFbgRLf0S2gfHYoP3yn9JlZAdJb5r6H/Ks0GEMEnAaQPHTq0ZpMmTdC7d28QURciymeMKdxeJH+nPh/GmAxuzQZAYmZmJqZOnYoHDx4gMTERwcHBaN68OYKDg6czxkat+2FNaU9SJQBQuexSAJN27NjxtGvXrjhw4ABmzpyJbt26AUB9vUZ9GUCAySpEAoDWJVTKZ9I8TqK+VlSb8pjMmQ/JcTlcDRRU4Hlpuu7bty95+tTJY+7cvv0wNTUVboN6LcZYiNv76s1EItQOE6mMe9P29ENLrVb78/r163H58mX07NmTkpKSsHr1auTl5emPHDnycMXKlbcmT56MCRMmAKIKb4QYmLaciH69c+cOgoKC4HK5Wi5f9l2n+/fve/K9AwD8/PwqhZYsuSw+ru6G5KSuU3bt2mXneR5ly5ZF28TEI3v27ptBRKpt27bxMpkMoaGhKgCl/tpIvkoatWobgOZWwfbGF5IxVpUxVlC+fPkbDRs2/KVUqVJ3AZxijIV786nyuYsKl8NYIPXxbo+ydOnSD+Ry+UPGWARjLMp7XhCRzeFwfJCent7p3r17ldatW3fl0qVLiI+PB4DqjLFwxlhRn64/HT9+/Ku+ffumNmrUCHPnzgVjDFOnTsXEiRMB4IOoCjFRk6fPrPj0WZYdIC3IpT97/kJTqVSK9PR0jBo1ComJidi4cSOGDRsGANO/mPZlZcZYQ7fzgqeNBgAFUVFRLTiOQ5s2bTxa+Q273T5l4cKFhyBq4IVkNnN87dq1sXjxYqxduxatWrXyxNvUypMo8vOZ/LaUnOEKV56fl9jXgwYNGj9r1qyxnuLn57f5/oMH4wAs0GvUVhXyn7lLlrs89RQf5D/1QYFMDqe/BK7AX44fbzV//nzcuHEDH37YD5UrV0aDBg2g1/tXmDp7XsvLt+6Wf24WImyQB7vApDbI6YsvZxzUaLXr3m3SdLxcoVj62WefoVOnTsg1GqvYIIcTjNkgZzbIJfmQvjIgNsidNsidAz8ZETFx8tQKj3PMsEHuskHuuvTrbwkTJ06E2WzG9OnT0aFDB8THx6NTp04YN3FySxvkShvkRhvkAnQBxYLiOF2Efod/Q3m9BhNqly+OzZveArDzn0X/VZqNe1PYO3DgwLhOnTqhTZs2cDgcdwH0YIyFyeXybYwxOWOsNxFt8pLrBxGryUMtGWPjAciUSuW0goKC3FMnTy5q0LAhA3ALQPjy5csRFRUFAFCpVChdujTUajWkUuncCWNHgzFW+XlObhdfhWz1rp3bJ0IMxFRcuHABdrsdISEhHtXe88W7DMCXDnNOBgMsfn66bwyckGzghJ8DvTJNuu0oH4FJtjJy/QJgNmNskVQq/Sk4KCh/xKgxp59nZwdUqlQJx44dQ93atYdnZGZ+K5FIwBjrS0RrvZ57MsQobQDA71ev1meMfQ1AHRYWNshkMuUzxsoDeCqTyTY2btwYPXv2hE6nQ1BQEJNIJCAiSCQS2ejRoyPHjx/vjE1OxvPnz6HRaGLCwsKali9fHhkZGSNr1BCTeU2ZMgWPHz8OSU5OLhEdXQbp6ekAUF+r1T6Ty2VC5SpVylqtVuw7cBApKSnw8/NDRkYGHj582Gzzpk2N5HJ515iYGF+VSuU5jvh3sKBmAxgH0aZVHDVMTk5GUlISsrKyUL9+faSmptabMmXKSgCtACDP9CKZgPt79uxRJffpdwXi1zcYY6hSpQry8vKCrFbrA61WK8nKyprtngtgjNWQSCSpLpfrGoAbMpmsarly5fDy5UsA6BUcHLw7Ly8PTEzMdtgtM1IikcxxuVz7GWPvMcYgk8lQUFCAsmXLIicnB4EBATH5BQW/Hjt+EnPmfr2FiLoBQGBAQIXfrlzBp59+CpvNhtatW2P37t04evQoALTdnba3bdmyZZGZmdkPwBr3/TqXKVNmfqVKldC+fXv06tULBQUFOHbsWHcA5oYNGza/cuVKc8ZYBBE9sQo2hdFobFeuXDmkpqbCbDZj8ODBWLRoEfr3768DMBSMbWGEFQDGOKxmnVKjSwfg26NHD6xbt67wA4SInBqVj4y5Cno6rGZAdGl/BNHFe79SoytWozUYDD2WLl0aotPpoFarIZPJoFAoIJPJsOTbRYmbN26QcBxnqlK1Wsyho8fCAKQndeo4z2w2N7lx/bqfYLNFNGncGEajEb6+vgUAqrjA3gGAb76eV23Fd9+187qdX2zF8ufi69e/cPzYsa4BAQE4c/r0z/sPHtoAoCA0NNS5YMEClCwparw6nfgNl5mZiaysrFsQ3f95AE5YTB/DnTDtdRp56jryXYSFjWLfMF1foSKNcP+x9E97KPydAqB+jRo1yOl00rZt22jNmjW0Zs0acuNH/T569GhPPvFvvWTkcrm8YM2aNXTmzBm6fv06rVmzxoOP9fTw4cPUqlUrmjBx4nccL5SBeBY6AMAiAFd1Oh2dOHHC441ml8lkREQklUrpwZNnzYgIfXom/6zVaunAgQP05Zdf0vfff0+ZmZlUunRpAtDU0xbBZPiYN+Vu8/zOsfAsx8L3zbHwKs/fLLzQx8ILkZ7fds7c7ccfVh9q1KgRnTx5klatWkXnzp2jXbt2kVwu5zQazZrJkyd7vJzmeD231tfXl9LT0+n27dt07949Sk9Pp9DQUAKQffr0aWrUqBG179Dxw7sPHnbx8fEpCAoKoj179tD69etp3bp1dPfuXerSpQuVK1eOVq5cSc2aNaNDhw55+m5LZGQkLVmyhHbu3EmLFy+mypUrE4DFjDHTqlWrqHPnzjRnzhy6evWqJ3dKXuPGjWn16tWUmppa6GVVsVKlp+PGjaMbN27QxYsX6ebNm5SQkEDwyuvyrxY3TlexeFoQj8+uQQS6vODv708mk4kA8A5jtp/DmP2xw5hdwm42TFT5+PwwYsQIOnDgADmdTkpPT6ehQ4eSVCqlLl260I4dOwjAHq+6e3fr1o0OHjxIq1atoitXrtCyZcuIMZYJYPP3339PAwcOJABDvWS2LFq0iLZt20arV6+mmzdv0tixYykuLo6OHz/u6fvFrVu3pr179xJECCOPrATAJF9f9eUKFSrQlStXPLl0ngFYtWjRIvrkk08IwBgvmbVDhgyhsmXLUlpaGk2dOpXGjx/vwWt7eufOHapQoQIBqOruz74Acnr06EGVK1em0NBQio+PpxMnTpC/v3+2hRdUds7ka+dMNe2cqYedM22wc6aVpcLC7p44cYIqVapEEomEANCIzz5b/2+sBRWUSuWnrVslfA/glwULFni80c4CyLxy5QrVrFmTANTx8kZ7tnfvXlq6dCl9//339ODBA8/aMUx81wq90TbOmjWLrly5QgUFBXT58mX67LPPCICxb9++tG7dOgKw2astKoiee4kAFvfv35+WLFlCAO7ezrzf1mQVFpiswkKTldvLnUw3Ggd/8CfvsnE1y1H1ID963Lf5X8FJI2NKQoExJWHWP70m/60x+6cb8DcnWLSfn5+zVq1a5F0CAwMJwIu1a9dSfHw8Aejq/QJKJJJHr8uoxBw1dPnyZVKpVHTi5KnxHC+U9b6fUql8XyqV8hUrViRfX1/S6/VUvXp12rx5MwE4beT4pkSEWV9OSZJIJPmxsbHUoUMHatq0KalUKgKww1OXw/SyqcP0cpqR4wcYOb6i5+85Fl6WY+H75Vh4uYUXki28UM5zzQ0oOPPGlctLlErl84iICKpfvz5FRUURgLsQ8c+OpKamUvny5WnNyuX77RZjXfdzSyUSyZ3Q0FDyLjKZzCyXy+n8+fMklUpdu9J+quHm7wrgpEKhoBo1alDNmjVJo9GQVCrl+vXrR5GRkZ5F4kaFipU+Cg0NW9q5c2fPYvZ7SEiJLZ+PH7eMM5vmq1QqYfr06R5wRwEASaXSJ1KptGDYsGEe+PsDABb17tO31/drflgE4DeZTEZqtZoYY3aIycEU/xPzhuOF6RwvhBR3HUCcRqOh8uXL0yeffEK7d+8mpVLxyGHM/tBhzGZ2s6G53WxoC2CoXq9/pT+1Wi0xxqhixYqeeXgAgMedvAJjzBwdHU3x8fEUFhZGgYGBmRBjcnI7dOjg6YuBXm3pKpFIKCYmhurUqUMBAQEkk8k8fHfd4/TVtGnTPG7QA4t4noqezYYx5urdI3kVY+xOenq6x5W7nBfvh4wx+vnnn6lcuXI0ZcoUz2bzICgoyLOh3QEg5XihNscL9QAMB5Dfpk0bWrBgAZ04cYIaNGhAtWrWPGnnTIPsnKm3nTPV9QC42jlTt9DQkpmHDh2ic+fOUWZmJq1fv558fHwKABTpRvxXitsd3gfAgODgYNLpdASgnUqlogsXLpBEIuEBqL02myWBgYHUuHFjql+/vgeEdT4Aibs+z2YzQCqVkkwmKyzuuW9YsmQJxcXFEYBur7fHZBXY2PGf91GpVHa5XF4wfeaskyYrv9Rq5RbwVm6ZYLX8bLdaiNux2um9cfze7V0CQKU1qldcnztEl3zTZmM2piS8+0+vyX9r/f6nG/C3GyxGhdd+rZQBcNgdH5DrmTxeMroiZCJVKlWBe+LM43ihF8cLNb3lbIIgfZGd3RZATQAVJBKJITo6miIiIqhb9+ShRo4vzH1jyn46GUAtAJ0hOhIUojk7TC9rOEwvFxERjBwvMXL8bCPHyzzXcyy8Ty7HLzFb+Rj3pJfaOdNEO2dK9vAIFtPqpC5d6kAMICvneUYAR6pUqUIALtktRma3GEfYLcbldotRB1FLCwMQNu+bBe+eO3tm6dHjJ3v5+vrmly1blgCMLKJ/fd39UwdAwNhRIwfI5fKfAUz55fTZUgYLX85g4TUymWywn58fqdXqnGcP73exc6YYT/wLgH5loqOvDR469Et3LE9PCy/UB7DHx8eHoqPLPomIKD0WwOB58+cfGvf55x45OQBfk1UY6I3i7L6mgOipNwhAmeLmR1GF4wUtxwvzOV4oMj4HQI+mTZvSnj17KCMjg7p160ZyudxERLCbDT52s2GaF28QgLBBQ4dV9ff3f16qVCn66KOPaOfOnbRv3z4aOXIkSaVSg9eGI4WIdtEAQCSf+6IbgF/at29P8+fP98R9ZXjqt1uM7Mm9u21Xfrd0wthRI4cBKAkxil/t1YYRgYGBxBjLKmpD9t5sAFy1mw0BZaIirwcGBpKvr+8Pr/EuGjhwII0ZM4YAGLw2G5LL5Wb3gpzIWXlfzmqd4NZWBnfp1HFr+fLlqW3btrRlyxZPxtWjxY1BxQoV9ikUCheAm1KplLZs2eLRFib/K+uAnTMF2TlTS6/niDi6f29/lY9PST8/P0+G20+I/oiz8Vo/mgFo5P2OuutM9OKTueejp0gBfFu6dGmSSqVPPe+fySpITFahh8kqfGuyCj+arMLSlwbDp7mGnKWC1TLebrW0s1stfkQEi9Va2vrs0S/GwR9Y/qL28qZiNaYkyP6Vvvunyn8VgsCbyA250RzihH/2Nn63THWIkPx7OF6IAxCoUat2eq6/jo3GGFOoVKrWU76c8cGAgQPX6TXqYx5ed9ZGh9Iv4Lj3PfLMOWUAfAGgnwfvzGQVogAk6jXqb4H/w953h0dR7e+/Z9ts380mJPTeSwCp0kRBJNJVOiIWOtIERKUjiDQB6Yh0kA5SFZUiiBRFCCAJHWkJ2c3MTtvZdn5/zCYkIYGg9/u71+t9n2efPNmdOXPO7Oz5nPMp7wvwktw+TGlKMIwyFgRSCcFzAD7NSn6piLwOak1AF8Zie5hpQ4gVqmE4TSlVc8B51gRgOgUEhRhOQg1a/24MK9UYm3MTIaQ4gKIAfqZPoPpRBK6JQjW3gtBqtQgLRhKqAZXuI7xg0eJL740afZXmoF6JjKmPzWxamuX/8q0SWk6j4XCHqlUf1g7s27cPN2/ebEgp/SnjPU6UiwKo4bCYdmcZ5+xnn312WLFixbBp06YfKaVNHtfvnBAk+TkAxa1m05qcnxFCogB8SggpZrPZWl6+fBmVKlWCx+MpeOnsryO27fx6/Adjx0uRtPi6UJMWHkTHxCxnDIbYjKQQURSxZMkS7Nu3D3Pnzp1EKR3/yP30eroYHdGjhw8fXl2WZYwePRolSpT4w+dNrwk16YIAOMDYnI99hgkhBaFSrTxShk4IqV2+fPlTW7ZsQXx8/CWoiyAYHx/uAAAgAElEQVRdk8aNFjtstvDHE8edr1C+/AbG7rpJCDl18uTJ2oQQBAIBFCtWDJRSTJkyBQe+/fansmVKs8WLF0+b9dlnWoMGqwnws9HmjNZoNNVHvv/+Mz8eOaL97cyZD1NSUmCz2WSorqT6AI5SSg9n6VPD7l271Fm6eGGZLt17loorWLBVnTp10Ldv3+WU0nfy/01G7qPAdQXwFWN1ZE5gfi6tIIByjLOAB0AhAD9QSsMZDAL5aDNXbrQsYyAAKh344WC4Tt16zaFS0DAAPaUDlTWgRgJ6hahxp2OMxRYAAE6US0LlVUujF05vwxdT7wOw53WdfCAMYKdz6b5X/kIb/9/xt0oQeByoynGV/8ou9ZzM+hhBkm8CqPmE4/1uXjoDdXWULZWasbsOKF7PWACZxsbPpbmgSr52yUqs6bSab7CCxLKCVEOrIYUB/GGkgXNh4DUFWp/Dav0o57UZiy2oiPwwqIkGfbL0SYCaEQZAFY6ChqkP4KA2HLQz1N+OUOxibM7fFV6pFjnnFtQfxGPh4aVoBqSiDuGyDAmnQ3WJHWWsDhEAho98H8NHPi72/hA2syn5xyNH7sybNw9msxlnzpwBoAbZ534+vzsvyUUB7LaZTZLDYrrNiXIzTpRNDotJJoTUj42NHRYRWsOmTZtc+bpoFljNpsOCJI8TJLm41fyQsZcQ8jYhZLorynm0fLlyzK+/nc3sV+FChfbXa/J8DVEUu384bkILo9GY+Oyzz6JAgQI4duwY7ty5g4kTJ2L27NngOO4ogFubNm3q1rBhQxBCSj6mO0Nnz57dKS4urv/o0aNhsVgsUHc+a3KTDM8NlNJcKfYJIZ/abLZRTqcTOp0OUVFRFSVJEhVF+SoQDHWR/QE8U7/RZNGTWlvxejrExESfbtKkSe0MGqQxY8ZAURR8+eWXCAQCzzZo2JD8cOgwBr07+I3Vq1Z9G7nGzmrVqjWdOX06wuEw3njjDVy4cAEF42JDaW7PrlGjRpmmTp3KIzKhEkLMRqPx4Jmz5/QWhwsulwvbtm3DqlWrACApt3E8DorAVQJwKauhAQCDI+a+n0trTCn9Ear8Rubtetpr5AQnysVZQZoONd3YANBvDAit0TzkWTsD4DxjsdEs51QB0ALADQDzHRZTSClb5o1AQqe9wX2b2uChWNrTQgEw+U8P5t+E/xpj8y/AXeQvzbYoAUxOq/nXXD67oHg9NRm764yfSzNCZQfobHDE5LZ7WAtgHaV0EUMDBgCTNATjglQT4+al1tE28+6cJzAW221F5DcqIj+asdiySQVwolwGKvdVEMCPDovJE/lopcKznRWeXQHg3JMGx/M8AfC8BrS8EVTUEugAbGKsjn9Z5su+ffuwdetWAIBWq53e/fWet0NhWl5D8DKvSj2AAIQC/QkhCwHsmTNnDj7++OOM1N8/ixkAPhUkeaj1IeNw02nTprlcLldbr9eLzxcsxJo1a8Bx7G9ms7nUmTO/4eWXXy6UlJRUPz4+Hh07dsS2bdsQHx+PWbNmoWXLlqhTpw52797daNmyZejduzcmT56M4SNGVuBEubnDYnqED8/nTWdOnDx1sVN3lVVAFEWRsTm//isDy4L6n3zyCeLj45GWloadO3di3rx52LJlS4fWrVsjPT0d3333HaDRJoHS6NvXrhg4jtualuZeFV+7bv0rV6586Pf7EQgExgN4Y+jQoaXPnj2LNatXX129ahV4SY6KjY0t06VLF7Rq1QqEEFy4cAFdu3aF3W5fHgrTIQMGDMDUqVOzpuXqtFqtft68eShUqBB8Ph+2bNmCVatW3QWw/E+MsQZjdeTFXv6bn0urYXDE/PYn2gWQmRHaIExRASpBqQWAlyA8mUG4bAgooVUVOo8zFtudnOdzolwfKqHtBQBzIoqiUNjUNgDpCb2+E9Rd0Z8xNn4AB5xL9535c6P79+F/xiYCq9kUEFQBpCehGFRVxUfA2F3bFK9nrJ9LOwfVmPQ0OGJypYzXasgLNBzepKWhkQA2MFbHBwDAAKKbl3RuXmofbTPvyHpOxP3VrNkLLzzT643X09u82nkNgOehplJedVhMWyPHaaCm7b4E1ed/w2IxT3XfuzNF4dlSAEYxNmcmW7QicNoQxfMUpKwGoBrQoxqCg4zVQSOV1f9Ssr9p06ZhypQpOH78OIYOHToqxmmvlc6LnjDFEFC6y2k1/8BLsoZSDHi5VetvTEbGdfPmTfz225+ePwAAVrNJFiR5NYDeAJb42VTyTq+e4vjx41GrVi1YrVbMnz8f169f/3XlF0vODx3xfo2UlBQkJyc/ALDp5MmTzU+ePFkcgNXlclW7efMmJk2aBEVRcP36daxZswYHDhzA3r17f9u7d+9zY8dPeJsT5U4AhhjDSjWosZv6oHTyc81bnI2Li/v8cf0lhNRD9ipxP4ADNAsTdo7jCYBdgwYNKgg1zuCDGsP0aLXaesWLF4+dNm0avtmzywfABUJWMVbHUgcNMw67rfOGNSsDPd5464Bf1RbfbbFYJiYlJSExMTEJwHFekssCaOrl+c4ffPDBvnHjxjl0Oh3sdjtEUYQgCEUSEhIwadIkQN2BAwAopd6qVatMTkhIGBkIBIwmkwkGgwEd2rW9s271yqeiFIo8jz/m9bnBEXPZz6V1RMRjkR9E9HVe0EJThxPlInhYQ3ZXh9AkHWgVqDGbUgAOBKCLMufQs+FEWQvVMJUCcNJhMWVS7ygCRxDyDwMNOxlXoWZM6x5gv17XCSqjwmOLPHOAQvWovP0U5/zH4L8mZvOvQL6UOnlpGgG+dNnMybm1oXg9PUHDLxNghMERkyuxEi/J7TThkEGHUF0F2uQwNBecVvNPWY9x81IhqIZkQ7TNTCM1Rhf79etXThAEeDyee+s3bR4AkP0OiymbzAAhZHS1atU+6dGjB4oWLYoLFy7g888/x9B3B034aPSoeVBde1cAnA1CUwwACYP8ZLPZsroe1PHkodT5OEQ0dV63mU1f5ujXBwUKFJj64MEDaLVazJ07F4QQDBw4cCvUyu36sbGx5YqXKElFURj7+8WLyS6X69zOnTvx4osvokSJEtiyZQuqVauGVm3arL5+9WpJn6Lg1s2b94LBYBiqsuLYJ8WhBEkehXBojyEoNQewlomKC0B1oZoB3BQ9qc/MXbDQO/OzeTtjYmKQnJzch1K6jBBSxul0Xqlbty7Kly+PihUrYtCgQdDr9f5ly5YZHjx4gJEjRyLyvR2uUL78GIfD3mzAu4NdHTq88pXdapmqeD3NRVE8F124eIW4uLgjJ0+eRIkSJVIA1KcR3Z/IvSodHR19tVmzZpn9vnXrFn7++ee5lNKhuY2LEPJemTJlZjZt2hR2ux1nz57FL6dPu3du2zJz5OgPK51LTGyvKMpsSunE3M5XvB4z1Cp/kpR8ecOLrdoedbvdhUOhUGevKIUBuGyRmCYhRFm7dq3h/PnziIqKQrdu3VCvXj3cvXv3ZlxsAWb9ii8GvfBy260A4JNE3dGjR+f36de/7/79+yHLMo4dO4bx48atvX3jqgfASMbqeCIFcoQHsANjdeSpDwUAfi6tFoB0gyPmGvBQYoCXZA3UHUdxZCmIpBRpFIghNPw6JeS0HqFvtKoQIYWqM3SMsdiCkbZ0AAo6LKbbkf+dUPWjzAD2OCymazn6bEPQPxbh4O+Mq9CKrJ+xfRL6QuWDy4/BCQEQADR1Lt3311Zd/yb8b2fz9IjLy9AAAGi4MEBkgyP6EUMT2Z6/rgsHimhAeQCj7FYrjfBEnXVazZlCTNE28z03L+0F8Iabl9YWKFBgTPXq1csNHToU586dQ7du3X42ItSWsdh25LwOgBJ169bF6dOnsX79erz11ltYuXIlBg0a+PpHH7z/W4jiBwpaSQv01SK8w2hzrv4X3JesiAbgzuX9L0Oh0J0HnvTaBVxR+1esWLFn0aJFAFC3adOmrw4ePBiRyR0ff/zxlgoVKh5/6aUWsNlsWLFiBex2O4oVK4a5c+diyJAh7QcNGmR/9tlnMxsfP348BgwaJPCSfB3AYZvZlCunmt4vbAxpdKtDGv2LJnuUP7LgOgwAitdTDED0B2PGr/1w7IQ6Ho/HBZX5GAAcTqcTLVq0QHx8PC5cUG3zggULDLGxsZg1axaqVq0KnucPmk2mn1IfPGjwRq9e6NWz57X2wmuJnCiv1hD9jKYvJiwqUaLEK6VKlYLBYEDVqlXjUlNTrxNCulBKMwT5YsuWLYsJEyZgwwbVY6SypuQuI6wIHClcqNAzjRs3ht1uh9frxcSJE3HgwIHops1blKeUvqHwbNvHuesYu0sC8IXi9TjKlS8/4PrVK8dIOPheUGfsDCDRZjYdznL4uB49emRoGTV0uVzali1b4ssvv5xyPyV1mZ9NXexnU08ZnLG3AAyIjo6eef369ZoVKlSo9vbbb5ueeeYZpLndPNTJdroicKPyYXBeBrDnCcfA4Ij5ReHcb/GSXBvqjqScV5R7EIIggBM2s+kYAEQUOccBNEoDesOA4O+A5jLUYsnVWeMvWVAYwG1OlCtA9Rx4AWxyWEyPkLMpAlcNQf+rCAcOM67Cj/TbuXTfErZPwm0AX0Gdi3Mt9oRqZFIBNHcu3Xf9SeP/T8X/jE12SIIkW6zmvNX38BiKCD+X1p4AAiXklOL1xDF2V2b1Oy/JOoTDQ/QIliXAsqyytQDmQK1dmJq1PZ2GcJTSG8ePH18pSVL3MWPGYMqUKWjTpg2CwWAIwA5F5N9mLLacfu/1y5cvL0sI2dKwwbOmKVOmfJaYmAiO8xYWqS4RIJLLZv4KABSeba3w7JcAdvwL4wYFAORk9QWAXTqdrk5stCsdwLvt27fPmLCF+/fv48MPP0Rqaiq6du2K9evX4/nnny+9du1aHDigzvWlS5dG+fLl8fnnnwOA0KBBA/v333+PU6dOAVDZlYcPHbrqnd59UgA8x0ty08h1M76zZIOfDxGgUlhnHABgIB5lGh6ACCszpfR0js9u3LhxY9CIESPKABh26tQp6PV6aDQacByHDz9UyZx/+eUXzJw5s3Tt2rXRsGFDAJAcFtMuTpT3hol2usVmq5fQqhVq1qyJQ4cO4aOPPsLmzZuxbdu2R7RgLl26hMmTM2PB56AyZgMAFIHTQa3ZqQaADhrY//sx4ybowuFwcQCFL1y4UHzmzJmYNGlSJYVnCfIZKGfsLk6QZI6EAnNBNGv0Qd+3BPRc1gU4pfRTQsjrzz//fJWiRYuiWrVqGf3MWHUPALDRJ/AzoNG4a9aqfYVSWo8Q8g6AZZnXsjpuKAI3F8AMReDy3OEoAhcFwJ+RnJIBXnV914Pq3s74nqlWo3XpA9J+oyP6LifKxShw0G423QEATpSbAPRNAkTrENqnVYP7RwDUYiy2PLPROFEmiKRMQ609mu+wPKo2qgicFkB7BBWGhIOXDLkYmgw4l+7bw/ZJKKmt+ezi0JnjLSNvZ2SbGqG67CcBWOFcuu//TMX1/wf+Z2yy4xyA6gB+yu3DdF4qBlW06BH4ubQKAF4wOGIGK16PBqq07WQA4CXZrAkHP9Mi/IAAg3LScDitZg8rSL+ygtTcaTV/x4myEWoat5Fl2RMvt2head68efj000/BMA+p3xiL7WtF5D9XRL4QY7HdA9QH3cezYQALOY7TVqxW/d1evd7E/v374XQ6rlgQuM3YnJk/aMbm3A1gt8KzXRSeXQ5gHWNz5qRcf1oUAPBHLu+XXr16NYoVKxal1WqRnJycQVq4JD09fU7BggXh8XgC+/fv1w8ZMgSKovhLlChZeuyEif0fPHhQd95ns5+7ceMGrly5Eobqt+/M8zzS09Nx+/ZtUEpHZEl7f2QMMud+O6TRlwzpjOcBVAUQz0vyKKiMxtf1QbkGAVYwdtcjkzIhpLNer/8qEAgkAUjS6/Ww2WwoWLAgRo9+/1Ramvta9Ro1K184n5gUDAZ9ALTlypXrOn78eCBi0BwWUwjAe2/1esO47quNCatXr75y//79jEQOHmqcLxuaNGmCxMREXLt2DWPGjIm/fv3a24rAnYO6wg5BJaBdyFgd9IOPxuLDMePinnnmmU7x8fF45ZVXMjjLzgNwQo1DPBGCJNelgEi1+voAOmuDckEAAxWv5zaA7YzdlTHBRjVt2hSlS5eG1+uFoiiAupOAwRkbVri0wSSkfEM1puqPux5jdVxXBG4O8tjh8JJs0ULzfohof/NLcpfI2xnfURjA6YzdSgb8nEig1rxtBnARQHVOlAYT0Foa4Loe4e0EOMhYbJm/Z0XgauXWv8gO6FWo9/CCw2LKM+tVEbjSAJ5FQE4kNFzf4Cq8NK9jM2CescYGYK105nhnAJWhuvlCAM47l+57JAHh74r/GZvsOA01OJirsaFAR+SSMuzn0hioFe+dAICxu8KK13NH8XrKBzQMp0NoJQGdb7Q68l7hWM37WUGaxgpSYUJIOoDvHBaT7LSa32rUqNEzLpcL+/fvD7Vr1y6DIfA1Qkgrn+AdBkrXKgK3AqqLJQTgxNnkG9dffOG5JY0bNWrSo0cPNGvWDK92aD8Nal3RI7EZxub8CsBXCs++o/BsdwCLGZvzVP5vXTYUgBqDyYZ+/fsfatOmTZ1gMFg84ro6CWAsgNKlS5eGw+HAuHHj9JUqVULv3r0B4G5S0qXrAEYlXb1eZd3q1Udat24dgJpVVsfj8aBHjx4YOHAgHA4HWrduPZMQ8iul9GDOa/vZ1G5a4BeDIzpzFyhI8hYAcygwVxvyvxAmmviQlmH9kpwx6WRMqikGg6FK//790alTpwopKSkVqlSpgu3bt+P27duXKKUNKaUBDy8ZALzvspknE0Kqb9iwoTjU5yWbm7Jn105HO/V4YxCAEVATAEY4LKaczN3uS5cuoXLlykhLS0OHDh2wa9culCtXbvyx48fLvvBiy+3IHYzD4UCxYsXgcDgyFicuALHIfbeZDRFX7zsA1tjMpkgg3nQXwFzF6ykFYJji9ZwyOqJ/A/Dm+PHjXwTQavz48ZUGDx6Mjz766FVCiBuASfByL+nC/vc1fnEyzJY80wh5SSbQGAKEhi9raWgHL0rrQUjGgoxqaMhBQL+xWcyPfK95weCIoQqXJooC3xlEMwhArA50kg70o4z4y5PAiXIJqEF/BcA2h8Xk4UQ5VyrmiBR7AgCe+MUfAHRF/vV5WgFYGlHdPB95/ffh311V+p/04kWJ8KL0GT+8rZYf3vYZfnTnt8Tzp/bxozu14Ie3Nad5xR1pXnFS1nMU9gFR2AfrFPZBNqVQH+cmMufeKPHcXplnbY+7LitIz7CC9Fo6L76Yzovjs34GYNnSpUvppUuX6IkTJ+jly5epx+Ohs2fPpjHR0ZeaN3thZZdOHbddT06a5PaKerdXLJl09UYZnV7/VcuWLemZM2dobGwsBTDw0IFvjD5vevsn3YcIE8FQnzf9C583vUcG7Uh+X15R6uPNUa0fUQhdEhmTBpHklMj/LXQ6neJ0OmnVqlXp6NGj6aFDhzIq5DPZINJ5sUw6L85K58UxBoNhICGEBbAPwNUxY8bQxYsXUwCrs30/6SlaJT1lsJKeUjiP77w0L4gTfJx7Si73weHzpneTvOy727ZsXmOxWNJcLhctX748tVgstEiRImfXbdgw2CtKnb2i1M4rSiXcXvEdt1cs99j7y7kzqU5YQXKwgrSYFaT3s7ImXPn9gvHNN3rO2Pv1jgl/XLvSixDivnTpEi1btiyFyvDQEhG+siz30QzVpTYIwOy4uDiamppKAaT7vOmNfd70qCd8bzavKC3xilKtxx239at1CWazWdFoNAKAnQBS5s6dSz/88EMK4FRsbCwtWbIkbdq06RqvKDklNm2qxLoXNWjYcLvFYnnw9ttv0wULFlCGYbxly5b96fa9+928otTEK0p6H8+W9vHsHB/P6jPvF892ze+z5xO8jCx4W3gFYRnHCz94vd7trCCaWEGa9sRzebYNK0iEFaRGrCANYQWpAytI2ar0WeEhb2GW82IjFD0FFPcdh+K+86HivqPNT38V9oFeYR88oi763/j6t3fgP+nFD29r4/es3cYPbyvww9t6hc2LfLIoUmHzIokf3lZJH99zGz+8bekcD8vHCvugds62JJ6bJnLp23ycO1c5XFaQdKwgtWQF6TVWeMjJls6LTdJ5sW3mFwT01Ol0lGEYyjAM7dSpE926dSvV6/UUgNSiRQvasGFD+u7AgYd43tsscs7IZs2a0StXrtD4+HgaExNDY2JiKIBjPm965/zeD583XePzpi/zedNX+rzp+eaw8orSI3xdEYLRF3J9CFUyzJFQs7haA6BpaWkZPF49ASwB0C9y315N58VGc+bN31GmbNmhUCvFh7Vs2ZLu3r2bAtif+d2kp8Qo6SlDlPQUfZ5j5NxE5LlveEF8NmJkG/m86d193vQePm96O583XZujr3FQU5jtOcZn9opSA04QO7m94lavKHWJvLpGXp0jr66il53hFaWmXlEq6RUli1eUCCtINVleXOnl+bE+nn23W5fOayJUMSyA02XKlKFut5uazWYKYF/9+vUzuNgqZ+nb15FzLgO41LBhQ3rx4kUK4IbPm97G503PU07bK0qVvaI0wCtKb+XxOfGKkskrSsXe/+CDtytXrkwTExPptm3b6IkTJ+jBgwepw+GgFSpWPDJs2DA6Z84cWr16jW+9opTgFaVYX3rKBADh06dP0xs3btDU1FR6+vRpWrFiRQqgZrbvRDU4n/l4Vu/j2YY+ni352OdU8Eb5BO+rPsHb0ysIi1lBXM8KUpPI7/OVyHMz63FtsIIUJfDez1hBGswKeRvbnMbGx7PP+Xg2wcezRHHfMSruO2MU9x0mj+dcDyDb86SwDzoo7IMSj+vbf8vrf260CIT32tUA8C2+32RBJOOHnvgGQRoGTh4wAYCOZ1sDaCm8126AddbOlX4u7XUAyQZHTGYgWRE4ZxhYEoL2gNVuH614PZMUr2d/RhyAE2UX1Ek1BOAHh8WULaXYaTUfYQVpFCtIP5sQ8Ph49qrHk94pEPCTrq/3Knj37t25iYmJKFykyAmdTufr3Lnzcz/88APmL1y4acann7ytiPwPAKrWq1cPf/zxB+bOnQsACIfDaNasWZ2nuSeMzRlWBG4NVOGs9xSejQYwhrE5c8s0exKetZlNq/L4bNLzzz/f+dq1axBFEa+88gpSUlLAcVw6gKkzZ84s8vHHH4MQspUVpG2EkIFDBw9q1KZNm3ZejvssKioK77//Pnbs2AGo9PTws6llATQxOGPnPqFfizTh4Haq1Y6jwCYCHGJszqN5HUxVpopHZA9sZpOEiPvVw0vpgRClLpv5kYJOXpKJhoZ0ITXAXAJANQ0NVdLRcCUAwQDRVvDBUDQtnQ307dsXb775poPjuFpxcXHo06cPihUrfiQ1NaXyvHnzMGjQIPQfMLAjL8m/A4Ddbq+1YsUKFCtWrGw4HIbZbEbv3r3xXNOmP4eItlFIozP5pUxvXVYtq2egPo8OACf4h3GRnJABpLdsmfDjzOnTv6ldu/ZLJUqUgMfjgc8np0qS/DbHcb3HjhmDyZMnIykpaZ3dYk4CYAWwuFLFCm82aNAgmxsqGAzeB3A1439CiBkAvtmz64vnmjSeCeAwY3U8IoyoiHxJAA0vXvzdsXX7dluh4iWYV17tWNJsNq91WExZ43W3/VxaUegerZ/kRFkD9bdYuX2b1k2P/3SsuaIoDwD8FDEOj+DLL75wDB86+DOtVttQr9dXoJTeUhSlseK+owEwHMDnBlfhbKrBhJDeAAZptdr4iCrtEQDDFPbBGQClDY6YvFyi/134d1u7/4QXP7xtk8huJswPb0vz8RKF+R/MVdgHU7O2I/NsU4nntnoFMXOn4+PcRX2ceyArSJUju5hmrCDlucX28axV5tk2HM9vlnm2rY9n4yilcHtF58o166rY7Y5djNF4GMBzer3+wcaNG6lOp6MAonyCt6JP8H4ClfrkGwCHcrxGPc3OJtKfJpnsvd50xudNn+Hzpi/0edOL5HVOzp2NV5SaeUWpZ17HA1j/+uuv071799KDBw/S+fPnZ8gzDDEYDPT27dsZLNp2SilYQSoEgM6bN48ePnyY7t69mw4YMIBqtdr7AAoo6SnxSnpKruP0edMrR3Yu3X2ce6mPc3eklIIXpSK8KE34Vz1Tbq84ye0Vc91J+Dh3Fx/PFvPxbB8fzw6KrI4z3YWsIGlWr1s/v3DhIm6DwZCxw6NQsxbjTCYTPXjwICWEpAHIXEVD1S66b7FYMhiNBajaOlqfN71tzn54Rcke2c2U50WpMC9K7Z5mjFAr4CsAiOVS75b1ce5R1apWPVW4cGFqsVhoqVKlMl8ul4sC6On+49qC5LOnn4UqD83gIaFsAwBnDQYDLVWqFNXr9Q9uXb081sezE308S3yCl/gEb22f4H3DJ3jfuJac1JwQstNqtdIGDRrQqlWr0kisqEXWPkbc3K9k3dmwglScFaR+rCANYgWpCoAmhQsXptevX8+QYPggrzGXLFlqYkJCAj1y5Ai9d+8ebdy4MQXQTHHfGaC47xTM5R5ZTSYTPXz4MD1//jxNSkqiK1asoHq9XtyzbXMXhX1Q7f96fvtPef3jizqF99oVB5CIpyXGI0QC0MM6c8d2APAJ3MgQNBXDGt0HNrMpFchMlWykDyl9g0Q3z26znsytKUXgCkEleNRAFVk6KkNfmVLUosD+yGGcK4vImtoFMker1XZv3uKlDfv37hkMAIrIfwRgN2Oxnc31WjzbmbE5N+b2WR59e6SoU+FZPdTAfhyARYzNma3IjJfkvjazaUmW/xcD6G8zm3J92CIqo4OgEooyUIszvwQQqlq16tEmTZpg4cKFiymlmTLNQ4e/N2rtmtV13WlpsQ6HQ9P8xRaG0mXKvP7x6GEuANEGZ+zuSF9LQZ3IMpDE2JynI8Spdsbu2prxgVbDLAUAACAASURBVCDJXQGkWs2m7/N7f/KCh5fKAWjsspkzC1sjqcqtEA53gEazA6pAmC+vNjhRtnIcN8vjdqd+tWH9uGlTp1BCCKPX62+aTKY4r9fbg1L6SGYUUdVsCaU063eWrcaGl+QGUA3FWpvKntEHwBdZaHyeGj5JjAoovs/e6dPXFQZpM2PGDCQmJgIAtm/fjhUrVkyjlH7gZ1MXAVhqcMZmUq4QQhaOHz++f69evVCwYEFUqVIFHV99pfnEcWOqA6gNotkP4BcAFxmLjU76eEq/DevWLtq5cyd+/PFHFClSBEajEQkJCQGfz1eIqgqkAAA/l/aqrDU3BiFHoWbx3QKw12Ex+QkhZkKIe9OmTUZATVufNm3ah5TST3KOTxAE+9AhQ+YcPHToTUIIFixYgOnTp6NE4bjBi+fOvGhwFX7kuSGEmIxGI1e6dGn9xYsXUzUaTezevXuxZs0aWBj95iXLV3T6s/f774b/udGAVcijUO6xoNQMYKX0w9ZfSN3m00LQXqAabV+b2RSMbM+bQU2VPKpFuJeW+sdAzb7KyFypDDVWAag8S7tFqg9Dda3EAkgjgF1DEHZazbmlEYOqleRD3bxUws1LHQFssWowFepE/eZTjymfYGzOAIBxkdqNIQrP9gewjbE5v8l5LC/JFQFcz8vQAACl9B7UVPFsIIS4zp8///X58+fNALJVvc+ZPWv6xMkfDwCw1GExBVlBsmtD/uVBhFO0Gs3xSEYdoE4s67MSXCpeT3kAVRm7K2e20FcAZgiSfNpqNnH5uRd5wWUzX/bwUhcPLxELCRSCyvqrAbAXoCbG6sitGDcbHBaT4LCY+jocjmoffDRmOSfK31FK1xNCSgUCAQulNFfaJBph/84NvCRnSDUk2symFQAgSHJNAGf/iqGJYKieMQ7atWdP61atWrfZtWsXBg8enPHZcUTUQaHW4Cz1s6lzDc7YjMyrM59++ikmTpyIixcvAgCeeaZmFRDNBtBwMmg4lrE6LnCi3MAnyu80bNT47LSpUwKVK1fWh0KhtQASDh48GN20aVP9/v37n4VKBQNOlGtoNMZqQLgqoF3tsJi25Ojz5C5duhgTExOh1WqRFxSBq6sBeaZGfLWBy7/8ciWA6eFwuB4AVKpQvpLBVThX6iFKqUwIeTESO/sxHA5/c/v27RctFguOHjn8+9Pd3r83NE8+5L8XwnvtGkHdUfxZo6unPDs7SPQeq9U6JUyh4US5NYAOAE47LKbNDovpHmN3BQEkK970NxWB6wCgPYAgY3VsF6l+j0j1d0WqLwK1MO2Wy2a+4bKZbxCCOQD6s4L0WK3xaJv5JlQ3WQ8hrCVQiz27/ckx5RuMzUkZm3MOY3P2BRCj8OwShWffQPbd8mAAM/9M+5RSD6W0HaX0RZqD5VjhWWII+5O1NPS5wrPdTSFpnB6hswENc1MmBqdMDOsZm3MdY3P+mMPQmAC8k4uhgVU1iBlS0n8JisBpGARvMQiuhrqz+pKxOhYwVsd1AEHF69Hnty2HxZTosJjeAsBzoryMFaSWGYaGEBJFCGlNCOlGCKkZ4UfLFbwkVwbwFoCNNrPpJAAIaqpzXavZdOIvDBc+SewA4IDRbBFk2RcCgOeeew6rVq3C8OHDYTKZnoWaEg+DM5ZCZS4f7mdTKykiX8oneOULZ8/0sVmtmXUlnbt238NYbPcYq2N3EJpCXkH8DirZ7NvNmjaZK8tyyVAoZAPwnkaj0TidTng8HpSvUEHDiXIvTpQHA7CHNdqJ+nBgO1SqmkxE2MSH9+3bF9OmZeO1zYwrKQLnVASuOwAuQPR7Bw0ZKlNKjyBLzdLs+YseIc3NCqpKLfwIYFr9+vVfbNSoETZs2ICLl5JWPu19/jvjn76zGYOnI8LLCRM98nXLcOn4wlzpqh0i733jsJgkAFAEzgq14tgEjVZAOFSbsTqGe3jJ5vP5ooxUKg4g6FKNxSNwWs0BVpDWQt2lfJnbMRmItpkfuHlpB4A3hLB2nVUTWqyI/FeMxZZztfpYw/Vnwdic6wCs8/FsK1048J7Csza/xrAchIg2sylPLfn8QuHZilB1WTIQ1oCe9hPtBk04UF9Hw6sYZ2yiEQArSPUAzGIFaaLTas7coSheD4FaD5WnMbGaTWmCJP8kSHJbq9n01IwKisC5ALwCwKwj9AeR6otZrOacq+lrUOudLj5N2w6LaReAXZwov8qJ8hevtm8XMplMfRo3boyoqCicPn0aV69e3UcIeZVSmpkJwEuyRku0jQHINrNpcY5mW+Khq/ZPwSeJcaFQqJzV7jgNdWdOEhMT8d5774HjOPTr1w/r169Hp06dlgKoooi8JgBdLY5lfzIZtF+IMrtk8Hsjt27fsVOkoGOzth2hhRkJorvEUP9OQnHJaHPqAVBK6d2IFtF3Y8eOjbpw4QIuX76ceu7ipSiodTEP3Yic+EeA0qY5uj5h5syZWLNmDcqUKYMCBQpAURQUKFCgn0ajOSZ70+9BnR82MFZH2JdHjc39lFQlt/dzYFJ8fPyo5cuXo127doiLLTDe6/X+baln/gz+scZGeK8dA+A5PGbyrfLFAVj1Omg1BDoNwZHuz+V2WIik3n6Tlq66yGEx+RWBK6QI/haRdkUAh0Wq1wJwLZ0/v9Sq1avPXEpKrhE59yKACZTSzXn1wWk1X2QFqQkrSGWdVvOVx40p2mbm3by0HkD3IMVcHcEEqMJt2aDwLMmvbsrTIqBl7gN43xBSfLpw4DAB3a/wiiEra8HjEBF+aw41gwlQ7yOFShy6Pme/CZva0Kcz6wNa42VD5D2n1XyCFaQrACaxgrTCaTVnxJRGA5jD2F2Ppf2wmk27BEmeKkjycavZ9MRCyIhbtC7UlbMHwEbG6uABQOQlp4eXXnLZzFldjBehFgA+lbHJQITde+u5c2cvr1y5Emlpabh//36GBEPCxo0bRwMYDwARnaD2Gho+ZzabDmRtR1DlHApazaZ9Oa8RoZXpCHUnoQUwnFL6CIeeTxJJ/wED1q1avebZQoUKfQoA9+7dQ1JSUigpKWk9gNW//vrrAZZlodFoKqfeufnFtes3z7zUqk1XRVEaRpppAGAVIQSEkMyCywM/HBoL4MbLL7UY+NOxo9EAxriioibodDoXAD8hRAFgGTZsmKZOnTro0KEDAoFA86IFYxMfGQ9whID2yPG2/Y8//kDz5s3RvHlzVKtWDaFQCMePH8fevXtnW6Ni+GAweAfAj5RSDoCGEKIF0E2r1ZbL0k5HQsh9AEOhqoDupZS+m+VejqlateqYr776Cp06dcL169d9fr8/lRBizxpX+2/HPzZBQHivXQuoVBZ5JgZU+eIADndvghgTk9chABBCoRIr9f0mU6grxDsS1SVTEBvUSZICkFw2s5sQcmzy5MkNOnbsiFAohJSUFPTq1Qu3bt1qRSndm9cFWEHSQl2Rj3FazU/cJbh5SQOgvZGE2ukI3mMstkzffmSHYMsvO8DTsj7zkvw6gO1Qq67nGELKZKjxGApgCmNzpkT6UQBAUzxc8GQ8iD4ABxmb87ExEz+bSgD0B7Bd1ts4AL0ALMrQDgEAVpA0UDnnOGPYpxDgFmN35UlPnxWCJNuhTtgjrHnEmyIcWG2hsgD8DODnnIJeAODhpXEum3lStnO9ni6M3fVVfvqSFwghc7Vabf/yFSr84nJFx1ot5tIjRozAiy++eIhS+jwvya0AGHUh/w4NaEKEmijrGLsD2Gk1m4Qc7ZqNRqO4efNm1KhRAwcPHkTPnj23UUpfzdkHnyR2N1msaxMTE5HB5s0wDBISEhAOh6HTaa8ajaYyFy5cgMvlClgslm/1en0rj8cDSZIy4zMPHjzAK6+8AkVRcP78ebRu3Rr37t37Xpbl2TqdbrnJZCpYvHhxbNy4EcWLF8eMGTOwaNEidOvWDS+//DLatWsHRVH+gFrk+wGl1JOzr15B2Gm3WttlGWdzqG5FDYBqEydOrCzLcoZL7cb69etLLlq0CD/++ONLlNJv3//gw4bTp33SqFy5ctPatm2L3r1749ChQ/jll1+wbNmySwaDoeLFixdRtmxZSinVEEIKAChrt9t/unz5Mr799ttMmYyff/4Zx44dG0kpzeZijqjBVoO6o7pMKf2v2f38Y3c2UBlbrU886snQomz1dgCiwxQ3ZehPAwjl4RoTd+/ejQkTJiAUCskjR440TZ06FT169HgbQJ7Gxmk1h1hBWgagL4CFT+pQtM0cBrDNzYv3GdC1jOoqyUASgC4A/iwVzZNgsZlNAi/JE0DpDKjJDscAGAAsUnjWCpWOYx+Anfnd8WSFn03VQs1eW2FwxnoNADhR3g2VLigz085pNYcBfMbz3sF+YugQJpouj102ZIHVbPIKkrwb6r3KJtSlCJwR6qrfBeBrxup4Up3EBQ8v1XDZzFmz9v4V7syhoVBo1O8XL/oBrBo8eHDpmzdvoniJElpekgcA+NZmNl1ReCUOOTSYBEmOBeDLaWgiCIZCIfe4ceOiS5UqhW7dcg//+SSxOCKkqy1atCiQnp4On8+HRYsW4Z133sHVq1fRtGnTMgkJCXj//fcRDoc38zz/ws2bN1GiRAmwLIvatWtntlelShVMmDABRYsWxYIFC3DixIlmEyZMqFKuXLmCS5YsQUJCApo0aYL+/ftDo9FAp9Nh7ty52Lt3L9auXQsAxRYvXtzn+++//wlq4k8OkICfS3MYHDEcAFBKvwPwHQBUrVJlyvbt2yuHQiFA/Z0tqVatGs6fPw8AqYSQE7GxsXVr1aqFtLQ0pKWl4ZNP1IQ1QRAAoELZsmVx9epVALhICClrtVovFS5cWHvnzh2MGjUqW08kSQJUocOHvSOkt8ViWRofHw+LxYLExEQQQrYAeJ1SmmfW4t8F/2RjUwRPSJAgIGi/9WcQAG/Gl8Bb8SVzP/DYbi2avzZYQ7DIZTWHFK+HKF6fAeoEy0T+Goa+O3DWoSM/fvvbyeNXp0yb3ik5OblLkyZNgHwYPafVfI0VJJEVpGpOq/kRN0FuiLZZfpIE/jDLix+HQKZG28wSY3NShf/ropuRTLQSUKlTMp4joiG62j6e7UI0+kb6cOAiVFfRJsbmDCPCEaaoxbGvAGiu8OwkxuZ8HMt2NvjZVA1Ud8U8gzM20x3msJhucaJckBPl5xyWh1T4itdTzABYZI2xD4BPWUGa77SaL+XnWlaz6aAgyRMESS5iNZvuKALnBNAZqltpM2N1PNHFBgAum3mrh5fGIrug1182NpRSSgjxA5hep06d1wcMGICmTZti2vSZ3jBFLaj3/grUFOecfFtt8TA7LGe7fkLIM2fOnOlWpEiRR1KAAcAniRoAA0DpuM9mzbwRCoVqXr16NWrzlq31Q6FQnUAggF9++QUcx2Hq1Km4f//+HgCfuFyubrduqfSCJpMJU6ZMgdvtxpo1a3Dt2jWMHTsWY8eqYRtJkqDVamOqV6+O7777DqIorhNF0Qw1AQdutxuVKlXK1q/79+8Dakzs0XGB/Bwk2s4GIJMcM7JwaLNx/ZpdM2Z9plm1Zu0pAEctFsuSiRMnIj09fSWAIs8//3zd2bNn4/Dhw5AkCffv38fnn3/upZS+B9VoxBqNxk9HjBgBqAS8ZRo0aKBdunQp1q9fj9u3b+PChQs4fvz4Yb/fvxJqDVTOxIJmH374IWJjYyHLMpYuXYoRI0a8tm3btkRkYfv+u+Kf7EbbD3V3kyfuCT4UshrxQFLQdstxzHihGhoVjX70QAMj6z9Y3DnHuwGoriR/lr9+AJq+Awc32Lpj57KjR49i2LBhMBn0i7dt2pDbzibjyyEZ/wSJ7nUdDa4n6gOeMWGxUEWe7jB21yNuNp/ArxSpdj+AX6Jt5ssKz3aJEG9mQ8SAWAFUAlAUqpGsCDV9OCdRJIXKlnyKsTkzA6S8JPeLfHbOZjYdz2VMWa/ngpqkYQawkbE5H0u0mMXQzDc4Y3PdEXGi3BZAksNiSopkfE0DMIKxuygrSDoAowBccVrNjxXgyoAgyWbQ8DwdDZ4l6gSxmbE6nkpdEgA8vNQPwNcum/kuACheT1fG7spL2jhfiGSeTa1Zs+bodevWoX379hAEYdydO3cmR2q8egGor6EhKUy0wzNcjIIkFwRQ22o2PTaLihDSpnXr1l/36tULr732WqYbTRF5IwX5BKApBLgD4PTkKVMvTflk2rwmTZoMWrx4MerVq4eKFSvi1KlTawGMo5ReJ4RUjI6O/t3pdOLq1av+4cOHG5KSklCzZk306dMHNWrUQPHixfFs3VopzzV7aeVPx4//MG/OZ5UrV6782a1btyAIQjyAsx999BHRaDT44osvMGPGDPTo0UOGGjMLAUjPmbmYAU6U7YSGltut1o6RONvzUFkT9jBWh18RuDaM1bErMvYeUJM45gEobDKZzvh8Pm+9OrUunDz9a+0LFy4YO3fujHPnztWilP4aqW3qDzVOuxBAixYtWuzv2rUr3nxTrUJwOhzJLMe1p5TmmvJMCGkLNcbqB1CidevWhfv164fWrVvvp5Qm5OOR+I/GP3ln80Tm10JWVcuogJlBm7IF8cv99NyNjdlKQTQfQRXZcgPg8HByJlAfHhmAMnTEyDKbtm5bsmvXLixYsABHj/54aPOGdaNANAqAYGQHkCdYQfo1SHSdTdQ/FwADSo0AigG0MYCSitfDQOVg0iESMyIgOisJveKnmipenicMYFd4NusqI+sqW4DKrXWOsTl9TxOz4SXZHBln/axFnXmBsTk9AIZHjFxPhWcXA7gL4JNILU8mIoZmMB5jaADAYTF9zYnyO5woPzCqCQEfZVAFOa3mIICprCC1YgVpPICPHxcDUwSukh5oGQa5HiR6v9ViznUnkE8shaqT8/FfaCMnhsbHx49ev349Xn31VSQnJwNAK0LILUrpKqg7lxUCz48FwWJOlK8DmKElSEAOJuonwWg0GhSRfw2Amaruw3tGi206kGn0ZtWpU2fQwoUL0apVK9SvXx8HDhw4BaB3hguIUnqJEFLL7XY7NRpNiZOnTg1h09OLHTx4iFSqVCkqISEBLpcLCxYs+GXOp1PLd2jx3PR5cz77/qIa2LkDoHl8fHzmsxobG4uqVauiQoUKpqSkpHGU0scWSDosJq9XEP2K1/MiNNoYAD8wVscj1EORvmaVe3B/OnNWvYRGtdPOJl547bdz5xtZrVZ4PB4gIjkSqW2annFCRgZ6gwYNsGnTJly8eBFz5swpD1U2OldjQyn9mhBSqUiRItMKFy6Mbt26Yd++fYD6e/zb459sbB6r7SEGgghTwGbQQQwE8f3NBxhdv0Kux5JaLwCqXvxPUFlwCwKwZR5AqQmAc9mXK8quXL129M6dO7Fjxw4sW7YMfd5+y+jzKZ0j/dFGJt7MpjNagOryC5sA4oe2eACaUXqEL4IQHwAOICcBfIuIUYNquCgQqS0hmlUGGvwxSDVFFWg6GBA8RNTdF6CuCO8ASGbsrpw7mKdBxcj1k57mpEg/VwFYpfBsSQCzFZ7VAljC2JxnsxiahY8zNFmwQhsObqMgHxjtUY/4up1W8x5WkG4CmMEK0gdOqzlb6qoicPWgZkhdAjDHZLVTQZJHC5Jcxmo2Xc3ZXn7gspnDHl4KenjJ6LKZfQAUxesxMnbXn/bF22y23kuWLIHVasWXX6qZ8VevXq3XvXt3E7LELPQInbNabJM5Ua4IYHGIohCATVBX4bmCEFI7KirqrYz/DXp9fMGixaJ9PuW+2Wye5/F4/gCwg1KaDGByrVq1hq1atQrt2rXD9evXcf36dUCdVC9HGCIkAMcWLFrSvnrNGqN7v/XmyKtXriiBQECRZYmx2+1QFAUXL14EpbQlExVHbVbr3Qrlyi25lJw8JNKniX/88bC+WZZlHDlyBN27d8fChQtq4wlQBC4G0EWB0qqM1ZFf+n8AQL/+A9ynftj7dq9+7767cuVKrFixArdv3/6OUpqXIZCSkpLQu3dveDwe9OrVC19//TWaNGmyiBBSkubtUiqVkJCAli1bokyZMpgzZw7w8Hf6t8Y/2Y02DmqWlCG3z6+zIrp9rcbQg5SiU8UiGFmvfG6HIlS+erK2+8i4ACVzKTQHAJxw2cyPPCCEkMMbNmxoUrZsWaxYoS6S09LS8MvpU1cvnD3zSIoyVCOTBpVh4D4AN2N1hCNFnpMAfOK0mqX8jFcR+aoAEhiLbYbMs5UV6DqGoFkRbTPfUrweHVQaj4rILk17DUQTA0J+zefOpgfUSXqwzWzKl2ZInv3lWQ2Ad0FpJVBaDKCdGUd0vtxXitczOAyS6Ncayzss6g6LEGKEyhMWl3FcgQIFtNt37dZWqVJ1iNNq5hWBqwE17fpnxurIRsYpqJX3swAMtf7JuiEPL5kAvOuymacrXo8DQGPG7nqsKys38JLsBNC5etUqje7du9dDo3kYeqSUQpbl+Rmpt5HFS5sMqhpBkruHKL4H8D7UeOJ0h8V0AwAUkddAjcFVii1c9NM333wzrnbt2qhZsybWr1+PjRs3wuN2PxgzdmyB3377DWvWrBkA4EuGYYS7d+/qTp06haQkdZ1x9OhRHD58GBUqVMAnn3yCvn37gud5bNyy7dTBgz9c2bd7V9cePXogOTkZNWvWRKVKldCoUSNERUVhwIAB8Pv9uHnzJvbt3cP+kXyhGxMVd8Jut7snT56MunXrghCCEydOYOzYsfB6vZg8cfyMkcOHHWCsjmzp3QCgCJweqmaM6IO+qSEkX9SCrjc4YmiO4zLdaFnBiXLc5zOmVJoybebOmbNm2TUaDQYOHPiAUlojUusTo976hxQ5kRTpN97p1bOg1Wq5P3fB4sUpKSn6ihUrwuPxxEGddzyUUinLOQTqb/A9AOXq1q3bZNmyZahevfplSmnuk8/fCP/knc1uqLT2uRqbUk4Ljvdsmp92FNRqfjtEdOU1BM0ppRUoxbB0XrpNVV37HS41OwwA6Pbt2xEd/dAVRymFTqfTIRz6KosCotqwwGkAREPdKdUAEKMIHDEBCAN/hKD5UhG4jMJDPx4apfs54wqMxXZeEfl3FZEnGuB3E4LJAgzl3bxUPNruOgo1LpMpDBcpgCwFSuuBhuMUr8cH1fV4HmoKcW6rFCuA8F81NIDKOO1nUz8HMIRqdLNBtJMVnmWgZtGtysvdqHg9AwCcMtmjjvtF+SYnyq9G6lKa1axZc1yfPn0yj/3uu+/QJqHlZzdu3VrsE7gkombNzcotfdlqNvkFSV4KVUp63p8Zk8tmlj28ZPDwksZld3GK1/NUfHwRYbMEAFEAll+7dm0JIaQvsrtBadYJDKpxTQEAQZL1AHQOi+k+gGGcKOsAOtYrSrW1CCfqVFG90wBWe73eEbdu3YpLSUnBnj2q5p8kSUhn2QI1a9bEokWLAFXZNhQMBtmOHTvGZO3rnTt3wHEcqlSpgp07d6J69erYtm1b8MyZX1tNmTTBGQ7TrmazGYULF8aqVatw6NAhxMTE4O7du2mVK1eOmTBhAurXr4+CcQVvU6D+zUuJpctXry3u3LnTsnPnzszrBAIBANg1ZtyEUYrATVAE7jZjdWS6qRSBaxy5B3sYq0P2ifK1gNb4pjYkV4XKifhEbNr4VeysufO3fjp9ut1oNKJ3796IMDiMJ4ScdDgcX1BKQQhpTynN6Fw3Qsj8I0d/upJ85cq5uLg4PcMwGZlr8+Pi4jqyLMsTQkpnoR1aTwh5MVIGIYRCIUQWEn+VRug/Av9kY3MG+Yjb5ANBBAOroGb+jCKE+AhBRQCNKKUtKMXb6bx0HwS/9+7b7/1lSxY/g+yTQ7hH1y4noAaus3FmMFZHGKq64gPk8sNgBelOEFrJaTUfVASOgZpmXBBAJUXgbDmPB3APwDIQsgOUlrKSwI8i1TncvNQFwOZo28P4RcSYXFME7jgiMZvIDqgKgOqK10OCwRBWrlnr+mrT5mtHfzrObd62rbHJaDrcKqFlLpd+FISQslCZgy9SSnOL0QwBsMjoiA4BWAOg6IC+fYpMGDdmgV11/e1gbM5MGn/F6+kP4Bxjdx0HAIfFdC2SodYIgLFUqVKIjY3F7NmzAagTYuuXE0oaENrgg64JQK44reY8t/pWsylRkORmgiRXtZpNf1ZNcQVUJcwnygVnBS/J8VB3jfttZnUnAgA5DEtuqIIIJx9UraBdishHA3jBqNZyXKTAQgW65kG1/XIApgJ4efv27Y0yGrFaLLqZM2a81H/gwITly5e7rly5coJSegwATCZTfCAYbKfVaBO0Oi0TDoXDoTC9oShK8d9//73VqVOnUKVKFfh8vo/69+n94K1unV7oN/DdkitXr6kLtdbKDOD3e/fuHQPw/9j77vgoqrbt68xudndmd7PLJhBCCD30EiAU6UWKSkdQWigWQEWaCgJSxUpTQFFRKQpShSBIR3rvRUILBEhCymZ3p2xJds/3x5kNCSSAPq/v+z3Pw/X7LWXnzJmyM+c+576v+7q/+u6778KvXLmiMsvoYHDaRhEREaX3bvvt28at2uWvdlsN7DkIkj1mAJjrlZzTweJKcQD2602WvNwqi5G/7pTdJgCV8ITGZuumjT2aN29he/PNN7F9+3YkJCQAQLWpU6dWO3nyZLPJkycjIyMDn3zySU0wNzoAPDNz5ky+QoUKtVwuV602bdpg4sSJ8Pl8vwKI3b17N/r162c+c+ZMWdynpXfctm2bNTk5eQDHcWjRogXGjBkDAI/V0ft3wH+tGw0ApLFdF4MV53pinapCkAKgNJ3xS1mw4F+mWeDzHmKn7C4JoCWltBqlqA3ARQjOEUJcYAbvnMXI53hd9h4AnPpQ219SHFYD3fPyy7I8Cl7J9S1A3wGlr4KQEwAiAhQmHzQNQxA4pyE0fz8UzHgdAqs5YlcNIACAEPJWVFTU/PDw+5PapKQkjHn7rf7j3x27StWEKxSEkFdKlCix2Gaz4fLlywmU0rxkw86NqQAAIABJREFUu3wxmkX6YhEmjUaTUq1atZBy5cohPT0dJ06cEAF0URxZJQE0A+AHDWQB2KsPte198FhO2d2jfdvWkaWjoha0b98eU6dOxb179xBZsuT5qKiohseOH/c4JEUPNsj+aDUJRRoSSXFrwKT+x5oE/i/nCAGAXVQ+sJmFGU/CSBNZPkw3ABfMAl9oufJHIaj27JHFin5w47QIHABTOdijN5ofitk4ZXcEmIvNAOAXi5HfBwAeRR4LYCVvNFXXaDTN5n7x5bH4QYOjcP/duQLgiMV4P29nyrTp5T0ez6rVq1advZl04xKABR7R0RLANb3JcrOw8yWEVAGjZRcDcJxS+isAeF32pgj4XwaoQIDXdNYSha9sJWdZMEM+RW+yHCmsjVN2z+Nz5b0P1pEpyo229uel3wwa+ubg8PDwAuNEeno63G63c8uWLZahQ4fi9u3bjSilxwDg9SGDPlv688p3a9asCUEQkJiYiIyMjM0ARhuNxiu7du1CkyZNHIFAIDJIoCCEfG40Gt+pVasWKKW4dOkSRFH8AcAblNInkcT5/xr/7camHFgQ0/CYpkV2kdN71EZavdEvNrPwG5A3OFQHoATFDoNwym4jpbQtgKZUnc1xhOSArTBJiN8TB5AFQqj11JOegENSQgGMspqEJ+Lhe2WxEwATAn6iN1vzBrosUSEAngeQEWYWgurUGjBfdwYY4SEM9+Vj0KxVm/j+A+I71q9fH7dusRzWOXPmwMgbBu3YsskOlo/iBXBAH2rLUyImhETrdLrkQ4cOged51KhR409KaXWggKH5Rmct4SaEPBMbG3to0qRJuHr1KmrWrAme59GhQwe73+8vSSnN8brsrwKkHggJgAW9P1WZbnl4e9ToRXeSbw2dNGkSXC4XypUrh2HDhmHbtm2fU0rfU++lBsBUAFutJuGhgl1BSIo7BkAPk8B/+iT3/EHYRaUegLJG6jEUZWxEJiXTCyywvsH8FxWZ1fhLAwQCfcBxp3PBFaMgG01G4Yky0lXq9EAADQgoz4He8YNLVTf7wYrUnbYYCze4TtndUT3/YRYjnwMAXslZG4BBb7IUWmrjsdfksociEBgPBBoQoIvOWiKPzKKu5DuCMUGvgQl9vl+YS9Qpu2cbcuUEAvyps4Sn5+vjIWPjyb7XGKBRvC1yF5iKe37YAeytW7du7OnTp3er7zZ8zsw4ABX01uKbwcYCHsANSukdQkhkaGjo3eLFi5Pr16+/QSn9On+HqtZbdTDX2dWilL3/HfFfbWwAQBrbdT6AV/DXBTkDYMljVX1TV74KtbRxMD4jKm4TWH0WCmD/g2KUTtmtCVDaH0AcYS9IAgHu6QLehT6i2wqO84MNNMfA8kaKHGwcktIagNFqEp4o2OyVxW8R8O8CsObB2EeWqNQCSwJcH2YWAo+iPhNCvpg3b97bBw8exJo1TN4tunTp3/b/sWtpyYgIFgujNITdG2oAAL8/cLNCleqvvDViRB1JkhAfH59nbFQJmrcALA4OJIQQPYB1YC5CGUCra9euoX379rhx40YVjzOrCVh+0Q4A8IoOM9jM3AogHcBcEMJtSNj0zsAhr77v8/muU0rFunXr1t+yZQtKlSolUUpDg+wglXwxFsCfVpOQ32VTAJLiHgrglEng/5YSg11UJhup5wSAQ/pQW16WrRqX6QBW7nqtWeCLLBfwILyyaADLHSkB9twdQ8BfWW+2JkiK+xWTwH//JP04ZXcxsAJ80QDVa0Cf94O7B0bzXW4xPjp/yim7PwDgtBj5vNiWWrOpnt5kKfKePim8jswXgcB4AL2g1aeBxbG8ALbpTZZc9XhNAdTXmywPxdecsrslKC3N+xWXzhKeZ1wKNTb2tKkcAtN0tlJF1WKygb3nBymlks+ZWRlAK50lvEg3qbp6KwHgwCNYaf9x+G+O2QTxHoB2ACrir90PN23c4XVzrzf8AL6xi0oFAD/bRWWmzSxcMDMZkD2i4uYANBUVtxbAxWBhNYuR90Ol+9pFJYIAL924cT1m966dZypGl+r+xsjRU3mex649e0vZwsJaqjNNgBm4cwDSLEaeqg+75p33xvX5Y8/unBPHj++klBbKliKEGAF8WSY6Oq5mjRrW9atX3gELiuchzCyczxKV28Nff/WHjevXRVssoSaHw+nKycnxA/iVUvpQ/szIkSPRq1cvLFu2DJs3b25brlIVPdjANIFSmkeD9rrs3Atdu0+KLFWqTuXKlTFu3DhkZmZCo9FUtBUrllyjejXf4PgBK/r169vdKzkpgIBHdGSsWbf+o6FvvLWvevXqmpo1ayIzMxO3b9/GtUvnWwC4HTQ0AKA3W0WwRFF4RUcpACtAqbFalSo36tWt++nk6TMcz7Vvt/T06dP3TCYTeJ43KYpiUs8XasxmlkNSXnFISn+rScifb5Ef3wGYJynuCyaB/zt08eMKdG4BvtZgWnLBuMwzALaZBf6JlJi9shgOZmB4MF25vXqjOag/RwBUlhR3HFjhsYfglN06sJl0bbD4GcCShA9ajPxvHkWeAKCPSeCz1GfwFafsHqC2+dhivG8MnbLbDObCmmcx3i9ZoGbpt9WbLEXdy78EvTV8rdeZdQI0sAP+3HXQaCfrTZYCKyy9yXLQKznLFeEa2wdCvgDw6CRie0pxEI1dV6xwQwOwMhhgVXHhc2ZGgsXFHkmrVt+Jv5Qe8J+A//qVDQBIY7tGAdgHRv99nEuNgs2wu9IZv3wA4JBZ4CcCgJ25oj4EkGkzCw89cKLirgkgHECGWeAv5t9GCOH1en1anTp18hhKkiQhJyd3//HTZ7pbjHkvezkAdQCUnPXZp9Xmzp71dlxcHMLDw5GYmIgLFy5cAvAcpTQZD4AQMq9nz54jX331VXTt2hXJ1xIHRkSXKzS5jxCSsWbNmnCTiSnpyLKMF198MYtSGp6vzUdxcXHvu91uUEpx7949jBw5ErVr18bGjRvx448/zqSUTsrXvqRWq03dsWMH+vbti+zsbAwcOBB9+/ZFaGgoDh48iPfffx+iKNajlJ5W3XjhM2Z+3HjpTz9vmD59OqpXr469e/di3LhxSLl5fY4tLCw4iHqQj40HllFeH8AvepPlbkhIyKLY2NihN2/ehCzLGD58OF5++WU0bNgwmVJatrB74JCUngAirSZhQWHbJcUdDWCISeCnFbb9cVBXN4k+Lb8HfyEu45XFSgAaA9CIomhXFGVXmQqVHiIKeEVHGQC2HI2+vkngv3fK7tDc3Nw6Ho+nRvB3BcvhuAQWOywQw/EoclsAeoNgfEjdwim7bWBsTjOYesUpsPjnUIuRz8sdUjP14wGs0Jss/3K+iPpMdABgAKVb4fetAMgNcJqxhTEkvZJzCtgzUGBwd8ruL/lceRuAHTpLuE9tW8Aw+ewpr3lDTPvN5tDHyhv5nJkWMKbipzpL+L9cUuM/EU+NjQppbNdQsEqNLcFmiYVpV0lgCgHPm2ZvvCQy2Y8hAHaY87lT7KLSRv3+rQdLOQOAqLgjwFhCAQD7zAIfIISUioyMvHv+/Hls2MDIJ9euXcPnn3/+R5ZTnAUWLwkAOGwxssRCQsiE+Pj4mY0bN0ZGRgaee+45bN++HUuXLTt7/NSZRQBugq2CUq0m4ZmIiIiDy5cvR7NmzWC1WnEn6dqM4qWiC8vvASHEnZqaamjQoAEARtG+e/fuHkppm3xtwgG8uOznn2uvXb065vixY88+//zziI2NhSRJeP/9978B8BalNFdtP3zQoEFfxcfHY+PGjfj111/xzDPPYP/+/cjKysIXX3wBt9uNr7/6aue5E0f66ENtwQJhGgDvgLGPBh48eBCTJk3Cnj178tSyvZKTB6O41gUbuK+D+e4BAI2aNn+lflyDNkOGDIHBYMCZM2cwdepUvDZ40PZx747dCOC7B1ULAODZdu1npdy92+nPPy8ZwCYab1FK81xBEsstumMS+D8euH8aACvAnqdkAO1Umfo82EVlgp7mlBvy+lBl9apVPcEmIsGkmaMAnqWU+tT4S0Mw9yYyMzOTylSo9GwgEBjIcVyZQCAA9VhjKaVp6qQkUhvIHZJLNFpCSOjFixfv9nv5pT5JSTfqazQa+P1+CmARgHGFVfb0KLIFwEiDYHxsLNApuz8FW5GdBTM6S4NuX7VY4D69yZL1iC4eCzUN4FkwlfbtBcqUO9KnAiQOnCZeH2qzP7CfFozQ8X6w7IN6zu9qAjkHdAFfFZ0lfIlqxBYCeFNvsvh99hQuAG6iV2/52GJ8NJXf58w0gBnez3SW8H/7QP4/Bkrp00++jzimS1NxTJet4pgukjimi6L+7RXHdDkljukySBzTRZO/vUtWiEtWPnLJSo3832e5ZH2WS/4uyyX3KOpYLlnRuGSlpUtWWg159dUakZGR9MSJE8GyBNRsNjkXLlz4VZZLrkYphUNSNA5JaeqQlHiHpMRPnfFhbwC7wNhil6Kjo+mtW7cox3GpDknhHJJS3iEp3W4k3xmh1+vllStX0rp161JRFKlOp6NZ91L3eFzZpLBzA5CTmppKGzRoQGNiYighJDDm3fcmZbpkbb42qwgh2c1btEgqVqzY5SZNmtAGDRrQ0aNH048//piGhoZSALvzte9fvXp1OnjwYDp48GDap08f+vbbb9OOHTtSALRz585006ZNFECix5nVwuPM6j521NsTOY7LAXP3/cBxXO7hw4dpq1atKNgADkopPKLD5BEdb3pERy+P6OAKuZ5yYIPrEY1Gc6569eonp0+b9qlHdPT2uLLHe1zZWzyu7K0eV/avHlf2ax7R0Xff7h2vWa1Wum7dOnrt2jU6a9YsCmBxgedFVogoK3NEWQl94HijWrZsSVNSUmizZs0ogLb5fnezS1biHaLc3+V0LAewaenSpfTy5cv0woUL9MKFC7RSpUp07uxZwzySK94juQZ4JFeVfH23rF69Oj1x4gQ9f/48vXr1Kh07diyNiCiZlJHtHO6QlGEOSemquBxDXJLyiigrBMDL7dq1o5cuXaJnzpyhiYmJtF+/fhTAysJ+f7csTXHLUmhh24Ifh6TwDklZ5pCUFvm+a+qQlPkOSVngEsWxHtFR9V95Hz2ig3hER0v1d7UV2S77XndP9r1dHkdmq0L6KOERHXM8ooMUOHdR/tyXem68P3H1HN/dY7c9ooP67h6/4U9cPcWXcvYVOTuj3ePOz+vI0HgdGRO8jgzL//XY9f/75+nKpghIY7tyYG41DYB7ptkbi5QVERkddiaAn8wP5F/YRWUgGD13tM0sFJkBv/DrRW1nzpi+88KFCzh27Bhu376N2bNno07NGn9888OSGQGiKQ5gk818XzHAKburjH/v3WEbf10/KiYmBj179kRubi7mz59/5/T5i2WCOSOEkI979uw5vkGDBhg/fjxEUURYWBhSbifv1/P8aT8XEkyC8wFIAnDdahKubN26VX/79m3UrFkTdrsd3bp1U7bs2DWqbr36R8PMwjlCSNYff/xhS05OhsFgQP369dG8eXO89NJLKFGiBO7cuYOFCxemU0oj1PMIAdAZLHhfMiYmZuaGDRtQo0YNaLVa7Ny5E/Pnz8e6detOUUrrAwBvMLwbP3DgZ926dcPdu3dRu3ZtXL9+HQMGDMjy+/3lPKJDAfAimNT90r8ikumU3T3ByBd5v5kqDjoaQGhqWpq+TlyjV6pXr66tU6cO4uLisGDB/H1HD+wrELeiQGiAaJ7VUP9sAGkNnmnKX7+RdHHTpk3Q6/WYPHkydu/e/axLVg6DqV37AfxqFniP6HKuDLVYTQkJCZ2mTZuGkyeZVzA8PPzaiuXLWrfr+Nwdp+wOA6WVCGhNQgOl1qxZXfWDDyb3pZTC4/E4/X6/5eLFi2jdujXeGvrqW8NfeyUZAALgWgU4raIN+I4uWPRt+UnTPvzS4/HAZDLdtlgs0RcvXkRYWBhNS7ra3Ww2BaAyDSmnaQAgkwT8O8CYiHadJbwAkcQpuxuBsQaH5qc7B+GRnFVyoHkxQDSR7BbhF4uRL5Lh9yDUFUlbMDfdAb3JUqi4Zn74HOm1KTAX4DaD477IL0rrlZwNwVaZ3+hNFlfgypq6ubpiK7S+7NIA+ACgoUI0iHIbHJBDQXIp4XZx1D+Uq9wrpdDjOTMJ2LOyQmcJf+z5/bfjqbH5H4JKBPgQrL772fzb7KIiAJgD4KzNLHxd2P6EEKvJZLLXrVuXJCUloU2bNpg5cyZq1KiBQ3/s/KZ0xapv+4nmBQAZNrNwIN9+w1q3bv11nz59ULduXXz55ZfYunVr6pUbN2daTcJCQkhZm812MyEhAe3atYPb7c4zNn6//4iYlZHNW4o9DwBO2a0HWwFUbNm0yYQ7d++UrV6tmuP48eMVN27cyC9evBhJN2+O37rrj10AYkqXCGuq1WrfrFatGrxeLxITE+H1ereOHj26Y4kSJbB582YcOHBgOaU0/sHrPfLHjkbPvtBtq06vt7pcrsCSJUu45ORkfPjhh3C73YMoE5IEIaQ2IeRg+fLlTREREbh9+zacTmdyMaul75VLF/xgZbfX6k2Wv1Vkyim7ewG4aDHyhVbNfGf0qG6JV65MKBYW3qBFixZISEhI+ennFbGhZlOB8gKSrPQmCJhyFOlyTLWaP74/YULl3bt346233sLnn3+OXi++uDF+QP87HALHCcvoTwOQ5gvQ6U2bNW87c+ZHFU6dOoXr169j586dqFO79vnVv6zcz3EcJaASAU0hNHCVA01Kvn0nrXLtes9Spkt2gxBy7cyZMxEDBw7EmTNn8nI9ZEmaRznNOyZV0YEQEgNWR6hijRo1kJCQgEqVKimUUjOlNAAAHkUuDkpf4XI9X4MxpoqDJUjmuZV9nK5hgHDVDH5P/pox2WDsv3TKaTkQ0kpvsqxX77EGwAAAwYTm4wB+VkkyBaC6Q9uDTfJ2PmnRvrxzc6TrKLAMIDI4zSR9qC1I14ZXcm4EcCMkZfshAEtQtLs8iFwwpmgHrnKvAgQL1dCMAPC7zhL+HyGU+U/jKRvtfwhmgQ+IinsSgOmi4ubMAn86uE1djQyzi0pbu6gsA/CxzSwUUH6llDoIIZ3379/vB5C4bNmy3+Pj46vUq1cPH8/+4uKgfi9/0e75zjOyXHKIXVT6AdgVFmq8B2DDnj17ovfs2RMVGho68ObNm4iKioq02+21AYydMm26dctvm2Cz2XDkCMtxEwQBJ0+eRJMmTRoPGDzkzrpfN6wGsJSyWEQiIeQ6GDvpTvcuneiRw4cHJyYmti1evDguXLwY27pZkxcIQcjGzb9fL1++3NnTJ0+m2e32E2Hh4Z6ZM2a0Cl7TkSNHYDAYfiCEtAYwDCwBdpw3+150vdg65WRFaer2eI4vXrxYSE9Px8SJEwHGClub776cc2Wk9tv42+aK8UNeOwYgxZGRRgx6/UTQwC1Qukofavvb1QwtRn6NU3a/5JTdAYuRfygQPGvuvA2EkNABAwYsBYBLly6e1cC/wyM6jhNGFDkIYL3JbF0tKe5Pq9aqW6xSTEzliIgIbN68GW+99RYAIOXuHdBAIOAHbUhYLaXiBFSvAXwlIyJK7d69GwDytMQ6d+5c6+2RI3cvWjh/A0DS2Idz6kwWWskSjkAgsFalha9/5ZVXItLS0nD27Nk7YInCcIsuEzjOZyooHVSzdevWFRcsWICyZcuiT58+oJQK+QwNATAShMzUWcLdYANtgYHUKbuHAHBYjPyLwTJMPmcmB7ZaLU6BWNBAFwQCe3zOzM4AwLMB3Q4gAcAlt0aoCELmqEYoDcBcA/XpwVh1HgBb9SbL34p9qEKtL3sd6e8h4F/gddkX6ENtQdZZd4399KtghkZ4gu60YLHSPwJX1jTiKve6pF6vFsAYAKt0lvDCiiQ+RWH4v/bj/ad91BjONJesxBW2PcslkyyXPDXLJX+c5ZLz4j8Amms0mlywwWIVz/P05s2btFq1apTn+c1RUVHUarXSGjVqPKf20bZuvXo/cxxHwaiX68LCwqjD4aBarZa279CRzxbljzs+97zFZrMdN5nM6UajMQtAXswGwIUKFSrQ2bNnUwCn851Lo/Lly9NOnTrRSpUq0e7du9PU1FQaExNDAWzo0aMHjY+Pp5UqVfrRIcmzs1zyJ/sOHyut1WqzWrduTb/66iu6YsUK2rp1a2o0Gv3FixdPnj59Oq1duzb9fNasRbLDvswhKcNKR0dfnD9/Pj18+DBt06YNbd26Na1fvz41Gk2/OSTF6pAUrceZ1dXjzOpHKYVHdHAe0dHfIzoGeUSHllIKjzOrlseZ9aLHmfWcx5ml+7u/m0NS+jgkpXIh3+siS5UaPmDAAPrdd9/R0tHRG7NFuWO2KG/KdklviS7XHNnl2Cm7HLslR9YJAPTkyZO0WbNmNCYmhu7bt48OHDiQGo1GunzpkvfV+EuB4yxcsGAvGP35HQBbhg8fThcvXkw5jlvmER2lPKKjnkd0PO8RHX2Dn7TbNwdUKF/+RI8ePejRo0epxWKhrwweNNwjOsp5RIdBFsUxkihWz38cMDWICwBo5cqV6Z07d2ixYsUogEhKKdyy9LJblho84h6965CUgUVtV3+fgR7RYShsu9eRYfQ6MuK8jowuwY/ssI9xucQDTlHa7BDlOQ5Jqfg/9S56s++19mTf2+rJzhjhcWZF+RNXl/cnrpb8iavpX/wE/Imrb/kTV/NeR0aY15Ex0evIKP5/Pdb8u32ermz+h2EWeCoq7qkAJouKW28WCvqpbWaBAphqF5XyAL63i8paVX2gZnx8vCY+Pj727t27sQ0aNMDKlSvx559/ngWQM2fOHCQkJKB0VOSoEA1RACiX//wz4ttvv0V4eHh7RVHQoEEDjBs3Drm5ub9u2/q72yEp369cvaaP1SQ0CB5fq9XaFy1aVMzv96P3Sy8niC5njcjISID55oPweL1ePPfcc3j99deRkpKCTp064erVq8sAeFu2bIlTp06hZevWlThCFhOOrjObzc1DQkKs3bp1Q05ODjIyMtCtWzdcuHCBy8jIiO7evTu+++47RIVZMgVLsUlO2U3u3rkzLC0tDceOHUPXrkyt5tatW0hOvl0WQAet3/d8LtHIuZzurE+Sp2pA6vihORYgXBaAIR7ZTaBhBcFAaaSW5r6QK7o0AcLdDhDNk2Ze5ykiAHhPrfkSvBfkh8XflTIajXkMvGx7doX4Pi/Vio4qdfW337d+7PN6U3789quP2rRskeaU3cmEkEs3btzAyJEjAQCVK1fGkCFDcPHiRQwYOKjPgIGDDGCroSFUtQDbd2zXRpcpo72dnHwXQLbb7UZISAgCgYDZYLYuBRANYBaldDGQx3Rb3bVr1/oTJkxAhw4dIEnSgdNnzoSMnzjp2aXLf5oQZgsLe/utN/Svv/pKLADMX/hVxbJlyvSoU7vWSQPPb1yzdt0Yu91uiIyMRHZ2dnGPImsARBoE40NF9QDAKbs/AXDAYiy84JpKce4L4Fe9yVJofFNnCZfBhD7hlZzVAVTXAAc1fs8PBKhBQUr6ON0klySFAyCE0mPaQM6XvMX2t0rL6qwl9vgc6acoAr8ggO5gK9EnrQyeHwSMKTgCTBXhBZ0l/ImqtD7FfTyN2fxDUDPBRwBINwt8oS8wANhFZRCA5i90ePa7o0eObCldunSx8PBw3Lp1C3a7/Q8wdYPzhw4dEtq1a4fPPvqwwyuD4mv4tPzXfV7qPWHL5s0fVKpUCQaDAUlJSZAkaQ2AoZTSbABwSMoQAEetJuEiABBCXgDLU9hfzGZ7pkvnzqOPHj2KTl26fDxp8tQ5FiOfqUqddwfQMaJEiRpOl+uax+PZBJbJf+rDDz+MnTJlCi5dTvw+slSpk2aB/xoASpaMHFIqKqp3ampKRlpqarBeUKrZbP7o7bffxqqVKy5fPHmkus5aIkhcaAb28hYQJtVoND/J9vSOALaD05wFo5GnAthYmPzIg/C67HUBVABzye3Rh9qeOL/DKbv7AzhkMfI3fM5MjRBWMv3NN9+0NWrUCBUrVsQvv/yCVatW4d69e4nz58+vsmXLFqSlpY3as2+/SCg1vTpkUFxKalrb1NTUu9euXSv7+++/l/j8889x6eJFe9q9e7Zz586hWbNm+Hr+F7F94wedJYRwhBD/nDlzcOjQIRQvXhzjx4/HgAEDsHfv3p/i4uL6jxs3Dr169TpKKW2s3rdn69Wrt+PgwYOYO3cu0tOZ4srGjRuRlJS0f8yYMc1zcnIwf/78aZTSqeo+X8THx7+t1+uRnZ2Nli1bolGjRmjRooXnWuKloWG2sJ4AXUsYeSGIXAqkexHyBgFdpEfunsLufz5Ds1lvshRpGNR2TcFWWH/qTZaLRbWVRSfxE01XgPRX1ScCXMB/MoTmnCEsr+eyzhL+RLWAfI50ghzpU232ybfw15VC8kMCUIqr3OuJVR2e4j6eGpt/GKLi7gampDvLLPCF3my7qBgAzM7JyblaMsyaACZCeJtSmk4IIRzH3Y6JiYlKTEycSykd43XZGwGI04faFhJCtAMHD27Z+JkmzZs0baYpV7bMR6FGIS+jXZVfmQlgitVUsMYOISQWwIz2z7bV/bp+3ZEcTncUzEdNARy1GPmrD8rVEEL6AYgfPGTImS/mL9gPIDpobILIEpU4MEWGjeGhRi+AOZUqVmgdUaL44AOHjpzGI+B12XVg6tdzwWnKAmgE4Ee9yWJ/1H5F9GUBUxUOAbBLH2p7ZME8nzOzOICGPk7/rIbmXtRQf6oxrOSPA+Lji+evGbNp0yakp6fj6NGj6NmzJ35YsvRys0YNPucI/gRwNIdoeQAfmY1CeIcOHfqeP38eKSkpPSIjI9dv2rQJDRs2vJd9L+UzvV4fHQgEOHNYiTd79+6tqVq1KpxOJzZv3ozExMR1APYMHDhwQeXKlTFx4sQllNLBAEAIaVWuXLk9bdu2LXD+O3bsQHJysmPlypXWr776Cvv3739x42WtAAAgAElEQVSZUrpK3WdkTEzMvE6dOsFiseDatWtYu3YtPB5PF7cshQM4bhCMBZiUoiQJAXArtfB/r0XAD1ZCOT+Cz3NTMPr9NbAYzL38MRev5LSBMcEA4FBR1TEfBafs5gB0BaWtAJgJAlZNIPdgCM29DiZVczK/ztmDCFxZMweMPaf5q8fOBxeAV7jKvdY+tuVTPISnxuZ/AaLirg/gZQAfmAW+yNmYXVSagQkIzrKZhXPB71VJmhgAJ6maIOl12ZsDqK4PtX2Tb38rIRjFERzhCJEAHDMLvM8hKaUB9LSahC8KO65XdPQD4ZrqTaFvAHnsoUYAKnE0UIWC7KaE7MmvzyYq7gVgshwVzQK//cE+s0RFB6bee8fslyIBnNdZS1x7sF2B83DZSwIYB8J9AlYD/oTeZHlIxfmvwuuy508I3KEPtTmBvEBvIzAXCcCk3o/pLOE5Ttk9CMAeq0kwgSUsAgBMJlPIhAkT6k2ZMuWVvn37kvXr1+9LTkkbCLaKfS9YZlpS3E3OnT0b17TJMy6wVRmtVq3aNqvVisOHD79FKV0Y7JMQUmL0yLcXZ2VnV9AQYm/6TOO0vi+/dKd33/4ttTp9vb1790KSpKo+ny9Rbc+BiaaWfOBSUwDMGTJkSJUffvhBARBKVekidbXaVL0WM4DbABLcsmQG0M4gGAtMGJyy2wpgMYBXLUb+UauVlwDsBqvQWjLfRwemgh4O5r76E2r+GFhidFDpITO/kviTQpXZiQdQC5RqCQIWbSBnv5b674ElP18EcCNYIC1wZU0ymDuyUMxb8hu+X7MbhBDUrByNHz5+AwZ9oaWu1nKVe/X6q+f7FE+Nzf8aRMVdGqxS5FSzwBfp71UlbyaA0U3H2cxCkdnLXpe9LYAy+lDbjw/s3wvA8RANiQBj1HD+AC0D4LLVJJx4qB/REQOQEeC4RXqjuQAF2Cs5W3ihFSnhaoC5uzIB/MERfAKmt7Ve1YErFJLT3juXaKv7ifb7MLNwu6h2quurGwh3EoREA/hBb7L8KyWqCzuGBpT2B2hVAGcIc4scL2xGrGbhDwaww4BcDwXa+sE1AmCgwBKzyVQGTK1gIaX0rkNSagDoA+CDYH6TpLgnAlhhEvgkQggPJmfCAZgTnDTkO7c+MjGUt5mFj4Lf6fX6suFhYe/G9+9nnPrBxOCqLPjCigA2ATijN1vzXF/NW7R40SQIo7Zu2zacUvrIei1qnOZDAJMMgjGvD6fsrgi2Go4vStUZALyS80WwejH38n1nBNAGzNicepCSrioB2HDfKOVXTXgQObhPE08FIBXlRlVr1LwOIBqUEgJq4wK5ySE0J4P4XAFt9slPUYQL7e49O1r0+QAXtswFb9DhpZFz8FzLehjUo1VhzSUAVq5yr6eSNH8RTwkC/wBUSmoDsMFIABOwvCIq7nEApomK+1ezwOfPlSFgA1VQoytQKipK3Pjb7z+hYsXVNrOwvohjRMTWrvUC4bg+p8+c/R3AcsokyVfbRaVdjp9m2czCEVFxE46gEaUY4ZKV5YSQA/lXWHqz9apXdBwHMBxshl4AeuRe1xstpwHAKbuLAxhJKYyU5bhsAXsBH4LPkR6jA7xezjANQJMsUWkCYF+YWUjN387rsj8PoA44jQIgSW+yJBTW39+Bz5kpgM3mTWpg6BwFWQFC2lMWLC703A3IjaFATg64T3zgRICcACEfB4VUKaVHAawJtreahIsOSfkNTNg1WHpgFoBZkuIeSSl1q/8vCumE+mvYRSUkWFLc6/XeAlPBfghe0VFMFKWeW7ZuHXsjKSm0fLlycveuXVK2b95UlYCmEKCyV3SwlYPZ+tAATQiJnDtn9liHw7lh6rRp+Q1NY7A4Yd/gSlZdSVUCy7m5SCl1eCVnD+RziXklZzWopTXA5GQKpS6rq5hM9fPIAnReyanD/YKAlQGY1bjPQ5djYC6u/VDdeB6i8/s1uo5+6NpockSzlhmuIuM1uf4A3B4fQrQaKB4fSpUoVlRTDoy6/pD24FM8Gk9XNv8ACCFH4uLiGsXFxcHtdmPp0qU7KaXtgDziwCtg/u95ZoH3E0Jio6OjT/fr1y+vjwsXLuC3335bkOWSD4O5gD6ymYVr+Y7xSZMmTcZ17twZJpMJp0+fxk8//eT2+Xx1qaq0bGexE6vNLOwEAIekFAcwWMORvbhfDvu4WeA9XtHRD5ymCYC39EZz3kNRWIkBUXHPBfAepRhOmZ8+HMx1cdRi5K8CgM+RbgHwos5aIk/WXq2Z0xxMPn9PmFlI97rsQ0BIDRDuPIDlepPlX5oxqsl21cEGJwo2+B3RWcIfSg5U40MdAGgAsh0abSyAShQgfnDmAIhCQVIomwQkWIx86oN9PAiHpLQHUNFqYsm7kuKOBdDMJPCFinnmOxcSAF5zE4PWZha+etxxCCGNOI7bFxsbq6tYsSKuXbuG06dPX12//tefn3+21VEwNYhnwFYRBXDm7NnQFm3bvxoXF4dz587lSpJUhlKa6pTdLwBoaTHy7+U7zmsAvi1fvjwiIyNx6NChGx7RMQZsVZuN+1qClx8V8P8noRogE6UoGQDKA6Q0ZYK6WgqEaORbMVqaM4iISXquiArLXy7dgknzVoLX69CuaR38NPvtog7nAtCEq9zr/+Ra/53xdGXzz6DKqFGjIMsy6tSpg6VLl+YpOaskgcWqAvQ8UXF/AiC0XLly6Nq1K+bPnw8AyMrKAgCPzSyssIvKKgAT7KISDeBDm1lIBmAODw/HoUOHIEkSRowYgapVq/LvvffeRDBfNmxm4YRdVCrYRaUXgLU2s5DhkJTL/gDVW03CPtXwNRQVt54jXAwXCGzlOK4vgJ8fc30aAPUJwcFQgT8J5AVwGzll9zOgFDpwsX6N7p38Xu8wRvvelyUqBJS2Fl3ON7WEc3KEfKY3WR6rrFsUfM7MYmAqyHowA3MJwIagv77oqwjRAvCD0uKggQ+pPzc1R6PPACEAsMks8LfUayMAXnPK7o0WI//I4LbVJGx3SEovh6T0tZqEFSaBPyMp7jaS4q5uEgpXKQBYGW6vyy6BKTg8CZ575513dI0aNcK5c+cwatQoHD9+PObtt0f0e/7S+U/1ZqsHLJZSAIThjxkzZmDIkCFo2rSptl5s7I43hg3VPtexo6d929Y7vaJ3NlRKeJXKlXtNnzEDUVFRaNy4MbRabYWvv/m24YGDhzp6vF6PXqf7bN2vGx5rhNVjNwJb8d8GkECLmOkSQkqCialqi5coIdSrH1eparVq6ZOnTr+A+3GfoOstAITk+zcUMAHaXDCD6+NDzC/k6sP0HKXgpBsPHS/bKSFh13Fc37UQVrOA3iPn4KeN+9C/a4vCTo/iyRJCn+IBPDU2/wym9u/fv1dsbGzTRYsWFdrALPAXVLfahHfefU88euQwbt26hRUrVgSbnATzp8NmFvwAZthFRQtgsl1USsQPGvzDsiU/5oK9vKUppdETJ05EubJlmuQ/js0s3LCLSjaAeLuoLLeZhQSHpEx1SMppq0kQwdSF4RG9xwKEG+EHaSgq7mQAjvzlrYMQFbcRLBhcH0DeDFx1uRwGcNjnSB/m0fA/UE7bVx2oswDssRhZ3RcT9WgAMpwSclZGyDFQUksSlbSwQhSyi4LPmWkF0ALM8NkB7H4SxV2vLJYAY6gZALgpsCeHC6kBgIJSZ4jfQwhjN6UEvS4WI0+dsvs7AEOdsnu9xcgXyXoCAKtJWOOQlFcdkvKCWoDtS7DaN6NNAv8oGjYF4LCLSpjNLDxOJfnC7Nmz4ff7DwI4MGvWrHHp6ekYO3ZsjCG0mP8RHov42NjYFiVKlEC5cuXQrl07NG7cuIYsyxgxajRu3bq1naqVSwEg8cqV9JdffnkapVTvdDrBcRyWr/hlQmxsLOxJSdBqNE29omM/7seSgijg7vpj7z6b2WweFFT8nvf5pz95RUe6etHaAEhZqONR+3bPxobo9FHlypXL23/5kh/Rr2e3b2vXqinm65uqf2gACAAxgv1oXP42VGsMhzakkFNk2HnoPMqVLoHiNjYn7N6+EQ6fvlKUseHACA9P8Rfx1Nj8A6CUfkEI2Qcmt14kzAKvAJgUoguZBAAtWrTApUuX4PV6MWrUqPp79+6dBCZdDgBQyQKT7aISMvfLBdNFl6u5W5HrNm3aFE2bNsXUqVPh9wcOel326QCmBOt72MxCtl1U1gMYYBeV5RzBPACjAMwI9m0wWz1e0ZECQlI1NPeAj2itouJuzoGrHSCc4FPcR8wC7wAwEsB8AN0Ko3L7HOm9APweajbfguqTV+M8nZyymyfUb9QRbgABJhjM1j8MALJERQOgXZaomABsCzMLheYx+JyZGjA3nA1MSuV3nSX8sTk0XlmsAibRT8D0uxJ8RGsCKyPcCaySqsp6E+B12Y0AOntddg+AbfpQm181ON8AGOKU3XstRv6RzDqrSVjskJSxDklxWU3Cfklxz1fv+eeP2O0WTz0n3cQw5DHtQCldSwgxU0olQsiAcuXK4d69e9BoNJLf7y+UVEIIiQwJCVkye/Zs9OrVC2XKlEGPHj2wZcsWRERE4PDhw2jYsOG7hJBllNILXslZwSM6rgHoazBb16WnpyMiIgLTpk0Dx3G4e/cuXn/99bN6s3Xso85VTUI9v2DBAvTs2RN//vknjp29kNz6hW5BV5QHwNagyOz2HTt/27RpU9SFCxfyyo0DwJ30zMM1QwwPGmECtooJEgnSeYOhwDORe2Vdj4Cp7E+clFRozKZMqXAcPXsVitsL3qDD7sPnEVezYlGXo4VaaO8p/hqeGpv/D/DxzJkreJ6fXLp06RCtVivXq1fPuGHDBkRHR79DCPmAUlqALq0GkN/f/NsmX/Xq1etevnwZDRo0QOPGjbFv3z4LWF2OOV6XfZw+1OZT9xHtorIOQHyAYjlHcNghKc9ZTcLvBU6G0j0gpKNZ4H8HsN8rOQlo4IyP6MqLirsWGOnhTzBXVQH4HOktASTprCUK6EVZjHwGgDVeMbsvBXr6iO5zSrgyHpZAeSzMLFwBsDWLrdw6ZImKHsDWMHXw8Tkzq4HVsgkA2K+zhD9y1u+VRQ2YWy04YiQC+NnH8l/aA3gJbDW0xizwD62G9KE2GcB6r8seCqCb6t7aYQm1BQB875TdPZyyO9xi5I886jzAxFenqAbnrKS4JUlx1zeprsdCcJhjyZFP9F6qhuYFq9W6bPny5Rg6dCiqVa2y8szZc4VO4TUazbfjxo3D8uXLkZWVlVmqVKnwMWPGwOl0/g4gqnnz5rWbNWsGQgNDvJLzAFhV2PVglWwRHR2N1NRUdO7c+Up8fHzlZs2aPfYc7aLCtWrTZhH1+6tpNBqcPcs0au+lpabxIVz+VUpbt4c95lFRUSUAYO3atXkq2ABGdO/WbcmT3BcAEBV3GQBlABCNrZ5isJ8oUnCzUZ0Y9OzQGHHdx0Gr1SC2Wjm89tKzRTX3Arj7pOfxFPfxlCDwD4EQUj82NvbEokWL0Lhx4+Nggx8PoLfaZA2lVFLb6sHoyr+n3EuvWb5M9PY///xT16pVKyQnJ7cFG2hvU0oT8vVfGkBVAAZeEOqZjMZp58+fR8mSJbMopeFel10Plhw5M1iEDADsomJUj/UTRzAOwNdWk2AHAK/oiAAQC07zgt5ofhsoSBBQYzxfgBUmO4P72eZX9D7RDKCGzlriISaZV3KGgNLZoFSrDy32RvB7Nc7TECyYDzCywdHcAOUIDfTQwl9HR3POcsB5nSW8yHgHAHhlUQATcgwWmTuiN5qvqeW424CVi5DBCt39JfkTr8tuBTNSt/ShtqPqubcEYLIY+c2P2tchKRzY7/CNliNJYPfvXVMR+VZel72fTAweAIk2s/BIthYh5LnQ0NAt27Ztw7x583Bg//5j4997p9WIUWO8YM9MFqU0TW0bajQanUlJSZg3bx4opRg+fDg2bdqEadOmQVEUnD17Fh06dEBKSsozsiwfAQCv5OwIINlgtl70er3Q6/UAMCg+Pn5Js2bN8Prrry9W3O7hYEy1kgAi/IGAxR9AAwqQo4cPh/bo1uXV33//HV26dMGqVavw2WefIT09vcex48c38gbDQxF7QsjmTZs2PV+hQgVoNBps27YN7733ns/r9cbQQirQAoBayDBG/S8FcNcs8EkAICluvSF1ZyLn9xRakfUvgAJYwVXu1f9f7Oe/Ek9XNv8ACCGfcBw3TqPRgBACjuMaAMgJBALLGzVqNJAQgiNHjoThPhV2bJkyZWampKSgVEQJtGnTBnq9Hnfv3gXHcVNefPHFFvv37wchpBalNDgArapYsWKT69evw60o6PXii7h69SpKRUVRu6jMATFMNFLPWAAzvC77Mn2oLREAbGZBtovKagADKMV8QvAOgMkAoDdb73lFRzgAjX92XwIgBnU71EFUtb45e5d/iP6f1QSLy3Q2C3xegqgoyzVzuZCBfq1hg1dxNwUre30FALySswoonQka+F0fastjpgF5cZ4j6gdOSa6qpbkzQig1UpDUHKKZLZOQZgAqQVSuhZmFAjkfavylNRgxQAGwR280Z6lGsbGPnUsugD2FJZ4+KfShNgeA1V6XPcbrsvcDsNUSatvrlN01nLI7HsByi7FwdQirSQg4JGUigFm5AfqJliOzwFyjMwprr2I9gPF4BDWYEBJnNpu3bNmyBQsXLsSqVatQrFixsBGjxnwIwFShQoXXMzIyQAipSilNvJp4uXGduvV8I0aMyONseL1enDx5EtnZ2diwYQPmzZuHa9euyQCOuhWJkEBgyLQPPzYs/v77j/If22w255171apVywBon+MPGPwBlKaMrZUNliPm79j+2T9mz56NuXPnwul0ZoAZJVy4cGGmwPNbVUr4g7g9aNAgZGVlwWAw4Oeff8bIkSN1n3322RsAxqu/byxYoD64YskwC/z+/J1Iirs4gJ4ACIhmA4A3wNQk/i5E5KO7P8Vfw1Nj88+g3YoVK1C1alUAwKlTpzB9+nRu/fr1vXv37o1bt27hyJEj+YlaoR06dMDo0aNBKUVWVhZ69OiBiJIlF0qiOHDy5Mno2bMnUlNT8+8TMX78eDRp0gSUUiQlJWHw4MFIuXv3HTAp91kyMSgAJhmp522vy35IH2o7CLCSB3ZRWUmBl0GxzSEpPa0mYR0AQMoGdzzBRAmxE0pDSG4OR0tV5lG29hD9qslZcNlnegfP+SN/yoI+R24BYJwgFAsAgKi4I0VZaaahuR1B0YKC+y6g1f9UlAKiz5lZA0AVnhmGz3WW8Gyn7A4nQBstwFNK/X6KvlmikiUQfxJHUBf34y8b9UazRz1uNZ/i7qR2e9Qs8EsLP+J9EEImgyXbGvJ9vQusCmgBA6IPtV31uuzXAHTwuuzEAGz1aPgsAG84Zfdii/FhlxwAWE1CjkNS3gfweW6ATtJyJFlS3C1MAr+vkOaXjNRTQyaGx1HAe48fPx61atXCsGHDMGzYMACo2KlTpzEOh+PKkiVLMGXKFOzZs6esR5FTS0dFNZs2edKwq9dvNKxRO7bDxPfH8506dSq5bNkyrF69GocOHYJa5oBPTU3tuXDhVwOOHT9xafeePRWGDB5ct2vXrtDpdDhw4ABmzpyZl4kfotPr3TmBsEMHD9zr/FyHTDBDs41SGiCEaDiOazl06FCUKVMG/fr1Kx4bG4spU6bA6XRWO3ny5GuEECeAM5TS/DWgZmdlZW0CsMXj8QxfsWLFwt69e6NkyZKNRcUd9N2dNQt8obETSXFXA6O0ZwJYahJ4d45QuhN1JQ4l/5qxCQDY8S/s/1+Np260fwCEkCFgyZH5M6OzANTduHGjtW/fvpBluWzQJUAIqQS2ymkDJiVyBsB3ANbbbLbUb775BiNHjsy8eDnxTY1Gs9Ys8AFCSAewBMKgIvFBAHMppeuCB7SLSnEA0wE4BOpJIkCaPtSWkG+7GUBXApQkBD+bv3m1KoANYC8kDwABcECN5sDF/VBzFCSweMezmrErrqqEgEM6a4k8P7ZXcoaB0g9AAzyAUT4tT4A8AwEA0OZ6kjTU30C9Rxd1lvDEwu6lVxY1FGiZC+45SlHMD5gClOyjwHKdhkhgBbmC6gaXwSR6nvihJoScOnjwYN2wsDDk5rK4epMmTeByuYpRSouWaXHZbWAEgxMeDX8HwKsAfrIY+SI13BySYgXLzH9Xy5GPAHxgKmTAVF1pPIAEm1kolPlGCOnF8/xKnU5XQOvL7/eneTyekgcPHsQzzzyDK4mJn5YqFfkMQA8FqOZiLjBMSzAismTEcEVRXlu5ciUuXbqEqVOnBrvIbdOq5ZY7KaldihcvjoMHD27leb6jTsfmOYqiICcnB/Hx8VDdaACreXOqdevWLyUlJeHmzZvPUkp3qTTrS5UqVaoa7PyHH37A4sWLsXbtWsiyjP79+2P16tUen89XjFLqeX/iRDLrs8+ywsPDi2VnZ6f7/f4SP/74IxITE/Hhhx/OopS+i0IgsdVOGwC1wJ6D7SaBD3hFBweWCnAjJHXHG2CVUv+OwZEBjOMq91r42JZPUSieGpv/RRBC5gMYCuATSunkJ2ivB6tqGAPgeZes5ICVQN4O4PcnHVTtolIKwGRCA6X0yDkqhBabmW9bcQBTtDdPm7hcX3/9kTUaTnlsSMMPQPE/03Mkqje/rLOWOBzc4JWcTUHpq6CBE/pQW4EXU9Uia0UBi58LCfdzIZdBSP4Z/EmzwLvV+EsbMNaZHyz+ch0AXLLbQCkdHmCJrloAf3CEfFZY1UcgT2z0NbAYBsDqBc2hlN5Vt586efJk3RdeeAFpaXmVfX8GMKCoPJD88LrsDQCU84PbnKPR9wWjeF8vqr1DUkoCmKAh+IwQMtwk8BML6bO/QgyrAbxjCOHWgcVCQnGfu0sAIDk5WSeJoslkDq1FczzZF/9M3F6zWpWoeg0brwwPDzdElYr8avfOndtBiOil3H4AqwAMsBh5mRASV6tWreMbNmyA2+1G8FI/+ugjrFy58vbo0aOjS5cujbFjxy4C8M7yFauqxlSuHPdMg3oLT506pTEYDNBoNPB6vejXrx/OnTvn3rZtGz9r1izs2LGjO6V0g3p/DWCBegD4fsmSJc2+/fZbHDp0aGBISMjSjIwMlCxZEoeOHH22UkyMz+PxkIjwsL2nT5+GTqeDRqPBwYMH8eabb8LtdsdQSguwACXFrQczIBEAdpsEPk9T0Cs66oDFBH/Sm63uwJU1pcDILaH4a/CDGdQ6XOVeRcr3PMWj8dTY/JtB9Ve3Vz/HwLTJnkhC3y4qBkIDswhoswC4uSBkmc0sUO/ySa1zarbdkRvTSKO9ehj87u8f3xmAAOGyORqooRm7ItUrOTlmZGhzgH6rD7Xl+c99zkwLWD15CpYP43ywL48slgyADAYgUMATAHcKhLjAEvQ8YLEZAYwNtNcs8GnqNbUFE/z0cwQHCCFbLUZeCfZLCDkzadKkOi1bMtHhnTt3YtasWVl+v78mpTSNEHL+5MmTNRMSEnDv3j0kJCQgJSWlyBl0YVCVCDoDSPFo+FIAbluM/LHC2ro9HkOuP9CIAvEajqQD8HCEFKDIkxxvE6rRnvRR0lan4eaAUXol3mAo8LJ6Jachl2hGaWjgNqGBGiBkN4CjBrOVB1Aq417aHZPJ9JqXcp8CWAngTYuRz1TviwFMW60SAF6j0eg5jiM5OTm3AOh+/vnnqu+//z4GDBr87ph33rsHIMlmFg4QQuaBicr6wdxKIQCuaDSa5jt37kTbtm0DgUDATClV8p+rqLhL9erZY+i+vXsH6w2GrLZt2/6Slpr6SefOnTF+/PjVlNKX8v1m48Gkk4JGageA9ymledQ0SXFXAZtwUAC/moT76g5e0SGAMQ6v6M3WAvWkAlfWtFWv+0lLDQTA4lB1ucq9bj7hPk9RCJ4am39jiIq7IdisLgPAErPAPy4REAAbHHPALc9BSIDSwD3T8rG9iUYb6W3cE/oj6/AEK5sgcgD8kTv06wGg9D3QgAnAODWgDp8zsxxY0qkLwC6dJTwv/8MriwSMTRenfpUOYG+++EslMAZfBJir7RSY0QFYoPaCWbivQp3FyjR0I0zZIJMj5CaYavO6Fi1aNLty5QpCQkLw/fffY+3atfj222/fpZTOIoQcHz16dFxWVhbKlCmD4cOHo1WrVrh69Wo7SunOJ7kJbo9HAyAc/tw4gDb3E00OBfFrOVIYxdkLIM3nD1ShFCYtR6oD+Mgk8HnlD7wuuxZAL5kYosEUwAOAyupj9ysi2DSHhJQLCfjWAqiiN1sP5D+QR5GnU4pPfOAWAZhkMfKFMrm8krMl/l97Zx4eRZX14fdUdbZON1lA9kWQVRECooioKOIGqDiKIq7Ahwhug6Ay4rhvo+KIOqAoMuiAiuigggvizjiiMCKyqYAICIFAFjrpTne6635/3OqQDQhL2Lzv8/RTXVW3qm/dpOrUvfec34HiJF/aAgAReSghIWFss2ZHL1rwv8XnZfq9u0xE5w6XfWvbdhfLsoZszctfTnkpfwE2+70pv5Q5po1t2/8BfLFYrINS6ueqzlu2d1kYDGWgXyzS0O7s83zeHT3acCBf0MoDKcDrSf70KrVpnJ/fPBvthOFl5yKgoBUIcoCeVuv+lepn2DOMsTkCCARDDYHrgFRgut+bUi3dpvD23JvUd7PbRBN916vE5MSEDctJWLvLOFTW5RWRHdjhtZvssUJtb33qHSu93kLgqaRamSpSsPVEtJ7Yb4lpdb4DLUHi9XqPfmXK5Lp9+/SJ50VZCSxKSvU7gWCoHloCP+5htBo9yV9peCwQDKUB7an6QRGKxFQxcJxAqy8+/ST80IP3n/PTypUZRUVFJzz44IOEQiEeeeSRB5RS94rIJejJ5G+AK++9996eCQkJ3H333X8LhkKPsEOduGIuF9Bv1YJ++80BslHOFquk+PSo2C2jklCIyE491fILg50k1UkAACAASURBVDcBv3gsOcvn3aFHBnreplgS14LqkyzOAndzDJ12IRugMBiygCsTYuF84P2y6s/FwaJLgQ1hZQ0Gnk5LrVoqJ1xYcBHwU5IvbWVuIGihXfOTPnh/zuwrL+9f5ctLmfYvzXJaUlJCQUGBXadOnQh6OHS3vW0R8QAqngahKgq163ov9FByAfCurwrX9XAgvwvQEXg3yZ++2yyazs9vtgKeA05FG8ay/itB9P/Wq8AYq3X/Pc6lZKiMMTZHEIFgKAU9xNEWrUr7ZlyluCpc9+ZstLIuJU07UNK0AxIJkfT9bKyS8s5Vy7ILOP3F/9C6devSbVu2bGFAS9/PD7z1+XHoeZZa6ERWvwI0bdLknC05Oa/7fL6MFi1asHz58khRUVEjd/7pNPe32wE+YJ3ot0moIEmyi23lUFpgtD5go5QnpmjYtUvn0wYPGpSelZVFQkIC/fr14/+GDr35nnvuWdu5U6c7LMuKHXvccUsXfPPNGTfeeGN7y7KYNWvWW1/Nn/8sO/KubK84jLUrwttz0x2sgSVWQn0l1kNVSfW7ie3+Zgk/WkCCKllPfD7BiZ0G8u8iSeyZ6U99qKrfKAyGTgQKE2LhNkn+9Fnx7cXBoobAgLCyagOz01JT/lvx2HBhgY1WGp9XpBK2ov9vbODNBFtC6NinOhWPc9kOLCvbs9zfFAZDx6L/nxTwsc91pa+IGxvWF/g+yZ++6zelKnB+fvN4dG6gs9Btvxn4EJhtte6/05QYhj3HuD4fQfi9KSFgCpRGUF8dCIbqouM1ZlXhKtoe3RsCIGHdEhLWLcFJ8BLufAF5xVFuGfsAK35dh4gw6KQWdO/eXQcQztcjNp988gmh9YtaEA5eQpL3w8S0OgXhokC9cFHgciCxbt2j+g8aPDgjLo/SvXv3xMefHDcVPWz2q2hX2WnAst3ohu2UUHGxhX4wxnshrhuz4AFi0ah/woQJZzRs2JCHH36Y/v37k5ubd9uva9etDwaDp91zzz3873//O+Pmm29m0KBBnHHGGTRp2mxW1FFf7e0D1R1KnMD2vO5RK+GFQGHhXX6fbxNAuLAgCeiYAvUVfBtWnkEKCqJi35ea6vscILw9dy6oviC7apN2nlj4HXTAKgDFwSIBbgwr+Q3YHDc07lxfXeAYlEqxsc6Mif1FVDFCBLGFeSISRXsNAqzye1Oq9BCsKQqDoUzgIvSLxwpgoq+Kni1AOJBvow1kIMmfXr1JxiqwWvf/EfiRHWkhDDWE6dn8AXAVpvuhDcsPwEd+b0pebNzAscBfKT+EUMp1r/2XbiedyNXXXEtJ0XY+mDqR6dv8XHzxxQwdOhSAk5vVYcpVpwWaX//IZ9Ru9K4DPgertUJylEijSS+80PrO20efFovFWLhwoVx33XUsXbq0w+4Se4WKiwX90IkbkPRdFFfomIpsYHNKcnJpoKCI9Ef3dtYC111wwQX/N3jwYG6+5ZaFzz0/6ar+/S5c2adPH4455hi2bdvG7Nmz6XzCCfNmvv3vb9DpuS10b+trdi9TUlZ9OCrKCXhUNE0p1TCGPdjCWWILX7vnW5LkS9sEkF8YbASMtgVE5Daf62XoukCHBX7x6N5GBrr3Ee/hnWc50QJH7IWINkoWznmOEttB6lrCFMqTk+BEAgI9i5QnB6QRMC2zQrDsgcQdJjsXaIF+8XjX502plA4iTjiQn4Ce/LeAGa66teEwwPRs/gD4vSlLgaXu2+3xwNBAMJSedNTRF9k5a6s0NNuLS5i/JocpA2zkP9OIJftJOv50+Px7zjzzTObMmcOyZct4/PHHWZrSPLV57UYXxqBzTDzvod21c4B/jBr555zRt40UYCE6Job+/fvXCxUXJ6PftG12PiwWQBuQH4GCPRnGAhCR1JSUlNfPPPNMa8GCBWRkZDB06FDmz5/PhvXrvzj1tNP978/9ZNDEfzx7zHPPPVfo8XjyHv3bE841110XcRTKrfNKW0hCG+vu7qlL0Bk444nDMtBDgaUZt1wlY09UPNuVSDYij0Qdp19MOX/Csqci0iISDLUAsC1RjqNWxBRn2cIDgWDoAwBbPK0Sc1YvVnkbH0/+8aNmUhw4WpRjAVuUJ+mzaFafT6Vt96wkn/9JgOJgUfOYIuQgLdNSUwZXbI9wYUG7EiX9IniiwJpMv3evVRX2lUKts9cDPQ811+fdtexPOJCfhB72iwJvJPnT96oXbDh4mJ7NH5jYuIEb0FkHK7H49zxumPktx9ZLY8nGPDo3zuRPHZoy/KPV1KlTh7y8PIYMGULPnj0Z0Pdcfpo74xfn2B5fWJY1kyp6So0aNnzq448/Pua6667jvPPOu+yBBx+cD+SkJCfvNO31viIiKUlJScGnnnqK9u3bEwgEmDt3LhMmTMiPRqPHK6U2AGwLBGuhDUkS+mH2H48lBUAXlGorUMvCKfYQ2yKgHPA4Yp8BEo/XyBPljPf6/L9VWZEyFBQGT7BUbGiCKnk2uVZmOUeO/MLgNQKXWsLN3ldu3uAk+Z+kJDTMcqI2O5LdxVHoVA//Aa4sufaZbUrxaARpCXJZxbijYKDgwgh2Vwfr40y/9/M9bsxdICIJ6MDajugX2HeVUpUm6Qv1kG5fIPW5Z58tHHvXX9Icx6mDdgYp1QosSziQ70Nr+YWAN8s6QRgOL4yx+QMTGzcwlzJv42VZuH4b3Z/9mC9v7EXXZnUYOWsRviQPbevWolmmj4yURE546gM252zlmGOOYeG8OYGAJ9WfkuId36Z1qz9XPJ+ILFq4cGHn6g6j7S9EpCdwFdqbqRDtQv1McSA/fu210cGj6YClFJ4IVlulc6PgwVnjEbWsBFtiWC3RKZJz0cGbRQCFwZAfuBo9TGkDn/u8O1eELigKpYmK3e1xokttnFfiqSDyC4MpwFLLia7ybPvthISvX0uxtm/eXaKuCJBbcuFfXomlNxgInJeamlpqxEKBguQSrEdjWKsV8o9MncBuvyEiloisbNeuXatOnTqRk5PD3LlzJyul/s8dIjsZ6OAW3wq870/1/l/jxo3/3rdvXxo0aMAPP/zArFmztjqOc7JSajVAOJBfG+3mXAi8tTM3ZsPhgxlGM1RJ4zQvjdO8dG2mHZL+1KEJN721kMe2rKBHi6PwJyfQoFFjbNsmEAgw5Npr1PqQYsuWLTd/s3BR+4YNG4Zs1OIP33v3+5v+/OebLJF4BD/Jycmvdu6UNeG/X30xGz2MEq1qmeRLc9yUv0nuJ7mK72W3xWM7SmVxigP5oCV4yj5kT3J/IxctI7QCyE/ypTmwQyRtWyAoUawsFHG14OUo9b3Hkkzg/IKiUGmQaVpqSmkiucJg6JzCYOgv7uqcslHtAGmpKQUFRaE7SiwZpFTsAbbnPptUK3NLus8bKn7/uVaxY8/c4tRrWbuky8UkfVp18r0yJAL1KMq71c5okITWebsKoCBQeA5Y/R2sezL8qdXKprkXeFNSUlqNHz+eYDBINBplzZo1WYXB0Ah0G3+Dnugv2/4nDx06lEAgwJIlSxg6dCjdu3evM2rUqMfDgfzn0WnD84F/JvnTzdvwEYLp2fyBiY0buB5ovLP9Pf4xj0n9T6JN3Vrc/9GPzFq6nmtH/ZU2bdoQCATo1q0b9913H9Efv+Cz34Oxz7+ab/fr148/j7zt3gFXXBGMORw7/umnevxv4XctRo4cSZcuXVi5ciXfffcd999//6o1q34ZZeHki34oedDGouwyHscRQQd0ht1PcYVlGAgn+dJqbEgOYFsgeDRabVjQk9lfeyyx0HMP9dy6LgRWpqWmKFev60J2SOXM9HnLJ10rKAx2sXAuT3Ai7wp87Zl2+yinVr17SrpcnJrw3VtYgd2GjADgeNNKnJMvz1cN2nQKSuJGC+dhC5VTy+//+/649p1RGAylnHRil9ezN23qesopp9QbPHgwAwYMeDcSiVy0s2NE5CrgfuB1INCqVatH58yZwwmdO+fkbFzfKcmfbvLFHIEYY/MHJjZu4LfoCP8qWfx7HsPe/JZILEbzTB/9Ozbh2te/pWXLlqSkpLB69WouaFWbe8453un2wnzrnXfe4eyzz86JRCKNlFIlACLSLTk5+evU1FIPa6LRKE2aNn3vv98s+Cfa06zsUFHZf8hcdsS5ZAM5Pm9KjRqU6rItEMwETkEbxQgw//I/9SvOysq6NC0jo92AAVesrVuv3s/A12mpKTE3APNy4Gh07+2f/lRvPtC1cZMm7e6+++4el/Xu9Xut9x4eQRl39J3xe34Ra7YGaJbpo2mmL765qPi4s8fEOvXpa6NGp/prLXX19bpQPgD2l3iemz3FNaDt0HNcCei5lC/9qd52ffr0eW/w4MFccskl/1ZK/WlX5wkH8iUcDvftemqPv5zZs2e3U089lSuvvHKeUursvamX4dDHDKP9sZmJ9k5LrmpnVqMMFvz53HLbLu3YjFVbA4RKYjS/pCUZ3kQ25AeLnFgsdeDAgVa/iy+ePvnlKUMLgyGAYKAo+M3RTZv4tm3bVqpFde2gwd6nxj97bSSm4kneY8BXwGw39XX8oZbBDtfndkDdwmConMpxmePjaYHjn3zfHqg/7ym1/d5cYDbAtkAw6fRuJ73y08qVl2Vv2khSUhL3jL1rdn5h8FZgQEFRyMZ1601LTSkqDIbsSZNeeMS27dGdO3e2WrRowYuTJnHvmNGBz289x9OqblViBTtYuy3AcQ+9y4knnsiPP3zFsrv6UD/NC5Dq+enLEZ7O55+d5EuL9w6mdOjQ4YpatXZoT3733XdFIlK3on7ZzigMhtLRAZb10S8DK9HS/WVdpttVdWxZ3NiYvmiJGmnUvGXPrKysbjfeeCM9e/YErVBuOEIxxuaPzXvAvXtyQIJt0a5e+Ydho3Rvwpw3pz23ctWa3GsGXv5gohsIWRgMpQInr123Pp4GIYpOn/C9z5tSmoArNxC00RHcj7nfQQ+NzQQWZfq9u8zSWRgMJbAjU2RzoBuQ4Rq8OPF5nELKG6XNPh0Mu9fU9nvDy5ctO2PRokWUlJSQkpLC6aeffnzUUR3QsTnfeixJBs4rKAqlApFHH37YHj16tNWlSxeWLFnCzTffzMKFC/3D/vEYn47sXek3ftpcwMDJn6EUrMrZDmJzwQUXUFRUxMaCYNzY4ImGm/PqbR6Gl8Y5NpswYQLr1q2joEDrny5dujQ1HA570bIslXCTjnVEi3Ra6PmTT32u+Gl1EZHUJo0bX3rZpZccd9edt/+YmpoaBeYk18oIAM9069Zt0PPPP0/fvn3ZsmXLcKXUV7s7p+HwxRibPzYr0Q+S3Xk87QpH4JNTz73g1pNOym4CjInkZQsw3ZdR/1d0IrJPoNQodASucz2VAJxEW1YDS9CyJAogNxCMS+9cmRsofSbmAlMy/d4NZSvgKg9sdD+7pDAY8qHnV+oDJwD1C4OhKnt2aOeBisN4O3O9fa9Lly5Xt27dOnHGjBkUFBRsr+33ztoWCKYD3aOO8qKN7SaBxWf2POu4J598krr16v2UkJDw5VNPPTU0JyeH2267jZjjYFvlZd/a1Etj0V39mPL1zzy/IsSqVato06ZNVfVw0L2Hcukd7r77btasWRNfHamU2uoO7bVEz0Nllim+Ff1S8KmvGgoKIvIMOn9TnIv9ft+W9scdtzzV5+vx3vsfMO7p8ZcppeJZLm896aSTbnrppZe48MILWbt2LcBEEclSSt2wu98zHJ4YY/MHxh41XcXGDfwrMB4drb83hHHTSidm1F8PPOIam6sjedkD0JP4LyRm1A+6RmGh+wHAHRZrgXaRrR/vjSTaUoJW9p0VV0R2c+8Mzg0E46rHAvwMvJrp91aK0agKnzelEN272WnOGbdeFuWH8Y4DjqpiGE+AkkBRcN7zEyd++dKLk8plB63t9+ZTJrvjtkDQp+DEiS+9vHDsvfdf1rhJk6KrLu/f4/cN69m4cSOZtXxYIlTF7/lFjHhjAQ899BBjx46lQYMGVRXzooMf48bGBpgyZQp5eXm88cYbfDxv3qh16zdEM2vXjgCrgE981VQMr0g4kO9PTk6+5qOPPqJ+/fokJCSwdOlSRowYcdSXX3554rRp05g9ezY///xz2RwyZw0bNoykpCTeeecdALZv384pp5xyOWCMzRGKMTaGV9DGIpUyLsPVJALMs0dNLyeAmJhRX7nnJZKX7QWGRvKyU9ACji8lZtQvHet3ewq/uJ9SCoOhRLQY5LnunIFKtCUuHPopsDwSU0G0vtsYtydUkSCwCPgSyNuTGBP3jX6b+9mlirZb17qFhYGu8W1H1a1bpzAYGl2hqCTZEldFyD7m6KbZbdu07hYKBu/49NNPGTZsGLf0aIPsxNjcMO0/3HXXXUyaNInkMh2ff327mk5NaiMi2rvCm966MBg6H2jWvEUL36hRo/jtt99o1KgRU6dOJRgMNm7WtImjlJpU3faA0gDLM9HZZOMEotHohB49egxHz+eUoOcAVwGdGzZsyMyZM0G7n8d5bciQIe3RwpfxrJkKnZ3WcIRivNEMxMYNzEJHou/JcFpcj+xYe9T0XeY7iRPJy04HBqNjQ7YAUxMz6u9RRHhhMORFT0Yfyw6vLbV69aqSC/v2PT8vLy9FRN4uKCh4OTcQ9AFd0Z5Tpdpqfx/3ZKu5H77favPmzX6lVH4sFns3NTX1oZ9Wrizak7pURETatmnTZsWMGTPo2LHjj0qpDu72FugXu18CRcFU3N7SnXfc3mf6tGljPvzwQ5544gkieZt58+KWiMDyTfnU8SXTwJ2LKQhFOPq+d1ixYgWtWrXi+uuv5/bbb+edd97hscceY+qoq0hNTqJlo3r4JFIcOXNoW2CdP9XbGi0TNB8Yef3114/MyspixIgRLyqlrq94DeFAfibalbusYoG4n0Lg8yR/eqVU1lVhWda8xMTEs8Lh8O1KqSf3slkNRwimZ2PAHjV9cWzcwCvQ2RyrY3CiaN2ys6praAASM+rnA08BRPKyGwC3RfKybfRD7NXEjPqVMnhWxOdNifdWyiUm69a166sXXHDBpb1792bYsGE9CoMhT6Jd2kPY7H5YsWJF6jN/Hzfy2WefpWXLlhQUFDR88cUXj122fMWVWwsK37L0XEl1o9VL0K6/4XvG3tU8PT2jV5l9LT0ez0eWZc2rW7fu4x6PB7Gsv0Ri6g3A//CD93eY9q9/jfnwww8ZP348b731FllH1+fOD6Nsjyi++nUbmzdv5utnxtCqSX2scASLWVx22WXUqlWLjRs3UlxczLp16wiFQpw18jE6dOhAcNOvLHvgckmIhU/bvn274/f5xkdKSryNGjZcuik7u1VWVhYbN26ke7dudcKB/MvZkZMH93sB8GGSP32fnCYAlFJnh8PhZKXUPp/LcPhjejaGUmLjBp4EzEFnOtxZrEchsAE4xx41fb/k+4jkZfvQUe+lWmNo41MtRV8ROatJkybzpkyZwoknnkhaWlpAKVVlnnkRSUtNTc0+/vjjk5cvX07Tpk354IMPOOuss7ht9OiHr7zyqmpdk3vf2OhhoMSOx7e/6c4772zatWtXWrduzQ8//MDTTz/NBx98UHLrrbcmpKam8v3iH36Z9NLk/wHF11x1ZcduJ3fNGjFiBMuW7RilO++886jvtXl55nuMHTuWv3RMpldbLV+3fFMew/41nw6NM/l4xUZemzOPG264gUuaWDz6yUq2bt2KL9VL+LlBefbwyZkiUjs9PX3rggULWLx4MU2aNCEWi9G3b18KCgqOV0otrc61Ggz7A2NsDOWIjRuYgvYsugWdIyb+wE8BfkXHQrxhj5peY4KIkbzso4CB7BD0XA+8mZhRv1JAp4j4RCTv7bff9jzwwAN8/vnnuzQ27jGdgQfRvbgzFixYwI033sjChQtP31v3WxF51Ov1jrHtHf4D4XCYSCRSPHPmzOQ777yT1atXn6mU+twtf1lycvK0hISEcqML9VKEtblB5s+fz6ndu5PzxED8yXpaIxiJcvTYN/jlgf48+P73vPjNWtIThScu7sILqxX9+vXjsyl/5+0beq23h09uKnry593U1NS+zZs3Jzc3l02bNmUrpYYppd7dm+s0GPYWY2wMOyU2bmADdMS7A/xkj5peKR3vgSCSl90cuJjyUfD5wL+TMhvce80119zctGlTnnzySTZv3lwdY5Pm8/nyp06dSvPmzZk3bx533HEHQJJSaq9zu4iIr0Idw8DbLVu27L1q1aoF4dxNZ6DjidoC1rbcXE8wFLJycrZ95/9i0lENaqVM8FhS6+h73sKXXpuRXRtyS8/jdvp7hcUlJCfYfPbzJq5943tCoRBf3HyW6tA4c6o9fPKgsteLTtOdB/yulDKiloYDjjE2hsOSSF527Rlvzxpx+933P/DGG2/Qq1cvbNuOGxuAl5VSQ6o6VkQSbNte3axZsyYtW7bkmWee4ZJLLmHZsmW9lFKf7GO9EtBu3CcAdiBQaL/3wYcNz+3VM7t2ZmYR8DmwLDGjfrkHfmziED/a4SIxJxBiU0GI4xtl7NQzrSKrtmwnwbZoVtu3HRhoD5+8y/wwBsOBxhgbw2GLiFzSp0+fmePHj6eoqAjLsjj22GNZsmQJnTp1ove5Z8/Lzc31Db7mqm+vvXLAOkDl5eV7Ro65+9QmjRttqJ2Zkfv435+98q/33HP0L7/8wrIliyd89M7M19BDh8W4k//onD9t2ZEpsyLxm8hCOw0sAhYkZtTfowRfsYlD/os2VPtCGMiwh082k/KGQwpjbAyHLSLSEHgfaAMkJycnl+3ZrGrfvn3L3r178/jjj89VSp3rHtO3TZs272VkZLB69WpatWrFK6+8wuWXX06Lpo1u+tfkFxaj40Tin0R0XMxyIHdPDcieEJs45GLgVaohxLkTIsA0e/jkSlk6DYaDjXF9Nhy2KKU2oqVWEJGkWCxWPH36dNDDUY917NjxpRYtWoB2541TopRi+PDhNG3alOzsbG644QYWLVo0d9GiRc/PePudg5kJchbwGzqOaE8DbEELkt69X2tkMOwnTM/GcMQgIkOA09BqzL1Gjx49bMaMGaxbt66bUuobt4yFzqp5HjpJVw4wF5i6L84B+4vYxCGd0AG2VSki7Ioi4K/28Mk1mr/GYNhbjLExHJGIyFnoBF2fKaX+erDrsyfEJg65GniB6hucIrSC90B7+GRzQxsOSYyxMRgOQWITh1wETEPHGu1quLsImAjcaQ+fbFyaDYcsxtgYDIcosYlDWgJPAueivdziApghdOzTeuAWe/jkj6s+g8Fw6GCMjcFwiBObOKQhWm05C93LWY0br2OGzQyHC8bYGAwGg6HGsXZfxGAwGAyGfcMYG4PBYDDUOMbYGAwGg6HGMcbGYDAYDDWOMTYGg8FgqHGMsTEYDAZDjbNvQpzFWxVKgYoBCpSDXnfc9ZheR6Eqbitdjx9T8Ryx8tudCksV06l5y5ZTatfHOE6ZMmV+yym7ji5XWp7y5cqdB31upSAW0/tjZdbLbFdVbncg5ujzl106CuXWScWU24T6e7ltbjldlnL7qywXc1BKoaK67Zyorovjrse3K7e+ylE4bv2dmINyHH2O0qXer+L7lSJWul3p34g5OGX2O+7+WLwuFfaVlgWiurVLlzF0JOOeLMse7wD3KbU3ApcHhaQThiqxbCxPImLb2J5E9HqCXibodbHK7ksst8/2eBBLsG2r/NJjIRZVbxfB9ki57YkeC9sSbEtIcr8nemx3aWGLXnrKlK20tC0sERJswRYhwRIsy12KkGBb2AIJtoUl6DK2u8+ysC2wLcFCsC0Qt0y8bPl19HUIet0SBHepFOJE9f3mxBDl3ntOFBzH3Ve2TFSXicVAOaXbVbQEnBiqJAKOg4pWWJZE9P54ufgyFoNoCcqJ4ZREUTGndBkrKSldd2IOTiSKcvTScRycSMmO9dLjFLGSGE5M4UT0MlYSQ8Xceyri4MQcYiX6vo1F9D0ci+xYd5Qi4ihipUsqLHdsL1FVldPfn1drd3p/mZ6NwWAwGGocY2wMBoPBUOMYY2MwGAyGGscYG4PBYDDUOMbYGAwGg6HGMcbGYDAYDDWOMTYGg8FgqHGMsTEYDAZDjWOMjcFgMBhqHGNsDAaDwVDjGGNjMBgMhhrHGBuDwWAw1DjG2BgMBoOhxjHGxmAwGAw1jjE2BoPBYKhxjLExGAwGQ40jSqm9P1jkeqXUpP1Yn8Me0yaVMW1y8DBtXzWmXSpT022yrz2b6/dLLY4sTJtUxrTJwcO0fdWYdqlMjbaJGUYzGAwGQ41jjI3BYDAYapx9NTZmzLMypk0qY9rk4GHavmpMu1SmRttknxwEDAaDwWCoDmYYzWAwGAw1TrWMjYicJyI/icgqERlTxX4RkWfc/UtEpPP+r+qhxe7apEy5E0UkJiKXHsj6HQyq8X+SJiLvicgPIrJMRAYdjHoeyYhIpoh8LCK/uMuMXZS1ReR7EZl9IOt4oDDPrcoczOfWbo2NiNjAP4DzgWOBK0Tk2ArFzgdauZ/rgYn7q4KHItVsk3i5vwEfHdgaHniq2SY3AsuVUh2BM4BxIpJ4QCt65DMG+EQp1Qr4xF3fGbcCKw5IrQ4w5rlVmYP93KpOz+YkYJVSao1SKgK8DlxUocxFwCtK8w2QLiIN9mdFDzGq0yYANwNvAVsOZOUOEtVpEwX4RUQAH5ALRA9sNY94LgKmut+nAv2qKiQijYE+wEsHqF4HGvPcqsxBfW5Vx9g0AtaXWd/gbtvTMkcSu71eEWkEXAw8fwDrdTCpzv/Ac0A7YCPwI3CrUso5MNX7w1BPKbUJwF3W3Um5p4E7gCO1/c1zqzIH9bnlqUYZqWJbRRe26pQ5kqjO9T4N3KmUiukX+SOe6rTJucBioCdwDPCxiHyllNpe05U7khCReUD9KnaNrebxfYEtSqlFInLG/qzbIYR5blXmoD63qmNsNgBNyqw3Rr+Z7mmZI4nqXG8X0IMwNgAAA4dJREFU4HX3D1YH6C0iUaXUrANTxQNOddpkEPCY0v72q0TkV6At8O2BqeKRgVKq1872ichmEWmglNrkDglVNRTSHbhQRHoDyUAtEfmXUuqqGqrywcA8typzcJ9bSqldftAGaQ3QHEgEfgCOq1CmD/AB2nKeDHy7u/Mezp/qtEmF8v8ELj3Y9T7YbYKegL3P/V4P+B2oc7DrfiR9gCeAMe73McDjuyl/BjD7YNe7BtrBPLf2ok0qlN+vz63d9myUUlERuQntmWADLyullonIDe7+54H3gd7AKiCIfoM9Yqlmm/yhqGabPAj8U0R+RN/gdyqlth60Sh+ZPAbMEJEhwDqgP4CINAReUkr1PpiVO1CY51ZlDvZzyygIGAwGg6HGMQoCBoPBYKhxjLExGAwGQ41jjM0BRkT6VRW1W43jlIi8WmbdIyI5ZaVGROR8EVkoIitEZKWIPOluv09ERu+fKzAYDm3MvXJoYozNgacfWipiTykC2otIirt+NtqbCwARaY8OmrxKKdUOaI/2PDEY/miYe+UQxBib/YCIzBKRRa645PXutsIy+y8VkX+KyCnAhcATIrJYRI4RkSwR+cYVAvz3roQT0W6afdzvVwCvldl3B/CwUmolaM8TpdSE/XmdBsNhhLlXDjGMsdk/DFZKnYAOiLpFRGpXVUgp9TXwLnC7UipLKbUaeAXtAtwBLeFy7y5+53VggIgkAx2ABWX2tQcW7fulGAxHBOZeOcQwxmb/cIuI/AB8g47QbVWdg0QkDUhXSn3hbpoKnL6z8kqpJcDR6De19/elwgbDkYy5Vw49jLHZR1xtqV5AN6Wl879HS4CUDWBK3sNzNnGH2RbHA67K8C7wJOWHBQCWASfsye8YDEc45l45hDDGZt9JA/KUUkERaYuWvQDYLCLtRMRCq6jGCQB+AKVUAZAnIqe5+64GvlBKrXeH2bKqiOp9GXhAKfVjhe1PAHeJSGsAEbFE5Lb9dpUGw+GHuVcOIaojxGnYNR8CN4jIEuAn9FAaaF2q2WhJ76Xo/C2gx5JfFJFbgEuBa4HnRcSL9ojZpWSGUmoDML6K7UtE5M/Aa+65FDBnH6/NYDhsMffKoYWRqzEYDAZDjWOG0QwGg8FQ4xhjYzAYDIYaxxgbg8FgMNQ4xtgYDAaDocYxxsZgMBgMNY4xNgaDwWCocYyxMRgMBkONY4yNwWAwGGqc/wcs9invtODsFwAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -288,7 +288,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/tutorials/tigramite_tutorial_pcmciplus.ipynb b/tutorials/tigramite_tutorial_pcmciplus.ipynb index 2a5eba20..22371c62 100644 --- a/tutorials/tigramite_tutorial_pcmciplus.ipynb +++ b/tutorials/tigramite_tutorial_pcmciplus.ipynb @@ -214,7 +214,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -281,7 +281,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -455,7 +455,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{0}$ has 18 parent(s):\n", + " Variable $X^{0}$ has 18 link(s):\n", " ($X^{0}$ -1): max_pval = 0.00000, min_val = 0.997\n", " ($X^{0}$ -2): max_pval = 0.00000, min_val = 0.992\n", " ($X^{0}$ -3): max_pval = 0.00000, min_val = 0.984\n", @@ -554,7 +554,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{0}$ has 14 parent(s):\n", + " Variable $X^{0}$ has 14 link(s):\n", " ($X^{0}$ -1): max_pval = 0.00000, min_val = 0.846\n", " ($X^{1}$ -1): max_pval = 0.00000, min_val = 0.703\n", " ($X^{1}$ -2): max_pval = 0.00000, min_val = 0.659\n", @@ -633,7 +633,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{0}$ has 2 parent(s):\n", + " Variable $X^{0}$ has 2 link(s):\n", " ($X^{0}$ -1): max_pval = 0.00000, min_val = 0.846\n", " ($X^{1}$ -1): max_pval = 0.00000, min_val = 0.366\n", "\n", @@ -671,7 +671,13 @@ " Subset 0: () gives pval = 0.00000 / val = 0.860\n", " No conditions of dimension 0 left.\n", "\n", - " Link ($X^{2}$ -1) --> $X^{1}$ (7/27):\n", + " Link ($X^{2}$ -1) --> $X^{1}$ (7/27):\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ " Subset 0: () gives pval = 0.00000 / val = -0.371\n", " No conditions of dimension 0 left.\n", "\n", @@ -743,13 +749,7 @@ " Subset 0: () gives pval = 0.00963 / val = -0.116\n", " No conditions of dimension 0 left.\n", "\n", - " Link ($X^{8}$ -1) --> $X^{1}$ (25/27):\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + " Link ($X^{8}$ -1) --> $X^{1}$ (25/27):\n", " Subset 0: () gives pval = 0.39701 / val = -0.038\n", " Non-significance detected.\n", "\n", @@ -766,7 +766,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{1}$ has 18 parent(s):\n", + " Variable $X^{1}$ has 18 link(s):\n", " ($X^{1}$ -1): max_pval = 0.00000, min_val = 0.954\n", " ($X^{1}$ -2): max_pval = 0.00000, min_val = 0.906\n", " ($X^{1}$ -3): max_pval = 0.00000, min_val = 0.860\n", @@ -865,7 +865,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{1}$ has 1 parent(s):\n", + " Variable $X^{1}$ has 1 link(s):\n", " ($X^{1}$ -1): max_pval = 0.00000, min_val = 0.702\n", "\n", "Algorithm converged for variable $X^{1}$\n", @@ -991,7 +991,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{2}$ has 18 parent(s):\n", + " Variable $X^{2}$ has 18 link(s):\n", " ($X^{2}$ -1): max_pval = 0.00000, min_val = 1.000\n", " ($X^{4}$ -1): max_pval = 0.00000, min_val = 0.999\n", " ($X^{2}$ -2): max_pval = 0.00000, min_val = 0.998\n", @@ -1025,7 +1025,13 @@ " Subset 0: ($X^{2}$ -1) gives pval = 0.00000 / val = -0.928\n", " No conditions of dimension 1 left.\n", "\n", - " Link ($X^{4}$ -2) --> $X^{2}$ (4/18):\n", + " Link ($X^{4}$ -2) --> $X^{2}$ (4/18):\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ " Subset 0: ($X^{2}$ -1) gives pval = 0.00000 / val = 0.610\n", " No conditions of dimension 1 left.\n", "\n", @@ -1090,7 +1096,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{2}$ has 17 parent(s):\n", + " Variable $X^{2}$ has 17 link(s):\n", " ($X^{2}$ -3): max_pval = 0.00000, min_val = 0.937\n", " ($X^{2}$ -2): max_pval = 0.00000, min_val = 0.928\n", " ($X^{3}$ -3): max_pval = 0.00000, min_val = 0.914\n", @@ -1184,7 +1190,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{2}$ has 13 parent(s):\n", + " Variable $X^{2}$ has 13 link(s):\n", " ($X^{3}$ -1): max_pval = 0.00000, min_val = 0.841\n", " ($X^{2}$ -1): max_pval = 0.00000, min_val = 0.741\n", " ($X^{3}$ -2): max_pval = 0.00000, min_val = 0.703\n", @@ -1241,7 +1247,13 @@ " Subset 0: ($X^{3}$ -1) ($X^{2}$ -1) ($X^{3}$ -2) gives pval = 0.00000 / val = -0.216\n", " Still subsets of dimension 3 left, but q_max = 1 reached.\n", "\n", - " Link ($X^{0}$ -3) --> $X^{2}$ (11/13):\n", + " Link ($X^{0}$ -3) --> $X^{2}$ (11/13):\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ " Subset 0: ($X^{3}$ -1) ($X^{2}$ -1) ($X^{3}$ -2) gives pval = 0.10329 / val = 0.074\n", " Non-significance detected.\n", "\n", @@ -1258,7 +1270,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{2}$ has 6 parent(s):\n", + " Variable $X^{2}$ has 6 link(s):\n", " ($X^{2}$ -1): max_pval = 0.00000, min_val = 0.662\n", " ($X^{3}$ -1): max_pval = 0.00000, min_val = 0.528\n", " ($X^{1}$ -1): max_pval = 0.00000, min_val = 0.216\n", @@ -1297,7 +1309,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{2}$ has 2 parent(s):\n", + " Variable $X^{2}$ has 2 link(s):\n", " ($X^{2}$ -1): max_pval = 0.00000, min_val = 0.662\n", " ($X^{3}$ -1): max_pval = 0.00000, min_val = 0.411\n", "\n", @@ -1424,7 +1436,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{3}$ has 18 parent(s):\n", + " Variable $X^{3}$ has 18 link(s):\n", " ($X^{3}$ -1): max_pval = 0.00000, min_val = 0.997\n", " ($X^{3}$ -2): max_pval = 0.00000, min_val = 0.992\n", " ($X^{3}$ -3): max_pval = 0.00000, min_val = 0.985\n", @@ -1523,7 +1535,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{3}$ has 13 parent(s):\n", + " Variable $X^{3}$ has 13 link(s):\n", " ($X^{3}$ -1): max_pval = 0.00000, min_val = 0.865\n", " ($X^{1}$ -2): max_pval = 0.00000, min_val = 0.698\n", " ($X^{1}$ -1): max_pval = 0.00000, min_val = 0.659\n", @@ -1568,7 +1580,13 @@ " Subset 0: ($X^{3}$ -1) ($X^{1}$ -2) gives pval = 0.43627 / val = -0.035\n", " Non-significance detected.\n", "\n", - " Link ($X^{2}$ -1) --> $X^{3}$ (8/13):\n", + " Link ($X^{2}$ -1) --> $X^{3}$ (8/13):\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ " Subset 0: ($X^{3}$ -1) ($X^{1}$ -2) gives pval = 0.43166 / val = -0.036\n", " Non-significance detected.\n", "\n", @@ -1584,13 +1602,7 @@ " Subset 0: ($X^{3}$ -1) ($X^{1}$ -2) gives pval = 0.44618 / val = 0.034\n", " Non-significance detected.\n", "\n", - " Link ($X^{4}$ -3) --> $X^{3}$ (12/13):\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + " Link ($X^{4}$ -3) --> $X^{3}$ (12/13):\n", " Subset 0: ($X^{3}$ -1) ($X^{1}$ -2) gives pval = 0.43643 / val = 0.035\n", " Non-significance detected.\n", "\n", @@ -1603,7 +1615,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{3}$ has 2 parent(s):\n", + " Variable $X^{3}$ has 2 link(s):\n", " ($X^{3}$ -1): max_pval = 0.00000, min_val = 0.865\n", " ($X^{1}$ -2): max_pval = 0.00000, min_val = 0.345\n", "\n", @@ -1730,7 +1742,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{4}$ has 18 parent(s):\n", + " Variable $X^{4}$ has 18 link(s):\n", " ($X^{4}$ -1): max_pval = 0.00000, min_val = 1.000\n", " ($X^{2}$ -1): max_pval = 0.00000, min_val = 0.999\n", " ($X^{4}$ -2): max_pval = 0.00000, min_val = 0.998\n", @@ -1814,7 +1826,13 @@ "\n", " Link ($X^{7}$ -2) --> $X^{4}$ (16/18):\n", " Subset 0: ($X^{4}$ -1) gives pval = 0.00044 / val = 0.158\n", - " No conditions of dimension 1 left.\n", + " No conditions of dimension 1 left.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "\n", " Link ($X^{1}$ -1) --> $X^{4}$ (17/18):\n", " Subset 0: ($X^{4}$ -1) gives pval = 0.00000 / val = 0.684\n", @@ -1829,7 +1847,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{4}$ has 17 parent(s):\n", + " Variable $X^{4}$ has 17 link(s):\n", " ($X^{4}$ -3): max_pval = 0.00000, min_val = 0.937\n", " ($X^{4}$ -2): max_pval = 0.00000, min_val = 0.926\n", " ($X^{3}$ -3): max_pval = 0.00000, min_val = 0.914\n", @@ -1923,7 +1941,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{4}$ has 13 parent(s):\n", + " Variable $X^{4}$ has 13 link(s):\n", " ($X^{3}$ -1): max_pval = 0.00000, min_val = 0.852\n", " ($X^{4}$ -1): max_pval = 0.00000, min_val = 0.737\n", " ($X^{3}$ -2): max_pval = 0.00000, min_val = 0.710\n", @@ -1997,7 +2015,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{4}$ has 6 parent(s):\n", + " Variable $X^{4}$ has 6 link(s):\n", " ($X^{4}$ -1): max_pval = 0.00000, min_val = 0.637\n", " ($X^{3}$ -1): max_pval = 0.00000, min_val = 0.542\n", " ($X^{1}$ -2): max_pval = 0.00000, min_val = 0.264\n", @@ -2036,7 +2054,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{4}$ has 2 parent(s):\n", + " Variable $X^{4}$ has 2 link(s):\n", " ($X^{4}$ -1): max_pval = 0.00000, min_val = 0.637\n", " ($X^{3}$ -1): max_pval = 0.00000, min_val = 0.542\n", "\n", @@ -2163,7 +2181,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{5}$ has 3 parent(s):\n", + " Variable $X^{5}$ has 3 link(s):\n", " ($X^{5}$ -1): max_pval = 0.00000, min_val = 0.416\n", " ($X^{6}$ -1): max_pval = 0.00000, min_val = 0.283\n", " ($X^{6}$ -2): max_pval = 0.00000, min_val = 0.208\n", @@ -2187,7 +2205,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{5}$ has 2 parent(s):\n", + " Variable $X^{5}$ has 2 link(s):\n", " ($X^{5}$ -1): max_pval = 0.00000, min_val = 0.383\n", " ($X^{6}$ -1): max_pval = 0.00000, min_val = 0.224\n", "\n", @@ -2217,13 +2235,7 @@ " Subset 0: () gives pval = 0.01699 / val = 0.107\n", " Non-significance detected.\n", "\n", - " Link ($X^{1}$ -2) --> $X^{6}$ (5/27):\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + " Link ($X^{1}$ -2) --> $X^{6}$ (5/27):\n", " Subset 0: () gives pval = 0.01816 / val = 0.106\n", " Non-significance detected.\n", "\n", @@ -2279,7 +2291,13 @@ " Subset 0: () gives pval = 0.00035 / val = -0.160\n", " No conditions of dimension 0 left.\n", "\n", - " Link ($X^{6}$ -1) --> $X^{6}$ (19/27):\n", + " Link ($X^{6}$ -1) --> $X^{6}$ (19/27):\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ " Subset 0: () gives pval = 0.00000 / val = 0.454\n", " No conditions of dimension 0 left.\n", "\n", @@ -2320,7 +2338,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{6}$ has 6 parent(s):\n", + " Variable $X^{6}$ has 6 link(s):\n", " ($X^{6}$ -1): max_pval = 0.00000, min_val = 0.454\n", " ($X^{5}$ -2): max_pval = 0.00000, min_val = 0.295\n", " ($X^{5}$ -1): max_pval = 0.00000, min_val = 0.278\n", @@ -2359,7 +2377,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{6}$ has 3 parent(s):\n", + " Variable $X^{6}$ has 3 link(s):\n", " ($X^{6}$ -1): max_pval = 0.00000, min_val = 0.405\n", " ($X^{5}$ -1): max_pval = 0.00000, min_val = 0.278\n", " ($X^{5}$ -2): max_pval = 0.00001, min_val = 0.197\n", @@ -2383,7 +2401,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{6}$ has 2 parent(s):\n", + " Variable $X^{6}$ has 2 link(s):\n", " ($X^{6}$ -1): max_pval = 0.00000, min_val = 0.405\n", " ($X^{5}$ -1): max_pval = 0.00000, min_val = 0.278\n", "\n", @@ -2510,7 +2528,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{7}$ has 19 parent(s):\n", + " Variable $X^{7}$ has 19 link(s):\n", " ($X^{7}$ -1): max_pval = 0.00000, min_val = 0.939\n", " ($X^{7}$ -2): max_pval = 0.00000, min_val = 0.887\n", " ($X^{7}$ -3): max_pval = 0.00000, min_val = 0.838\n", @@ -2601,13 +2619,7 @@ " Subset 0: ($X^{7}$ -1) gives pval = 0.35285 / val = -0.042\n", " Non-significance detected.\n", "\n", - " Link ($X^{1}$ -1) --> $X^{7}$ (18/19):\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + " Link ($X^{1}$ -1) --> $X^{7}$ (18/19):\n", " Subset 0: ($X^{7}$ -1) gives pval = 0.35919 / val = -0.041\n", " Non-significance detected.\n", "\n", @@ -2620,7 +2632,7 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{7}$ has 1 parent(s):\n", + " Variable $X^{7}$ has 1 link(s):\n", " ($X^{7}$ -1): max_pval = 0.00000, min_val = 0.668\n", "\n", "Algorithm converged for variable $X^{7}$\n", @@ -2677,7 +2689,13 @@ " Subset 0: () gives pval = 0.19184 / val = -0.059\n", " Non-significance detected.\n", "\n", - " Link ($X^{3}$ -3) --> $X^{8}$ (12/27):\n", + " Link ($X^{3}$ -3) --> $X^{8}$ (12/27):\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ " Subset 0: () gives pval = 0.18215 / val = -0.060\n", " Non-significance detected.\n", "\n", @@ -2746,43 +2764,43 @@ "\n", "Updating parents:\n", "\n", - " Variable $X^{8}$ has 0 parent(s):\n", + " Variable $X^{8}$ has 0 link(s):\n", "\n", "Algorithm converged for variable $X^{8}$\n", "\n", "## Resulting lagged parent (super)sets:\n", "\n", - " Variable $X^{0}$ has 2 parent(s):\n", + " Variable $X^{0}$ has 2 link(s):\n", " ($X^{0}$ -1): max_pval = 0.00000, min_val = 0.846\n", " ($X^{1}$ -1): max_pval = 0.00000, min_val = 0.366\n", "\n", - " Variable $X^{1}$ has 1 parent(s):\n", + " Variable $X^{1}$ has 1 link(s):\n", " ($X^{1}$ -1): max_pval = 0.00000, min_val = 0.702\n", "\n", - " Variable $X^{2}$ has 2 parent(s):\n", + " Variable $X^{2}$ has 2 link(s):\n", " ($X^{2}$ -1): max_pval = 0.00000, min_val = 0.662\n", " ($X^{3}$ -1): max_pval = 0.00000, min_val = -0.411\n", "\n", - " Variable $X^{3}$ has 2 parent(s):\n", + " Variable $X^{3}$ has 2 link(s):\n", " ($X^{3}$ -1): max_pval = 0.00000, min_val = 0.865\n", " ($X^{1}$ -2): max_pval = 0.00000, min_val = 0.345\n", "\n", - " Variable $X^{4}$ has 2 parent(s):\n", + " Variable $X^{4}$ has 2 link(s):\n", " ($X^{4}$ -1): max_pval = 0.00000, min_val = 0.637\n", " ($X^{3}$ -1): max_pval = 0.00000, min_val = 0.542\n", "\n", - " Variable $X^{5}$ has 2 parent(s):\n", + " Variable $X^{5}$ has 2 link(s):\n", " ($X^{5}$ -1): max_pval = 0.00000, min_val = 0.383\n", " ($X^{6}$ -1): max_pval = 0.00000, min_val = 0.224\n", "\n", - " Variable $X^{6}$ has 2 parent(s):\n", + " Variable $X^{6}$ has 2 link(s):\n", " ($X^{6}$ -1): max_pval = 0.00000, min_val = 0.405\n", " ($X^{5}$ -1): max_pval = 0.00000, min_val = -0.278\n", "\n", - " Variable $X^{7}$ has 1 parent(s):\n", + " Variable $X^{7}$ has 1 link(s):\n", " ($X^{7}$ -1): max_pval = 0.00000, min_val = 0.668\n", "\n", - " Variable $X^{8}$ has 0 parent(s):\n", + " Variable $X^{8}$ has 0 link(s):\n", "\n", "##\n", "## Step 2: PC algorithm with contemp. conditions and MCI tests\n", @@ -3289,32 +3307,32 @@ "\n", "Updated contemp. adjacencies:\n", "\n", - " Variable $X^{0}$ has 0 parent(s):\n", + " Variable $X^{0}$ has 0 link(s):\n", "\n", - " Variable $X^{1}$ has 0 parent(s):\n", + " Variable $X^{1}$ has 0 link(s):\n", "\n", - " Variable $X^{2}$ has 2 parent(s):\n", + " Variable $X^{2}$ has 2 link(s):\n", " ($X^{3}$ 0): max_pval = 0.00000, min_val = 0.382\n", " ($X^{4}$ 0): max_pval = 0.00000, min_val = 0.243\n", "\n", - " Variable $X^{3}$ has 2 parent(s):\n", + " Variable $X^{3}$ has 2 link(s):\n", " ($X^{2}$ 0): max_pval = 0.00000, min_val = 0.382\n", " ($X^{4}$ 0): max_pval = 0.00000, min_val = 0.375\n", "\n", - " Variable $X^{4}$ has 2 parent(s):\n", + " Variable $X^{4}$ has 2 link(s):\n", " ($X^{3}$ 0): max_pval = 0.00000, min_val = 0.375\n", " ($X^{2}$ 0): max_pval = 0.00000, min_val = 0.243\n", "\n", - " Variable $X^{5}$ has 1 parent(s):\n", + " Variable $X^{5}$ has 1 link(s):\n", " ($X^{6}$ 0): max_pval = 0.00000, min_val = 0.292\n", "\n", - " Variable $X^{6}$ has 1 parent(s):\n", + " Variable $X^{6}$ has 1 link(s):\n", " ($X^{5}$ 0): max_pval = 0.00000, min_val = 0.292\n", "\n", - " Variable $X^{7}$ has 1 parent(s):\n", + " Variable $X^{7}$ has 1 link(s):\n", " ($X^{8}$ 0): max_pval = 0.00000, min_val = 0.342\n", "\n", - " Variable $X^{8}$ has 1 parent(s):\n", + " Variable $X^{8}$ has 1 link(s):\n", " ($X^{7}$ 0): max_pval = 0.00000, min_val = 0.342\n", "\n", "Testing contemporaneous condition sets of dimension 1: \n", @@ -3323,20 +3341,20 @@ " Iterate through 2 subset(s) of conditions: \n", " with conds_y = [ ($X^{3}$ -1) ]\n", " with conds_x = [ ($X^{1}$ -3) ]\n", - " Subset 0: ($X^{2}$ 0) gives pval = 0.00000 / val = 0.358\n", - " Subset 1: ($X^{4}$ 0) gives pval = 0.00000 / val = 0.358\n", - " No conditions of dimension 1 left.\n", - "\n", - " Link ($X^{2}$ -1) --> $X^{2}$ (2/17):\n", - " Iterate through 2 subset(s) of conditions: \n", - " with conds_y = [ ($X^{3}$ -1) ]\n", - " with conds_x = [ ($X^{2}$ -2) ($X^{3}$ -2) ]\n" + " Subset 0: ($X^{2}$ 0) gives pval = 0.00000 / val = 0.358\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ + " Subset 1: ($X^{4}$ 0) gives pval = 0.00000 / val = 0.358\n", + " No conditions of dimension 1 left.\n", + "\n", + " Link ($X^{2}$ -1) --> $X^{2}$ (2/17):\n", + " Iterate through 2 subset(s) of conditions: \n", + " with conds_y = [ ($X^{3}$ -1) ]\n", + " with conds_x = [ ($X^{2}$ -2) ($X^{3}$ -2) ]\n", " Subset 0: ($X^{3}$ 0) gives pval = 0.00000 / val = 0.696\n", " Subset 1: ($X^{4}$ 0) gives pval = 0.00000 / val = 0.663\n", " No conditions of dimension 1 left.\n", @@ -3446,30 +3464,30 @@ "\n", "Updated contemp. adjacencies:\n", "\n", - " Variable $X^{0}$ has 0 parent(s):\n", + " Variable $X^{0}$ has 0 link(s):\n", "\n", - " Variable $X^{1}$ has 0 parent(s):\n", + " Variable $X^{1}$ has 0 link(s):\n", "\n", - " Variable $X^{2}$ has 1 parent(s):\n", + " Variable $X^{2}$ has 1 link(s):\n", " ($X^{3}$ 0): max_pval = 0.00000, min_val = 0.381\n", "\n", - " Variable $X^{3}$ has 2 parent(s):\n", + " Variable $X^{3}$ has 2 link(s):\n", " ($X^{2}$ 0): max_pval = 0.00000, min_val = 0.381\n", " ($X^{4}$ 0): max_pval = 0.00000, min_val = 0.374\n", "\n", - " Variable $X^{4}$ has 1 parent(s):\n", + " Variable $X^{4}$ has 1 link(s):\n", " ($X^{3}$ 0): max_pval = 0.00000, min_val = 0.374\n", "\n", - " Variable $X^{5}$ has 1 parent(s):\n", + " Variable $X^{5}$ has 1 link(s):\n", " ($X^{6}$ 0): max_pval = 0.00000, min_val = 0.292\n", "\n", - " Variable $X^{6}$ has 1 parent(s):\n", + " Variable $X^{6}$ has 1 link(s):\n", " ($X^{5}$ 0): max_pval = 0.00000, min_val = 0.292\n", "\n", - " Variable $X^{7}$ has 1 parent(s):\n", + " Variable $X^{7}$ has 1 link(s):\n", " ($X^{8}$ 0): max_pval = 0.00000, min_val = 0.342\n", "\n", - " Variable $X^{8}$ has 1 parent(s):\n", + " Variable $X^{8}$ has 1 link(s):\n", " ($X^{7}$ 0): max_pval = 0.00000, min_val = 0.342\n", "\n", "Testing contemporaneous condition sets of dimension 2: \n", @@ -3490,30 +3508,30 @@ "\n", "Updated contemp. adjacencies:\n", "\n", - " Variable $X^{0}$ has 0 parent(s):\n", + " Variable $X^{0}$ has 0 link(s):\n", "\n", - " Variable $X^{1}$ has 0 parent(s):\n", + " Variable $X^{1}$ has 0 link(s):\n", "\n", - " Variable $X^{2}$ has 1 parent(s):\n", + " Variable $X^{2}$ has 1 link(s):\n", " ($X^{3}$ 0): max_pval = 0.00000, min_val = 0.381\n", "\n", - " Variable $X^{3}$ has 2 parent(s):\n", + " Variable $X^{3}$ has 2 link(s):\n", " ($X^{2}$ 0): max_pval = 0.00000, min_val = 0.381\n", " ($X^{4}$ 0): max_pval = 0.00000, min_val = 0.374\n", "\n", - " Variable $X^{4}$ has 1 parent(s):\n", + " Variable $X^{4}$ has 1 link(s):\n", " ($X^{3}$ 0): max_pval = 0.00000, min_val = 0.374\n", "\n", - " Variable $X^{5}$ has 1 parent(s):\n", + " Variable $X^{5}$ has 1 link(s):\n", " ($X^{6}$ 0): max_pval = 0.00000, min_val = 0.292\n", "\n", - " Variable $X^{6}$ has 1 parent(s):\n", + " Variable $X^{6}$ has 1 link(s):\n", " ($X^{5}$ 0): max_pval = 0.00000, min_val = 0.292\n", "\n", - " Variable $X^{7}$ has 1 parent(s):\n", + " Variable $X^{7}$ has 1 link(s):\n", " ($X^{8}$ 0): max_pval = 0.00000, min_val = 0.342\n", "\n", - " Variable $X^{8}$ has 1 parent(s):\n", + " Variable $X^{8}$ has 1 link(s):\n", " ($X^{7}$ 0): max_pval = 0.00000, min_val = 0.342\n", "\n", "Algorithm converged at p = 2.\n", @@ -3623,39 +3641,39 @@ "\n", "Updated adjacencies:\n", "\n", - " Variable $X^{0}$ has 2 parent(s):\n", + " Variable $X^{0}$ has 2 link(s):\n", " ($X^{0}$ -1)\n", " ($X^{1}$ -1)\n", "\n", - " Variable $X^{1}$ has 1 parent(s):\n", + " Variable $X^{1}$ has 1 link(s):\n", " ($X^{1}$ -1)\n", "\n", - " Variable $X^{2}$ has 2 parent(s):\n", + " Variable $X^{2}$ has 2 link(s):\n", " ($X^{2}$ -1)\n", " ($X^{3}$ 0)\n", "\n", - " Variable $X^{3}$ has 2 parent(s):\n", + " Variable $X^{3}$ has 2 link(s):\n", " ($X^{1}$ -2)\n", " ($X^{3}$ -1)\n", "\n", - " Variable $X^{4}$ has 2 parent(s):\n", + " Variable $X^{4}$ has 2 link(s):\n", " ($X^{3}$ 0)\n", " ($X^{4}$ -1)\n", "\n", - " Variable $X^{5}$ has 2 parent(s):\n", + " Variable $X^{5}$ has 2 link(s):\n", " ($X^{5}$ -1)\n", " ($X^{6}$ 0)\n", "\n", - " Variable $X^{6}$ has 3 parent(s):\n", + " Variable $X^{6}$ has 3 link(s):\n", " ($X^{5}$ 0)\n", " ($X^{5}$ -1)\n", " ($X^{6}$ -1)\n", "\n", - " Variable $X^{7}$ has 2 parent(s):\n", + " Variable $X^{7}$ has 2 link(s):\n", " ($X^{7}$ -1)\n", " ($X^{8}$ 0)\n", "\n", - " Variable $X^{8}$ has 0 parent(s):\n", + " Variable $X^{8}$ has 0 link(s):\n", "\n", "\n", "----------------------------\n", @@ -3669,38 +3687,38 @@ "\n", "Updated adjacencies:\n", "\n", - " Variable $X^{0}$ has 2 parent(s):\n", + " Variable $X^{0}$ has 2 link(s):\n", " ($X^{0}$ -1)\n", " ($X^{1}$ -1)\n", "\n", - " Variable $X^{1}$ has 1 parent(s):\n", + " Variable $X^{1}$ has 1 link(s):\n", " ($X^{1}$ -1)\n", "\n", - " Variable $X^{2}$ has 2 parent(s):\n", + " Variable $X^{2}$ has 2 link(s):\n", " ($X^{2}$ -1)\n", " ($X^{3}$ 0)\n", "\n", - " Variable $X^{3}$ has 2 parent(s):\n", + " Variable $X^{3}$ has 2 link(s):\n", " ($X^{1}$ -2)\n", " ($X^{3}$ -1)\n", "\n", - " Variable $X^{4}$ has 2 parent(s):\n", + " Variable $X^{4}$ has 2 link(s):\n", " ($X^{3}$ 0)\n", " ($X^{4}$ -1)\n", "\n", - " Variable $X^{5}$ has 2 parent(s):\n", + " Variable $X^{5}$ has 2 link(s):\n", " ($X^{5}$ -1)\n", " ($X^{6}$ 0)\n", "\n", - " Variable $X^{6}$ has 2 parent(s):\n", + " Variable $X^{6}$ has 2 link(s):\n", " ($X^{5}$ -1)\n", " ($X^{6}$ -1)\n", "\n", - " Variable $X^{7}$ has 2 parent(s):\n", + " Variable $X^{7}$ has 2 link(s):\n", " ($X^{7}$ -1)\n", " ($X^{8}$ 0)\n", "\n", - " Variable $X^{8}$ has 0 parent(s):\n", + " Variable $X^{8}$ has 0 link(s):\n", "\n", "-----------------------------\n", "PCMCIplus algorithm finished.\n", @@ -4064,7 +4082,7 @@ "metadata": {}, "outputs": [], "source": [ - "q_matrix = pcmci.get_corrected_pvalues(p_matrix=results['p_matrix'], fdr_method='fdr_bh',\n", + "q_matrix = pcmci.get_corrected_pvalues(p_matrix=results['p_matrix'], tau_max=tau_max, fdr_method='fdr_bh',\n", " exclude_contemporaneous=False)" ] }, @@ -4117,7 +4135,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -4154,7 +4172,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -4206,7 +4224,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -4262,7 +4280,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -4307,7 +4325,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/tutorials/tigramite_tutorial_prediction.ipynb b/tutorials/tigramite_tutorial_prediction.ipynb index 1fe09cb0..f23a2ebb 100644 --- a/tutorials/tigramite_tutorial_prediction.ipynb +++ b/tutorials/tigramite_tutorial_prediction.ipynb @@ -24,7 +24,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -56,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -80,7 +80,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -105,7 +105,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -129,17 +129,17 @@ "\n", "## Resulting lagged parent (super)sets:\n", "\n", - " Variable 0 has 1 parent(s):\n", + " Variable 0 has 1 link(s):\n", " [pc_alpha = 0.05]\n", " (0 -1): max_pval = 0.00000, min_val = 0.485\n", "\n", - " Variable 1 has 3 parent(s):\n", + " Variable 1 has 3 link(s):\n", " [pc_alpha = 0.3]\n", " (1 -1): max_pval = 0.00000, min_val = 0.671\n", " (0 -1): max_pval = 0.00000, min_val = 0.622\n", " (0 -4): max_pval = 0.24260, min_val = 0.113\n", "\n", - " Variable 2 has 4 parent(s):\n", + " Variable 2 has 4 link(s):\n", " [pc_alpha = 0.2]\n", " (2 -1): max_pval = 0.00000, min_val = 0.558\n", " (1 -1): max_pval = 0.00000, min_val = 0.467\n", @@ -149,7 +149,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -194,7 +194,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -218,7 +218,7 @@ "\n", "## Resulting lagged parent (super)sets:\n", "\n", - " Variable 0 has 6 parent(s):\n", + " Variable 0 has 6 link(s):\n", " [pc_alpha = 0.5]\n", " (0 -26): max_pval = 0.13044, min_val = -0.199\n", " (0 -18): max_pval = 0.17469, min_val = -0.187\n", @@ -227,7 +227,7 @@ " (0 -29): max_pval = 0.39563, min_val = -0.114\n", " (2 -2): max_pval = 0.48642, min_val = -0.092\n", "\n", - " Variable 1 has 9 parent(s):\n", + " Variable 1 has 9 link(s):\n", " [pc_alpha = 0.5]\n", " (0 -2): max_pval = 0.00007, min_val = 0.494\n", " (0 -4): max_pval = 0.03531, min_val = 0.277\n", @@ -239,7 +239,7 @@ " (0 -5): max_pval = 0.40215, min_val = 0.112\n", " (0 -22): max_pval = 0.43156, min_val = 0.103\n", "\n", - " Variable 2 has 9 parent(s):\n", + " Variable 2 has 9 link(s):\n", " [pc_alpha = 0.5]\n", " (1 -2): max_pval = 0.00000, min_val = 0.598\n", " (0 -2): max_pval = 0.00057, min_val = 0.432\n", @@ -254,7 +254,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -303,16 +303,16 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 27, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -332,7 +332,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -347,7 +347,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -379,7 +379,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -394,7 +394,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -427,7 +427,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -481,7 +481,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -496,7 +496,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -542,7 +542,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -567,21 +567,20 @@ "\n", "## Resulting lagged parent (super)sets:\n", "\n", - " Variable 0 has 2 parent(s):\n", - " (0 -2): max_pval = 0.00000, min_val = 0.135\n", - " (2 -3): max_pval = 0.19300, min_val = 0.008\n", + " Variable 0 has 1 link(s):\n", + " (0 -2): max_pval = 0.00000, min_val = 0.368\n", "\n", - " Variable 1 has 4 parent(s):\n", - " (0 -2): max_pval = 0.00000, min_val = 0.461\n", - " (1 -2): max_pval = 0.00000, min_val = 0.287\n", - " (2 -7): max_pval = 0.14300, min_val = 0.009\n", - " (0 -8): max_pval = 0.19800, min_val = 0.008\n", + " Variable 1 has 4 link(s):\n", + " (0 -2): max_pval = 0.00000, min_val = 0.679\n", + " (1 -2): max_pval = 0.00000, min_val = 0.536\n", + " (2 -7): max_pval = 0.16800, min_val = 0.098\n", + " (2 -2): max_pval = 0.16900, min_val = 0.098\n", "\n", - " Variable 2 has 4 parent(s):\n", - " (1 -2): max_pval = 0.00000, min_val = 0.635\n", - " (0 -2): max_pval = 0.00000, min_val = 0.259\n", - " (2 -2): max_pval = 0.00000, min_val = 0.387\n", - " (0 -4): max_pval = 0.13600, min_val = 0.010\n", + " Variable 2 has 4 link(s):\n", + " (1 -2): max_pval = 0.00000, min_val = 0.797\n", + " (0 -2): max_pval = 0.00000, min_val = 0.509\n", + " (2 -2): max_pval = 0.00000, min_val = 0.622\n", + " (0 -4): max_pval = 0.16900, min_val = 0.098\n", "\n", "##\n", "## Predicting target 2\n", @@ -590,7 +589,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] From 20b144060748a64fe71a73c45d610bf26d57ee15 Mon Sep 17 00:00:00 2001 From: jakobrunge Date: Fri, 14 May 2021 18:24:14 +0200 Subject: [PATCH 5/6] fixes on consistency of selected_links, random seed handling, distance correlation fixed GPDCtorch memory issue fixed --- tigramite/independence_tests/LBFGS.py | 38 +- tigramite/pcmci.py | 17 +- tigramite/plotting.py | 32 - tigramite/tigramite_cython_code.c | 15192 +++++++++--------------- 4 files changed, 5920 insertions(+), 9359 deletions(-) diff --git a/tigramite/independence_tests/LBFGS.py b/tigramite/independence_tests/LBFGS.py index 3f344c22..74dadff2 100644 --- a/tigramite/independence_tests/LBFGS.py +++ b/tigramite/independence_tests/LBFGS.py @@ -1,6 +1,30 @@ +""" +MIT License + +Copyright (c) 2017 Jake Gardner + +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. +""" + import torch import numpy as np -import matplotlib.pyplot as plt +# import matplotlib.pyplot as plt from functools import reduce from copy import deepcopy from torch.optim import Optimizer @@ -140,12 +164,12 @@ def polyinterp(points, x_min_bound=None, x_max_bound=None, plot=False): x_sol = np.real(crit_pt) f_min = np.real(F_cp) - if plot: - plt.figure() - x = np.arange(x_min_bound, x_max_bound, (x_max_bound - x_min_bound) / 10000) - f = np.polyval(coeff, x) - plt.plot(x, f) - plt.plot(x_sol, f_min, "x") + # if plot: + # plt.figure() + # x = np.arange(x_min_bound, x_max_bound, (x_max_bound - x_min_bound) / 10000) + # f = np.polyval(coeff, x) + # plt.plot(x, f) + # plt.plot(x_sol, f_min, "x") return x_sol diff --git a/tigramite/pcmci.py b/tigramite/pcmci.py index f1ac8e61..54f6d65a 100644 --- a/tigramite/pcmci.py +++ b/tigramite/pcmci.py @@ -1360,9 +1360,10 @@ def get_corrected_pvalues(self, p_matrix, p_matrix : array-like Matrix of p-values. Must be of shape (N, N, tau_max + 1). tau_min : int, default: 0 - Minimum time lag to test. Note that zero-lags are undirected. + Minimum time lag. Only used as consistency check of selected_links. tau_max : int, default: 1 - Maximum time lag. Must be larger or equal to tau_min. + Maximum time lag. Must be larger or equal to tau_min. Only used as + consistency check of selected_links. selected_links : dict or None Dictionary of form {0: [(3, -2), ...], 1:[], ...} specifying whether only selected links should be tested. If None is @@ -1385,7 +1386,7 @@ def _ecdf(x): nobs = len(x) return np.arange(1, nobs + 1) / float(nobs) - # Get the shape paramters from the p_matrix + # Get the shape parameters from the p_matrix _, N, tau_max_plusone = p_matrix.shape # Check the limits on tau self._check_tau_limits(tau_min, tau_max) @@ -1819,7 +1820,9 @@ def run_pcmci(self, # Initialize and fill the q_matrix if there is a fdr_method q_matrix = None if fdr_method != 'none': - q_matrix = self.get_corrected_pvalues(p_matrix, tau_min, tau_max, + q_matrix = self.get_corrected_pvalues(p_matrix=p_matrix, tau_min=tau_min, + tau_max=tau_max, + selected_links=selected_links, fdr_method=fdr_method) # Store the parents in the pcmci member self.all_parents = all_parents @@ -2176,11 +2179,13 @@ def run_pcmciplus(self, # Initialize and fill the q_matrix if there is a fdr_method q_matrix = None if fdr_method != 'none': - q_matrix = self.get_corrected_pvalues(p_matrix, tau_min, tau_max, + q_matrix = self.get_corrected_pvalues(p_matrix=p_matrix, tau_min=tau_min, + tau_max=tau_max, + selected_links=selected_links, fdr_method=fdr_method, exclude_contemporaneous=False) # Store the parents in the pcmci member - self.all_parents = lagged_parents + self.all_lagged_parents = lagged_parents # Cache the resulting values in the return dictionary return_dict = {'graph': graph, diff --git a/tigramite/plotting.py b/tigramite/plotting.py index 9342c48c..fb12c6d5 100644 --- a/tigramite/plotting.py +++ b/tigramite/plotting.py @@ -3134,38 +3134,6 @@ def _links_to_tsg(link_coeffs, max_lag=None): network_lower_bound=network_lower_bound, inner_edge_style=inner_edge_style, ) - # _draw_network_with_curved_edges( - # fig=fig, - # ax=ax, - # G=deepcopy(G), - # pos=pos, - # # dictionary of rings: {0:{'sizes':(N,)-array, 'color_array':(N,)-array - # # or None, 'cmap':string, - # node_rings=node_rings, - # # 'vmin':float or None, 'vmax':float or None, 'label':string or None}} - # node_labels=node_labels, - # node_label_size=node_label_size, - # node_alpha=alpha, - # standard_size=node_size, - # node_aspect=None, - # standard_cmap="OrRd", - # standard_color="lightgrey", - # log_sizes=False, - # cmap_links=cmap_edges, - # links_vmin=vmin_edges, - # links_vmax=vmax_edges, - # links_ticks=edge_ticks, - # arrowstyle="simple", - # arrowhead_size=arrowhead_size, - # curved_radius=curved_radius, - # label_fontsize=label_fontsize, - # label_fraction=0.5, - # link_colorbar_label=link_colorbar_label, - # inner_edge_curved=True, - # network_lower_bound=network_lower_bound, - # inner_edge_style=inner_edge_style, - # show_colorbar=False, - # ) for i in range(N): trans = transforms.blended_transform_factory(fig.transFigure, ax.transData) diff --git a/tigramite/tigramite_cython_code.c b/tigramite/tigramite_cython_code.c index 5e504a5a..1417da44 100644 --- a/tigramite/tigramite_cython_code.c +++ b/tigramite/tigramite_cython_code.c @@ -6,7 +6,7 @@ "depends": [], "name": "tigramite.tigramite_cython_code", "sources": [ - "/home/rung_ja/work/code/python_code/tigramite/tigramite_v4/tigramite/tigramite/tigramite_cython_code.pyx" + "tigramite/tigramite_cython_code.pyx" ] }, "module_name": "tigramite.tigramite_cython_code" @@ -908,6 +908,18 @@ typedef volatile __pyx_atomic_int_type __pyx_atomic_int; __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) #endif +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + +/* NoFastGil.proto */ +#define __Pyx_PyGILState_Ensure PyGILState_Ensure +#define __Pyx_PyGILState_Release PyGILState_Release +#define __Pyx_FastGIL_Remember() +#define __Pyx_FastGIL_Forget() +#define __Pyx_FastGilFuncInit() + /* BufferFormatStructs.proto */ #define IS_UNSIGNED(type) (((type) -1) > 0) struct __Pyx_StructField_; @@ -944,18 +956,6 @@ typedef struct { char is_valid_array; } __Pyx_BufFmt_Context; -/* NoFastGil.proto */ -#define __Pyx_PyGILState_Ensure PyGILState_Ensure -#define __Pyx_PyGILState_Release PyGILState_Release -#define __Pyx_FastGIL_Remember() -#define __Pyx_FastGIL_Forget() -#define __Pyx_FastGilFuncInit() - -/* ForceInitThreads.proto */ -#ifndef __PYX_FORCE_INIT_THREADS - #define __PYX_FORCE_INIT_THREADS 0 -#endif - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":776 * # in Cython to enable them only on the right systems. @@ -1145,15 +1145,6 @@ typedef npy_double __pyx_t_5numpy_double_t; * ctypedef npy_cfloat cfloat_t */ typedef npy_longdouble __pyx_t_5numpy_longdouble_t; - -/* "tigramite/tigramite_cython_code.pyx":215 - * - * - * ctypedef np.double_t DTYPE_t # <<<<<<<<<<<<<< - * - * def dcov_all(x, y): - */ -typedef __pyx_t_5numpy_double_t __pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t; /* Declarations.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus @@ -1597,82 +1588,6 @@ static void __Pyx_WriteUnraisable(const char *name, int clineno, int lineno, const char *filename, int full_traceback, int nogil); -/* pyobject_as_double.proto */ -static double __Pyx__PyObject_AsDouble(PyObject* obj); -#if CYTHON_COMPILING_IN_PYPY -#define __Pyx_PyObject_AsDouble(obj)\ -(likely(PyFloat_CheckExact(obj)) ? PyFloat_AS_DOUBLE(obj) :\ - likely(PyInt_CheckExact(obj)) ?\ - PyFloat_AsDouble(obj) : __Pyx__PyObject_AsDouble(obj)) -#else -#define __Pyx_PyObject_AsDouble(obj)\ -((likely(PyFloat_CheckExact(obj))) ?\ - PyFloat_AS_DOUBLE(obj) : __Pyx__PyObject_AsDouble(obj)) -#endif - -/* PyObjectCallNoArg.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); -#else -#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) -#endif - -/* PyObjectSetAttrStr.proto */ -#if CYTHON_USE_TYPE_SLOTS -#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o, n, NULL) -static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value); -#else -#define __Pyx_PyObject_DelAttrStr(o,n) PyObject_DelAttr(o,n) -#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) -#endif - -/* GetItemInt.proto */ -#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ - (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ - __Pyx_GetItemInt_Generic(o, to_py_func(i)))) -#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ - (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, - int wraparound, int boundscheck); -#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ - (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, - int wraparound, int boundscheck); -static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, - int is_list, int wraparound, int boundscheck); - -/* ExtTypeTest.proto */ -static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); - -/* IsLittleEndian.proto */ -static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); - -/* BufferFormatCheck.proto */ -static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); -static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, - __Pyx_BufFmt_StackElem* stack, - __Pyx_TypeInfo* type); - -/* BufferGetAndValidate.proto */ -#define __Pyx_GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)\ - ((obj == Py_None || obj == NULL) ?\ - (__Pyx_ZeroBuffer(buf), 0) :\ - __Pyx__GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)) -static int __Pyx__GetBufferAndValidate(Py_buffer* buf, PyObject* obj, - __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); -static void __Pyx_ZeroBuffer(Py_buffer* buf); -static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); -static Py_ssize_t __Pyx_minusones[] = { -1, -1, -1, -1, -1, -1, -1, -1 }; -static Py_ssize_t __Pyx_zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; - -#define __Pyx_BufPtrStrided1d(type, buf, i0, s0) (type)((char*)buf + i0 * s0) /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); @@ -1696,6 +1611,9 @@ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); /* RaiseNoneIterError.proto */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); @@ -1762,6 +1680,28 @@ static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *); /*proto*/ /* GetAttr.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound, int boundscheck); + /* ObjectGetItem.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key); @@ -1915,83 +1855,6 @@ enum __Pyx_ImportType_CheckSize { static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); #endif -/* FetchCommonType.proto */ -static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); - -/* CythonFunction.proto */ -#define __Pyx_CyFunction_USED 1 -#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 -#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 -#define __Pyx_CYFUNCTION_CCLASS 0x04 -#define __Pyx_CyFunction_GetClosure(f)\ - (((__pyx_CyFunctionObject *) (f))->func_closure) -#define __Pyx_CyFunction_GetClassObj(f)\ - (((__pyx_CyFunctionObject *) (f))->func_classobj) -#define __Pyx_CyFunction_Defaults(type, f)\ - ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) -#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ - ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) -typedef struct { - PyCFunctionObject func; -#if PY_VERSION_HEX < 0x030500A0 - PyObject *func_weakreflist; -#endif - PyObject *func_dict; - PyObject *func_name; - PyObject *func_qualname; - PyObject *func_doc; - PyObject *func_globals; - PyObject *func_code; - PyObject *func_closure; - PyObject *func_classobj; - void *defaults; - int defaults_pyobjects; - int flags; - PyObject *defaults_tuple; - PyObject *defaults_kwdict; - PyObject *(*defaults_getter)(PyObject *); - PyObject *func_annotations; -} __pyx_CyFunctionObject; -static PyTypeObject *__pyx_CyFunctionType = 0; -#define __Pyx_CyFunction_Check(obj) (__Pyx_TypeCheck(obj, __pyx_CyFunctionType)) -#define __Pyx_CyFunction_NewEx(ml, flags, qualname, self, module, globals, code)\ - __Pyx_CyFunction_New(__pyx_CyFunctionType, ml, flags, qualname, self, module, globals, code) -static PyObject *__Pyx_CyFunction_New(PyTypeObject *, PyMethodDef *ml, - int flags, PyObject* qualname, - PyObject *self, - PyObject *module, PyObject *globals, - PyObject* code); -static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, - size_t size, - int pyobjects); -static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, - PyObject *tuple); -static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, - PyObject *dict); -static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, - PyObject *dict); -static int __pyx_CyFunction_init(void); - -/* SetNameInClass.proto */ -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 -#define __Pyx_SetNameInClass(ns, name, value)\ - (likely(PyDict_CheckExact(ns)) ? _PyDict_SetItem_KnownHash(ns, name, value, ((PyASCIIObject *) name)->hash) : PyObject_SetItem(ns, name, value)) -#elif CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_SetNameInClass(ns, name, value)\ - (likely(PyDict_CheckExact(ns)) ? PyDict_SetItem(ns, name, value) : PyObject_SetItem(ns, name, value)) -#else -#define __Pyx_SetNameInClass(ns, name, value) PyObject_SetItem(ns, name, value) -#endif - -/* CalculateMetaclass.proto */ -static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases); - -/* Py3ClassCreate.proto */ -static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname, - PyObject *mkw, PyObject *modname, PyObject *doc); -static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, - PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass); - /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) @@ -2052,6 +1915,15 @@ static int __pyx_slices_overlap(__Pyx_memviewslice *slice1, /* Capsule.proto */ static CYTHON_INLINE PyObject *__pyx_capsule_create(void *p, const char *sig); +/* IsLittleEndian.proto */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); + +/* BufferFormatCheck.proto */ +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type); + /* TypeInfoCompare.proto */ static int __pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b); @@ -2092,9 +1964,6 @@ static CYTHON_INLINE int __pyx_memview_set_int(const char *itemp, PyObject *obj) static CYTHON_INLINE PyObject *__pyx_memview_get_double(const char *itemp); static CYTHON_INLINE int __pyx_memview_set_double(const char *itemp, PyObject *obj); -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value); - /* RealImag.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus @@ -2206,9 +2075,6 @@ __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); -/* CIntFromPy.proto */ -static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *); - /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); @@ -2313,7 +2179,6 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *, Py_ssize_t *, Py_ static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *, int, size_t, void *, int); /*proto*/ static void __pyx_memoryview__slice_assign_scalar(char *, Py_ssize_t *, Py_ssize_t *, int, size_t, void *); /*proto*/ static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *, PyObject *); /*proto*/ -static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t = { "DTYPE_t", NULL, sizeof(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t), { 0 }, 0, 'R', 0, 0 }; static __Pyx_TypeInfo __Pyx_TypeInfo_double = { "double", NULL, sizeof(double), { 0 }, 0, 'R', 0, 0 }; static __Pyx_TypeInfo __Pyx_TypeInfo_int = { "int", NULL, sizeof(int), { 0 }, 0, IS_UNSIGNED(int) ? 'U' : 'I', IS_UNSIGNED(int), 0 }; #define __Pyx_MODULE_NAME "tigramite.tigramite_cython_code" @@ -2343,26 +2208,14 @@ static const char __pyx_k_n[] = "n"; static const char __pyx_k_p[] = "p"; static const char __pyx_k_t[] = "t"; static const char __pyx_k_v[] = "v"; -static const char __pyx_k_x[] = "x"; -static const char __pyx_k_y[] = "y"; -static const char __pyx_k_dc[] = "dc"; -static const char __pyx_k_dr[] = "dr"; static const char __pyx_k_dx[] = "dx"; static const char __pyx_k_dy[] = "dy"; static const char __pyx_k_dz[] = "dz"; static const char __pyx_k_id[] = "id"; -static const char __pyx_k_ii[] = "ii"; -static const char __pyx_k_jj[] = "jj"; static const char __pyx_k_kz[] = "kz"; static const char __pyx_k_np[] = "np"; -static const char __pyx_k_D_N[] = "D_N"; static const char __pyx_k_ave[] = "ave"; static const char __pyx_k_dim[] = "dim"; -static const char __pyx_k_dnx[] = "dnx"; -static const char __pyx_k_dny[] = "dny"; -static const char __pyx_k_doc[] = "__doc__"; -static const char __pyx_k_dvx[] = "dvx"; -static const char __pyx_k_dvy[] = "dvy"; static const char __pyx_k_fac[] = "fac"; static const char __pyx_k_k_z[] = "k_z"; static const char __pyx_k_kxz[] = "kxz"; @@ -2375,21 +2228,16 @@ static const char __pyx_k_use[] = "use"; static const char __pyx_k_var[] = "var"; static const char __pyx_k_base[] = "base"; static const char __pyx_k_dict[] = "__dict__"; -static const char __pyx_k_dist[] = "dist"; -static const char __pyx_k_init[] = "__init__"; static const char __pyx_k_k_xz[] = "k_xz"; static const char __pyx_k_k_yz[] = "k_yz"; static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_mask[] = "mask"; -static const char __pyx_k_mean[] = "mean"; static const char __pyx_k_mode[] = "mode"; static const char __pyx_k_name[] = "name"; static const char __pyx_k_ndim[] = "ndim"; static const char __pyx_k_pack[] = "pack"; static const char __pyx_k_patt[] = "patt"; -static const char __pyx_k_self[] = "self"; static const char __pyx_k_size[] = "size"; -static const char __pyx_k_sqrt[] = "sqrt"; static const char __pyx_k_step[] = "step"; static const char __pyx_k_stop[] = "stop"; static const char __pyx_k_test[] = "__test__"; @@ -2398,7 +2246,6 @@ static const char __pyx_k_ASCII[] = "ASCII"; static const char __pyx_k_array[] = "array"; static const char __pyx_k_class[] = "__class__"; static const char __pyx_k_count[] = "count"; -static const char __pyx_k_denom[] = "denom"; static const char __pyx_k_dim_x[] = "dim_x"; static const char __pyx_k_dim_y[] = "dim_y"; static const char __pyx_k_dtype[] = "dtype"; @@ -2409,23 +2256,14 @@ static const char __pyx_k_index[] = "index"; static const char __pyx_k_int32[] = "int32"; static const char __pyx_k_numpy[] = "numpy"; static const char __pyx_k_order[] = "order"; -static const char __pyx_k_other[] = "other"; static const char __pyx_k_range[] = "range"; static const char __pyx_k_shape[] = "shape"; static const char __pyx_k_start[] = "start"; -static const char __pyx_k_sum_0[] = "sum_0"; -static const char __pyx_k_sum_1[] = "sum_1"; -static const char __pyx_k_value[] = "value"; static const char __pyx_k_zeros[] = "zeros"; -static const char __pyx_k_d_here[] = "d_here"; -static const char __pyx_k_double[] = "double"; static const char __pyx_k_encode[] = "encode"; static const char __pyx_k_epsmax[] = "epsmax"; static const char __pyx_k_format[] = "format"; static const char __pyx_k_import[] = "__import__"; -static const char __pyx_k_mean_0[] = "mean_0"; -static const char __pyx_k_mean_1[] = "mean_1"; -static const char __pyx_k_module[] = "__module__"; static const char __pyx_k_name_2[] = "__name__"; static const char __pyx_k_pickle[] = "pickle"; static const char __pyx_k_random[] = "random"; @@ -2435,56 +2273,37 @@ static const char __pyx_k_timeit[] = "timeit"; static const char __pyx_k_unpack[] = "unpack"; static const char __pyx_k_update[] = "update"; static const char __pyx_k_asarray[] = "asarray"; -static const char __pyx_k_d_there[] = "d_there"; static const char __pyx_k_fortran[] = "fortran"; static const char __pyx_k_memview[] = "memview"; -static const char __pyx_k_prepare[] = "__prepare__"; -static const char __pyx_k_shuffle[] = "shuffle"; static const char __pyx_k_weights[] = "weights"; static const char __pyx_k_Ellipsis[] = "Ellipsis"; -static const char __pyx_k_dcov_all[] = "dcov_all"; static const char __pyx_k_epsarray[] = "epsarray"; static const char __pyx_k_getstate[] = "__getstate__"; static const char __pyx_k_itemsize[] = "itemsize"; static const char __pyx_k_pyx_type[] = "__pyx_type"; -static const char __pyx_k_qualname[] = "__qualname__"; static const char __pyx_k_setstate[] = "__setstate__"; static const char __pyx_k_unittest[] = "unittest"; static const char __pyx_k_TypeError[] = "TypeError"; static const char __pyx_k_enumerate[] = "enumerate"; -static const char __pyx_k_mean_here[] = "mean_here"; -static const char __pyx_k_metaclass[] = "__metaclass__"; static const char __pyx_k_neighbors[] = "neighbors"; static const char __pyx_k_patt_mask[] = "patt_mask"; static const char __pyx_k_pyx_state[] = "__pyx_state"; static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; -static const char __pyx_k_sum_total[] = "sum_total"; -static const char __pyx_k_D_N___init[] = "D_N.__init__"; static const char __pyx_k_IndexError[] = "IndexError"; static const char __pyx_k_ValueError[] = "ValueError"; static const char __pyx_k_array_mask[] = "array_mask"; -static const char __pyx_k_mean_there[] = "mean_there"; static const char __pyx_k_pyx_result[] = "__pyx_result"; static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; static const char __pyx_k_ImportError[] = "ImportError"; static const char __pyx_k_MemoryError[] = "MemoryError"; static const char __pyx_k_PickleError[] = "PickleError"; -static const char __pyx_k_mean_0_here[] = "mean_0_here"; -static const char __pyx_k_mean_1_here[] = "mean_1_here"; -static const char __pyx_k_product_sum[] = "product_sum"; -static const char __pyx_k_squared_sum[] = "squared_sum"; static const char __pyx_k_RuntimeError[] = "RuntimeError"; -static const char __pyx_k_mean_0_there[] = "mean_0_there"; -static const char __pyx_k_mean_1_there[] = "mean_1_there"; static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; static const char __pyx_k_stringsource[] = "stringsource"; static const char __pyx_k_pyx_getbuffer[] = "__pyx_getbuffer"; static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; -static const char __pyx_k_D_N_product_sum[] = "D_N.product_sum"; -static const char __pyx_k_D_N_squared_sum[] = "D_N.squared_sum"; static const char __pyx_k_View_MemoryView[] = "View.MemoryView"; static const char __pyx_k_allocate_buffer[] = "allocate_buffer"; -static const char __pyx_k_calculate_means[] = "calculate_means"; static const char __pyx_k_dtype_is_object[] = "dtype_is_object"; static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError"; static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; @@ -2492,7 +2311,6 @@ static const char __pyx_k_pyx_unpickle_Enum[] = "__pyx_unpickle_Enum"; static const char __pyx_k_shuffle_neighbors[] = "shuffle_neighbors"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_strided_and_direct[] = ""; -static const char __pyx_k_D_N_calculate_means[] = "D_N.calculate_means"; static const char __pyx_k_get_patterns_cython[] = "_get_patterns_cython"; static const char __pyx_k_strided_and_indirect[] = ""; static const char __pyx_k_contiguous_and_direct[] = ""; @@ -2519,7 +2337,6 @@ static const char __pyx_k_Empty_shape_tuple_for_cython_arr[] = "Empty shape tupl static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd"; static const char __pyx_k_Incompatible_checksums_s_vs_0xb0[] = "Incompatible checksums (%s vs 0xb068931 = (name))"; static const char __pyx_k_Indirect_dimensions_not_supporte[] = "Indirect dimensions not supported"; -static const char __pyx_k_Inner_helper_of_dcov_all_Cache_d[] = "Inner helper of dcov_all. Cache different means that are required for calculating\n the matrix members on the fly"; static const char __pyx_k_Invalid_mode_expected_c_or_fortr[] = "Invalid mode, expected 'c' or 'fortran', got %s"; static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported"; static const char __pyx_k_Out_of_bounds_on_buffer_access_a[] = "Out of bounds on buffer access (axis %d)"; @@ -2537,11 +2354,6 @@ static PyObject *__pyx_kp_s_Can_only_create_a_buffer_that_is; static PyObject *__pyx_kp_s_Cannot_assign_to_read_only_memor; static PyObject *__pyx_kp_s_Cannot_create_writable_memory_vi; static PyObject *__pyx_kp_s_Cannot_index_with_type_s; -static PyObject *__pyx_n_s_D_N; -static PyObject *__pyx_n_s_D_N___init; -static PyObject *__pyx_n_s_D_N_calculate_means; -static PyObject *__pyx_n_s_D_N_product_sum; -static PyObject *__pyx_n_s_D_N_squared_sum; static PyObject *__pyx_n_s_Ellipsis; static PyObject *__pyx_kp_s_Empty_shape_tuple_for_cython_arr; static PyObject *__pyx_kp_u_Format_string_allocated_too_shor; @@ -2550,7 +2362,6 @@ static PyObject *__pyx_n_s_ImportError; static PyObject *__pyx_kp_s_Incompatible_checksums_s_vs_0xb0; static PyObject *__pyx_n_s_IndexError; static PyObject *__pyx_kp_s_Indirect_dimensions_not_supporte; -static PyObject *__pyx_kp_s_Inner_helper_of_dcov_all_Cache_d; static PyObject *__pyx_kp_s_Invalid_mode_expected_c_or_fortr; static PyObject *__pyx_kp_s_Invalid_shape_in_axis_d_d; static PyObject *__pyx_n_s_MemoryError; @@ -2575,32 +2386,18 @@ static PyObject *__pyx_n_s_ave; static PyObject *__pyx_n_s_base; static PyObject *__pyx_n_s_c; static PyObject *__pyx_n_u_c; -static PyObject *__pyx_n_s_calculate_means; static PyObject *__pyx_n_s_class; static PyObject *__pyx_n_s_cline_in_traceback; static PyObject *__pyx_kp_s_contiguous_and_direct; static PyObject *__pyx_kp_s_contiguous_and_indirect; static PyObject *__pyx_n_s_count; static PyObject *__pyx_n_s_d; -static PyObject *__pyx_n_s_d_here; -static PyObject *__pyx_n_s_d_there; -static PyObject *__pyx_n_s_dc; -static PyObject *__pyx_n_s_dcov_all; -static PyObject *__pyx_n_s_denom; static PyObject *__pyx_n_s_dict; static PyObject *__pyx_n_s_dim; static PyObject *__pyx_n_s_dim_x; static PyObject *__pyx_n_s_dim_y; -static PyObject *__pyx_n_s_dist; -static PyObject *__pyx_n_s_dnx; -static PyObject *__pyx_n_s_dny; -static PyObject *__pyx_n_s_doc; -static PyObject *__pyx_n_s_double; -static PyObject *__pyx_n_s_dr; static PyObject *__pyx_n_s_dtype; static PyObject *__pyx_n_s_dtype_is_object; -static PyObject *__pyx_n_s_dvx; -static PyObject *__pyx_n_s_dvy; static PyObject *__pyx_n_s_dx; static PyObject *__pyx_n_s_dy; static PyObject *__pyx_n_s_dz; @@ -2622,15 +2419,12 @@ static PyObject *__pyx_n_s_getstate; static PyObject *__pyx_kp_s_got_differing_extents_in_dimensi; static PyObject *__pyx_n_s_i; static PyObject *__pyx_n_s_id; -static PyObject *__pyx_n_s_ii; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_index; -static PyObject *__pyx_n_s_init; static PyObject *__pyx_n_u_int32; static PyObject *__pyx_n_s_itemsize; static PyObject *__pyx_kp_s_itemsize_0_for_cython_array; static PyObject *__pyx_n_s_j; -static PyObject *__pyx_n_s_jj; static PyObject *__pyx_n_s_k; static PyObject *__pyx_n_s_k_xz; static PyObject *__pyx_n_s_k_yz; @@ -2640,19 +2434,8 @@ static PyObject *__pyx_n_s_kyz; static PyObject *__pyx_n_s_kz; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_mask; -static PyObject *__pyx_n_s_mean; -static PyObject *__pyx_n_s_mean_0; -static PyObject *__pyx_n_s_mean_0_here; -static PyObject *__pyx_n_s_mean_0_there; -static PyObject *__pyx_n_s_mean_1; -static PyObject *__pyx_n_s_mean_1_here; -static PyObject *__pyx_n_s_mean_1_there; -static PyObject *__pyx_n_s_mean_here; -static PyObject *__pyx_n_s_mean_there; static PyObject *__pyx_n_s_memview; -static PyObject *__pyx_n_s_metaclass; static PyObject *__pyx_n_s_mode; -static PyObject *__pyx_n_s_module; static PyObject *__pyx_n_s_n; static PyObject *__pyx_n_s_name; static PyObject *__pyx_n_s_name_2; @@ -2668,14 +2451,11 @@ static PyObject *__pyx_kp_u_numpy_core_multiarray_failed_to; static PyObject *__pyx_kp_u_numpy_core_umath_failed_to_impor; static PyObject *__pyx_n_s_obj; static PyObject *__pyx_n_s_order; -static PyObject *__pyx_n_s_other; static PyObject *__pyx_n_s_p; static PyObject *__pyx_n_s_pack; static PyObject *__pyx_n_s_patt; static PyObject *__pyx_n_s_patt_mask; static PyObject *__pyx_n_s_pickle; -static PyObject *__pyx_n_s_prepare; -static PyObject *__pyx_n_s_product_sum; static PyObject *__pyx_n_s_pyx_PickleError; static PyObject *__pyx_n_s_pyx_checksum; static PyObject *__pyx_n_s_pyx_getbuffer; @@ -2684,22 +2464,17 @@ static PyObject *__pyx_n_s_pyx_state; static PyObject *__pyx_n_s_pyx_type; static PyObject *__pyx_n_s_pyx_unpickle_Enum; static PyObject *__pyx_n_s_pyx_vtable; -static PyObject *__pyx_n_s_qualname; static PyObject *__pyx_n_s_random; static PyObject *__pyx_n_s_range; static PyObject *__pyx_n_s_reduce; static PyObject *__pyx_n_s_reduce_cython; static PyObject *__pyx_n_s_reduce_ex; static PyObject *__pyx_n_s_restricted_permutation; -static PyObject *__pyx_n_s_self; static PyObject *__pyx_n_s_setstate; static PyObject *__pyx_n_s_setstate_cython; static PyObject *__pyx_n_s_shape; -static PyObject *__pyx_n_s_shuffle; static PyObject *__pyx_n_s_shuffle_neighbors; static PyObject *__pyx_n_s_size; -static PyObject *__pyx_n_s_sqrt; -static PyObject *__pyx_n_s_squared_sum; static PyObject *__pyx_n_s_start; static PyObject *__pyx_n_s_step; static PyObject *__pyx_n_s_stop; @@ -2708,9 +2483,6 @@ static PyObject *__pyx_kp_s_strided_and_direct_or_indirect; static PyObject *__pyx_kp_s_strided_and_indirect; static PyObject *__pyx_kp_s_stringsource; static PyObject *__pyx_n_s_struct; -static PyObject *__pyx_n_s_sum_0; -static PyObject *__pyx_n_s_sum_1; -static PyObject *__pyx_n_s_sum_total; static PyObject *__pyx_n_s_sys; static PyObject *__pyx_n_s_t; static PyObject *__pyx_n_s_tau; @@ -2727,20 +2499,12 @@ static PyObject *__pyx_n_s_update; static PyObject *__pyx_n_s_use; static PyObject *__pyx_n_s_used; static PyObject *__pyx_n_s_v; -static PyObject *__pyx_n_s_value; static PyObject *__pyx_n_s_var; static PyObject *__pyx_n_s_weights; -static PyObject *__pyx_n_s_x; -static PyObject *__pyx_n_s_y; static PyObject *__pyx_n_s_zeros; static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code__get_neighbors_within_eps_cython(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_array, int __pyx_v_T, int __pyx_v_dim_x, int __pyx_v_dim_y, __Pyx_memviewslice __pyx_v_epsarray, CYTHON_UNUSED int __pyx_v_k, int __pyx_v_dim); /* proto */ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_2_get_patterns_cython(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_array, __Pyx_memviewslice __pyx_v_array_mask, __Pyx_memviewslice __pyx_v_patt, __Pyx_memviewslice __pyx_v_patt_mask, __Pyx_memviewslice __pyx_v_weights, int __pyx_v_dim, int __pyx_v_step, __Pyx_memviewslice __pyx_v_fac, int __pyx_v_N, int __pyx_v_T); /* proto */ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_4_get_restricted_permutation_cython(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_T, int __pyx_v_shuffle_neighbors, __Pyx_memviewslice __pyx_v_neighbors, __Pyx_memviewslice __pyx_v_order); /* proto */ -static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_6dcov_all(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x, PyObject *__pyx_v_y); /* proto */ -static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_x); /* proto */ -static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_2calculate_means(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_4squared_sum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_6product_sum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer); /* proto */ @@ -2791,7 +2555,6 @@ static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_int_0; static PyObject *__pyx_int_1; -static PyObject *__pyx_int_2; static PyObject *__pyx_int_184977713; static PyObject *__pyx_int_neg_1; static PyObject *__pyx_tuple_; @@ -2823,25 +2586,15 @@ static PyObject *__pyx_tuple__26; static PyObject *__pyx_tuple__28; static PyObject *__pyx_tuple__30; static PyObject *__pyx_tuple__32; +static PyObject *__pyx_tuple__33; static PyObject *__pyx_tuple__34; +static PyObject *__pyx_tuple__35; static PyObject *__pyx_tuple__36; -static PyObject *__pyx_tuple__38; -static PyObject *__pyx_tuple__40; -static PyObject *__pyx_tuple__42; -static PyObject *__pyx_tuple__43; -static PyObject *__pyx_tuple__44; -static PyObject *__pyx_tuple__45; -static PyObject *__pyx_tuple__46; -static PyObject *__pyx_tuple__47; +static PyObject *__pyx_tuple__37; static PyObject *__pyx_codeobj__27; static PyObject *__pyx_codeobj__29; static PyObject *__pyx_codeobj__31; -static PyObject *__pyx_codeobj__33; -static PyObject *__pyx_codeobj__35; -static PyObject *__pyx_codeobj__37; -static PyObject *__pyx_codeobj__39; -static PyObject *__pyx_codeobj__41; -static PyObject *__pyx_codeobj__48; +static PyObject *__pyx_codeobj__38; /* Late includes */ /* "tigramite/tigramite_cython_code.pyx":13 @@ -4474,73 +4227,8 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_4_get_restricted_pe __pyx_t_5.memview = NULL; __pyx_t_5.data = NULL; - /* "tigramite/tigramite_cython_code.pyx":162 - * - * # Shuffle neighbor indices for each sample index - * for i in range(T): # <<<<<<<<<<<<<< - * numpy.random.shuffle(neighbors[i]) - * - */ - __pyx_t_6 = __pyx_v_T; - __pyx_t_7 = __pyx_t_6; - for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { - __pyx_v_i = __pyx_t_8; - - /* "tigramite/tigramite_cython_code.pyx":163 - * # Shuffle neighbor indices for each sample index - * for i in range(T): - * numpy.random.shuffle(neighbors[i]) # <<<<<<<<<<<<<< - * - * for i in range(T): - */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_numpy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 163, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 163, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_shuffle); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 163, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5.data = __pyx_v_neighbors.data; - __pyx_t_5.memview = __pyx_v_neighbors.memview; - __PYX_INC_MEMVIEW(&__pyx_t_5, 0); - { - Py_ssize_t __pyx_tmp_idx = __pyx_v_i; - Py_ssize_t __pyx_tmp_stride = __pyx_v_neighbors.strides[0]; - if ((0)) __PYX_ERR(0, 163, __pyx_L1_error) - __pyx_t_5.data += __pyx_tmp_idx * __pyx_tmp_stride; -} - -__pyx_t_5.shape[0] = __pyx_v_neighbors.shape[1]; -__pyx_t_5.strides[0] = __pyx_v_neighbors.strides[1]; - __pyx_t_5.suboffsets[0] = -1; - -__pyx_t_3 = __pyx_memoryview_fromslice(__pyx_t_5, 1, (PyObject *(*)(char *)) __pyx_memview_get_int, (int (*)(char *, PyObject *)) __pyx_memview_set_int, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 163, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __PYX_XDEC_MEMVIEW(&__pyx_t_5, 1); - __pyx_t_5.memview = NULL; - __pyx_t_5.data = NULL; - __pyx_t_1 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_1); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - } - } - __pyx_t_2 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_1, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 163, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - - /* "tigramite/tigramite_cython_code.pyx":165 - * numpy.random.shuffle(neighbors[i]) + /* "tigramite/tigramite_cython_code.pyx":161 + * cdef int i, index, count, use * * for i in range(T): # <<<<<<<<<<<<<< * @@ -4551,7 +4239,7 @@ __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_t_5, 1, (PyObject *(*)(char *)) __p for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { __pyx_v_i = __pyx_t_8; - /* "tigramite/tigramite_cython_code.pyx":167 + /* "tigramite/tigramite_cython_code.pyx":163 * for i in range(T): * * index = order[i]; # <<<<<<<<<<<<<< @@ -4561,7 +4249,7 @@ __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_t_5, 1, (PyObject *(*)(char *)) __p __pyx_t_9 = __pyx_v_i; __pyx_v_index = (*((int *) ( /* dim=0 */ (__pyx_v_order.data + __pyx_t_9 * __pyx_v_order.strides[0]) ))); - /* "tigramite/tigramite_cython_code.pyx":168 + /* "tigramite/tigramite_cython_code.pyx":164 * * index = order[i]; * count = 0 # <<<<<<<<<<<<<< @@ -4570,7 +4258,7 @@ __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_t_5, 1, (PyObject *(*)(char *)) __p */ __pyx_v_count = 0; - /* "tigramite/tigramite_cython_code.pyx":170 + /* "tigramite/tigramite_cython_code.pyx":166 * count = 0 * * use = neighbors[index, count] # <<<<<<<<<<<<<< @@ -4581,7 +4269,7 @@ __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_t_5, 1, (PyObject *(*)(char *)) __p __pyx_t_11 = __pyx_v_count; __pyx_v_use = (*((int *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_neighbors.data + __pyx_t_10 * __pyx_v_neighbors.strides[0]) ) + __pyx_t_11 * __pyx_v_neighbors.strides[1]) ))); - /* "tigramite/tigramite_cython_code.pyx":171 + /* "tigramite/tigramite_cython_code.pyx":167 * * use = neighbors[index, count] * while(isvalueinarray(use, used, i) and (count < shuffle_neighbors - 1)): # <<<<<<<<<<<<<< @@ -4593,14 +4281,14 @@ __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_t_5, 1, (PyObject *(*)(char *)) __p if (__pyx_t_13) { } else { __pyx_t_12 = __pyx_t_13; - goto __pyx_L9_bool_binop_done; + goto __pyx_L7_bool_binop_done; } __pyx_t_13 = ((__pyx_v_count < (__pyx_v_shuffle_neighbors - 1)) != 0); __pyx_t_12 = __pyx_t_13; - __pyx_L9_bool_binop_done:; + __pyx_L7_bool_binop_done:; if (!__pyx_t_12) break; - /* "tigramite/tigramite_cython_code.pyx":172 + /* "tigramite/tigramite_cython_code.pyx":168 * use = neighbors[index, count] * while(isvalueinarray(use, used, i) and (count < shuffle_neighbors - 1)): * count += 1 # <<<<<<<<<<<<<< @@ -4609,7 +4297,7 @@ __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_t_5, 1, (PyObject *(*)(char *)) __p */ __pyx_v_count = (__pyx_v_count + 1); - /* "tigramite/tigramite_cython_code.pyx":173 + /* "tigramite/tigramite_cython_code.pyx":169 * while(isvalueinarray(use, used, i) and (count < shuffle_neighbors - 1)): * count += 1 * use = neighbors[index, count] # <<<<<<<<<<<<<< @@ -4621,7 +4309,7 @@ __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_t_5, 1, (PyObject *(*)(char *)) __p __pyx_v_use = (*((int *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_neighbors.data + __pyx_t_14 * __pyx_v_neighbors.strides[0]) ) + __pyx_t_15 * __pyx_v_neighbors.strides[1]) ))); } - /* "tigramite/tigramite_cython_code.pyx":175 + /* "tigramite/tigramite_cython_code.pyx":171 * use = neighbors[index, count] * * restricted_permutation[index] = use # <<<<<<<<<<<<<< @@ -4631,7 +4319,7 @@ __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_t_5, 1, (PyObject *(*)(char *)) __p __pyx_t_16 = __pyx_v_index; *((int *) ( /* dim=0 */ (__pyx_v_restricted_permutation.data + __pyx_t_16 * __pyx_v_restricted_permutation.strides[0]) )) = __pyx_v_use; - /* "tigramite/tigramite_cython_code.pyx":177 + /* "tigramite/tigramite_cython_code.pyx":173 * restricted_permutation[index] = use * * used[i] = use # <<<<<<<<<<<<<< @@ -4642,20 +4330,18 @@ __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_t_5, 1, (PyObject *(*)(char *)) __p *((int *) ( /* dim=0 */ (__pyx_v_used.data + __pyx_t_17 * __pyx_v_used.strides[0]) )) = __pyx_v_use; } - /* "tigramite/tigramite_cython_code.pyx":179 + /* "tigramite/tigramite_cython_code.pyx":175 * used[i] = use * * return numpy.asarray(restricted_permutation) # <<<<<<<<<<<<<< - * - * */ __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_numpy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_numpy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 175, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_asarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 179, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_asarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 175, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __pyx_memoryview_fromslice(__pyx_v_restricted_permutation, 1, (PyObject *(*)(char *)) __pyx_memview_get_int, (int (*)(char *, PyObject *)) __pyx_memview_set_int, 0);; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 179, __pyx_L1_error) + __pyx_t_4 = __pyx_memoryview_fromslice(__pyx_v_restricted_permutation, 1, (PyObject *(*)(char *)) __pyx_memview_get_int, (int (*)(char *, PyObject *)) __pyx_memview_set_int, 0);; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 175, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { @@ -4670,7 +4356,7 @@ __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_t_5, 1, (PyObject *(*)(char *)) __p __pyx_t_2 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 179, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 175, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_2; @@ -4704,1848 +4390,739 @@ __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_t_5, 1, (PyObject *(*)(char *)) __p return __pyx_r; } -/* "tigramite/tigramite_cython_code.pyx":217 - * ctypedef np.double_t DTYPE_t - * - * def dcov_all(x, y): # <<<<<<<<<<<<<< - * 'Calculate distance covariance, distance correlation, distance variance of x sample and distance variance of y sample' - * x = np.array(x, dtype=np.double) +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":258 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fulfill the PEP. */ /* Python wrapper */ -static PyObject *__pyx_pw_9tigramite_21tigramite_cython_code_7dcov_all(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_9tigramite_21tigramite_cython_code_6dcov_all[] = "Calculate distance covariance, distance correlation, distance variance of x sample and distance variance of y sample"; -static PyMethodDef __pyx_mdef_9tigramite_21tigramite_cython_code_7dcov_all = {"dcov_all", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9tigramite_21tigramite_cython_code_7dcov_all, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9tigramite_21tigramite_cython_code_6dcov_all}; -static PyObject *__pyx_pw_9tigramite_21tigramite_cython_code_7dcov_all(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_x = 0; - PyObject *__pyx_v_y = 0; - PyObject *__pyx_r = 0; +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("dcov_all (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,&__pyx_n_s_y,0}; - PyObject* values[2] = {0,0}; - if (unlikely(__pyx_kwds)) { - Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { - case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_x)) != 0)) kw_args--; - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("dcov_all", 1, 2, 2, 1); __PYX_ERR(0, 217, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "dcov_all") < 0)) __PYX_ERR(0, 217, __pyx_L3_error) - } - } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - } - __pyx_v_x = values[0]; - __pyx_v_y = values[1]; - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("dcov_all", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 217, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("tigramite.tigramite_cython_code.dcov_all", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_9tigramite_21tigramite_cython_code_6dcov_all(__pyx_self, __pyx_v_x, __pyx_v_y); + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_6dcov_all(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x, PyObject *__pyx_v_y) { - PyObject *__pyx_v_dnx = NULL; - PyObject *__pyx_v_dny = NULL; - double __pyx_v_denom; - PyObject *__pyx_v_dc = NULL; - PyObject *__pyx_v_dvx = NULL; - PyObject *__pyx_v_dvy = NULL; - PyObject *__pyx_v_dr = NULL; - PyObject *__pyx_r = NULL; +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_v_i; + int __pyx_v_ndim; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + int __pyx_v_t; + char *__pyx_v_f; + PyArray_Descr *__pyx_v_descr = 0; + int __pyx_v_offset; + int __pyx_r; __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; + int __pyx_t_1; + int __pyx_t_2; PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - double __pyx_t_6; - __Pyx_RefNannySetupContext("dcov_all", 0); - __Pyx_INCREF(__pyx_v_x); - __Pyx_INCREF(__pyx_v_y); - - /* "tigramite/tigramite_cython_code.pyx":219 - * def dcov_all(x, y): - * 'Calculate distance covariance, distance correlation, distance variance of x sample and distance variance of y sample' - * x = np.array(x, dtype=np.double) # <<<<<<<<<<<<<< - * y = np.array(y, dtype=np.double) - * dnx = D_N(x) - */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 219, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_array); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 219, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 219, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_x); - __Pyx_GIVEREF(__pyx_v_x); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_x); - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 219, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 219, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_double); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 219, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 219, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 219, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF_SET(__pyx_v_x, __pyx_t_5); - __pyx_t_5 = 0; - - /* "tigramite/tigramite_cython_code.pyx":220 - * 'Calculate distance covariance, distance correlation, distance variance of x sample and distance variance of y sample' - * x = np.array(x, dtype=np.double) - * y = np.array(y, dtype=np.double) # <<<<<<<<<<<<<< - * dnx = D_N(x) - * dny = D_N(y) - */ - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_INCREF(__pyx_v_y); - __Pyx_GIVEREF(__pyx_v_y); - PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_y); - __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_double); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_4); - __pyx_t_4 = 0; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + PyArray_Descr *__pyx_t_7; + PyObject *__pyx_t_8 = NULL; + char *__pyx_t_9; + if (__pyx_v_info == NULL) { + PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); + return -1; + } + __Pyx_RefNannySetupContext("__getbuffer__", 0); + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); - /* "tigramite/tigramite_cython_code.pyx":221 - * x = np.array(x, dtype=np.double) - * y = np.array(y, dtype=np.double) - * dnx = D_N(x) # <<<<<<<<<<<<<< - * dny = D_N(y) + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":265 + * + * cdef int i, ndim + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) * */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_D_N); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 221, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - } - } - __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v_x) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_x); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 221, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_dnx = __pyx_t_4; - __pyx_t_4 = 0; + __pyx_v_endian_detector = 1; - /* "tigramite/tigramite_cython_code.pyx":222 - * y = np.array(y, dtype=np.double) - * dnx = D_N(x) - * dny = D_N(y) # <<<<<<<<<<<<<< + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":266 + * cdef int i, ndim + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< * - * denom = float(dnx.dim * dnx.dim) + * ndim = PyArray_NDIM(self) */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_D_N); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 222, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - } - } - __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v_y) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_y); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 222, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_dny = __pyx_t_4; - __pyx_t_4 = 0; + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); - /* "tigramite/tigramite_cython_code.pyx":224 - * dny = D_N(y) + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":268 + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * + * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< * - * denom = float(dnx.dim * dnx.dim) # <<<<<<<<<<<<<< - * dc = dnx.product_sum(dny) / denom - * dvx = dnx.squared_sum() / denom + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_dnx, __pyx_n_s_dim); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 224, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dnx, __pyx_n_s_dim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 224, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = PyNumber_Multiply(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 224, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_6 = __Pyx_PyObject_AsDouble(__pyx_t_5); if (unlikely(__pyx_t_6 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 224, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_denom = __pyx_t_6; + __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); - /* "tigramite/tigramite_cython_code.pyx":225 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":270 + * ndim = PyArray_NDIM(self) * - * denom = float(dnx.dim * dnx.dim) - * dc = dnx.product_sum(dny) / denom # <<<<<<<<<<<<<< - * dvx = dnx.squared_sum() / denom - * dvy = dny.squared_sum() / denom + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dnx, __pyx_n_s_product_sum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 225, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - } + __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; } - __pyx_t_5 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_4, __pyx_v_dny) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_dny); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 225, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_denom); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 225, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 225, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_dc = __pyx_t_4; - __pyx_t_4 = 0; - /* "tigramite/tigramite_cython_code.pyx":226 - * denom = float(dnx.dim * dnx.dim) - * dc = dnx.product_sum(dny) / denom - * dvx = dnx.squared_sum() / denom # <<<<<<<<<<<<<< - * dvy = dny.squared_sum() / denom - * dr = dc / (np.sqrt(dvx) * np.sqrt(dvy)) + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":271 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not C contiguous") + * */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dnx, __pyx_n_s_squared_sum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 226, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - } - } - __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 226, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_denom); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 226, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 226, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_dvx = __pyx_t_5; - __pyx_t_5 = 0; + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_C_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; - /* "tigramite/tigramite_cython_code.pyx":227 - * dc = dnx.product_sum(dny) / denom - * dvx = dnx.squared_sum() / denom - * dvy = dny.squared_sum() / denom # <<<<<<<<<<<<<< - * dr = dc / (np.sqrt(dvx) * np.sqrt(dvy)) - * return dc, dr, dvx, dvy + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":270 + * ndim = PyArray_NDIM(self) + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dny, __pyx_n_s_squared_sum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 227, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - } - } - __pyx_t_5 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 227, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_denom); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 227, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 227, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_dvy = __pyx_t_4; - __pyx_t_4 = 0; + if (unlikely(__pyx_t_1)) { - /* "tigramite/tigramite_cython_code.pyx":228 - * dvx = dnx.squared_sum() / denom - * dvy = dny.squared_sum() / denom - * dr = dc / (np.sqrt(dvx) * np.sqrt(dvy)) # <<<<<<<<<<<<<< - * return dc, dr, dvx, dvy + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":272 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 272, __pyx_L1_error) + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":270 + * ndim = PyArray_NDIM(self) + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 228, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_sqrt); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 228, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_1); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - } } - __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_1, __pyx_v_dvx) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_dvx); - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 228, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 228, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_sqrt); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 228, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_1); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - } + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":274 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L7_bool_binop_done; } - __pyx_t_5 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_1, __pyx_v_dvy) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_dvy); - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 228, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyNumber_Multiply(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 228, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_v_dc, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 228, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_dr = __pyx_t_5; - __pyx_t_5 = 0; - /* "tigramite/tigramite_cython_code.pyx":229 - * dvy = dny.squared_sum() / denom - * dr = dc / (np.sqrt(dvx) * np.sqrt(dvy)) - * return dc, dr, dvx, dvy # <<<<<<<<<<<<<< + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":275 * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not Fortran contiguous") * */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 229, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_INCREF(__pyx_v_dc); - __Pyx_GIVEREF(__pyx_v_dc); - PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_dc); - __Pyx_INCREF(__pyx_v_dr); - __Pyx_GIVEREF(__pyx_v_dr); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_v_dr); - __Pyx_INCREF(__pyx_v_dvx); - __Pyx_GIVEREF(__pyx_v_dvx); - PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_dvx); - __Pyx_INCREF(__pyx_v_dvy); - __Pyx_GIVEREF(__pyx_v_dvy); - PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_v_dvy); - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; - goto __pyx_L0; + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_F_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L7_bool_binop_done:; - /* "tigramite/tigramite_cython_code.pyx":217 - * ctypedef np.double_t DTYPE_t + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":274 + * raise ValueError(u"ndarray is not C contiguous") * - * def dcov_all(x, y): # <<<<<<<<<<<<<< - * 'Calculate distance covariance, distance correlation, distance variance of x sample and distance variance of y sample' - * x = np.array(x, dtype=np.double) + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") */ + if (unlikely(__pyx_t_1)) { - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("tigramite.tigramite_cython_code.dcov_all", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_dnx); - __Pyx_XDECREF(__pyx_v_dny); - __Pyx_XDECREF(__pyx_v_dc); - __Pyx_XDECREF(__pyx_v_dvx); - __Pyx_XDECREF(__pyx_v_dvy); - __Pyx_XDECREF(__pyx_v_dr); - __Pyx_XDECREF(__pyx_v_x); - __Pyx_XDECREF(__pyx_v_y); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":276 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + * + * info.buf = PyArray_DATA(self) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 276, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 276, __pyx_L1_error) -/* "tigramite/tigramite_cython_code.pyx":236 - * the matrix members on the fly""" + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":274 + * raise ValueError(u"ndarray is not C contiguous") * - * def __init__(self, x): # <<<<<<<<<<<<<< - * self.x = np.array(x) - * self.dim = x.shape[0] + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") */ + } -/* Python wrapper */ -static PyObject *__pyx_pw_9tigramite_21tigramite_cython_code_3D_N_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyMethodDef __pyx_mdef_9tigramite_21tigramite_cython_code_3D_N_1__init__ = {"__init__", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9tigramite_21tigramite_cython_code_3D_N_1__init__, METH_VARARGS|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_9tigramite_21tigramite_cython_code_3D_N_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_self = 0; - PyObject *__pyx_v_x = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_x,0}; - PyObject* values[2] = {0,0}; - if (unlikely(__pyx_kwds)) { - Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { - case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_x)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); __PYX_ERR(0, 236, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 236, __pyx_L3_error) - } - } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - } - __pyx_v_self = values[0]; - __pyx_v_x = values[1]; - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 236, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("tigramite.tigramite_cython_code.D_N.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_9tigramite_21tigramite_cython_code_3D_N___init__(__pyx_self, __pyx_v_self, __pyx_v_x); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_x) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - __Pyx_RefNannySetupContext("__init__", 0); - - /* "tigramite/tigramite_cython_code.pyx":237 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":278 + * raise ValueError(u"ndarray is not Fortran contiguous") * - * def __init__(self, x): - * self.x = np.array(x) # <<<<<<<<<<<<<< - * self.dim = x.shape[0] - * self.calculate_means() + * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< + * info.ndim = ndim + * if sizeof(npy_intp) != sizeof(Py_ssize_t): */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 237, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 237, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - } - } - __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_v_x) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_x); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 237, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_x, __pyx_t_1) < 0) __PYX_ERR(0, 237, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); - /* "tigramite/tigramite_cython_code.pyx":238 - * def __init__(self, x): - * self.x = np.array(x) - * self.dim = x.shape[0] # <<<<<<<<<<<<<< - * self.calculate_means() + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":279 * + * info.buf = PyArray_DATA(self) + * info.ndim = ndim # <<<<<<<<<<<<<< + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * # Allocate new buffer for strides and shape info. */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 238, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 238, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_dim, __pyx_t_3) < 0) __PYX_ERR(0, 238, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_info->ndim = __pyx_v_ndim; - /* "tigramite/tigramite_cython_code.pyx":239 - * self.x = np.array(x) - * self.dim = x.shape[0] - * self.calculate_means() # <<<<<<<<<<<<<< - * - * @cython.boundscheck(False) + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":280 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_calculate_means); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 239, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - } - } - __pyx_t_3 = (__pyx_t_2) ? __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2) : __Pyx_PyObject_CallNoArg(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 239, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { - /* "tigramite/tigramite_cython_code.pyx":236 - * the matrix members on the fly""" - * - * def __init__(self, x): # <<<<<<<<<<<<<< - * self.x = np.array(x) - * self.dim = x.shape[0] + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":283 + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) # <<<<<<<<<<<<<< + * info.shape = info.strides + ndim + * for i in range(ndim): */ + __pyx_v_info->strides = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * 2) * ((size_t)__pyx_v_ndim)))); - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("tigramite.tigramite_cython_code.D_N.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "tigramite/tigramite_cython_code.pyx":243 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * def calculate_means(self): # <<<<<<<<<<<<<< - * cdef int dim = self.dim - * cdef DTYPE_t value + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":284 + * # This is allocated as one block, strides first. + * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) + * info.shape = info.strides + ndim # <<<<<<<<<<<<<< + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] */ + __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); -/* Python wrapper */ -static PyObject *__pyx_pw_9tigramite_21tigramite_cython_code_3D_N_3calculate_means(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/ -static PyMethodDef __pyx_mdef_9tigramite_21tigramite_cython_code_3D_N_3calculate_means = {"calculate_means", (PyCFunction)__pyx_pw_9tigramite_21tigramite_cython_code_3D_N_3calculate_means, METH_O, 0}; -static PyObject *__pyx_pw_9tigramite_21tigramite_cython_code_3D_N_3calculate_means(PyObject *__pyx_self, PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("calculate_means (wrapper)", 0); - __pyx_r = __pyx_pf_9tigramite_21tigramite_cython_code_3D_N_2calculate_means(__pyx_self, ((PyObject *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_2calculate_means(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { - int __pyx_v_dim; - __pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t __pyx_v_value; - __pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t __pyx_v_sum_total; - PyArrayObject *__pyx_v_sum_0 = 0; - PyArrayObject *__pyx_v_sum_1 = 0; - PyArrayObject *__pyx_v_x = 0; - unsigned int __pyx_v_ii; - unsigned int __pyx_v_jj; - __Pyx_LocalBuf_ND __pyx_pybuffernd_sum_0; - __Pyx_Buffer __pyx_pybuffer_sum_0; - __Pyx_LocalBuf_ND __pyx_pybuffernd_sum_1; - __Pyx_Buffer __pyx_pybuffer_sum_1; - __Pyx_LocalBuf_ND __pyx_pybuffernd_x; - __Pyx_Buffer __pyx_pybuffer_x; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyArrayObject *__pyx_t_7 = NULL; - PyArrayObject *__pyx_t_8 = NULL; - PyArrayObject *__pyx_t_9 = NULL; - int __pyx_t_10; - unsigned int __pyx_t_11; - int __pyx_t_12; - int __pyx_t_13; - unsigned int __pyx_t_14; - size_t __pyx_t_15; - size_t __pyx_t_16; - size_t __pyx_t_17; - size_t __pyx_t_18; - __Pyx_RefNannySetupContext("calculate_means", 0); - __pyx_pybuffer_sum_0.pybuffer.buf = NULL; - __pyx_pybuffer_sum_0.refcount = 0; - __pyx_pybuffernd_sum_0.data = NULL; - __pyx_pybuffernd_sum_0.rcbuffer = &__pyx_pybuffer_sum_0; - __pyx_pybuffer_sum_1.pybuffer.buf = NULL; - __pyx_pybuffer_sum_1.refcount = 0; - __pyx_pybuffernd_sum_1.data = NULL; - __pyx_pybuffernd_sum_1.rcbuffer = &__pyx_pybuffer_sum_1; - __pyx_pybuffer_x.pybuffer.buf = NULL; - __pyx_pybuffer_x.refcount = 0; - __pyx_pybuffernd_x.data = NULL; - __pyx_pybuffernd_x.rcbuffer = &__pyx_pybuffer_x; - - /* "tigramite/tigramite_cython_code.pyx":244 - * @cython.wraparound(False) - * def calculate_means(self): - * cdef int dim = self.dim # <<<<<<<<<<<<<< - * cdef DTYPE_t value - * cdef DTYPE_t sum_total = 0 - */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 244, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 244, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_dim = __pyx_t_2; + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":285 + * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) + * info.shape = info.strides + ndim + * for i in range(ndim): # <<<<<<<<<<<<<< + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] + */ + __pyx_t_4 = __pyx_v_ndim; + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; - /* "tigramite/tigramite_cython_code.pyx":246 - * cdef int dim = self.dim - * cdef DTYPE_t value - * cdef DTYPE_t sum_total = 0 # <<<<<<<<<<<<<< - * cdef np.ndarray[DTYPE_t, ndim=1] sum_0 = np.zeros(dim, dtype=np.double) - * cdef np.ndarray[DTYPE_t, ndim=1] sum_1 = np.zeros(dim, dtype=np.double) + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":286 + * info.shape = info.strides + ndim + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< + * info.shape[i] = PyArray_DIMS(self)[i] + * else: */ - __pyx_v_sum_total = 0.0; + (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); - /* "tigramite/tigramite_cython_code.pyx":247 - * cdef DTYPE_t value - * cdef DTYPE_t sum_total = 0 - * cdef np.ndarray[DTYPE_t, ndim=1] sum_0 = np.zeros(dim, dtype=np.double) # <<<<<<<<<<<<<< - * cdef np.ndarray[DTYPE_t, ndim=1] sum_1 = np.zeros(dim, dtype=np.double) - * cdef np.ndarray[DTYPE_t, ndim=1] x = self.x + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":287 + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< + * else: + * info.strides = PyArray_STRIDES(self) */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 247, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 247, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 247, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 247, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 247, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 247, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_double); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 247, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(0, 247, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 247, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 247, __pyx_L1_error) - __pyx_t_7 = ((PyArrayObject *)__pyx_t_6); - { - __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sum_0.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) { - __pyx_v_sum_0 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_sum_0.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 247, __pyx_L1_error) - } else {__pyx_pybuffernd_sum_0.diminfo[0].strides = __pyx_pybuffernd_sum_0.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sum_0.diminfo[0].shape = __pyx_pybuffernd_sum_0.rcbuffer->pybuffer.shape[0]; + (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); } - } - __pyx_t_7 = 0; - __pyx_v_sum_0 = ((PyArrayObject *)__pyx_t_6); - __pyx_t_6 = 0; - /* "tigramite/tigramite_cython_code.pyx":248 - * cdef DTYPE_t sum_total = 0 - * cdef np.ndarray[DTYPE_t, ndim=1] sum_0 = np.zeros(dim, dtype=np.double) - * cdef np.ndarray[DTYPE_t, ndim=1] sum_1 = np.zeros(dim, dtype=np.double) # <<<<<<<<<<<<<< - * cdef np.ndarray[DTYPE_t, ndim=1] x = self.x - * cdef unsigned int ii + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":280 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 248, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 248, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 248, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 248, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 248, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 248, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_double); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 248, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(0, 248, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 248, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 248, __pyx_L1_error) - __pyx_t_8 = ((PyArrayObject *)__pyx_t_5); - { - __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sum_1.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) { - __pyx_v_sum_1 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_sum_1.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 248, __pyx_L1_error) - } else {__pyx_pybuffernd_sum_1.diminfo[0].strides = __pyx_pybuffernd_sum_1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sum_1.diminfo[0].shape = __pyx_pybuffernd_sum_1.rcbuffer->pybuffer.shape[0]; - } + goto __pyx_L9; } - __pyx_t_8 = 0; - __pyx_v_sum_1 = ((PyArrayObject *)__pyx_t_5); - __pyx_t_5 = 0; - /* "tigramite/tigramite_cython_code.pyx":249 - * cdef np.ndarray[DTYPE_t, ndim=1] sum_0 = np.zeros(dim, dtype=np.double) - * cdef np.ndarray[DTYPE_t, ndim=1] sum_1 = np.zeros(dim, dtype=np.double) - * cdef np.ndarray[DTYPE_t, ndim=1] x = self.x # <<<<<<<<<<<<<< - * cdef unsigned int ii - * cdef unsigned int jj + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":289 + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 249, __pyx_L1_error) - __pyx_t_9 = ((PyArrayObject *)__pyx_t_5); - { - __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_t_9, &__Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { - __pyx_v_x = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_x.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 249, __pyx_L1_error) - } else {__pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; - } - } - __pyx_t_9 = 0; - __pyx_v_x = ((PyArrayObject *)__pyx_t_5); - __pyx_t_5 = 0; + /*else*/ { + __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); - /* "tigramite/tigramite_cython_code.pyx":254 - * - * # Adding prange() here leads to erros. Why? - * for ii in range(dim): # <<<<<<<<<<<<<< - * for jj in range(dim): - * value = abs(x[jj] - x[ii]) - */ - __pyx_t_2 = __pyx_v_dim; - __pyx_t_10 = __pyx_t_2; - for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { - __pyx_v_ii = __pyx_t_11; - - /* "tigramite/tigramite_cython_code.pyx":255 - * # Adding prange() here leads to erros. Why? - * for ii in range(dim): - * for jj in range(dim): # <<<<<<<<<<<<<< - * value = abs(x[jj] - x[ii]) - * sum_total += value - */ - __pyx_t_12 = __pyx_v_dim; - __pyx_t_13 = __pyx_t_12; - for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { - __pyx_v_jj = __pyx_t_14; - - /* "tigramite/tigramite_cython_code.pyx":256 - * for ii in range(dim): - * for jj in range(dim): - * value = abs(x[jj] - x[ii]) # <<<<<<<<<<<<<< - * sum_total += value - * sum_1[jj] += value - */ - __pyx_t_15 = __pyx_v_jj; - __pyx_t_16 = __pyx_v_ii; - __pyx_v_value = __pyx_f_9tigramite_21tigramite_cython_code_abs(((*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_x.diminfo[0].strides)) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_x.diminfo[0].strides)))); - - /* "tigramite/tigramite_cython_code.pyx":257 - * for jj in range(dim): - * value = abs(x[jj] - x[ii]) - * sum_total += value # <<<<<<<<<<<<<< - * sum_1[jj] += value - * sum_0[ii] += value - */ - __pyx_v_sum_total = (__pyx_v_sum_total + __pyx_v_value); - - /* "tigramite/tigramite_cython_code.pyx":258 - * value = abs(x[jj] - x[ii]) - * sum_total += value - * sum_1[jj] += value # <<<<<<<<<<<<<< - * sum_0[ii] += value - * self.mean = sum_total / (self.dim**2) - */ - __pyx_t_17 = __pyx_v_jj; - *__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_sum_1.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_sum_1.diminfo[0].strides) += __pyx_v_value; - - /* "tigramite/tigramite_cython_code.pyx":259 - * sum_total += value - * sum_1[jj] += value - * sum_0[ii] += value # <<<<<<<<<<<<<< - * self.mean = sum_total / (self.dim**2) - * self.mean_0 = sum_0 / (self.dim) - */ - __pyx_t_18 = __pyx_v_ii; - *__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_sum_0.rcbuffer->pybuffer.buf, __pyx_t_18, __pyx_pybuffernd_sum_0.diminfo[0].strides) += __pyx_v_value; - } + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":290 + * else: + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + */ + __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self)); } + __pyx_L9:; - /* "tigramite/tigramite_cython_code.pyx":260 - * sum_1[jj] += value - * sum_0[ii] += value - * self.mean = sum_total / (self.dim**2) # <<<<<<<<<<<<<< - * self.mean_0 = sum_0 / (self.dim) - * self.mean_1 = sum_1 / (self.dim) + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":291 + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) */ - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_sum_total); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 260, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 260, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_4 = PyNumber_Power(__pyx_t_6, __pyx_int_2, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 260, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyNumber_Divide(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 260, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_mean, __pyx_t_6) < 0) __PYX_ERR(0, 260, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_v_info->suboffsets = NULL; - /* "tigramite/tigramite_cython_code.pyx":261 - * sum_0[ii] += value - * self.mean = sum_total / (self.dim**2) - * self.mean_0 = sum_0 / (self.dim) # <<<<<<<<<<<<<< - * self.mean_1 = sum_1 / (self.dim) + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":292 + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< + * info.readonly = not PyArray_ISWRITEABLE(self) * */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 261, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_4 = __Pyx_PyNumber_Divide(((PyObject *)__pyx_v_sum_0), __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 261, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_mean_0, __pyx_t_4) < 0) __PYX_ERR(0, 261, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); - /* "tigramite/tigramite_cython_code.pyx":262 - * self.mean = sum_total / (self.dim**2) - * self.mean_0 = sum_0 / (self.dim) - * self.mean_1 = sum_1 / (self.dim) # <<<<<<<<<<<<<< + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":293 + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< * - * return + * cdef int t */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dim); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 262, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = __Pyx_PyNumber_Divide(((PyObject *)__pyx_v_sum_1), __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 262, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_mean_1, __pyx_t_6) < 0) __PYX_ERR(0, 262, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); - /* "tigramite/tigramite_cython_code.pyx":264 - * self.mean_1 = sum_1 / (self.dim) - * - * return # <<<<<<<<<<<<<< + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":296 * - * @cython.boundscheck(False) + * cdef int t + * cdef char* f = NULL # <<<<<<<<<<<<<< + * cdef dtype descr = PyArray_DESCR(self) + * cdef int offset */ - __Pyx_XDECREF(__pyx_r); - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; + __pyx_v_f = NULL; - /* "tigramite/tigramite_cython_code.pyx":243 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * def calculate_means(self): # <<<<<<<<<<<<<< - * cdef int dim = self.dim - * cdef DTYPE_t value + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":297 + * cdef int t + * cdef char* f = NULL + * cdef dtype descr = PyArray_DESCR(self) # <<<<<<<<<<<<<< + * cdef int offset + * */ + __pyx_t_7 = PyArray_DESCR(__pyx_v_self); + __pyx_t_3 = ((PyObject *)__pyx_t_7); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); + __pyx_t_3 = 0; - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sum_0.rcbuffer->pybuffer); - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sum_1.rcbuffer->pybuffer); - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); - __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} - __Pyx_AddTraceback("tigramite.tigramite_cython_code.D_N.calculate_means", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - goto __pyx_L2; - __pyx_L0:; - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sum_0.rcbuffer->pybuffer); - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sum_1.rcbuffer->pybuffer); - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); - __pyx_L2:; - __Pyx_XDECREF((PyObject *)__pyx_v_sum_0); - __Pyx_XDECREF((PyObject *)__pyx_v_sum_1); - __Pyx_XDECREF((PyObject *)__pyx_v_x); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "tigramite/tigramite_cython_code.pyx":268 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * def squared_sum(self): # <<<<<<<<<<<<<< - * cdef np.ndarray[DTYPE_t, ndim=1] mean_0 = self.mean_0 - * cdef np.ndarray[DTYPE_t, ndim=1] mean_1 = self.mean_1 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":300 + * cdef int offset + * + * info.obj = self # <<<<<<<<<<<<<< + * + * if not PyDataType_HASFIELDS(descr): */ + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); -/* Python wrapper */ -static PyObject *__pyx_pw_9tigramite_21tigramite_cython_code_3D_N_5squared_sum(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/ -static PyMethodDef __pyx_mdef_9tigramite_21tigramite_cython_code_3D_N_5squared_sum = {"squared_sum", (PyCFunction)__pyx_pw_9tigramite_21tigramite_cython_code_3D_N_5squared_sum, METH_O, 0}; -static PyObject *__pyx_pw_9tigramite_21tigramite_cython_code_3D_N_5squared_sum(PyObject *__pyx_self, PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("squared_sum (wrapper)", 0); - __pyx_r = __pyx_pf_9tigramite_21tigramite_cython_code_3D_N_4squared_sum(__pyx_self, ((PyObject *)__pyx_v_self)); + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":302 + * info.obj = self + * + * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ + __pyx_t_1 = ((!(PyDataType_HASFIELDS(__pyx_v_descr) != 0)) != 0); + if (__pyx_t_1) { - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":303 + * + * if not PyDataType_HASFIELDS(descr): + * t = descr.type_num # <<<<<<<<<<<<<< + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + */ + __pyx_t_4 = __pyx_v_descr->type_num; + __pyx_v_t = __pyx_t_4; -static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_4squared_sum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { - PyArrayObject *__pyx_v_mean_0 = 0; - PyArrayObject *__pyx_v_mean_1 = 0; - __pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t __pyx_v_mean; - __pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t __pyx_v_squared_sum; - __pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t __pyx_v_dist; - __pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t __pyx_v_d; - PyArrayObject *__pyx_v_x = 0; - unsigned int __pyx_v_dim; - unsigned int __pyx_v_ii; - unsigned int __pyx_v_jj; - __Pyx_LocalBuf_ND __pyx_pybuffernd_mean_0; - __Pyx_Buffer __pyx_pybuffer_mean_0; - __Pyx_LocalBuf_ND __pyx_pybuffernd_mean_1; - __Pyx_Buffer __pyx_pybuffer_mean_1; - __Pyx_LocalBuf_ND __pyx_pybuffernd_x; - __Pyx_Buffer __pyx_pybuffer_x; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyArrayObject *__pyx_t_2 = NULL; - PyArrayObject *__pyx_t_3 = NULL; - __pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t __pyx_t_4; - PyArrayObject *__pyx_t_5 = NULL; - unsigned int __pyx_t_6; - unsigned int __pyx_t_7; - unsigned int __pyx_t_8; - unsigned int __pyx_t_9; - unsigned int __pyx_t_10; - unsigned int __pyx_t_11; - size_t __pyx_t_12; - size_t __pyx_t_13; - size_t __pyx_t_14; - size_t __pyx_t_15; - __Pyx_RefNannySetupContext("squared_sum", 0); - __pyx_pybuffer_mean_0.pybuffer.buf = NULL; - __pyx_pybuffer_mean_0.refcount = 0; - __pyx_pybuffernd_mean_0.data = NULL; - __pyx_pybuffernd_mean_0.rcbuffer = &__pyx_pybuffer_mean_0; - __pyx_pybuffer_mean_1.pybuffer.buf = NULL; - __pyx_pybuffer_mean_1.refcount = 0; - __pyx_pybuffernd_mean_1.data = NULL; - __pyx_pybuffernd_mean_1.rcbuffer = &__pyx_pybuffer_mean_1; - __pyx_pybuffer_x.pybuffer.buf = NULL; - __pyx_pybuffer_x.refcount = 0; - __pyx_pybuffernd_x.data = NULL; - __pyx_pybuffernd_x.rcbuffer = &__pyx_pybuffer_x; - - /* "tigramite/tigramite_cython_code.pyx":269 - * @cython.wraparound(False) - * def squared_sum(self): - * cdef np.ndarray[DTYPE_t, ndim=1] mean_0 = self.mean_0 # <<<<<<<<<<<<<< - * cdef np.ndarray[DTYPE_t, ndim=1] mean_1 = self.mean_1 - * cdef DTYPE_t mean = self.mean - */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_mean_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 269, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 269, __pyx_L1_error) - __pyx_t_2 = ((PyArrayObject *)__pyx_t_1); - { - __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_mean_0.rcbuffer->pybuffer, (PyObject*)__pyx_t_2, &__Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { - __pyx_v_mean_0 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_mean_0.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 269, __pyx_L1_error) - } else {__pyx_pybuffernd_mean_0.diminfo[0].strides = __pyx_pybuffernd_mean_0.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_mean_0.diminfo[0].shape = __pyx_pybuffernd_mean_0.rcbuffer->pybuffer.shape[0]; + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":304 + * if not PyDataType_HASFIELDS(descr): + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0); + if (!__pyx_t_2) { + goto __pyx_L15_next_or; + } else { } - } - __pyx_t_2 = 0; - __pyx_v_mean_0 = ((PyArrayObject *)__pyx_t_1); - __pyx_t_1 = 0; + __pyx_t_2 = (__pyx_v_little_endian != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L14_bool_binop_done; + } + __pyx_L15_next_or:; - /* "tigramite/tigramite_cython_code.pyx":270 - * def squared_sum(self): - * cdef np.ndarray[DTYPE_t, ndim=1] mean_0 = self.mean_0 - * cdef np.ndarray[DTYPE_t, ndim=1] mean_1 = self.mean_1 # <<<<<<<<<<<<<< - * cdef DTYPE_t mean = self.mean - * cdef DTYPE_t squared_sum = 0 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":305 + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_mean_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 270, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 270, __pyx_L1_error) - __pyx_t_3 = ((PyArrayObject *)__pyx_t_1); - { - __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_mean_1.rcbuffer->pybuffer, (PyObject*)__pyx_t_3, &__Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { - __pyx_v_mean_1 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_mean_1.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 270, __pyx_L1_error) - } else {__pyx_pybuffernd_mean_1.diminfo[0].strides = __pyx_pybuffernd_mean_1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_mean_1.diminfo[0].shape = __pyx_pybuffernd_mean_1.rcbuffer->pybuffer.shape[0]; + __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L14_bool_binop_done; } - } - __pyx_t_3 = 0; - __pyx_v_mean_1 = ((PyArrayObject *)__pyx_t_1); - __pyx_t_1 = 0; + __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L14_bool_binop_done:; - /* "tigramite/tigramite_cython_code.pyx":271 - * cdef np.ndarray[DTYPE_t, ndim=1] mean_0 = self.mean_0 - * cdef np.ndarray[DTYPE_t, ndim=1] mean_1 = self.mean_1 - * cdef DTYPE_t mean = self.mean # <<<<<<<<<<<<<< - * cdef DTYPE_t squared_sum = 0 - * cdef DTYPE_t dist + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":304 + * if not PyDataType_HASFIELDS(descr): + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_mean); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 271, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == ((npy_double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 271, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_mean = __pyx_t_4; + if (unlikely(__pyx_t_1)) { - /* "tigramite/tigramite_cython_code.pyx":272 - * cdef np.ndarray[DTYPE_t, ndim=1] mean_1 = self.mean_1 - * cdef DTYPE_t mean = self.mean - * cdef DTYPE_t squared_sum = 0 # <<<<<<<<<<<<<< - * cdef DTYPE_t dist - * cdef DTYPE_t d + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":306 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" */ - __pyx_v_squared_sum = 0.0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 306, __pyx_L1_error) - /* "tigramite/tigramite_cython_code.pyx":275 - * cdef DTYPE_t dist - * cdef DTYPE_t d - * cdef np.ndarray[DTYPE_t, ndim=1] x = self.x # <<<<<<<<<<<<<< - * cdef unsigned int dim = self.dim - * cdef unsigned int ii + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":304 + * if not PyDataType_HASFIELDS(descr): + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 275, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 275, __pyx_L1_error) - __pyx_t_5 = ((PyArrayObject *)__pyx_t_1); - { - __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { - __pyx_v_x = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_x.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 275, __pyx_L1_error) - } else {__pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; } - } - __pyx_t_5 = 0; - __pyx_v_x = ((PyArrayObject *)__pyx_t_1); - __pyx_t_1 = 0; - /* "tigramite/tigramite_cython_code.pyx":276 - * cdef DTYPE_t d - * cdef np.ndarray[DTYPE_t, ndim=1] x = self.x - * cdef unsigned int dim = self.dim # <<<<<<<<<<<<<< - * cdef unsigned int ii - * cdef unsigned int jj + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":307 + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 276, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_6 = __Pyx_PyInt_As_unsigned_int(__pyx_t_1); if (unlikely((__pyx_t_6 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 276, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_dim = __pyx_t_6; + switch (__pyx_v_t) { + case NPY_BYTE: + __pyx_v_f = ((char *)"b"); + break; + case NPY_UBYTE: - /* "tigramite/tigramite_cython_code.pyx":279 - * cdef unsigned int ii - * cdef unsigned int jj - * for ii in prange(dim, nogil=True): # <<<<<<<<<<<<<< - * for jj in range(dim): - * dist = abs(x[jj] - x[ii]) + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":308 + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" */ - { - #ifdef WITH_THREAD - PyThreadState *_save; - Py_UNBLOCK_THREADS - __Pyx_FastGIL_Remember(); - #endif - /*try:*/ { - __pyx_t_6 = __pyx_v_dim; - if (1 == 0) abort(); - { - #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) - #undef likely - #undef unlikely - #define likely(x) (x) - #define unlikely(x) (x) - #endif - __pyx_t_8 = (__pyx_t_6 - 0 + 1 - 1/abs(1)) / 1; - if (__pyx_t_8 > 0) - { - #ifdef _OPENMP - #pragma omp parallel reduction(+:__pyx_v_squared_sum) private(__pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_9) - #endif /* _OPENMP */ - { - #ifdef _OPENMP - #pragma omp for lastprivate(__pyx_v_d) lastprivate(__pyx_v_dist) firstprivate(__pyx_v_ii) lastprivate(__pyx_v_ii) lastprivate(__pyx_v_jj) - #endif /* _OPENMP */ - for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_8; __pyx_t_7++){ - { - __pyx_v_ii = (unsigned int)(0 + 1 * __pyx_t_7); - /* Initialize private variables to invalid values */ - __pyx_v_d = ((__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t)__PYX_NAN()); - __pyx_v_dist = ((__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t)__PYX_NAN()); - __pyx_v_jj = ((unsigned int)0xbad0bad0); - - /* "tigramite/tigramite_cython_code.pyx":280 - * cdef unsigned int jj - * for ii in prange(dim, nogil=True): - * for jj in range(dim): # <<<<<<<<<<<<<< - * dist = abs(x[jj] - x[ii]) - * d = dist - mean_0[ii] - mean_1[jj] + mean - */ - __pyx_t_9 = __pyx_v_dim; - __pyx_t_10 = __pyx_t_9; - for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { - __pyx_v_jj = __pyx_t_11; - - /* "tigramite/tigramite_cython_code.pyx":281 - * for ii in prange(dim, nogil=True): - * for jj in range(dim): - * dist = abs(x[jj] - x[ii]) # <<<<<<<<<<<<<< - * d = dist - mean_0[ii] - mean_1[jj] + mean - * squared_sum += d * d - */ - __pyx_t_12 = __pyx_v_jj; - __pyx_t_13 = __pyx_v_ii; - __pyx_v_dist = __pyx_f_9tigramite_21tigramite_cython_code_abs(((*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_12, __pyx_pybuffernd_x.diminfo[0].strides)) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_13, __pyx_pybuffernd_x.diminfo[0].strides)))); - - /* "tigramite/tigramite_cython_code.pyx":282 - * for jj in range(dim): - * dist = abs(x[jj] - x[ii]) - * d = dist - mean_0[ii] - mean_1[jj] + mean # <<<<<<<<<<<<<< - * squared_sum += d * d - * return squared_sum - */ - __pyx_t_14 = __pyx_v_ii; - __pyx_t_15 = __pyx_v_jj; - __pyx_v_d = (((__pyx_v_dist - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_mean_0.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_mean_0.diminfo[0].strides))) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_mean_1.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_mean_1.diminfo[0].strides))) + __pyx_v_mean); - - /* "tigramite/tigramite_cython_code.pyx":283 - * dist = abs(x[jj] - x[ii]) - * d = dist - mean_0[ii] - mean_1[jj] + mean - * squared_sum += d * d # <<<<<<<<<<<<<< - * return squared_sum - * - */ - __pyx_v_squared_sum = (__pyx_v_squared_sum + (__pyx_v_d * __pyx_v_d)); - } - } - } - } - } - } - #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) - #undef likely - #undef unlikely - #define likely(x) __builtin_expect(!!(x), 1) - #define unlikely(x) __builtin_expect(!!(x), 0) - #endif - } + __pyx_v_f = ((char *)"B"); + break; + case NPY_SHORT: - /* "tigramite/tigramite_cython_code.pyx":279 - * cdef unsigned int ii - * cdef unsigned int jj - * for ii in prange(dim, nogil=True): # <<<<<<<<<<<<<< - * for jj in range(dim): - * dist = abs(x[jj] - x[ii]) - */ - /*finally:*/ { - /*normal exit:*/{ - #ifdef WITH_THREAD - __Pyx_FastGIL_Forget(); - Py_BLOCK_THREADS - #endif - goto __pyx_L5; - } - __pyx_L5:; - } - } + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":309 + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + */ + __pyx_v_f = ((char *)"h"); + break; + case NPY_USHORT: - /* "tigramite/tigramite_cython_code.pyx":284 - * d = dist - mean_0[ii] - mean_1[jj] + mean - * squared_sum += d * d - * return squared_sum # <<<<<<<<<<<<<< - * - * @cython.boundscheck(False) + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":310 + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_squared_sum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 284, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + __pyx_v_f = ((char *)"H"); + break; + case NPY_INT: - /* "tigramite/tigramite_cython_code.pyx":268 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * def squared_sum(self): # <<<<<<<<<<<<<< - * cdef np.ndarray[DTYPE_t, ndim=1] mean_0 = self.mean_0 - * cdef np.ndarray[DTYPE_t, ndim=1] mean_1 = self.mean_1 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":311 + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" */ + __pyx_v_f = ((char *)"i"); + break; + case NPY_UINT: - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mean_0.rcbuffer->pybuffer); - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mean_1.rcbuffer->pybuffer); - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); - __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} - __Pyx_AddTraceback("tigramite.tigramite_cython_code.D_N.squared_sum", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - goto __pyx_L2; - __pyx_L0:; - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mean_0.rcbuffer->pybuffer); - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mean_1.rcbuffer->pybuffer); - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); - __pyx_L2:; - __Pyx_XDECREF((PyObject *)__pyx_v_mean_0); - __Pyx_XDECREF((PyObject *)__pyx_v_mean_1); - __Pyx_XDECREF((PyObject *)__pyx_v_x); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":312 + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + */ + __pyx_v_f = ((char *)"I"); + break; + case NPY_LONG: -/* "tigramite/tigramite_cython_code.pyx":288 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * def product_sum(self, other): # <<<<<<<<<<<<<< - * cdef np.ndarray[DTYPE_t, ndim=1] mean_0_here = self.mean_0 - * cdef np.ndarray[DTYPE_t, ndim=1] mean_1_here = self.mean_1 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":313 + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" */ + __pyx_v_f = ((char *)"l"); + break; + case NPY_ULONG: -/* Python wrapper */ -static PyObject *__pyx_pw_9tigramite_21tigramite_cython_code_3D_N_7product_sum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyMethodDef __pyx_mdef_9tigramite_21tigramite_cython_code_3D_N_7product_sum = {"product_sum", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9tigramite_21tigramite_cython_code_3D_N_7product_sum, METH_VARARGS|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_9tigramite_21tigramite_cython_code_3D_N_7product_sum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_self = 0; - PyObject *__pyx_v_other = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("product_sum (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_other,0}; - PyObject* values[2] = {0,0}; - if (unlikely(__pyx_kwds)) { - Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { - case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_other)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("product_sum", 1, 2, 2, 1); __PYX_ERR(0, 288, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "product_sum") < 0)) __PYX_ERR(0, 288, __pyx_L3_error) - } - } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - } - __pyx_v_self = values[0]; - __pyx_v_other = values[1]; - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("product_sum", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 288, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("tigramite.tigramite_cython_code.D_N.product_sum", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_9tigramite_21tigramite_cython_code_3D_N_6product_sum(__pyx_self, __pyx_v_self, __pyx_v_other); + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":314 + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + */ + __pyx_v_f = ((char *)"L"); + break; + case NPY_LONGLONG: - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":315 + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + */ + __pyx_v_f = ((char *)"q"); + break; + case NPY_ULONGLONG: -static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_6product_sum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_other) { - PyArrayObject *__pyx_v_mean_0_here = 0; - PyArrayObject *__pyx_v_mean_1_here = 0; - __pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t __pyx_v_mean_here; - PyArrayObject *__pyx_v_mean_0_there = 0; - PyArrayObject *__pyx_v_mean_1_there = 0; - __pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t __pyx_v_mean_there; - __pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t __pyx_v_d_here; - __pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t __pyx_v_d_there; - __pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t __pyx_v_product_sum; - PyArrayObject *__pyx_v_x = 0; - PyArrayObject *__pyx_v_y = 0; - unsigned int __pyx_v_dim; - unsigned int __pyx_v_ii; - unsigned int __pyx_v_jj; - __Pyx_LocalBuf_ND __pyx_pybuffernd_mean_0_here; - __Pyx_Buffer __pyx_pybuffer_mean_0_here; - __Pyx_LocalBuf_ND __pyx_pybuffernd_mean_0_there; - __Pyx_Buffer __pyx_pybuffer_mean_0_there; - __Pyx_LocalBuf_ND __pyx_pybuffernd_mean_1_here; - __Pyx_Buffer __pyx_pybuffer_mean_1_here; - __Pyx_LocalBuf_ND __pyx_pybuffernd_mean_1_there; - __Pyx_Buffer __pyx_pybuffer_mean_1_there; - __Pyx_LocalBuf_ND __pyx_pybuffernd_x; - __Pyx_Buffer __pyx_pybuffer_x; - __Pyx_LocalBuf_ND __pyx_pybuffernd_y; - __Pyx_Buffer __pyx_pybuffer_y; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyArrayObject *__pyx_t_2 = NULL; - PyArrayObject *__pyx_t_3 = NULL; - __pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t __pyx_t_4; - PyArrayObject *__pyx_t_5 = NULL; - PyArrayObject *__pyx_t_6 = NULL; - PyArrayObject *__pyx_t_7 = NULL; - PyArrayObject *__pyx_t_8 = NULL; - unsigned int __pyx_t_9; - unsigned int __pyx_t_10; - unsigned int __pyx_t_11; - unsigned int __pyx_t_12; - unsigned int __pyx_t_13; - unsigned int __pyx_t_14; - size_t __pyx_t_15; - size_t __pyx_t_16; - size_t __pyx_t_17; - size_t __pyx_t_18; - size_t __pyx_t_19; - size_t __pyx_t_20; - size_t __pyx_t_21; - size_t __pyx_t_22; - __Pyx_RefNannySetupContext("product_sum", 0); - __pyx_pybuffer_mean_0_here.pybuffer.buf = NULL; - __pyx_pybuffer_mean_0_here.refcount = 0; - __pyx_pybuffernd_mean_0_here.data = NULL; - __pyx_pybuffernd_mean_0_here.rcbuffer = &__pyx_pybuffer_mean_0_here; - __pyx_pybuffer_mean_1_here.pybuffer.buf = NULL; - __pyx_pybuffer_mean_1_here.refcount = 0; - __pyx_pybuffernd_mean_1_here.data = NULL; - __pyx_pybuffernd_mean_1_here.rcbuffer = &__pyx_pybuffer_mean_1_here; - __pyx_pybuffer_mean_0_there.pybuffer.buf = NULL; - __pyx_pybuffer_mean_0_there.refcount = 0; - __pyx_pybuffernd_mean_0_there.data = NULL; - __pyx_pybuffernd_mean_0_there.rcbuffer = &__pyx_pybuffer_mean_0_there; - __pyx_pybuffer_mean_1_there.pybuffer.buf = NULL; - __pyx_pybuffer_mean_1_there.refcount = 0; - __pyx_pybuffernd_mean_1_there.data = NULL; - __pyx_pybuffernd_mean_1_there.rcbuffer = &__pyx_pybuffer_mean_1_there; - __pyx_pybuffer_x.pybuffer.buf = NULL; - __pyx_pybuffer_x.refcount = 0; - __pyx_pybuffernd_x.data = NULL; - __pyx_pybuffernd_x.rcbuffer = &__pyx_pybuffer_x; - __pyx_pybuffer_y.pybuffer.buf = NULL; - __pyx_pybuffer_y.refcount = 0; - __pyx_pybuffernd_y.data = NULL; - __pyx_pybuffernd_y.rcbuffer = &__pyx_pybuffer_y; - - /* "tigramite/tigramite_cython_code.pyx":289 - * @cython.wraparound(False) - * def product_sum(self, other): - * cdef np.ndarray[DTYPE_t, ndim=1] mean_0_here = self.mean_0 # <<<<<<<<<<<<<< - * cdef np.ndarray[DTYPE_t, ndim=1] mean_1_here = self.mean_1 - * cdef DTYPE_t mean_here = self.mean - */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_mean_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 289, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 289, __pyx_L1_error) - __pyx_t_2 = ((PyArrayObject *)__pyx_t_1); - { - __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_mean_0_here.rcbuffer->pybuffer, (PyObject*)__pyx_t_2, &__Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { - __pyx_v_mean_0_here = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_mean_0_here.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 289, __pyx_L1_error) - } else {__pyx_pybuffernd_mean_0_here.diminfo[0].strides = __pyx_pybuffernd_mean_0_here.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_mean_0_here.diminfo[0].shape = __pyx_pybuffernd_mean_0_here.rcbuffer->pybuffer.shape[0]; - } - } - __pyx_t_2 = 0; - __pyx_v_mean_0_here = ((PyArrayObject *)__pyx_t_1); - __pyx_t_1 = 0; + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":316 + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + */ + __pyx_v_f = ((char *)"Q"); + break; + case NPY_FLOAT: - /* "tigramite/tigramite_cython_code.pyx":290 - * def product_sum(self, other): - * cdef np.ndarray[DTYPE_t, ndim=1] mean_0_here = self.mean_0 - * cdef np.ndarray[DTYPE_t, ndim=1] mean_1_here = self.mean_1 # <<<<<<<<<<<<<< - * cdef DTYPE_t mean_here = self.mean - * cdef np.ndarray[DTYPE_t, ndim=1] mean_0_there = other.mean_0 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":317 + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_mean_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 290, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 290, __pyx_L1_error) - __pyx_t_3 = ((PyArrayObject *)__pyx_t_1); - { - __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_mean_1_here.rcbuffer->pybuffer, (PyObject*)__pyx_t_3, &__Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { - __pyx_v_mean_1_here = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_mean_1_here.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 290, __pyx_L1_error) - } else {__pyx_pybuffernd_mean_1_here.diminfo[0].strides = __pyx_pybuffernd_mean_1_here.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_mean_1_here.diminfo[0].shape = __pyx_pybuffernd_mean_1_here.rcbuffer->pybuffer.shape[0]; - } - } - __pyx_t_3 = 0; - __pyx_v_mean_1_here = ((PyArrayObject *)__pyx_t_1); - __pyx_t_1 = 0; + __pyx_v_f = ((char *)"f"); + break; + case NPY_DOUBLE: - /* "tigramite/tigramite_cython_code.pyx":291 - * cdef np.ndarray[DTYPE_t, ndim=1] mean_0_here = self.mean_0 - * cdef np.ndarray[DTYPE_t, ndim=1] mean_1_here = self.mean_1 - * cdef DTYPE_t mean_here = self.mean # <<<<<<<<<<<<<< - * cdef np.ndarray[DTYPE_t, ndim=1] mean_0_there = other.mean_0 - * cdef np.ndarray[DTYPE_t, ndim=1] mean_1_there = other.mean_1 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":318 + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_mean); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 291, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == ((npy_double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 291, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_mean_here = __pyx_t_4; + __pyx_v_f = ((char *)"d"); + break; + case NPY_LONGDOUBLE: - /* "tigramite/tigramite_cython_code.pyx":292 - * cdef np.ndarray[DTYPE_t, ndim=1] mean_1_here = self.mean_1 - * cdef DTYPE_t mean_here = self.mean - * cdef np.ndarray[DTYPE_t, ndim=1] mean_0_there = other.mean_0 # <<<<<<<<<<<<<< - * cdef np.ndarray[DTYPE_t, ndim=1] mean_1_there = other.mean_1 - * cdef DTYPE_t mean_there = other.mean + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":319 + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_mean_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 292, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 292, __pyx_L1_error) - __pyx_t_5 = ((PyArrayObject *)__pyx_t_1); - { - __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_mean_0_there.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { - __pyx_v_mean_0_there = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_mean_0_there.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 292, __pyx_L1_error) - } else {__pyx_pybuffernd_mean_0_there.diminfo[0].strides = __pyx_pybuffernd_mean_0_there.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_mean_0_there.diminfo[0].shape = __pyx_pybuffernd_mean_0_there.rcbuffer->pybuffer.shape[0]; - } - } - __pyx_t_5 = 0; - __pyx_v_mean_0_there = ((PyArrayObject *)__pyx_t_1); - __pyx_t_1 = 0; + __pyx_v_f = ((char *)"g"); + break; + case NPY_CFLOAT: - /* "tigramite/tigramite_cython_code.pyx":293 - * cdef DTYPE_t mean_here = self.mean - * cdef np.ndarray[DTYPE_t, ndim=1] mean_0_there = other.mean_0 - * cdef np.ndarray[DTYPE_t, ndim=1] mean_1_there = other.mean_1 # <<<<<<<<<<<<<< - * cdef DTYPE_t mean_there = other.mean - * cdef DTYPE_t d_here + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":320 + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_mean_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 293, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 293, __pyx_L1_error) - __pyx_t_6 = ((PyArrayObject *)__pyx_t_1); - { - __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_mean_1_there.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { - __pyx_v_mean_1_there = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_mean_1_there.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 293, __pyx_L1_error) - } else {__pyx_pybuffernd_mean_1_there.diminfo[0].strides = __pyx_pybuffernd_mean_1_there.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_mean_1_there.diminfo[0].shape = __pyx_pybuffernd_mean_1_there.rcbuffer->pybuffer.shape[0]; - } - } - __pyx_t_6 = 0; - __pyx_v_mean_1_there = ((PyArrayObject *)__pyx_t_1); - __pyx_t_1 = 0; + __pyx_v_f = ((char *)"Zf"); + break; + case NPY_CDOUBLE: - /* "tigramite/tigramite_cython_code.pyx":294 - * cdef np.ndarray[DTYPE_t, ndim=1] mean_0_there = other.mean_0 - * cdef np.ndarray[DTYPE_t, ndim=1] mean_1_there = other.mean_1 - * cdef DTYPE_t mean_there = other.mean # <<<<<<<<<<<<<< - * cdef DTYPE_t d_here - * cdef DTYPE_t d_there + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":321 + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_mean); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 294, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == ((npy_double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 294, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_mean_there = __pyx_t_4; + __pyx_v_f = ((char *)"Zd"); + break; + case NPY_CLONGDOUBLE: - /* "tigramite/tigramite_cython_code.pyx":297 - * cdef DTYPE_t d_here - * cdef DTYPE_t d_there - * cdef DTYPE_t product_sum = 0 # <<<<<<<<<<<<<< - * cdef np.ndarray[DTYPE_t, ndim=1] x = self.x - * cdef np.ndarray[DTYPE_t, ndim=1] y = other.x + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":322 + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f = "O" + * else: */ - __pyx_v_product_sum = 0.0; + __pyx_v_f = ((char *)"Zg"); + break; + case NPY_OBJECT: - /* "tigramite/tigramite_cython_code.pyx":298 - * cdef DTYPE_t d_there - * cdef DTYPE_t product_sum = 0 - * cdef np.ndarray[DTYPE_t, ndim=1] x = self.x # <<<<<<<<<<<<<< - * cdef np.ndarray[DTYPE_t, ndim=1] y = other.x - * + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":323 + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 298, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 298, __pyx_L1_error) - __pyx_t_7 = ((PyArrayObject *)__pyx_t_1); - { - __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { - __pyx_v_x = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_x.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 298, __pyx_L1_error) - } else {__pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; - } - } - __pyx_t_7 = 0; - __pyx_v_x = ((PyArrayObject *)__pyx_t_1); - __pyx_t_1 = 0; + __pyx_v_f = ((char *)"O"); + break; + default: - /* "tigramite/tigramite_cython_code.pyx":299 - * cdef DTYPE_t product_sum = 0 - * cdef np.ndarray[DTYPE_t, ndim=1] x = self.x - * cdef np.ndarray[DTYPE_t, ndim=1] y = other.x # <<<<<<<<<<<<<< - * - * cdef unsigned int dim = self.dim + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":325 + * elif t == NPY_OBJECT: f = "O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * info.format = f + * return */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 299, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 299, __pyx_L1_error) - __pyx_t_8 = ((PyArrayObject *)__pyx_t_1); - { - __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_y.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { - __pyx_v_y = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_y.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 299, __pyx_L1_error) - } else {__pyx_pybuffernd_y.diminfo[0].strides = __pyx_pybuffernd_y.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_y.diminfo[0].shape = __pyx_pybuffernd_y.rcbuffer->pybuffer.shape[0]; + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 325, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 325, __pyx_L1_error) + break; } - } - __pyx_t_8 = 0; - __pyx_v_y = ((PyArrayObject *)__pyx_t_1); - __pyx_t_1 = 0; - /* "tigramite/tigramite_cython_code.pyx":301 - * cdef np.ndarray[DTYPE_t, ndim=1] y = other.x - * - * cdef unsigned int dim = self.dim # <<<<<<<<<<<<<< - * cdef unsigned int ii - * cdef unsigned int jj + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":326 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f # <<<<<<<<<<<<<< + * return + * else: */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 301, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_9 = __Pyx_PyInt_As_unsigned_int(__pyx_t_1); if (unlikely((__pyx_t_9 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 301, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_dim = __pyx_t_9; + __pyx_v_info->format = __pyx_v_f; - /* "tigramite/tigramite_cython_code.pyx":304 - * cdef unsigned int ii - * cdef unsigned int jj - * for ii in prange(dim, nogil=True): # <<<<<<<<<<<<<< - * for jj in range(dim): - * d_here = abs(x[jj] - x[ii]) - mean_0_here[ii] - mean_1_here[jj] + mean_here + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":327 + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f + * return # <<<<<<<<<<<<<< + * else: + * info.format = PyObject_Malloc(_buffer_format_string_len) */ - { - #ifdef WITH_THREAD - PyThreadState *_save; - Py_UNBLOCK_THREADS - __Pyx_FastGIL_Remember(); - #endif - /*try:*/ { - __pyx_t_9 = __pyx_v_dim; - if (1 == 0) abort(); - { - #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) - #undef likely - #undef unlikely - #define likely(x) (x) - #define unlikely(x) (x) - #endif - __pyx_t_11 = (__pyx_t_9 - 0 + 1 - 1/abs(1)) / 1; - if (__pyx_t_11 > 0) - { - #ifdef _OPENMP - #pragma omp parallel reduction(+:__pyx_v_product_sum) private(__pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_t_18, __pyx_t_19, __pyx_t_20, __pyx_t_21, __pyx_t_22) - #endif /* _OPENMP */ - { - #ifdef _OPENMP - #pragma omp for lastprivate(__pyx_v_d_here) lastprivate(__pyx_v_d_there) firstprivate(__pyx_v_ii) lastprivate(__pyx_v_ii) lastprivate(__pyx_v_jj) - #endif /* _OPENMP */ - for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_11; __pyx_t_10++){ - { - __pyx_v_ii = (unsigned int)(0 + 1 * __pyx_t_10); - /* Initialize private variables to invalid values */ - __pyx_v_d_here = ((__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t)__PYX_NAN()); - __pyx_v_d_there = ((__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t)__PYX_NAN()); - __pyx_v_jj = ((unsigned int)0xbad0bad0); - - /* "tigramite/tigramite_cython_code.pyx":305 - * cdef unsigned int jj - * for ii in prange(dim, nogil=True): - * for jj in range(dim): # <<<<<<<<<<<<<< - * d_here = abs(x[jj] - x[ii]) - mean_0_here[ii] - mean_1_here[jj] + mean_here - * d_there = abs(y[jj] - y[ii]) - mean_0_there[ii] - mean_1_there[jj] + mean_there - */ - __pyx_t_12 = __pyx_v_dim; - __pyx_t_13 = __pyx_t_12; - for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { - __pyx_v_jj = __pyx_t_14; - - /* "tigramite/tigramite_cython_code.pyx":306 - * for ii in prange(dim, nogil=True): - * for jj in range(dim): - * d_here = abs(x[jj] - x[ii]) - mean_0_here[ii] - mean_1_here[jj] + mean_here # <<<<<<<<<<<<<< - * d_there = abs(y[jj] - y[ii]) - mean_0_there[ii] - mean_1_there[jj] + mean_there - * product_sum += d_here * d_there - */ - __pyx_t_15 = __pyx_v_jj; - __pyx_t_16 = __pyx_v_ii; - __pyx_t_17 = __pyx_v_ii; - __pyx_t_18 = __pyx_v_jj; - __pyx_v_d_here = (((__pyx_f_9tigramite_21tigramite_cython_code_abs(((*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_x.diminfo[0].strides)) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_x.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_x.diminfo[0].strides)))) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_mean_0_here.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_mean_0_here.diminfo[0].strides))) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_mean_1_here.rcbuffer->pybuffer.buf, __pyx_t_18, __pyx_pybuffernd_mean_1_here.diminfo[0].strides))) + __pyx_v_mean_here); - - /* "tigramite/tigramite_cython_code.pyx":307 - * for jj in range(dim): - * d_here = abs(x[jj] - x[ii]) - mean_0_here[ii] - mean_1_here[jj] + mean_here - * d_there = abs(y[jj] - y[ii]) - mean_0_there[ii] - mean_1_there[jj] + mean_there # <<<<<<<<<<<<<< - * product_sum += d_here * d_there - * return product_sum - */ - __pyx_t_19 = __pyx_v_jj; - __pyx_t_20 = __pyx_v_ii; - __pyx_t_21 = __pyx_v_ii; - __pyx_t_22 = __pyx_v_jj; - __pyx_v_d_there = (((__pyx_f_9tigramite_21tigramite_cython_code_abs(((*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_y.rcbuffer->pybuffer.buf, __pyx_t_19, __pyx_pybuffernd_y.diminfo[0].strides)) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_y.rcbuffer->pybuffer.buf, __pyx_t_20, __pyx_pybuffernd_y.diminfo[0].strides)))) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_mean_0_there.rcbuffer->pybuffer.buf, __pyx_t_21, __pyx_pybuffernd_mean_0_there.diminfo[0].strides))) - (*__Pyx_BufPtrStrided1d(__pyx_t_9tigramite_21tigramite_cython_code_DTYPE_t *, __pyx_pybuffernd_mean_1_there.rcbuffer->pybuffer.buf, __pyx_t_22, __pyx_pybuffernd_mean_1_there.diminfo[0].strides))) + __pyx_v_mean_there); - - /* "tigramite/tigramite_cython_code.pyx":308 - * d_here = abs(x[jj] - x[ii]) - mean_0_here[ii] - mean_1_here[jj] + mean_here - * d_there = abs(y[jj] - y[ii]) - mean_0_there[ii] - mean_1_there[jj] + mean_there - * product_sum += d_here * d_there # <<<<<<<<<<<<<< - * return product_sum - */ - __pyx_v_product_sum = (__pyx_v_product_sum + (__pyx_v_d_here * __pyx_v_d_there)); - } - } - } - } - } - } - #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) - #undef likely - #undef unlikely - #define likely(x) __builtin_expect(!!(x), 1) - #define unlikely(x) __builtin_expect(!!(x), 0) - #endif - } + __pyx_r = 0; + goto __pyx_L0; - /* "tigramite/tigramite_cython_code.pyx":304 - * cdef unsigned int ii - * cdef unsigned int jj - * for ii in prange(dim, nogil=True): # <<<<<<<<<<<<<< - * for jj in range(dim): - * d_here = abs(x[jj] - x[ii]) - mean_0_here[ii] - mean_1_here[jj] + mean_here - */ - /*finally:*/ { - /*normal exit:*/{ - #ifdef WITH_THREAD - __Pyx_FastGIL_Forget(); - Py_BLOCK_THREADS - #endif - goto __pyx_L5; - } - __pyx_L5:; - } + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":302 + * info.obj = self + * + * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ } - /* "tigramite/tigramite_cython_code.pyx":309 - * d_there = abs(y[jj] - y[ii]) - mean_0_there[ii] - mean_1_there[jj] + mean_there - * product_sum += d_here * d_there - * return product_sum # <<<<<<<<<<<<<< + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":329 + * return + * else: + * info.format = PyObject_Malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_product_sum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 309, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + /*else*/ { + __pyx_v_info->format = ((char *)PyObject_Malloc(0xFF)); - /* "tigramite/tigramite_cython_code.pyx":288 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * def product_sum(self, other): # <<<<<<<<<<<<<< - * cdef np.ndarray[DTYPE_t, ndim=1] mean_0_here = self.mean_0 - * cdef np.ndarray[DTYPE_t, ndim=1] mean_1_here = self.mean_1 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":330 + * else: + * info.format = PyObject_Malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, */ + (__pyx_v_info->format[0]) = '^'; - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mean_0_here.rcbuffer->pybuffer); - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mean_0_there.rcbuffer->pybuffer); - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mean_1_here.rcbuffer->pybuffer); - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mean_1_there.rcbuffer->pybuffer); - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_y.rcbuffer->pybuffer); - __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} - __Pyx_AddTraceback("tigramite.tigramite_cython_code.D_N.product_sum", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - goto __pyx_L2; - __pyx_L0:; - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mean_0_here.rcbuffer->pybuffer); - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mean_0_there.rcbuffer->pybuffer); - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mean_1_here.rcbuffer->pybuffer); - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mean_1_there.rcbuffer->pybuffer); - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); - __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_y.rcbuffer->pybuffer); - __pyx_L2:; - __Pyx_XDECREF((PyObject *)__pyx_v_mean_0_here); - __Pyx_XDECREF((PyObject *)__pyx_v_mean_1_here); - __Pyx_XDECREF((PyObject *)__pyx_v_mean_0_there); - __Pyx_XDECREF((PyObject *)__pyx_v_mean_1_there); - __Pyx_XDECREF((PyObject *)__pyx_v_x); - __Pyx_XDECREF((PyObject *)__pyx_v_y); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":331 + * info.format = PyObject_Malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 # <<<<<<<<<<<<<< + * f = _util_dtypestring(descr, info.format + 1, + * info.format + _buffer_format_string_len, + */ + __pyx_v_offset = 0; -/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":258 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":332 + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< + * info.format + _buffer_format_string_len, + * &offset) + */ + __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 332, __pyx_L1_error) + __pyx_v_f = __pyx_t_9; + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":335 + * info.format + _buffer_format_string_len, + * &offset) + * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + */ + (__pyx_v_f[0]) = '\x00'; + } + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":258 * # experimental exception made for __getbuffer__ and __releasebuffer__ * # -- the details of this may change. * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< @@ -6553,4273 +5130,4060 @@ static PyObject *__pyx_pf_9tigramite_21tigramite_cython_code_3D_N_6product_sum(C * # requirements, and does not yet fulfill the PEP. */ + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_descr); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":337 + * f[0] = c'\0' # Terminate format string + * + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * PyObject_Free(info.format) + */ + /* Python wrapper */ -static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ -static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { - int __pyx_r; +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) { __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); - __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0); + __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info)); /* function exit code */ __Pyx_RefNannyFinishContext(); - return __pyx_r; } -static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { - int __pyx_v_i; - int __pyx_v_ndim; - int __pyx_v_endian_detector; - int __pyx_v_little_endian; - int __pyx_v_t; - char *__pyx_v_f; - PyArray_Descr *__pyx_v_descr = 0; - int __pyx_v_offset; - int __pyx_r; +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) { __Pyx_RefNannyDeclarations int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - int __pyx_t_5; - int __pyx_t_6; - PyArray_Descr *__pyx_t_7; - PyObject *__pyx_t_8 = NULL; - char *__pyx_t_9; - if (__pyx_v_info == NULL) { - PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); - return -1; - } - __Pyx_RefNannySetupContext("__getbuffer__", 0); - __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(__pyx_v_info->obj); - - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":265 - * - * cdef int i, ndim - * cdef int endian_detector = 1 # <<<<<<<<<<<<<< - * cdef bint little_endian = ((&endian_detector)[0] != 0) - * - */ - __pyx_v_endian_detector = 1; + __Pyx_RefNannySetupContext("__releasebuffer__", 0); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":266 - * cdef int i, ndim - * cdef int endian_detector = 1 - * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":338 * - * ndim = PyArray_NDIM(self) + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * PyObject_Free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): */ - __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); + if (__pyx_t_1) { - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":268 - * cdef bint little_endian = ((&endian_detector)[0] != 0) - * - * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< - * - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":339 + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): + * PyObject_Free(info.format) # <<<<<<<<<<<<<< + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * PyObject_Free(info.strides) */ - __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); + PyObject_Free(__pyx_v_info->format); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":270 - * ndim = PyArray_NDIM(self) + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":338 * - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): - * raise ValueError(u"ndarray is not C contiguous") + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * PyObject_Free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): */ - __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L4_bool_binop_done; } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":271 - * - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< - * raise ValueError(u"ndarray is not C contiguous") - * - */ - __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_C_CONTIGUOUS) != 0)) != 0); - __pyx_t_1 = __pyx_t_2; - __pyx_L4_bool_binop_done:; - - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":270 - * ndim = PyArray_NDIM(self) - * - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): - * raise ValueError(u"ndarray is not C contiguous") + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":340 + * if PyArray_HASFIELDS(self): + * PyObject_Free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * PyObject_Free(info.strides) + * # info.shape was stored after info.strides in the same block */ - if (unlikely(__pyx_t_1)) { + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":272 - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): - * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":341 + * PyObject_Free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * PyObject_Free(info.strides) # <<<<<<<<<<<<<< + * # info.shape was stored after info.strides in the same block * - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 272, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 272, __pyx_L1_error) + PyObject_Free(__pyx_v_info->strides); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":270 - * ndim = PyArray_NDIM(self) - * - * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): - * raise ValueError(u"ndarray is not C contiguous") + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":340 + * if PyArray_HASFIELDS(self): + * PyObject_Free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * PyObject_Free(info.strides) + * # info.shape was stored after info.strides in the same block */ } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":274 - * raise ValueError(u"ndarray is not C contiguous") + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":337 + * f[0] = c'\0' # Terminate format string * - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): - * raise ValueError(u"ndarray is not Fortran contiguous") + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * PyObject_Free(info.format) */ - __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L7_bool_binop_done; - } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":275 + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":821 + * ctypedef npy_cdouble complex_t * - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< - * raise ValueError(u"ndarray is not Fortran contiguous") + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) * */ - __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_F_CONTIGUOUS) != 0)) != 0); - __pyx_t_1 = __pyx_t_2; - __pyx_L7_bool_binop_done:; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":274 - * raise ValueError(u"ndarray is not C contiguous") +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":822 * - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): - * raise ValueError(u"ndarray is not Fortran contiguous") + * cdef inline object PyArray_MultiIterNew1(a): + * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew2(a, b): */ - if (unlikely(__pyx_t_1)) { + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 822, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":276 - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): - * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":821 + * ctypedef npy_cdouble complex_t * - * info.buf = PyArray_DATA(self) - */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 276, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 276, __pyx_L1_error) - - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":274 - * raise ValueError(u"ndarray is not C contiguous") + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) * - * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< - * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): - * raise ValueError(u"ndarray is not Fortran contiguous") */ - } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":278 - * raise ValueError(u"ndarray is not Fortran contiguous") - * - * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< - * info.ndim = ndim - * if sizeof(npy_intp) != sizeof(Py_ssize_t): - */ - __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":279 +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":824 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) * - * info.buf = PyArray_DATA(self) - * info.ndim = ndim # <<<<<<<<<<<<<< - * if sizeof(npy_intp) != sizeof(Py_ssize_t): - * # Allocate new buffer for strides and shape info. */ - __pyx_v_info->ndim = __pyx_v_ndim; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":280 - * info.buf = PyArray_DATA(self) - * info.ndim = ndim - * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< - * # Allocate new buffer for strides and shape info. - * # This is allocated as one block, strides first. - */ - __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); - if (__pyx_t_1) { +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":283 - * # Allocate new buffer for strides and shape info. - * # This is allocated as one block, strides first. - * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) # <<<<<<<<<<<<<< - * info.shape = info.strides + ndim - * for i in range(ndim): + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":825 + * + * cdef inline object PyArray_MultiIterNew2(a, b): + * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): */ - __pyx_v_info->strides = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * 2) * ((size_t)__pyx_v_ndim)))); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 825, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":284 - * # This is allocated as one block, strides first. - * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) - * info.shape = info.strides + ndim # <<<<<<<<<<<<<< - * for i in range(ndim): - * info.strides[i] = PyArray_STRIDES(self)[i] + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":824 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * */ - __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":285 - * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) - * info.shape = info.strides + ndim - * for i in range(ndim): # <<<<<<<<<<<<<< - * info.strides[i] = PyArray_STRIDES(self)[i] - * info.shape[i] = PyArray_DIMS(self)[i] - */ - __pyx_t_4 = __pyx_v_ndim; - __pyx_t_5 = __pyx_t_4; - for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { - __pyx_v_i = __pyx_t_6; + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":286 - * info.shape = info.strides + ndim - * for i in range(ndim): - * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< - * info.shape[i] = PyArray_DIMS(self)[i] - * else: +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":827 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * */ - (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":287 - * for i in range(ndim): - * info.strides[i] = PyArray_STRIDES(self)[i] - * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< - * else: - * info.strides = PyArray_STRIDES(self) - */ - (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); - } +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":280 - * info.buf = PyArray_DATA(self) - * info.ndim = ndim - * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< - * # Allocate new buffer for strides and shape info. - * # This is allocated as one block, strides first. + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":828 + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ - goto __pyx_L9; - } + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 828, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":289 - * info.shape[i] = PyArray_DIMS(self)[i] - * else: - * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< - * info.shape = PyArray_DIMS(self) - * info.suboffsets = NULL + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":827 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * */ - /*else*/ { - __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":290 - * else: - * info.strides = PyArray_STRIDES(self) - * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< - * info.suboffsets = NULL - * info.itemsize = PyArray_ITEMSIZE(self) - */ - __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self)); - } - __pyx_L9:; + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":291 - * info.strides = PyArray_STRIDES(self) - * info.shape = PyArray_DIMS(self) - * info.suboffsets = NULL # <<<<<<<<<<<<<< - * info.itemsize = PyArray_ITEMSIZE(self) - * info.readonly = not PyArray_ISWRITEABLE(self) +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":830 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * */ - __pyx_v_info->suboffsets = NULL; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":292 - * info.shape = PyArray_DIMS(self) - * info.suboffsets = NULL - * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< - * info.readonly = not PyArray_ISWRITEABLE(self) +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":831 + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): */ - __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 831, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":293 - * info.suboffsets = NULL - * info.itemsize = PyArray_ITEMSIZE(self) - * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":830 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) * - * cdef int t */ - __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":296 - * - * cdef int t - * cdef char* f = NULL # <<<<<<<<<<<<<< - * cdef dtype descr = PyArray_DESCR(self) - * cdef int offset - */ - __pyx_v_f = NULL; + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":297 - * cdef int t - * cdef char* f = NULL - * cdef dtype descr = PyArray_DESCR(self) # <<<<<<<<<<<<<< - * cdef int offset +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":833 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) * */ - __pyx_t_7 = PyArray_DESCR(__pyx_v_self); - __pyx_t_3 = ((PyObject *)__pyx_t_7); - __Pyx_INCREF(__pyx_t_3); - __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); - __pyx_t_3 = 0; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":300 - * cdef int offset +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":834 * - * info.obj = self # <<<<<<<<<<<<<< + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< * - * if not PyDataType_HASFIELDS(descr): + * cdef inline tuple PyDataType_SHAPE(dtype d): */ - __Pyx_INCREF(((PyObject *)__pyx_v_self)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); - __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 834, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":302 - * info.obj = self + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":833 + * return PyArray_MultiIterNew(4, a, b, c, d) * - * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< - * t = descr.type_num - * if ((descr.byteorder == c'>' and little_endian) or - */ - __pyx_t_1 = ((!(PyDataType_HASFIELDS(__pyx_v_descr) != 0)) != 0); - if (__pyx_t_1) { - - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":303 + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) * - * if not PyDataType_HASFIELDS(descr): - * t = descr.type_num # <<<<<<<<<<<<<< - * if ((descr.byteorder == c'>' and little_endian) or - * (descr.byteorder == c'<' and not little_endian)): */ - __pyx_t_4 = __pyx_v_descr->type_num; - __pyx_v_t = __pyx_t_4; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":304 - * if not PyDataType_HASFIELDS(descr): - * t = descr.type_num - * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (descr.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") - */ - __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0); - if (!__pyx_t_2) { - goto __pyx_L15_next_or; - } else { - } - __pyx_t_2 = (__pyx_v_little_endian != 0); - if (!__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L14_bool_binop_done; - } - __pyx_L15_next_or:; + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":305 - * t = descr.type_num - * if ((descr.byteorder == c'>' and little_endian) or - * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< - * raise ValueError(u"Non-native byte order not supported") - * if t == NPY_BYTE: f = "b" +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":836 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape */ - __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L14_bool_binop_done; - } - __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0); - __pyx_t_1 = __pyx_t_2; - __pyx_L14_bool_binop_done:; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":304 - * if not PyDataType_HASFIELDS(descr): - * t = descr.type_num - * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (descr.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") - */ - if (unlikely(__pyx_t_1)) { +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":306 - * if ((descr.byteorder == c'>' and little_endian) or - * (descr.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< - * if t == NPY_BYTE: f = "b" - * elif t == NPY_UBYTE: f = "B" + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":837 + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 306, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 306, __pyx_L1_error) + __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); + if (__pyx_t_1) { - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":304 - * if not PyDataType_HASFIELDS(descr): - * t = descr.type_num - * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (descr.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":838 + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape # <<<<<<<<<<<<<< + * else: + * return () */ - } + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); + __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); + goto __pyx_L0; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":307 - * (descr.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") - * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< - * elif t == NPY_UBYTE: f = "B" - * elif t == NPY_SHORT: f = "h" + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":837 + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: */ - switch (__pyx_v_t) { - case NPY_BYTE: - __pyx_v_f = ((char *)"b"); - break; - case NPY_UBYTE: + } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":308 - * raise ValueError(u"Non-native byte order not supported") - * if t == NPY_BYTE: f = "b" - * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< - * elif t == NPY_SHORT: f = "h" - * elif t == NPY_USHORT: f = "H" + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":840 + * return d.subarray.shape + * else: + * return () # <<<<<<<<<<<<<< + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: */ - __pyx_v_f = ((char *)"B"); - break; - case NPY_SHORT: + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_r = __pyx_empty_tuple; + goto __pyx_L0; + } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":309 - * if t == NPY_BYTE: f = "b" - * elif t == NPY_UBYTE: f = "B" - * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< - * elif t == NPY_USHORT: f = "H" - * elif t == NPY_INT: f = "i" + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":836 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape */ - __pyx_v_f = ((char *)"h"); - break; - case NPY_USHORT: - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":310 - * elif t == NPY_UBYTE: f = "B" - * elif t == NPY_SHORT: f = "h" - * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< - * elif t == NPY_INT: f = "i" - * elif t == NPY_UINT: f = "I" - */ - __pyx_v_f = ((char *)"H"); - break; - case NPY_INT: + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":311 - * elif t == NPY_SHORT: f = "h" - * elif t == NPY_USHORT: f = "H" - * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< - * elif t == NPY_UINT: f = "I" - * elif t == NPY_LONG: f = "l" +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":842 + * return () + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. */ - __pyx_v_f = ((char *)"i"); - break; - case NPY_UINT: - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":312 - * elif t == NPY_USHORT: f = "H" - * elif t == NPY_INT: f = "i" - * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< - * elif t == NPY_LONG: f = "l" - * elif t == NPY_ULONG: f = "L" - */ - __pyx_v_f = ((char *)"I"); - break; - case NPY_LONG: +static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) { + PyArray_Descr *__pyx_v_child = 0; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + PyObject *__pyx_v_fields = 0; + PyObject *__pyx_v_childname = NULL; + PyObject *__pyx_v_new_offset = NULL; + PyObject *__pyx_v_t = NULL; + char *__pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + long __pyx_t_8; + char *__pyx_t_9; + __Pyx_RefNannySetupContext("_util_dtypestring", 0); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":313 - * elif t == NPY_INT: f = "i" - * elif t == NPY_UINT: f = "I" - * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< - * elif t == NPY_ULONG: f = "L" - * elif t == NPY_LONGLONG: f = "q" + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":847 + * + * cdef dtype child + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * cdef tuple fields */ - __pyx_v_f = ((char *)"l"); - break; - case NPY_ULONG: + __pyx_v_endian_detector = 1; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":314 - * elif t == NPY_UINT: f = "I" - * elif t == NPY_LONG: f = "l" - * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< - * elif t == NPY_LONGLONG: f = "q" - * elif t == NPY_ULONGLONG: f = "Q" + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":848 + * cdef dtype child + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + * cdef tuple fields + * */ - __pyx_v_f = ((char *)"L"); - break; - case NPY_LONGLONG: + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":315 - * elif t == NPY_LONG: f = "l" - * elif t == NPY_ULONG: f = "L" - * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< - * elif t == NPY_ULONGLONG: f = "Q" - * elif t == NPY_FLOAT: f = "f" + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":851 + * cdef tuple fields + * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields */ - __pyx_v_f = ((char *)"q"); - break; - case NPY_ULONGLONG: + if (unlikely(__pyx_v_descr->names == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(1, 851, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 851, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 851, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); + __pyx_t_3 = 0; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":316 - * elif t == NPY_ULONG: f = "L" - * elif t == NPY_LONGLONG: f = "q" - * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< - * elif t == NPY_FLOAT: f = "f" - * elif t == NPY_DOUBLE: f = "d" + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":852 + * + * for childname in descr.names: + * fields = descr.fields[childname] # <<<<<<<<<<<<<< + * child, new_offset = fields + * */ - __pyx_v_f = ((char *)"Q"); - break; - case NPY_FLOAT: + if (unlikely(__pyx_v_descr->fields == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 852, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 852, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 852, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":317 - * elif t == NPY_LONGLONG: f = "q" - * elif t == NPY_ULONGLONG: f = "Q" - * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< - * elif t == NPY_DOUBLE: f = "d" - * elif t == NPY_LONGDOUBLE: f = "g" + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":853 + * for childname in descr.names: + * fields = descr.fields[childname] + * child, new_offset = fields # <<<<<<<<<<<<<< + * + * if (end - f) - (new_offset - offset[0]) < 15: */ - __pyx_v_f = ((char *)"f"); - break; - case NPY_DOUBLE: + if (likely(__pyx_v_fields != Py_None)) { + PyObject* sequence = __pyx_v_fields; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(1, 853, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 853, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 853, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 853, __pyx_L1_error) + } + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 853, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); + __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); + __pyx_t_4 = 0; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":318 - * elif t == NPY_ULONGLONG: f = "Q" - * elif t == NPY_FLOAT: f = "f" - * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< - * elif t == NPY_LONGDOUBLE: f = "g" - * elif t == NPY_CFLOAT: f = "Zf" + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":855 + * child, new_offset = fields + * + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * */ - __pyx_v_f = ((char *)"d"); - break; - case NPY_LONGDOUBLE: + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 855, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 855, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 855, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); + if (unlikely(__pyx_t_6)) { - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":319 - * elif t == NPY_FLOAT: f = "f" - * elif t == NPY_DOUBLE: f = "d" - * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< - * elif t == NPY_CFLOAT: f = "Zf" - * elif t == NPY_CDOUBLE: f = "Zd" + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":856 + * + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + * + * if ((child.byteorder == c'>' and little_endian) or */ - __pyx_v_f = ((char *)"g"); - break; - case NPY_CFLOAT: + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 856, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 856, __pyx_L1_error) - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":320 - * elif t == NPY_DOUBLE: f = "d" - * elif t == NPY_LONGDOUBLE: f = "g" - * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< - * elif t == NPY_CDOUBLE: f = "Zd" - * elif t == NPY_CLONGDOUBLE: f = "Zg" + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":855 + * child, new_offset = fields + * + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * */ - __pyx_v_f = ((char *)"Zf"); - break; - case NPY_CDOUBLE: + } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":321 - * elif t == NPY_LONGDOUBLE: f = "g" - * elif t == NPY_CFLOAT: f = "Zf" - * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< - * elif t == NPY_CLONGDOUBLE: f = "Zg" - * elif t == NPY_OBJECT: f = "O" + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":858 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") */ - __pyx_v_f = ((char *)"Zd"); - break; - case NPY_CLONGDOUBLE: + __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0); + if (!__pyx_t_7) { + goto __pyx_L8_next_or; + } else { + } + __pyx_t_7 = (__pyx_v_little_endian != 0); + if (!__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_L8_next_or:; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":322 - * elif t == NPY_CFLOAT: f = "Zf" - * elif t == NPY_CDOUBLE: f = "Zd" - * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< - * elif t == NPY_OBJECT: f = "O" - * else: - */ - __pyx_v_f = ((char *)"Zg"); - break; - case NPY_OBJECT: + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":859 + * + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * # One could encode it in the format string and have Cython + */ + __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0); + if (__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_6 = __pyx_t_7; + __pyx_L7_bool_binop_done:; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":323 - * elif t == NPY_CDOUBLE: f = "Zd" - * elif t == NPY_CLONGDOUBLE: f = "Zg" - * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":858 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") */ - __pyx_v_f = ((char *)"O"); - break; - default: + if (unlikely(__pyx_t_6)) { - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":325 - * elif t == NPY_OBJECT: f = "O" - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< - * info.format = f - * return + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":860 + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * # One could encode it in the format string and have Cython + * # complain instead, BUT: < and > in format strings also imply */ - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 325, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 860, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 325, __pyx_L1_error) - break; + __PYX_ERR(1, 860, __pyx_L1_error) + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":858 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":326 - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) - * info.format = f # <<<<<<<<<<<<<< - * return - * else: + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":870 + * + * # Output padding bytes + * while offset[0] < new_offset: # <<<<<<<<<<<<<< + * f[0] = 120 # "x"; pad byte + * f += 1 */ - __pyx_v_info->format = __pyx_v_f; + while (1) { + __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 870, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 870, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 870, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!__pyx_t_6) break; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":327 - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) - * info.format = f - * return # <<<<<<<<<<<<<< - * else: - * info.format = PyObject_Malloc(_buffer_format_string_len) + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":871 + * # Output padding bytes + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< + * f += 1 + * offset[0] += 1 */ - __pyx_r = 0; - goto __pyx_L0; + (__pyx_v_f[0]) = 0x78; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":302 - * info.obj = self + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":872 + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte + * f += 1 # <<<<<<<<<<<<<< + * offset[0] += 1 * - * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<< - * t = descr.type_num - * if ((descr.byteorder == c'>' and little_endian) or */ - } + __pyx_v_f = (__pyx_v_f + 1); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":329 - * return - * else: - * info.format = PyObject_Malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< - * info.format[0] = c'^' # Native data types, manual alignment - * offset = 0 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":873 + * f[0] = 120 # "x"; pad byte + * f += 1 + * offset[0] += 1 # <<<<<<<<<<<<<< + * + * offset[0] += child.itemsize */ - /*else*/ { - __pyx_v_info->format = ((char *)PyObject_Malloc(0xFF)); + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); + } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":330 - * else: - * info.format = PyObject_Malloc(_buffer_format_string_len) - * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< - * offset = 0 - * f = _util_dtypestring(descr, info.format + 1, + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":875 + * offset[0] += 1 + * + * offset[0] += child.itemsize # <<<<<<<<<<<<<< + * + * if not PyDataType_HASFIELDS(child): */ - (__pyx_v_info->format[0]) = '^'; + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":331 - * info.format = PyObject_Malloc(_buffer_format_string_len) - * info.format[0] = c'^' # Native data types, manual alignment - * offset = 0 # <<<<<<<<<<<<<< - * f = _util_dtypestring(descr, info.format + 1, - * info.format + _buffer_format_string_len, + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":877 + * offset[0] += child.itemsize + * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: */ - __pyx_v_offset = 0; + __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); + if (__pyx_t_6) { - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":332 - * info.format[0] = c'^' # Native data types, manual alignment - * offset = 0 - * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< - * info.format + _buffer_format_string_len, - * &offset) + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":878 + * + * if not PyDataType_HASFIELDS(child): + * t = child.type_num # <<<<<<<<<<<<<< + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") */ - __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 332, __pyx_L1_error) - __pyx_v_f = __pyx_t_9; + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 878, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); + __pyx_t_4 = 0; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":335 - * info.format + _buffer_format_string_len, - * &offset) - * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":879 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") * - * def __releasebuffer__(ndarray self, Py_buffer* info): */ - (__pyx_v_f[0]) = '\x00'; - } + __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); + if (unlikely(__pyx_t_6)) { - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":258 - * # experimental exception made for __getbuffer__ and __releasebuffer__ - * # -- the details of this may change. - * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< - * # This implementation of getbuffer is geared towards Cython - * # requirements, and does not yet fulfill the PEP. + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":880 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + * + * # Until ticket #99 is fixed, use integers to avoid warnings */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 880, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(1, 880, __pyx_L1_error) - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - if (__pyx_v_info->obj != NULL) { - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; - } - goto __pyx_L2; - __pyx_L0:; - if (__pyx_v_info->obj == Py_None) { - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; - } - __pyx_L2:; - __Pyx_XDECREF((PyObject *)__pyx_v_descr); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":337 - * f[0] = c'\0' # Terminate format string + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":879 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") * - * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< - * if PyArray_HASFIELDS(self): - * PyObject_Free(info.format) */ + } -/* Python wrapper */ -static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/ -static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0); - __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) { - __Pyx_RefNannyDeclarations - int __pyx_t_1; - __Pyx_RefNannySetupContext("__releasebuffer__", 0); - - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":338 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":883 * - * def __releasebuffer__(ndarray self, Py_buffer* info): - * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< - * PyObject_Free(info.format) - * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" */ - __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); - if (__pyx_t_1) { + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 883, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 883, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 883, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 98; + goto __pyx_L15; + } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":339 - * def __releasebuffer__(ndarray self, Py_buffer* info): - * if PyArray_HASFIELDS(self): - * PyObject_Free(info.format) # <<<<<<<<<<<<<< - * if sizeof(npy_intp) != sizeof(Py_ssize_t): - * PyObject_Free(info.strides) + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":884 + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" */ - PyObject_Free(__pyx_v_info->format); + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 884, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 884, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 884, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 66; + goto __pyx_L15; + } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":338 - * - * def __releasebuffer__(ndarray self, Py_buffer* info): - * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< - * PyObject_Free(info.format) - * if sizeof(npy_intp) != sizeof(Py_ssize_t): + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":885 + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" */ - } + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 885, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 885, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 885, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x68; + goto __pyx_L15; + } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":340 - * if PyArray_HASFIELDS(self): - * PyObject_Free(info.format) - * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< - * PyObject_Free(info.strides) - * # info.shape was stored after info.strides in the same block + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":886 + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" */ - __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); - if (__pyx_t_1) { + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 886, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 886, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 886, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 72; + goto __pyx_L15; + } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":341 - * PyObject_Free(info.format) - * if sizeof(npy_intp) != sizeof(Py_ssize_t): - * PyObject_Free(info.strides) # <<<<<<<<<<<<<< - * # info.shape was stored after info.strides in the same block - * + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":887 + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" */ - PyObject_Free(__pyx_v_info->strides); + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 887, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 887, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 887, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x69; + goto __pyx_L15; + } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":340 - * if PyArray_HASFIELDS(self): - * PyObject_Free(info.format) - * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< - * PyObject_Free(info.strides) - * # info.shape was stored after info.strides in the same block + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":888 + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" */ - } + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 888, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 888, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 888, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 73; + goto __pyx_L15; + } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":337 - * f[0] = c'\0' # Terminate format string - * - * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< - * if PyArray_HASFIELDS(self): - * PyObject_Free(info.format) + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":889 + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 889, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 889, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 889, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x6C; + goto __pyx_L15; + } - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":821 - * ctypedef npy_cdouble complex_t - * - * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(1, a) - * + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":890 + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 890, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 890, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 890, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 76; + goto __pyx_L15; + } -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); - - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":822 - * - * cdef inline object PyArray_MultiIterNew1(a): - * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< - * - * cdef inline object PyArray_MultiIterNew2(a, b): + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":891 + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 822, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 891, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 891, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 891, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x71; + goto __pyx_L15; + } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":821 - * ctypedef npy_cdouble complex_t - * - * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(1, a) - * + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":892 + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 892, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 892, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 892, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 81; + goto __pyx_L15; + } - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":893 + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 893, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 893, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 893, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x66; + goto __pyx_L15; + } -/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":824 - * return PyArray_MultiIterNew(1, a) + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":894 + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 894, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 894, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 894, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x64; + goto __pyx_L15; + } + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":895 + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 895, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 895, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 895, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x67; + goto __pyx_L15; + } + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":896 + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 896, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 896, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 896, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x66; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":897 + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 897, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 897, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 897, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x64; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":898 + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 898, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 898, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 898, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x67; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":899 + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 899, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 899, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 899, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (likely(__pyx_t_6)) { + (__pyx_v_f[0]) = 79; + goto __pyx_L15; + } + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":901 + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * f += 1 + * else: + */ + /*else*/ { + __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 901, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 901, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(1, 901, __pyx_L1_error) + } + __pyx_L15:; + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":902 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * f += 1 # <<<<<<<<<<<<<< + * else: + * # Cython ignores struct boundary information ("T{...}"), + */ + __pyx_v_f = (__pyx_v_f + 1); + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":877 + * offset[0] += child.itemsize * - * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(2, a, b) + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: + */ + goto __pyx_L13; + } + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":906 + * # Cython ignores struct boundary information ("T{...}"), + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< + * return f * */ + /*else*/ { + __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 906, __pyx_L1_error) + __pyx_v_f = __pyx_t_9; + } + __pyx_L13:; -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":851 + * cdef tuple fields + * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":825 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":907 + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) + * return f # <<<<<<<<<<<<<< * - * cdef inline object PyArray_MultiIterNew2(a, b): - * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< * - * cdef inline object PyArray_MultiIterNew3(a, b, c): */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 825, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; + __pyx_r = __pyx_v_f; goto __pyx_L0; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":824 - * return PyArray_MultiIterNew(1, a) - * - * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(2, a, b) + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":842 + * return () * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); + __Pyx_XDECREF((PyObject *)__pyx_v_child); + __Pyx_XDECREF(__pyx_v_fields); + __Pyx_XDECREF(__pyx_v_childname); + __Pyx_XDECREF(__pyx_v_new_offset); + __Pyx_XDECREF(__pyx_v_t); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":827 - * return PyArray_MultiIterNew(2, a, b) - * - * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(3, a, b, c) +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1022 + * int _import_umath() except -1 * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) */ -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { - PyObject *__pyx_r = NULL; +static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); + __Pyx_RefNannySetupContext("set_array_base", 0); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":828 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1023 * - * cdef inline object PyArray_MultiIterNew3(a, b, c): - * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< + * cdef inline void set_array_base(ndarray arr, object base): + * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< + * PyArray_SetBaseObject(arr, base) * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 828, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + Py_INCREF(__pyx_v_base); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":827 - * return PyArray_MultiIterNew(2, a, b) + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1024 + * cdef inline void set_array_base(ndarray arr, object base): + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< * - * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(3, a, b, c) + * cdef inline object get_array_base(ndarray arr): + */ + (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1022 + * int _import_umath() except -1 * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) */ /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); - return __pyx_r; } -/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":830 - * return PyArray_MultiIterNew(3, a, b, c) - * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(4, a, b, c, d) +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1026 + * PyArray_SetBaseObject(arr, base) * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: */ -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { +static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { + PyObject *__pyx_v_base; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); + int __pyx_t_1; + __Pyx_RefNannySetupContext("get_array_base", 0); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":831 - * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): - * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1027 * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< + * if base is NULL: + * return None */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 831, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + __pyx_v_base = PyArray_BASE(__pyx_v_arr); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":830 - * return PyArray_MultiIterNew(3, a, b, c) - * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(4, a, b, c, d) - * + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1028 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base */ + __pyx_t_1 = ((__pyx_v_base == NULL) != 0); + if (__pyx_t_1) { - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":833 - * return PyArray_MultiIterNew(4, a, b, c, d) - * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(5, a, b, c, d, e) + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1029 + * base = PyArray_BASE(arr) + * if base is NULL: + * return None # <<<<<<<<<<<<<< + * return base * */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1028 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base + */ + } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":834 - * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): - * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1030 + * if base is NULL: + * return None + * return base # <<<<<<<<<<<<<< * - * cdef inline tuple PyDataType_SHAPE(dtype d): + * # Versions of the import_* functions which are more suitable for */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 834, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; + __Pyx_INCREF(((PyObject *)__pyx_v_base)); + __pyx_r = ((PyObject *)__pyx_v_base); goto __pyx_L0; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":833 - * return PyArray_MultiIterNew(4, a, b, c, d) - * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(5, a, b, c, d, e) + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1026 + * PyArray_SetBaseObject(arr, base) * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: */ /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":836 - * return PyArray_MultiIterNew(5, a, b, c, d, e) - * - * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< - * if PyDataType_HASSUBARRAY(d): - * return d.subarray.shape +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1034 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * _import_array() */ -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { - PyObject *__pyx_r = NULL; +static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { + int __pyx_r; __Pyx_RefNannyDeclarations - int __pyx_t_1; - __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("import_array", 0); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":837 - * - * cdef inline tuple PyDataType_SHAPE(dtype d): - * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< - * return d.subarray.shape - * else: + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1035 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * _import_array() + * except Exception: */ - __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); - if (__pyx_t_1) { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":838 - * cdef inline tuple PyDataType_SHAPE(dtype d): - * if PyDataType_HASSUBARRAY(d): - * return d.subarray.shape # <<<<<<<<<<<<<< - * else: - * return () + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1036 + * cdef inline int import_array() except -1: + * try: + * _import_array() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); - __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); - goto __pyx_L0; + __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1036, __pyx_L3_error) - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":837 - * - * cdef inline tuple PyDataType_SHAPE(dtype d): - * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< - * return d.subarray.shape - * else: + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1035 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * _import_array() + * except Exception: */ - } + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":840 - * return d.subarray.shape - * else: - * return () # <<<<<<<<<<<<<< + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1037 + * try: + * _import_array() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.multiarray failed to import") * - * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: */ - /*else*/ { - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_empty_tuple); - __pyx_r = __pyx_empty_tuple; - goto __pyx_L0; - } + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1037, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":836 - * return PyArray_MultiIterNew(5, a, b, c, d, e) + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1038 + * _import_array() + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * - * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< - * if PyDataType_HASSUBARRAY(d): - * return d.subarray.shape + * cdef inline int import_umath() except -1: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1038, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 1038, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1035 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * _import_array() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1034 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * _import_array() */ /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":842 - * return () +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1040 + * raise ImportError("numpy.core.multiarray failed to import") * - * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< - * # Recursive utility function used in __getbuffer__ to get format - * # string. The new location in the format string is returned. + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() */ -static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) { - PyArray_Descr *__pyx_v_child = 0; - int __pyx_v_endian_detector; - int __pyx_v_little_endian; - PyObject *__pyx_v_fields = 0; - PyObject *__pyx_v_childname = NULL; - PyObject *__pyx_v_new_offset = NULL; - PyObject *__pyx_v_t = NULL; - char *__pyx_r; +static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { + int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - int __pyx_t_5; - int __pyx_t_6; - int __pyx_t_7; - long __pyx_t_8; - char *__pyx_t_9; - __Pyx_RefNannySetupContext("_util_dtypestring", 0); + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("import_umath", 0); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":847 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * - * cdef dtype child - * cdef int endian_detector = 1 # <<<<<<<<<<<<<< - * cdef bint little_endian = ((&endian_detector)[0] != 0) - * cdef tuple fields + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: */ - __pyx_v_endian_detector = 1; + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":848 - * cdef dtype child - * cdef int endian_detector = 1 - * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< - * cdef tuple fields - * + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1042 + * cdef inline int import_umath() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.umath failed to import") */ - __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1042, __pyx_L3_error) - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":851 - * cdef tuple fields + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * - * for childname in descr.names: # <<<<<<<<<<<<<< - * fields = descr.fields[childname] - * child, new_offset = fields + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: */ - if (unlikely(__pyx_v_descr->names == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(1, 851, __pyx_L1_error) - } - __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; - for (;;) { - if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 851, __pyx_L1_error) - #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 851, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); - __pyx_t_3 = 0; + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":852 - * - * for childname in descr.names: - * fields = descr.fields[childname] # <<<<<<<<<<<<<< - * child, new_offset = fields + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1043 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.umath failed to import") * */ - if (unlikely(__pyx_v_descr->fields == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 852, __pyx_L1_error) - } - __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 852, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 852, __pyx_L1_error) - __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); - __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1043, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":853 - * for childname in descr.names: - * fields = descr.fields[childname] - * child, new_offset = fields # <<<<<<<<<<<<<< + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1044 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * - * if (end - f) - (new_offset - offset[0]) < 15: + * cdef inline int import_ufunc() except -1: */ - if (likely(__pyx_v_fields != Py_None)) { - PyObject* sequence = __pyx_v_fields; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 853, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(__pyx_t_4); - #else - __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 853, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 853, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - } else { - __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 853, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1044, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 1044, __pyx_L5_except_error) } - if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 853, __pyx_L1_error) - __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); - __pyx_t_3 = 0; - __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); - __pyx_t_4 = 0; + goto __pyx_L5_except_error; + __pyx_L5_except_error:; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":855 - * child, new_offset = fields - * - * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1041 * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: */ - __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 855, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 855, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 855, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); - if (unlikely(__pyx_t_6)) { + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":856 - * - * if (end - f) - (new_offset - offset[0]) < 15: - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1040 + * raise ImportError("numpy.core.multiarray failed to import") * - * if ((child.byteorder == c'>' and little_endian) or + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 856, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 856, __pyx_L1_error) - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":855 - * child, new_offset = fields - * - * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") - * - */ - } + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":858 - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") +/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1046 + * raise ImportError("numpy.core.umath failed to import") * - * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (child.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() */ - __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0); - if (!__pyx_t_7) { - goto __pyx_L8_next_or; - } else { - } - __pyx_t_7 = (__pyx_v_little_endian != 0); - if (!__pyx_t_7) { - } else { - __pyx_t_6 = __pyx_t_7; - goto __pyx_L7_bool_binop_done; - } - __pyx_L8_next_or:; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":859 - * - * if ((child.byteorder == c'>' and little_endian) or - * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< - * raise ValueError(u"Non-native byte order not supported") - * # One could encode it in the format string and have Cython - */ - __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0); - if (__pyx_t_7) { - } else { - __pyx_t_6 = __pyx_t_7; - goto __pyx_L7_bool_binop_done; - } - __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); - __pyx_t_6 = __pyx_t_7; - __pyx_L7_bool_binop_done:; +static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("import_ufunc", 0); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":858 - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * - * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (child.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: */ - if (unlikely(__pyx_t_6)) { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":860 - * if ((child.byteorder == c'>' and little_endian) or - * (child.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< - * # One could encode it in the format string and have Cython - * # complain instead, BUT: < and > in format strings also imply + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1048 + * cdef inline int import_ufunc() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.umath failed to import") */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 860, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 860, __pyx_L1_error) + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1048, __pyx_L3_error) - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":858 - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * - * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (child.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: */ } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":870 - * - * # Output padding bytes - * while offset[0] < new_offset: # <<<<<<<<<<<<<< - * f[0] = 120 # "x"; pad byte - * f += 1 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1049 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.umath failed to import") */ - while (1) { - __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 870, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 870, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 870, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (!__pyx_t_6) break; + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1049, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":871 - * # Output padding bytes - * while offset[0] < new_offset: - * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< - * f += 1 - * offset[0] += 1 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1050 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< */ - (__pyx_v_f[0]) = 0x78; + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1050, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 1050, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":872 - * while offset[0] < new_offset: - * f[0] = 120 # "x"; pad byte - * f += 1 # <<<<<<<<<<<<<< - * offset[0] += 1 + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1047 * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: */ - __pyx_v_f = (__pyx_v_f + 1); + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":873 - * f[0] = 120 # "x"; pad byte - * f += 1 - * offset[0] += 1 # <<<<<<<<<<<<<< + /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1046 + * raise ImportError("numpy.core.umath failed to import") * - * offset[0] += child.itemsize + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() */ - __pyx_t_8 = 0; - (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); - } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":875 - * offset[0] += 1 - * - * offset[0] += child.itemsize # <<<<<<<<<<<<<< - * - * if not PyDataType_HASFIELDS(child): - */ - __pyx_t_8 = 0; - (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":877 - * offset[0] += child.itemsize +/* "View.MemoryView":122 + * cdef bint dtype_is_object * - * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< - * t = child.type_num - * if end - f < 5: - */ - __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); - if (__pyx_t_6) { - - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":878 + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< + * mode="c", bint allocate_buffer=True): * - * if not PyDataType_HASFIELDS(child): - * t = child.type_num # <<<<<<<<<<<<<< - * if end - f < 5: - * raise RuntimeError(u"Format string allocated too short.") */ - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 878, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); - __pyx_t_4 = 0; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":879 - * if not PyDataType_HASFIELDS(child): - * t = child.type_num - * if end - f < 5: # <<<<<<<<<<<<<< - * raise RuntimeError(u"Format string allocated too short.") - * - */ - __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); - if (unlikely(__pyx_t_6)) { +/* Python wrapper */ +static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_shape = 0; + Py_ssize_t __pyx_v_itemsize; + PyObject *__pyx_v_format = 0; + PyObject *__pyx_v_mode = 0; + int __pyx_v_allocate_buffer; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_shape,&__pyx_n_s_itemsize,&__pyx_n_s_format,&__pyx_n_s_mode,&__pyx_n_s_allocate_buffer,0}; + PyObject* values[5] = {0,0,0,0,0}; + values[3] = ((PyObject *)__pyx_n_s_c); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_shape)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_itemsize)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 1); __PYX_ERR(2, 122, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_format)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 2); __PYX_ERR(2, 122, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mode); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_allocate_buffer); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(2, 122, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_shape = ((PyObject*)values[0]); + __pyx_v_itemsize = __Pyx_PyIndex_AsSsize_t(values[1]); if (unlikely((__pyx_v_itemsize == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 122, __pyx_L3_error) + __pyx_v_format = values[2]; + __pyx_v_mode = values[3]; + if (values[4]) { + __pyx_v_allocate_buffer = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_allocate_buffer == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 123, __pyx_L3_error) + } else { - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":880 - * t = child.type_num - * if end - f < 5: - * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + /* "View.MemoryView":123 * - * # Until ticket #99 is fixed, use integers to avoid warnings + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, + * mode="c", bint allocate_buffer=True): # <<<<<<<<<<<<<< + * + * cdef int idx */ - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 880, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(1, 880, __pyx_L1_error) + __pyx_v_allocate_buffer = ((int)1); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 122, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_shape), (&PyTuple_Type), 1, "shape", 1))) __PYX_ERR(2, 122, __pyx_L1_error) + if (unlikely(((PyObject *)__pyx_v_format) == Py_None)) { + PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "format"); __PYX_ERR(2, 122, __pyx_L1_error) + } + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v_shape, __pyx_v_itemsize, __pyx_v_format, __pyx_v_mode, __pyx_v_allocate_buffer); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":879 - * if not PyDataType_HASFIELDS(child): - * t = child.type_num - * if end - f < 5: # <<<<<<<<<<<<<< - * raise RuntimeError(u"Format string allocated too short.") + /* "View.MemoryView":122 + * cdef bint dtype_is_object + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< + * mode="c", bint allocate_buffer=True): * */ - } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":883 + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer) { + int __pyx_v_idx; + Py_ssize_t __pyx_v_i; + Py_ssize_t __pyx_v_dim; + PyObject **__pyx_v_p; + char __pyx_v_order; + int __pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + char *__pyx_t_7; + int __pyx_t_8; + Py_ssize_t __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + Py_ssize_t __pyx_t_11; + __Pyx_RefNannySetupContext("__cinit__", 0); + __Pyx_INCREF(__pyx_v_format); + + /* "View.MemoryView":129 + * cdef PyObject **p + * + * self.ndim = len(shape) # <<<<<<<<<<<<<< + * self.itemsize = itemsize * - * # Until ticket #99 is fixed, use integers to avoid warnings - * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< - * elif t == NPY_UBYTE: f[0] = 66 #"B" - * elif t == NPY_SHORT: f[0] = 104 #"h" */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 883, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 883, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 883, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 98; - goto __pyx_L15; - } + if (unlikely(__pyx_v_shape == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(2, 129, __pyx_L1_error) + } + __pyx_t_1 = PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(2, 129, __pyx_L1_error) + __pyx_v_self->ndim = ((int)__pyx_t_1); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":884 - * # Until ticket #99 is fixed, use integers to avoid warnings - * if t == NPY_BYTE: f[0] = 98 #"b" - * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< - * elif t == NPY_SHORT: f[0] = 104 #"h" - * elif t == NPY_USHORT: f[0] = 72 #"H" + /* "View.MemoryView":130 + * + * self.ndim = len(shape) + * self.itemsize = itemsize # <<<<<<<<<<<<<< + * + * if not self.ndim: */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 884, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 884, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 884, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 66; - goto __pyx_L15; - } + __pyx_v_self->itemsize = __pyx_v_itemsize; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":885 - * if t == NPY_BYTE: f[0] = 98 #"b" - * elif t == NPY_UBYTE: f[0] = 66 #"B" - * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< - * elif t == NPY_USHORT: f[0] = 72 #"H" - * elif t == NPY_INT: f[0] = 105 #"i" + /* "View.MemoryView":132 + * self.itemsize = itemsize + * + * if not self.ndim: # <<<<<<<<<<<<<< + * raise ValueError("Empty shape tuple for cython.array") + * */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 885, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 885, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 885, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x68; - goto __pyx_L15; - } + __pyx_t_2 = ((!(__pyx_v_self->ndim != 0)) != 0); + if (unlikely(__pyx_t_2)) { - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":886 - * elif t == NPY_UBYTE: f[0] = 66 #"B" - * elif t == NPY_SHORT: f[0] = 104 #"h" - * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< - * elif t == NPY_INT: f[0] = 105 #"i" - * elif t == NPY_UINT: f[0] = 73 #"I" + /* "View.MemoryView":133 + * + * if not self.ndim: + * raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<< + * + * if itemsize <= 0: */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 886, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 886, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 886, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 72; - goto __pyx_L15; - } - - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":887 - * elif t == NPY_SHORT: f[0] = 104 #"h" - * elif t == NPY_USHORT: f[0] = 72 #"H" - * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< - * elif t == NPY_UINT: f[0] = 73 #"I" - * elif t == NPY_LONG: f[0] = 108 #"l" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 887, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 887, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 887, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x69; - goto __pyx_L15; - } + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(2, 133, __pyx_L1_error) - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":888 - * elif t == NPY_USHORT: f[0] = 72 #"H" - * elif t == NPY_INT: f[0] = 105 #"i" - * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< - * elif t == NPY_LONG: f[0] = 108 #"l" - * elif t == NPY_ULONG: f[0] = 76 #"L" + /* "View.MemoryView":132 + * self.itemsize = itemsize + * + * if not self.ndim: # <<<<<<<<<<<<<< + * raise ValueError("Empty shape tuple for cython.array") + * */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 888, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 888, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 888, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 73; - goto __pyx_L15; - } + } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":889 - * elif t == NPY_INT: f[0] = 105 #"i" - * elif t == NPY_UINT: f[0] = 73 #"I" - * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< - * elif t == NPY_ULONG: f[0] = 76 #"L" - * elif t == NPY_LONGLONG: f[0] = 113 #"q" + /* "View.MemoryView":135 + * raise ValueError("Empty shape tuple for cython.array") + * + * if itemsize <= 0: # <<<<<<<<<<<<<< + * raise ValueError("itemsize <= 0 for cython.array") + * */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 889, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 889, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 889, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x6C; - goto __pyx_L15; - } + __pyx_t_2 = ((__pyx_v_itemsize <= 0) != 0); + if (unlikely(__pyx_t_2)) { - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":890 - * elif t == NPY_UINT: f[0] = 73 #"I" - * elif t == NPY_LONG: f[0] = 108 #"l" - * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< - * elif t == NPY_LONGLONG: f[0] = 113 #"q" - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + /* "View.MemoryView":136 + * + * if itemsize <= 0: + * raise ValueError("itemsize <= 0 for cython.array") # <<<<<<<<<<<<<< + * + * if not isinstance(format, bytes): */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 890, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 890, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 890, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 76; - goto __pyx_L15; - } + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(2, 136, __pyx_L1_error) - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":891 - * elif t == NPY_LONG: f[0] = 108 #"l" - * elif t == NPY_ULONG: f[0] = 76 #"L" - * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" - * elif t == NPY_FLOAT: f[0] = 102 #"f" + /* "View.MemoryView":135 + * raise ValueError("Empty shape tuple for cython.array") + * + * if itemsize <= 0: # <<<<<<<<<<<<<< + * raise ValueError("itemsize <= 0 for cython.array") + * */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 891, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 891, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 891, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x71; - goto __pyx_L15; - } + } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":892 - * elif t == NPY_ULONG: f[0] = 76 #"L" - * elif t == NPY_LONGLONG: f[0] = 113 #"q" - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< - * elif t == NPY_FLOAT: f[0] = 102 #"f" - * elif t == NPY_DOUBLE: f[0] = 100 #"d" + /* "View.MemoryView":138 + * raise ValueError("itemsize <= 0 for cython.array") + * + * if not isinstance(format, bytes): # <<<<<<<<<<<<<< + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 892, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 892, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 892, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 81; - goto __pyx_L15; - } + __pyx_t_2 = PyBytes_Check(__pyx_v_format); + __pyx_t_4 = ((!(__pyx_t_2 != 0)) != 0); + if (__pyx_t_4) { - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":893 - * elif t == NPY_LONGLONG: f[0] = 113 #"q" - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" - * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< - * elif t == NPY_DOUBLE: f[0] = 100 #"d" - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + /* "View.MemoryView":139 + * + * if not isinstance(format, bytes): + * format = format.encode('ASCII') # <<<<<<<<<<<<<< + * self._format = format # keep a reference to the byte string + * self.format = self._format */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 893, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 893, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 893, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x66; - goto __pyx_L15; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); } + } + __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_n_s_ASCII) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_n_s_ASCII); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF_SET(__pyx_v_format, __pyx_t_3); + __pyx_t_3 = 0; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":894 - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" - * elif t == NPY_FLOAT: f[0] = 102 #"f" - * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + /* "View.MemoryView":138 + * raise ValueError("itemsize <= 0 for cython.array") + * + * if not isinstance(format, bytes): # <<<<<<<<<<<<<< + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 894, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 894, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 894, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x64; - goto __pyx_L15; - } + } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":895 - * elif t == NPY_FLOAT: f[0] = 102 #"f" - * elif t == NPY_DOUBLE: f[0] = 100 #"d" - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + /* "View.MemoryView":140 + * if not isinstance(format, bytes): + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string # <<<<<<<<<<<<<< + * self.format = self._format + * */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 895, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 895, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 895, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x67; - goto __pyx_L15; - } + if (!(likely(PyBytes_CheckExact(__pyx_v_format))||((__pyx_v_format) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_v_format)->tp_name), 0))) __PYX_ERR(2, 140, __pyx_L1_error) + __pyx_t_3 = __pyx_v_format; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_self->_format); + __Pyx_DECREF(__pyx_v_self->_format); + __pyx_v_self->_format = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":896 - * elif t == NPY_DOUBLE: f[0] = 100 #"d" - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd - * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + /* "View.MemoryView":141 + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string + * self.format = self._format # <<<<<<<<<<<<<< + * + * */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 896, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 896, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 896, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 90; - (__pyx_v_f[1]) = 0x66; - __pyx_v_f = (__pyx_v_f + 1); - goto __pyx_L15; - } + if (unlikely(__pyx_v_self->_format == Py_None)) { + PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); + __PYX_ERR(2, 141, __pyx_L1_error) + } + __pyx_t_7 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(2, 141, __pyx_L1_error) + __pyx_v_self->format = __pyx_t_7; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":897 - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< - * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg - * elif t == NPY_OBJECT: f[0] = 79 #"O" + /* "View.MemoryView":144 + * + * + * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) # <<<<<<<<<<<<<< + * self._strides = self._shape + self.ndim + * */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 897, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 897, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 897, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 90; - (__pyx_v_f[1]) = 0x64; - __pyx_v_f = (__pyx_v_f + 1); - goto __pyx_L15; - } + __pyx_v_self->_shape = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * __pyx_v_self->ndim) * 2))); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":898 - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd - * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< - * elif t == NPY_OBJECT: f[0] = 79 #"O" - * else: + /* "View.MemoryView":145 + * + * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) + * self._strides = self._shape + self.ndim # <<<<<<<<<<<<<< + * + * if not self._shape: */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 898, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 898, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 898, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 90; - (__pyx_v_f[1]) = 0x67; - __pyx_v_f = (__pyx_v_f + 1); - goto __pyx_L15; - } + __pyx_v_self->_strides = (__pyx_v_self->_shape + __pyx_v_self->ndim); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":899 - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd - * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg - * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + /* "View.MemoryView":147 + * self._strides = self._shape + self.ndim + * + * if not self._shape: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate shape and strides.") + * */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 899, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 899, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 899, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (likely(__pyx_t_6)) { - (__pyx_v_f[0]) = 79; - goto __pyx_L15; - } + __pyx_t_4 = ((!(__pyx_v_self->_shape != 0)) != 0); + if (unlikely(__pyx_t_4)) { - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":901 - * elif t == NPY_OBJECT: f[0] = 79 #"O" - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< - * f += 1 - * else: + /* "View.MemoryView":148 + * + * if not self._shape: + * raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<< + * + * */ - /*else*/ { - __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 901, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 901, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(1, 901, __pyx_L1_error) - } - __pyx_L15:; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(2, 148, __pyx_L1_error) - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":902 - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) - * f += 1 # <<<<<<<<<<<<<< - * else: - * # Cython ignores struct boundary information ("T{...}"), + /* "View.MemoryView":147 + * self._strides = self._shape + self.ndim + * + * if not self._shape: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate shape and strides.") + * */ - __pyx_v_f = (__pyx_v_f + 1); + } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":877 - * offset[0] += child.itemsize + /* "View.MemoryView":151 * - * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< - * t = child.type_num - * if end - f < 5: + * + * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) */ - goto __pyx_L13; - } + __pyx_t_8 = 0; + __pyx_t_3 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0; + for (;;) { + if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(2, 151, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_5); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 151, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_dim = __pyx_t_9; + __pyx_v_idx = __pyx_t_8; + __pyx_t_8 = (__pyx_t_8 + 1); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":906 - * # Cython ignores struct boundary information ("T{...}"), - * # so don't output it - * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< - * return f + /* "View.MemoryView":152 * + * for idx, dim in enumerate(shape): + * if dim <= 0: # <<<<<<<<<<<<<< + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * self._shape[idx] = dim */ - /*else*/ { - __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 906, __pyx_L1_error) - __pyx_v_f = __pyx_t_9; - } - __pyx_L13:; + __pyx_t_4 = ((__pyx_v_dim <= 0) != 0); + if (unlikely(__pyx_t_4)) { - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":851 - * cdef tuple fields + /* "View.MemoryView":153 + * for idx, dim in enumerate(shape): + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) # <<<<<<<<<<<<<< + * self._shape[idx] = dim * - * for childname in descr.names: # <<<<<<<<<<<<<< - * fields = descr.fields[childname] - * child, new_offset = fields */ - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_idx); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_6); + __pyx_t_5 = 0; + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(2, 153, __pyx_L1_error) - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":907 - * # so don't output it - * f = _util_dtypestring(child, f, end, offset) - * return f # <<<<<<<<<<<<<< - * + /* "View.MemoryView":152 * + * for idx, dim in enumerate(shape): + * if dim <= 0: # <<<<<<<<<<<<<< + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * self._shape[idx] = dim */ - __pyx_r = __pyx_v_f; - goto __pyx_L0; + } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":842 - * return () + /* "View.MemoryView":154 + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * self._shape[idx] = dim # <<<<<<<<<<<<<< * - * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< - * # Recursive utility function used in __getbuffer__ to get format - * # string. The new location in the format string is returned. + * cdef char order */ + (__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim; - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_child); - __Pyx_XDECREF(__pyx_v_fields); - __Pyx_XDECREF(__pyx_v_childname); - __Pyx_XDECREF(__pyx_v_new_offset); - __Pyx_XDECREF(__pyx_v_t); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1022 - * int _import_umath() except -1 + /* "View.MemoryView":151 * - * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< - * Py_INCREF(base) # important to do this before stealing the reference below! - * PyArray_SetBaseObject(arr, base) + * + * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; -static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("set_array_base", 0); - - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1023 - * - * cdef inline void set_array_base(ndarray arr, object base): - * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< - * PyArray_SetBaseObject(arr, base) + /* "View.MemoryView":157 * + * cdef char order + * if mode == 'fortran': # <<<<<<<<<<<<<< + * order = b'F' + * self.mode = u'fortran' */ - Py_INCREF(__pyx_v_base); + __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_fortran, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 157, __pyx_L1_error) + if (__pyx_t_4) { - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1024 - * cdef inline void set_array_base(ndarray arr, object base): - * Py_INCREF(base) # important to do this before stealing the reference below! - * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< - * - * cdef inline object get_array_base(ndarray arr): + /* "View.MemoryView":158 + * cdef char order + * if mode == 'fortran': + * order = b'F' # <<<<<<<<<<<<<< + * self.mode = u'fortran' + * elif mode == 'c': */ - (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); + __pyx_v_order = 'F'; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1022 - * int _import_umath() except -1 - * - * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< - * Py_INCREF(base) # important to do this before stealing the reference below! - * PyArray_SetBaseObject(arr, base) + /* "View.MemoryView":159 + * if mode == 'fortran': + * order = b'F' + * self.mode = u'fortran' # <<<<<<<<<<<<<< + * elif mode == 'c': + * order = b'C' */ + __Pyx_INCREF(__pyx_n_u_fortran); + __Pyx_GIVEREF(__pyx_n_u_fortran); + __Pyx_GOTREF(__pyx_v_self->mode); + __Pyx_DECREF(__pyx_v_self->mode); + __pyx_v_self->mode = __pyx_n_u_fortran; - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1026 - * PyArray_SetBaseObject(arr, base) + /* "View.MemoryView":157 * - * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< - * base = PyArray_BASE(arr) - * if base is NULL: + * cdef char order + * if mode == 'fortran': # <<<<<<<<<<<<<< + * order = b'F' + * self.mode = u'fortran' */ + goto __pyx_L10; + } -static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { - PyObject *__pyx_v_base; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - __Pyx_RefNannySetupContext("get_array_base", 0); - - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1027 - * - * cdef inline object get_array_base(ndarray arr): - * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< - * if base is NULL: - * return None + /* "View.MemoryView":160 + * order = b'F' + * self.mode = u'fortran' + * elif mode == 'c': # <<<<<<<<<<<<<< + * order = b'C' + * self.mode = u'c' */ - __pyx_v_base = PyArray_BASE(__pyx_v_arr); + __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_c, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 160, __pyx_L1_error) + if (likely(__pyx_t_4)) { - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1028 - * cdef inline object get_array_base(ndarray arr): - * base = PyArray_BASE(arr) - * if base is NULL: # <<<<<<<<<<<<<< - * return None - * return base + /* "View.MemoryView":161 + * self.mode = u'fortran' + * elif mode == 'c': + * order = b'C' # <<<<<<<<<<<<<< + * self.mode = u'c' + * else: */ - __pyx_t_1 = ((__pyx_v_base == NULL) != 0); - if (__pyx_t_1) { + __pyx_v_order = 'C'; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1029 - * base = PyArray_BASE(arr) - * if base is NULL: - * return None # <<<<<<<<<<<<<< - * return base - * + /* "View.MemoryView":162 + * elif mode == 'c': + * order = b'C' + * self.mode = u'c' # <<<<<<<<<<<<<< + * else: + * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) */ - __Pyx_XDECREF(__pyx_r); - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; + __Pyx_INCREF(__pyx_n_u_c); + __Pyx_GIVEREF(__pyx_n_u_c); + __Pyx_GOTREF(__pyx_v_self->mode); + __Pyx_DECREF(__pyx_v_self->mode); + __pyx_v_self->mode = __pyx_n_u_c; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1028 - * cdef inline object get_array_base(ndarray arr): - * base = PyArray_BASE(arr) - * if base is NULL: # <<<<<<<<<<<<<< - * return None - * return base + /* "View.MemoryView":160 + * order = b'F' + * self.mode = u'fortran' + * elif mode == 'c': # <<<<<<<<<<<<<< + * order = b'C' + * self.mode = u'c' */ + goto __pyx_L10; } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1030 - * if base is NULL: - * return None - * return base # <<<<<<<<<<<<<< + /* "View.MemoryView":164 + * self.mode = u'c' + * else: + * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) # <<<<<<<<<<<<<< * - * # Versions of the import_* functions which are more suitable for + * self.len = fill_contig_strides_array(self._shape, self._strides, */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_base)); - __pyx_r = ((PyObject *)__pyx_v_base); - goto __pyx_L0; + /*else*/ { + __pyx_t_3 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_v_mode); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(2, 164, __pyx_L1_error) + } + __pyx_L10:; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1026 - * PyArray_SetBaseObject(arr, base) + /* "View.MemoryView":166 + * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) + * + * self.len = fill_contig_strides_array(self._shape, self._strides, # <<<<<<<<<<<<<< + * itemsize, self.ndim, order) * - * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< - * base = PyArray_BASE(arr) - * if base is NULL: */ + __pyx_v_self->len = __pyx_fill_contig_strides_array(__pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_itemsize, __pyx_v_self->ndim, __pyx_v_order); - /* function exit code */ - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "View.MemoryView":169 + * itemsize, self.ndim, order) + * + * self.free_data = allocate_buffer # <<<<<<<<<<<<<< + * self.dtype_is_object = format == b'O' + * if allocate_buffer: + */ + __pyx_v_self->free_data = __pyx_v_allocate_buffer; -/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1034 - * # Versions of the import_* functions which are more suitable for - * # Cython code. - * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< - * try: - * _import_array() + /* "View.MemoryView":170 + * + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' # <<<<<<<<<<<<<< + * if allocate_buffer: + * */ + __pyx_t_10 = PyObject_RichCompare(__pyx_v_format, __pyx_n_b_O, Py_EQ); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 170, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 170, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_v_self->dtype_is_object = __pyx_t_4; -static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { - int __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - __Pyx_RefNannySetupContext("import_array", 0); + /* "View.MemoryView":171 + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' + * if allocate_buffer: # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_4 = (__pyx_v_allocate_buffer != 0); + if (__pyx_t_4) { - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1035 - * # Cython code. - * cdef inline int import_array() except -1: - * try: # <<<<<<<<<<<<<< - * _import_array() - * except Exception: + /* "View.MemoryView":174 + * + * + * self.data = malloc(self.len) # <<<<<<<<<<<<<< + * if not self.data: + * raise MemoryError("unable to allocate array data.") */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_1); - __Pyx_XGOTREF(__pyx_t_2); - __Pyx_XGOTREF(__pyx_t_3); - /*try:*/ { + __pyx_v_self->data = ((char *)malloc(__pyx_v_self->len)); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1036 - * cdef inline int import_array() except -1: - * try: - * _import_array() # <<<<<<<<<<<<<< - * except Exception: - * raise ImportError("numpy.core.multiarray failed to import") + /* "View.MemoryView":175 + * + * self.data = malloc(self.len) + * if not self.data: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate array data.") + * */ - __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1036, __pyx_L3_error) + __pyx_t_4 = ((!(__pyx_v_self->data != 0)) != 0); + if (unlikely(__pyx_t_4)) { - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1035 - * # Cython code. - * cdef inline int import_array() except -1: - * try: # <<<<<<<<<<<<<< - * _import_array() - * except Exception: - */ - } - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L8_try_end; - __pyx_L3_error:; - - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1037 - * try: - * _import_array() - * except Exception: # <<<<<<<<<<<<<< - * raise ImportError("numpy.core.multiarray failed to import") + /* "View.MemoryView":176 + * self.data = malloc(self.len) + * if not self.data: + * raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<< * + * if self.dtype_is_object: */ - __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - if (__pyx_t_4) { - __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1037, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(2, 176, __pyx_L1_error) - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1038 - * _import_array() - * except Exception: - * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< + /* "View.MemoryView":175 + * + * self.data = malloc(self.len) + * if not self.data: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate array data.") * - * cdef inline int import_umath() except -1: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1038, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 1038, __pyx_L5_except_error) } - goto __pyx_L5_except_error; - __pyx_L5_except_error:; - - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1035 - * # Cython code. - * cdef inline int import_array() except -1: - * try: # <<<<<<<<<<<<<< - * _import_array() - * except Exception: - */ - __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); - goto __pyx_L1_error; - __pyx_L8_try_end:; - } - - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1034 - * # Versions of the import_* functions which are more suitable for - * # Cython code. - * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< - * try: - * _import_array() - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} -/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1040 - * raise ImportError("numpy.core.multiarray failed to import") + /* "View.MemoryView":178 + * raise MemoryError("unable to allocate array data.") * - * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * p = self.data + * for i in range(self.len / itemsize): */ + __pyx_t_4 = (__pyx_v_self->dtype_is_object != 0); + if (__pyx_t_4) { -static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { - int __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - __Pyx_RefNannySetupContext("import_umath", 0); - - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1041 + /* "View.MemoryView":179 * - * cdef inline int import_umath() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: + * if self.dtype_is_object: + * p = self.data # <<<<<<<<<<<<<< + * for i in range(self.len / itemsize): + * p[i] = Py_None */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_1); - __Pyx_XGOTREF(__pyx_t_2); - __Pyx_XGOTREF(__pyx_t_3); - /*try:*/ { + __pyx_v_p = ((PyObject **)__pyx_v_self->data); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1042 - * cdef inline int import_umath() except -1: - * try: - * _import_umath() # <<<<<<<<<<<<<< - * except Exception: - * raise ImportError("numpy.core.umath failed to import") + /* "View.MemoryView":180 + * if self.dtype_is_object: + * p = self.data + * for i in range(self.len / itemsize): # <<<<<<<<<<<<<< + * p[i] = Py_None + * Py_INCREF(Py_None) */ - __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1042, __pyx_L3_error) + if (unlikely(__pyx_v_itemsize == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); + __PYX_ERR(2, 180, __pyx_L1_error) + } + else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_self->len))) { + PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); + __PYX_ERR(2, 180, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_div_Py_ssize_t(__pyx_v_self->len, __pyx_v_itemsize); + __pyx_t_9 = __pyx_t_1; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_9; __pyx_t_11+=1) { + __pyx_v_i = __pyx_t_11; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1041 + /* "View.MemoryView":181 + * p = self.data + * for i in range(self.len / itemsize): + * p[i] = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) * - * cdef inline int import_umath() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: */ - } - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L8_try_end; - __pyx_L3_error:; + (__pyx_v_p[__pyx_v_i]) = Py_None; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1043 - * try: - * _import_umath() - * except Exception: # <<<<<<<<<<<<<< - * raise ImportError("numpy.core.umath failed to import") + /* "View.MemoryView":182 + * for i in range(self.len / itemsize): + * p[i] = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< * + * @cname('getbuffer') */ - __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - if (__pyx_t_4) { - __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1043, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GOTREF(__pyx_t_7); + Py_INCREF(Py_None); + } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1044 - * _import_umath() - * except Exception: - * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + /* "View.MemoryView":178 + * raise MemoryError("unable to allocate array data.") * - * cdef inline int import_ufunc() except -1: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * p = self.data + * for i in range(self.len / itemsize): */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1044, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 1044, __pyx_L5_except_error) } - goto __pyx_L5_except_error; - __pyx_L5_except_error:; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1041 + /* "View.MemoryView":171 + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' + * if allocate_buffer: # <<<<<<<<<<<<<< + * * - * cdef inline int import_umath() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: */ - __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); - goto __pyx_L1_error; - __pyx_L8_try_end:; } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1040 - * raise ImportError("numpy.core.multiarray failed to import") + /* "View.MemoryView":122 + * cdef bint dtype_is_object + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< + * mode="c", bint allocate_buffer=True): * - * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; + __Pyx_XDECREF(__pyx_v_format); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1046 - * raise ImportError("numpy.core.umath failed to import") +/* "View.MemoryView":185 * - * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * cdef int bufmode = -1 + * if self.mode == u"c": */ -static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { int __pyx_r; __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(((struct __pyx_array_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_v_bufmode; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - __Pyx_RefNannySetupContext("import_ufunc", 0); + char *__pyx_t_4; + Py_ssize_t __pyx_t_5; + int __pyx_t_6; + Py_ssize_t *__pyx_t_7; + if (__pyx_v_info == NULL) { + PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); + return -1; + } + __Pyx_RefNannySetupContext("__getbuffer__", 0); + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1047 - * - * cdef inline int import_ufunc() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: + /* "View.MemoryView":186 + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 # <<<<<<<<<<<<<< + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_1); - __Pyx_XGOTREF(__pyx_t_2); - __Pyx_XGOTREF(__pyx_t_3); - /*try:*/ { + __pyx_v_bufmode = -1; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1048 - * cdef inline int import_ufunc() except -1: - * try: - * _import_umath() # <<<<<<<<<<<<<< - * except Exception: - * raise ImportError("numpy.core.umath failed to import") + /* "View.MemoryView":187 + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 + * if self.mode == u"c": # <<<<<<<<<<<<<< + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": */ - __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1048, __pyx_L3_error) + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_c, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(2, 187, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1047 - * - * cdef inline int import_ufunc() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: + /* "View.MemoryView":188 + * cdef int bufmode = -1 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS */ - } - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L8_try_end; - __pyx_L3_error:; + __pyx_v_bufmode = (PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1049 - * try: - * _import_umath() - * except Exception: # <<<<<<<<<<<<<< - * raise ImportError("numpy.core.umath failed to import") + /* "View.MemoryView":187 + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 + * if self.mode == u"c": # <<<<<<<<<<<<<< + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": */ - __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - if (__pyx_t_4) { - __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1049, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GOTREF(__pyx_t_7); + goto __pyx_L3; + } - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1050 - * _import_umath() - * except Exception: - * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + /* "View.MemoryView":189 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": # <<<<<<<<<<<<<< + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1050, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 1050, __pyx_L5_except_error) - } - goto __pyx_L5_except_error; - __pyx_L5_except_error:; + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_fortran, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(2, 189, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1047 - * - * cdef inline int import_ufunc() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: + /* "View.MemoryView":190 + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< + * if not (flags & bufmode): + * raise ValueError("Can only create a buffer that is contiguous in memory.") + */ + __pyx_v_bufmode = (PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); + + /* "View.MemoryView":189 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": # <<<<<<<<<<<<<< + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): */ - __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); - goto __pyx_L1_error; - __pyx_L8_try_end:; } + __pyx_L3:; - /* "../../../../../../anaconda3/envs/py36/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1046 - * raise ImportError("numpy.core.umath failed to import") - * - * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() + /* "View.MemoryView":191 + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): # <<<<<<<<<<<<<< + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data */ + __pyx_t_1 = ((!((__pyx_v_flags & __pyx_v_bufmode) != 0)) != 0); + if (unlikely(__pyx_t_1)) { - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "View.MemoryView":192 + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): + * raise ValueError("Can only create a buffer that is contiguous in memory.") # <<<<<<<<<<<<<< + * info.buf = self.data + * info.len = self.len + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(2, 192, __pyx_L1_error) -/* "View.MemoryView":122 - * cdef bint dtype_is_object - * - * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< - * mode="c", bint allocate_buffer=True): - * + /* "View.MemoryView":191 + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): # <<<<<<<<<<<<<< + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data */ + } -/* Python wrapper */ -static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_shape = 0; - Py_ssize_t __pyx_v_itemsize; - PyObject *__pyx_v_format = 0; - PyObject *__pyx_v_mode = 0; - int __pyx_v_allocate_buffer; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_shape,&__pyx_n_s_itemsize,&__pyx_n_s_format,&__pyx_n_s_mode,&__pyx_n_s_allocate_buffer,0}; - PyObject* values[5] = {0,0,0,0,0}; - values[3] = ((PyObject *)__pyx_n_s_c); - if (unlikely(__pyx_kwds)) { - Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { - case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_shape)) != 0)) kw_args--; - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_itemsize)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 1); __PYX_ERR(2, 122, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_format)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 2); __PYX_ERR(2, 122, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mode); - if (value) { values[3] = value; kw_args--; } - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_allocate_buffer); - if (value) { values[4] = value; kw_args--; } - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(2, 122, __pyx_L3_error) - } - } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } - } - __pyx_v_shape = ((PyObject*)values[0]); - __pyx_v_itemsize = __Pyx_PyIndex_AsSsize_t(values[1]); if (unlikely((__pyx_v_itemsize == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 122, __pyx_L3_error) - __pyx_v_format = values[2]; - __pyx_v_mode = values[3]; - if (values[4]) { - __pyx_v_allocate_buffer = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_allocate_buffer == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 123, __pyx_L3_error) - } else { + /* "View.MemoryView":193 + * if not (flags & bufmode): + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data # <<<<<<<<<<<<<< + * info.len = self.len + * info.ndim = self.ndim + */ + __pyx_t_4 = __pyx_v_self->data; + __pyx_v_info->buf = __pyx_t_4; - /* "View.MemoryView":123 - * - * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, - * mode="c", bint allocate_buffer=True): # <<<<<<<<<<<<<< - * - * cdef int idx + /* "View.MemoryView":194 + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data + * info.len = self.len # <<<<<<<<<<<<<< + * info.ndim = self.ndim + * info.shape = self._shape */ - __pyx_v_allocate_buffer = ((int)1); - } - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 122, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return -1; - __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_shape), (&PyTuple_Type), 1, "shape", 1))) __PYX_ERR(2, 122, __pyx_L1_error) - if (unlikely(((PyObject *)__pyx_v_format) == Py_None)) { - PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "format"); __PYX_ERR(2, 122, __pyx_L1_error) - } - __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v_shape, __pyx_v_itemsize, __pyx_v_format, __pyx_v_mode, __pyx_v_allocate_buffer); + __pyx_t_5 = __pyx_v_self->len; + __pyx_v_info->len = __pyx_t_5; - /* "View.MemoryView":122 - * cdef bint dtype_is_object - * - * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< - * mode="c", bint allocate_buffer=True): - * + /* "View.MemoryView":195 + * info.buf = self.data + * info.len = self.len + * info.ndim = self.ndim # <<<<<<<<<<<<<< + * info.shape = self._shape + * info.strides = self._strides */ + __pyx_t_6 = __pyx_v_self->ndim; + __pyx_v_info->ndim = __pyx_t_6; - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __pyx_r = -1; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "View.MemoryView":196 + * info.len = self.len + * info.ndim = self.ndim + * info.shape = self._shape # <<<<<<<<<<<<<< + * info.strides = self._strides + * info.suboffsets = NULL + */ + __pyx_t_7 = __pyx_v_self->_shape; + __pyx_v_info->shape = __pyx_t_7; -static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer) { - int __pyx_v_idx; - Py_ssize_t __pyx_v_i; - Py_ssize_t __pyx_v_dim; - PyObject **__pyx_v_p; - char __pyx_v_order; - int __pyx_r; - __Pyx_RefNannyDeclarations - Py_ssize_t __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - char *__pyx_t_7; - int __pyx_t_8; - Py_ssize_t __pyx_t_9; - PyObject *__pyx_t_10 = NULL; - Py_ssize_t __pyx_t_11; - __Pyx_RefNannySetupContext("__cinit__", 0); - __Pyx_INCREF(__pyx_v_format); + /* "View.MemoryView":197 + * info.ndim = self.ndim + * info.shape = self._shape + * info.strides = self._strides # <<<<<<<<<<<<<< + * info.suboffsets = NULL + * info.itemsize = self.itemsize + */ + __pyx_t_7 = __pyx_v_self->_strides; + __pyx_v_info->strides = __pyx_t_7; - /* "View.MemoryView":129 - * cdef PyObject **p - * - * self.ndim = len(shape) # <<<<<<<<<<<<<< - * self.itemsize = itemsize - * + /* "View.MemoryView":198 + * info.shape = self._shape + * info.strides = self._strides + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * info.itemsize = self.itemsize + * info.readonly = 0 */ - if (unlikely(__pyx_v_shape == Py_None)) { - PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(2, 129, __pyx_L1_error) - } - __pyx_t_1 = PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(2, 129, __pyx_L1_error) - __pyx_v_self->ndim = ((int)__pyx_t_1); + __pyx_v_info->suboffsets = NULL; - /* "View.MemoryView":130 - * - * self.ndim = len(shape) - * self.itemsize = itemsize # <<<<<<<<<<<<<< + /* "View.MemoryView":199 + * info.strides = self._strides + * info.suboffsets = NULL + * info.itemsize = self.itemsize # <<<<<<<<<<<<<< + * info.readonly = 0 * - * if not self.ndim: */ - __pyx_v_self->itemsize = __pyx_v_itemsize; + __pyx_t_5 = __pyx_v_self->itemsize; + __pyx_v_info->itemsize = __pyx_t_5; - /* "View.MemoryView":132 - * self.itemsize = itemsize - * - * if not self.ndim: # <<<<<<<<<<<<<< - * raise ValueError("Empty shape tuple for cython.array") + /* "View.MemoryView":200 + * info.suboffsets = NULL + * info.itemsize = self.itemsize + * info.readonly = 0 # <<<<<<<<<<<<<< * + * if flags & PyBUF_FORMAT: */ - __pyx_t_2 = ((!(__pyx_v_self->ndim != 0)) != 0); - if (unlikely(__pyx_t_2)) { + __pyx_v_info->readonly = 0; - /* "View.MemoryView":133 - * - * if not self.ndim: - * raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<< + /* "View.MemoryView":202 + * info.readonly = 0 * - * if itemsize <= 0: + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.format + * else: */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 133, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(2, 133, __pyx_L1_error) + __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); + if (__pyx_t_1) { - /* "View.MemoryView":132 - * self.itemsize = itemsize + /* "View.MemoryView":203 * - * if not self.ndim: # <<<<<<<<<<<<<< - * raise ValueError("Empty shape tuple for cython.array") + * if flags & PyBUF_FORMAT: + * info.format = self.format # <<<<<<<<<<<<<< + * else: + * info.format = NULL + */ + __pyx_t_4 = __pyx_v_self->format; + __pyx_v_info->format = __pyx_t_4; + + /* "View.MemoryView":202 + * info.readonly = 0 * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.format + * else: */ + goto __pyx_L5; } - /* "View.MemoryView":135 - * raise ValueError("Empty shape tuple for cython.array") - * - * if itemsize <= 0: # <<<<<<<<<<<<<< - * raise ValueError("itemsize <= 0 for cython.array") + /* "View.MemoryView":205 + * info.format = self.format + * else: + * info.format = NULL # <<<<<<<<<<<<<< * + * info.obj = self */ - __pyx_t_2 = ((__pyx_v_itemsize <= 0) != 0); - if (unlikely(__pyx_t_2)) { + /*else*/ { + __pyx_v_info->format = NULL; + } + __pyx_L5:; - /* "View.MemoryView":136 + /* "View.MemoryView":207 + * info.format = NULL * - * if itemsize <= 0: - * raise ValueError("itemsize <= 0 for cython.array") # <<<<<<<<<<<<<< + * info.obj = self # <<<<<<<<<<<<<< * - * if not isinstance(format, bytes): + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 136, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(2, 136, __pyx_L1_error) - - /* "View.MemoryView":135 - * raise ValueError("Empty shape tuple for cython.array") - * - * if itemsize <= 0: # <<<<<<<<<<<<<< - * raise ValueError("itemsize <= 0 for cython.array") + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + + /* "View.MemoryView":185 * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * cdef int bufmode = -1 + * if self.mode == u"c": */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.array.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; } + __pyx_L2:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "View.MemoryView":138 - * raise ValueError("itemsize <= 0 for cython.array") +/* "View.MemoryView":211 + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") * - * if not isinstance(format, bytes): # <<<<<<<<<<<<<< - * format = format.encode('ASCII') - * self._format = format # keep a reference to the byte string + * def __dealloc__(array self): # <<<<<<<<<<<<<< + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) */ - __pyx_t_2 = PyBytes_Check(__pyx_v_format); - __pyx_t_4 = ((!(__pyx_t_2 != 0)) != 0); - if (__pyx_t_4) { - /* "View.MemoryView":139 +/* Python wrapper */ +static void __pyx_array___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_array___dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "View.MemoryView":212 * - * if not isinstance(format, bytes): - * format = format.encode('ASCII') # <<<<<<<<<<<<<< - * self._format = format # keep a reference to the byte string - * self.format = self._format + * def __dealloc__(array self): + * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< + * self.callback_free_data(self.data) + * elif self.free_data: */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 139, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_6)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - } - } - __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_n_s_ASCII) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_n_s_ASCII); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 139, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF_SET(__pyx_v_format, __pyx_t_3); - __pyx_t_3 = 0; + __pyx_t_1 = ((__pyx_v_self->callback_free_data != NULL) != 0); + if (__pyx_t_1) { - /* "View.MemoryView":138 - * raise ValueError("itemsize <= 0 for cython.array") + /* "View.MemoryView":213 + * def __dealloc__(array self): + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) # <<<<<<<<<<<<<< + * elif self.free_data: + * if self.dtype_is_object: + */ + __pyx_v_self->callback_free_data(__pyx_v_self->data); + + /* "View.MemoryView":212 * - * if not isinstance(format, bytes): # <<<<<<<<<<<<<< - * format = format.encode('ASCII') - * self._format = format # keep a reference to the byte string + * def __dealloc__(array self): + * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< + * self.callback_free_data(self.data) + * elif self.free_data: */ + goto __pyx_L3; } - /* "View.MemoryView":140 - * if not isinstance(format, bytes): - * format = format.encode('ASCII') - * self._format = format # keep a reference to the byte string # <<<<<<<<<<<<<< - * self.format = self._format - * + /* "View.MemoryView":214 + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + * elif self.free_data: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, */ - if (!(likely(PyBytes_CheckExact(__pyx_v_format))||((__pyx_v_format) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_v_format)->tp_name), 0))) __PYX_ERR(2, 140, __pyx_L1_error) - __pyx_t_3 = __pyx_v_format; - __Pyx_INCREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - __Pyx_GOTREF(__pyx_v_self->_format); - __Pyx_DECREF(__pyx_v_self->_format); - __pyx_v_self->_format = ((PyObject*)__pyx_t_3); - __pyx_t_3 = 0; + __pyx_t_1 = (__pyx_v_self->free_data != 0); + if (__pyx_t_1) { - /* "View.MemoryView":141 - * format = format.encode('ASCII') - * self._format = format # keep a reference to the byte string - * self.format = self._format # <<<<<<<<<<<<<< - * - * + /* "View.MemoryView":215 + * self.callback_free_data(self.data) + * elif self.free_data: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice(self.data, self._shape, + * self._strides, self.ndim, False) */ - if (unlikely(__pyx_v_self->_format == Py_None)) { - PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); - __PYX_ERR(2, 141, __pyx_L1_error) - } - __pyx_t_7 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(2, 141, __pyx_L1_error) - __pyx_v_self->format = __pyx_t_7; + __pyx_t_1 = (__pyx_v_self->dtype_is_object != 0); + if (__pyx_t_1) { - /* "View.MemoryView":144 - * - * - * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) # <<<<<<<<<<<<<< - * self._strides = self._shape + self.ndim - * + /* "View.MemoryView":216 + * elif self.free_data: + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, # <<<<<<<<<<<<<< + * self._strides, self.ndim, False) + * free(self.data) */ - __pyx_v_self->_shape = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * __pyx_v_self->ndim) * 2))); + __pyx_memoryview_refcount_objects_in_slice(__pyx_v_self->data, __pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_self->ndim, 0); - /* "View.MemoryView":145 - * - * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) - * self._strides = self._shape + self.ndim # <<<<<<<<<<<<<< - * - * if not self._shape: + /* "View.MemoryView":215 + * self.callback_free_data(self.data) + * elif self.free_data: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice(self.data, self._shape, + * self._strides, self.ndim, False) */ - __pyx_v_self->_strides = (__pyx_v_self->_shape + __pyx_v_self->ndim); + } - /* "View.MemoryView":147 - * self._strides = self._shape + self.ndim - * - * if not self._shape: # <<<<<<<<<<<<<< - * raise MemoryError("unable to allocate shape and strides.") + /* "View.MemoryView":218 + * refcount_objects_in_slice(self.data, self._shape, + * self._strides, self.ndim, False) + * free(self.data) # <<<<<<<<<<<<<< + * PyObject_Free(self._shape) * */ - __pyx_t_4 = ((!(__pyx_v_self->_shape != 0)) != 0); - if (unlikely(__pyx_t_4)) { + free(__pyx_v_self->data); - /* "View.MemoryView":148 - * - * if not self._shape: - * raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<< - * - * + /* "View.MemoryView":214 + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + * elif self.free_data: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(2, 148, __pyx_L1_error) + } + __pyx_L3:; - /* "View.MemoryView":147 - * self._strides = self._shape + self.ndim + /* "View.MemoryView":219 + * self._strides, self.ndim, False) + * free(self.data) + * PyObject_Free(self._shape) # <<<<<<<<<<<<<< * - * if not self._shape: # <<<<<<<<<<<<<< - * raise MemoryError("unable to allocate shape and strides.") + * @property + */ + PyObject_Free(__pyx_v_self->_shape); + + /* "View.MemoryView":211 + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") * + * def __dealloc__(array self): # <<<<<<<<<<<<<< + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) */ - } - /* "View.MemoryView":151 + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":222 * + * @property + * def memview(self): # <<<<<<<<<<<<<< + * return self.get_memview() * - * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< - * if dim <= 0: - * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) */ - __pyx_t_8 = 0; - __pyx_t_3 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0; - for (;;) { - if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_3)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(2, 151, __pyx_L1_error) - #else - __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 151, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - #endif - __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_5); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 151, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_dim = __pyx_t_9; - __pyx_v_idx = __pyx_t_8; - __pyx_t_8 = (__pyx_t_8 + 1); - /* "View.MemoryView":152 +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_5array_7memview___get__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":223 + * @property + * def memview(self): + * return self.get_memview() # <<<<<<<<<<<<<< * - * for idx, dim in enumerate(shape): - * if dim <= 0: # <<<<<<<<<<<<<< - * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) - * self._shape[idx] = dim + * @cname('get_memview') */ - __pyx_t_4 = ((__pyx_v_dim <= 0) != 0); - if (unlikely(__pyx_t_4)) { + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((struct __pyx_vtabstruct_array *)__pyx_v_self->__pyx_vtab)->get_memview(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "View.MemoryView":153 - * for idx, dim in enumerate(shape): - * if dim <= 0: - * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) # <<<<<<<<<<<<<< - * self._shape[idx] = dim + /* "View.MemoryView":222 + * + * @property + * def memview(self): # <<<<<<<<<<<<<< + * return self.get_memview() * */ - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_idx); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_5); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_6); - __pyx_t_5 = 0; - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_Raise(__pyx_t_10, 0, 0, 0); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __PYX_ERR(2, 153, __pyx_L1_error) - /* "View.MemoryView":152 + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.memview.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":226 * - * for idx, dim in enumerate(shape): - * if dim <= 0: # <<<<<<<<<<<<<< - * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) - * self._shape[idx] = dim + * @cname('get_memview') + * cdef get_memview(self): # <<<<<<<<<<<<<< + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE + * return memoryview(self, flags, self.dtype_is_object) */ - } - /* "View.MemoryView":154 - * if dim <= 0: - * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) - * self._shape[idx] = dim # <<<<<<<<<<<<<< +static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) { + int __pyx_v_flags; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("get_memview", 0); + + /* "View.MemoryView":227 + * @cname('get_memview') + * cdef get_memview(self): + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE # <<<<<<<<<<<<<< + * return memoryview(self, flags, self.dtype_is_object) * - * cdef char order */ - (__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim; + __pyx_v_flags = ((PyBUF_ANY_CONTIGUOUS | PyBUF_FORMAT) | PyBUF_WRITABLE); - /* "View.MemoryView":151 - * + /* "View.MemoryView":228 + * cdef get_memview(self): + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE + * return memoryview(self, flags, self.dtype_is_object) # <<<<<<<<<<<<<< * - * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< - * if dim <= 0: - * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * def __len__(self): */ - } + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; - /* "View.MemoryView":157 + /* "View.MemoryView":226 * - * cdef char order - * if mode == 'fortran': # <<<<<<<<<<<<<< - * order = b'F' - * self.mode = u'fortran' - */ - __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_fortran, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 157, __pyx_L1_error) - if (__pyx_t_4) { - - /* "View.MemoryView":158 - * cdef char order - * if mode == 'fortran': - * order = b'F' # <<<<<<<<<<<<<< - * self.mode = u'fortran' - * elif mode == 'c': + * @cname('get_memview') + * cdef get_memview(self): # <<<<<<<<<<<<<< + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE + * return memoryview(self, flags, self.dtype_is_object) */ - __pyx_v_order = 'F'; - /* "View.MemoryView":159 - * if mode == 'fortran': - * order = b'F' - * self.mode = u'fortran' # <<<<<<<<<<<<<< - * elif mode == 'c': - * order = b'C' - */ - __Pyx_INCREF(__pyx_n_u_fortran); - __Pyx_GIVEREF(__pyx_n_u_fortran); - __Pyx_GOTREF(__pyx_v_self->mode); - __Pyx_DECREF(__pyx_v_self->mode); - __pyx_v_self->mode = __pyx_n_u_fortran; + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.array.get_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "View.MemoryView":157 +/* "View.MemoryView":230 + * return memoryview(self, flags, self.dtype_is_object) + * + * def __len__(self): # <<<<<<<<<<<<<< + * return self._shape[0] * - * cdef char order - * if mode == 'fortran': # <<<<<<<<<<<<<< - * order = b'F' - * self.mode = u'fortran' */ - goto __pyx_L10; - } - /* "View.MemoryView":160 - * order = b'F' - * self.mode = u'fortran' - * elif mode == 'c': # <<<<<<<<<<<<<< - * order = b'C' - * self.mode = u'c' +/* Python wrapper */ +static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self); /*proto*/ +static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__", 0); + + /* "View.MemoryView":231 + * + * def __len__(self): + * return self._shape[0] # <<<<<<<<<<<<<< + * + * def __getattr__(self, attr): */ - __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_c, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 160, __pyx_L1_error) - if (likely(__pyx_t_4)) { + __pyx_r = (__pyx_v_self->_shape[0]); + goto __pyx_L0; - /* "View.MemoryView":161 - * self.mode = u'fortran' - * elif mode == 'c': - * order = b'C' # <<<<<<<<<<<<<< - * self.mode = u'c' - * else: + /* "View.MemoryView":230 + * return memoryview(self, flags, self.dtype_is_object) + * + * def __len__(self): # <<<<<<<<<<<<<< + * return self._shape[0] + * */ - __pyx_v_order = 'C'; - /* "View.MemoryView":162 - * elif mode == 'c': - * order = b'C' - * self.mode = u'c' # <<<<<<<<<<<<<< - * else: - * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) - */ - __Pyx_INCREF(__pyx_n_u_c); - __Pyx_GIVEREF(__pyx_n_u_c); - __Pyx_GOTREF(__pyx_v_self->mode); - __Pyx_DECREF(__pyx_v_self->mode); - __pyx_v_self->mode = __pyx_n_u_c; - - /* "View.MemoryView":160 - * order = b'F' - * self.mode = u'fortran' - * elif mode == 'c': # <<<<<<<<<<<<<< - * order = b'C' - * self.mode = u'c' - */ - goto __pyx_L10; - } + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "View.MemoryView":164 - * self.mode = u'c' - * else: - * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) # <<<<<<<<<<<<<< +/* "View.MemoryView":233 + * return self._shape[0] + * + * def __getattr__(self, attr): # <<<<<<<<<<<<<< + * return getattr(self.memview, attr) * - * self.len = fill_contig_strides_array(self._shape, self._strides, */ - /*else*/ { - __pyx_t_3 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_v_mode); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 164, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 164, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_10, 0, 0, 0); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __PYX_ERR(2, 164, __pyx_L1_error) - } - __pyx_L10:; - /* "View.MemoryView":166 - * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) +/* Python wrapper */ +static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr); /*proto*/ +static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_attr)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__getattr__", 0); + + /* "View.MemoryView":234 * - * self.len = fill_contig_strides_array(self._shape, self._strides, # <<<<<<<<<<<<<< - * itemsize, self.ndim, order) + * def __getattr__(self, attr): + * return getattr(self.memview, attr) # <<<<<<<<<<<<<< * + * def __getitem__(self, item): */ - __pyx_v_self->len = __pyx_fill_contig_strides_array(__pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_itemsize, __pyx_v_self->ndim, __pyx_v_order); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_GetAttr(__pyx_t_1, __pyx_v_attr); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; - /* "View.MemoryView":169 - * itemsize, self.ndim, order) + /* "View.MemoryView":233 + * return self._shape[0] + * + * def __getattr__(self, attr): # <<<<<<<<<<<<<< + * return getattr(self.memview, attr) * - * self.free_data = allocate_buffer # <<<<<<<<<<<<<< - * self.dtype_is_object = format == b'O' - * if allocate_buffer: */ - __pyx_v_self->free_data = __pyx_v_allocate_buffer; - /* "View.MemoryView":170 + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.array.__getattr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":236 + * return getattr(self.memview, attr) * - * self.free_data = allocate_buffer - * self.dtype_is_object = format == b'O' # <<<<<<<<<<<<<< - * if allocate_buffer: + * def __getitem__(self, item): # <<<<<<<<<<<<<< + * return self.memview[item] * */ - __pyx_t_10 = PyObject_RichCompare(__pyx_v_format, __pyx_n_b_O, Py_EQ); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 170, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 170, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_v_self->dtype_is_object = __pyx_t_4; - /* "View.MemoryView":171 - * self.free_data = allocate_buffer - * self.dtype_is_object = format == b'O' - * if allocate_buffer: # <<<<<<<<<<<<<< +/* Python wrapper */ +static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item); /*proto*/ +static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "View.MemoryView":237 * + * def __getitem__(self, item): + * return self.memview[item] # <<<<<<<<<<<<<< * + * def __setitem__(self, item, value): */ - __pyx_t_4 = (__pyx_v_allocate_buffer != 0); - if (__pyx_t_4) { + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; - /* "View.MemoryView":174 + /* "View.MemoryView":236 + * return getattr(self.memview, attr) * + * def __getitem__(self, item): # <<<<<<<<<<<<<< + * return self.memview[item] * - * self.data = malloc(self.len) # <<<<<<<<<<<<<< - * if not self.data: - * raise MemoryError("unable to allocate array data.") */ - __pyx_v_self->data = ((char *)malloc(__pyx_v_self->len)); - /* "View.MemoryView":175 + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":239 + * return self.memview[item] * - * self.data = malloc(self.len) - * if not self.data: # <<<<<<<<<<<<<< - * raise MemoryError("unable to allocate array data.") + * def __setitem__(self, item, value): # <<<<<<<<<<<<<< + * self.memview[item] = value * */ - __pyx_t_4 = ((!(__pyx_v_self->data != 0)) != 0); - if (unlikely(__pyx_t_4)) { - /* "View.MemoryView":176 - * self.data = malloc(self.len) - * if not self.data: - * raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<< - * - * if self.dtype_is_object: - */ - __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 176, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __Pyx_Raise(__pyx_t_10, 0, 0, 0); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __PYX_ERR(2, 176, __pyx_L1_error) +/* Python wrapper */ +static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item), ((PyObject *)__pyx_v_value)); - /* "View.MemoryView":175 + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__setitem__", 0); + + /* "View.MemoryView":240 * - * self.data = malloc(self.len) - * if not self.data: # <<<<<<<<<<<<<< - * raise MemoryError("unable to allocate array data.") + * def __setitem__(self, item, value): + * self.memview[item] = value # <<<<<<<<<<<<<< * - */ - } - - /* "View.MemoryView":178 - * raise MemoryError("unable to allocate array data.") * - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * p = self.data - * for i in range(self.len / itemsize): */ - __pyx_t_4 = (__pyx_v_self->dtype_is_object != 0); - if (__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_v_item, __pyx_v_value) < 0)) __PYX_ERR(2, 240, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "View.MemoryView":179 + /* "View.MemoryView":239 + * return self.memview[item] + * + * def __setitem__(self, item, value): # <<<<<<<<<<<<<< + * self.memview[item] = value * - * if self.dtype_is_object: - * p = self.data # <<<<<<<<<<<<<< - * for i in range(self.len / itemsize): - * p[i] = Py_None */ - __pyx_v_p = ((PyObject **)__pyx_v_self->data); - /* "View.MemoryView":180 - * if self.dtype_is_object: - * p = self.data - * for i in range(self.len / itemsize): # <<<<<<<<<<<<<< - * p[i] = Py_None - * Py_INCREF(Py_None) - */ - if (unlikely(__pyx_v_itemsize == 0)) { - PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); - __PYX_ERR(2, 180, __pyx_L1_error) - } - else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_self->len))) { - PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); - __PYX_ERR(2, 180, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_div_Py_ssize_t(__pyx_v_self->len, __pyx_v_itemsize); - __pyx_t_9 = __pyx_t_1; - for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_9; __pyx_t_11+=1) { - __pyx_v_i = __pyx_t_11; + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "View.MemoryView":181 - * p = self.data - * for i in range(self.len / itemsize): - * p[i] = Py_None # <<<<<<<<<<<<<< - * Py_INCREF(Py_None) - * +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): */ - (__pyx_v_p[__pyx_v_i]) = Py_None; - /* "View.MemoryView":182 - * for i in range(self.len / itemsize): - * p[i] = Py_None - * Py_INCREF(Py_None) # <<<<<<<<<<<<<< - * - * @cname('getbuffer') - */ - Py_INCREF(Py_None); - } +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_array___reduce_cython__(((struct __pyx_array_obj *)__pyx_v_self)); - /* "View.MemoryView":178 - * raise MemoryError("unable to allocate array data.") - * - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * p = self.data - * for i in range(self.len / itemsize): - */ - } + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "View.MemoryView":171 - * self.free_data = allocate_buffer - * self.dtype_is_object = format == b'O' - * if allocate_buffer: # <<<<<<<<<<<<<< - * - * +static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ - } + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(2, 2, __pyx_L1_error) - /* "View.MemoryView":122 - * cdef bint dtype_is_object - * - * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< - * mode="c", bint allocate_buffer=True): - * + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_10); - __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_format); + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "View.MemoryView":185 - * - * @cname('getbuffer') - * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< - * cdef int bufmode = -1 - * if self.mode == u"c": +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* Python wrapper */ -static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ -static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { - int __pyx_r; +static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); - __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(((struct __pyx_array_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_array_2__setstate_cython__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { - int __pyx_v_bufmode; - int __pyx_r; +static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - char *__pyx_t_4; - Py_ssize_t __pyx_t_5; - int __pyx_t_6; - Py_ssize_t *__pyx_t_7; - if (__pyx_v_info == NULL) { - PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); - return -1; - } - __Pyx_RefNannySetupContext("__getbuffer__", 0); - __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(__pyx_v_info->obj); + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); - /* "View.MemoryView":186 - * @cname('getbuffer') - * def __getbuffer__(self, Py_buffer *info, int flags): - * cdef int bufmode = -1 # <<<<<<<<<<<<<< - * if self.mode == u"c": - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + /* "(tree fragment)":4 + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_v_bufmode = -1; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(2, 4, __pyx_L1_error) - /* "View.MemoryView":187 - * def __getbuffer__(self, Py_buffer *info, int flags): - * cdef int bufmode = -1 - * if self.mode == u"c": # <<<<<<<<<<<<<< - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * elif self.mode == u"fortran": + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_c, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(2, 187, __pyx_L1_error) - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { - /* "View.MemoryView":188 - * cdef int bufmode = -1 - * if self.mode == u"c": - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< - * elif self.mode == u"fortran": - * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - */ - __pyx_v_bufmode = (PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "View.MemoryView":187 - * def __getbuffer__(self, Py_buffer *info, int flags): - * cdef int bufmode = -1 - * if self.mode == u"c": # <<<<<<<<<<<<<< - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * elif self.mode == u"fortran": +/* "View.MemoryView":244 + * + * @cname("__pyx_array_new") + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< + * char *mode, char *buf): + * cdef array result */ - goto __pyx_L3; - } - /* "View.MemoryView":189 - * if self.mode == u"c": - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * elif self.mode == u"fortran": # <<<<<<<<<<<<<< - * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * if not (flags & bufmode): +static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, char *__pyx_v_format, char *__pyx_v_mode, char *__pyx_v_buf) { + struct __pyx_array_obj *__pyx_v_result = 0; + struct __pyx_array_obj *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("array_cwrapper", 0); + + /* "View.MemoryView":248 + * cdef array result + * + * if buf == NULL: # <<<<<<<<<<<<<< + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: */ - __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_fortran, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(2, 189, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_2 != 0); + __pyx_t_1 = ((__pyx_v_buf == NULL) != 0); if (__pyx_t_1) { - /* "View.MemoryView":190 - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * elif self.mode == u"fortran": - * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< - * if not (flags & bufmode): - * raise ValueError("Can only create a buffer that is contiguous in memory.") + /* "View.MemoryView":249 + * + * if buf == NULL: + * result = array(shape, itemsize, format, mode.decode('ASCII')) # <<<<<<<<<<<<<< + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), */ - __pyx_v_bufmode = (PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); - - /* "View.MemoryView":189 - * if self.mode == u"c": - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * elif self.mode == u"fortran": # <<<<<<<<<<<<<< - * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * if not (flags & bufmode): - */ - } - __pyx_L3:; - - /* "View.MemoryView":191 - * elif self.mode == u"fortran": - * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * if not (flags & bufmode): # <<<<<<<<<<<<<< - * raise ValueError("Can only create a buffer that is contiguous in memory.") - * info.buf = self.data - */ - __pyx_t_1 = ((!((__pyx_v_flags & __pyx_v_bufmode) != 0)) != 0); - if (unlikely(__pyx_t_1)) { - - /* "View.MemoryView":192 - * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * if not (flags & bufmode): - * raise ValueError("Can only create a buffer that is contiguous in memory.") # <<<<<<<<<<<<<< - * info.buf = self.data - * info.len = self.len - */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 192, __pyx_L1_error) + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(2, 192, __pyx_L1_error) - - /* "View.MemoryView":191 - * elif self.mode == u"fortran": - * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * if not (flags & bufmode): # <<<<<<<<<<<<<< - * raise ValueError("Can only create a buffer that is contiguous in memory.") - * info.buf = self.data - */ - } - - /* "View.MemoryView":193 - * if not (flags & bufmode): - * raise ValueError("Can only create a buffer that is contiguous in memory.") - * info.buf = self.data # <<<<<<<<<<<<<< - * info.len = self.len - * info.ndim = self.ndim - */ - __pyx_t_4 = __pyx_v_self->data; - __pyx_v_info->buf = __pyx_t_4; - - /* "View.MemoryView":194 - * raise ValueError("Can only create a buffer that is contiguous in memory.") - * info.buf = self.data - * info.len = self.len # <<<<<<<<<<<<<< - * info.ndim = self.ndim - * info.shape = self._shape - */ - __pyx_t_5 = __pyx_v_self->len; - __pyx_v_info->len = __pyx_t_5; - - /* "View.MemoryView":195 - * info.buf = self.data - * info.len = self.len - * info.ndim = self.ndim # <<<<<<<<<<<<<< - * info.shape = self._shape - * info.strides = self._strides - */ - __pyx_t_6 = __pyx_v_self->ndim; - __pyx_v_info->ndim = __pyx_t_6; - - /* "View.MemoryView":196 - * info.len = self.len - * info.ndim = self.ndim - * info.shape = self._shape # <<<<<<<<<<<<<< - * info.strides = self._strides - * info.suboffsets = NULL - */ - __pyx_t_7 = __pyx_v_self->_shape; - __pyx_v_info->shape = __pyx_t_7; - - /* "View.MemoryView":197 - * info.ndim = self.ndim - * info.shape = self._shape - * info.strides = self._strides # <<<<<<<<<<<<<< - * info.suboffsets = NULL - * info.itemsize = self.itemsize - */ - __pyx_t_7 = __pyx_v_self->_strides; - __pyx_v_info->strides = __pyx_t_7; - - /* "View.MemoryView":198 - * info.shape = self._shape - * info.strides = self._strides - * info.suboffsets = NULL # <<<<<<<<<<<<<< - * info.itemsize = self.itemsize - * info.readonly = 0 - */ - __pyx_v_info->suboffsets = NULL; + __pyx_t_4 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v_shape); + __Pyx_GIVEREF(__pyx_v_shape); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_shape); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4); + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_4); + __pyx_t_4 = 0; - /* "View.MemoryView":199 - * info.strides = self._strides - * info.suboffsets = NULL - * info.itemsize = self.itemsize # <<<<<<<<<<<<<< - * info.readonly = 0 + /* "View.MemoryView":248 + * cdef array result * + * if buf == NULL: # <<<<<<<<<<<<<< + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: */ - __pyx_t_5 = __pyx_v_self->itemsize; - __pyx_v_info->itemsize = __pyx_t_5; + goto __pyx_L3; + } - /* "View.MemoryView":200 - * info.suboffsets = NULL - * info.itemsize = self.itemsize - * info.readonly = 0 # <<<<<<<<<<<<<< - * - * if flags & PyBUF_FORMAT: + /* "View.MemoryView":251 + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< + * allocate_buffer=False) + * result.data = buf */ - __pyx_v_info->readonly = 0; + /*else*/ { + __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_shape); + __Pyx_GIVEREF(__pyx_v_shape); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_shape); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_3); + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_3 = 0; - /* "View.MemoryView":202 - * info.readonly = 0 + /* "View.MemoryView":252 + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), + * allocate_buffer=False) # <<<<<<<<<<<<<< + * result.data = buf * - * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< - * info.format = self.format - * else: */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); - if (__pyx_t_1) { + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_allocate_buffer, Py_False) < 0) __PYX_ERR(2, 252, __pyx_L1_error) - /* "View.MemoryView":203 - * - * if flags & PyBUF_FORMAT: - * info.format = self.format # <<<<<<<<<<<<<< - * else: - * info.format = NULL + /* "View.MemoryView":251 + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< + * allocate_buffer=False) + * result.data = buf */ - __pyx_t_4 = __pyx_v_self->format; - __pyx_v_info->format = __pyx_t_4; + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_5); + __pyx_t_5 = 0; - /* "View.MemoryView":202 - * info.readonly = 0 + /* "View.MemoryView":253 + * result = array(shape, itemsize, format, mode.decode('ASCII'), + * allocate_buffer=False) + * result.data = buf # <<<<<<<<<<<<<< * - * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< - * info.format = self.format - * else: + * return result */ - goto __pyx_L5; + __pyx_v_result->data = __pyx_v_buf; } + __pyx_L3:; - /* "View.MemoryView":205 - * info.format = self.format - * else: - * info.format = NULL # <<<<<<<<<<<<<< + /* "View.MemoryView":255 + * result.data = buf * - * info.obj = self - */ - /*else*/ { - __pyx_v_info->format = NULL; - } - __pyx_L5:; - - /* "View.MemoryView":207 - * info.format = NULL + * return result # <<<<<<<<<<<<<< * - * info.obj = self # <<<<<<<<<<<<<< * - * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") */ - __Pyx_INCREF(((PyObject *)__pyx_v_self)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); - __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = __pyx_v_result; + goto __pyx_L0; - /* "View.MemoryView":185 + /* "View.MemoryView":244 * - * @cname('getbuffer') - * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< - * cdef int bufmode = -1 - * if self.mode == u"c": + * @cname("__pyx_array_new") + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< + * char *mode, char *buf): + * cdef array result */ /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.array.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - if (__pyx_v_info->obj != NULL) { - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; - } - goto __pyx_L2; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.array_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; - if (__pyx_v_info->obj == Py_None) { - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; - } - __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "View.MemoryView":211 - * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") - * - * def __dealloc__(array self): # <<<<<<<<<<<<<< - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) +/* "View.MemoryView":281 + * cdef class Enum(object): + * cdef object name + * def __init__(self, name): # <<<<<<<<<<<<<< + * self.name = name + * def __repr__(self): */ /* Python wrapper */ -static void __pyx_array___dealloc__(PyObject *__pyx_v_self); /*proto*/ -static void __pyx_array___dealloc__(PyObject *__pyx_v_self) { +static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_name = 0; + int __pyx_r; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); - __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(((struct __pyx_array_obj *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(2, 281, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_name = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 281, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("View.MemoryView.Enum.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v_name); /* function exit code */ __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self) { +static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name) { + int __pyx_r; __Pyx_RefNannyDeclarations - int __pyx_t_1; - __Pyx_RefNannySetupContext("__dealloc__", 0); - - /* "View.MemoryView":212 - * - * def __dealloc__(array self): - * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< - * self.callback_free_data(self.data) - * elif self.free_data: - */ - __pyx_t_1 = ((__pyx_v_self->callback_free_data != NULL) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":213 - * def __dealloc__(array self): - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) # <<<<<<<<<<<<<< - * elif self.free_data: - * if self.dtype_is_object: - */ - __pyx_v_self->callback_free_data(__pyx_v_self->data); - - /* "View.MemoryView":212 - * - * def __dealloc__(array self): - * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< - * self.callback_free_data(self.data) - * elif self.free_data: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":214 - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) - * elif self.free_data: # <<<<<<<<<<<<<< - * if self.dtype_is_object: - * refcount_objects_in_slice(self.data, self._shape, - */ - __pyx_t_1 = (__pyx_v_self->free_data != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":215 - * self.callback_free_data(self.data) - * elif self.free_data: - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * refcount_objects_in_slice(self.data, self._shape, - * self._strides, self.ndim, False) - */ - __pyx_t_1 = (__pyx_v_self->dtype_is_object != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":216 - * elif self.free_data: - * if self.dtype_is_object: - * refcount_objects_in_slice(self.data, self._shape, # <<<<<<<<<<<<<< - * self._strides, self.ndim, False) - * free(self.data) - */ - __pyx_memoryview_refcount_objects_in_slice(__pyx_v_self->data, __pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_self->ndim, 0); - - /* "View.MemoryView":215 - * self.callback_free_data(self.data) - * elif self.free_data: - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * refcount_objects_in_slice(self.data, self._shape, - * self._strides, self.ndim, False) - */ - } - - /* "View.MemoryView":218 - * refcount_objects_in_slice(self.data, self._shape, - * self._strides, self.ndim, False) - * free(self.data) # <<<<<<<<<<<<<< - * PyObject_Free(self._shape) - * - */ - free(__pyx_v_self->data); - - /* "View.MemoryView":214 - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) - * elif self.free_data: # <<<<<<<<<<<<<< - * if self.dtype_is_object: - * refcount_objects_in_slice(self.data, self._shape, - */ - } - __pyx_L3:; + __Pyx_RefNannySetupContext("__init__", 0); - /* "View.MemoryView":219 - * self._strides, self.ndim, False) - * free(self.data) - * PyObject_Free(self._shape) # <<<<<<<<<<<<<< - * - * @property + /* "View.MemoryView":282 + * cdef object name + * def __init__(self, name): + * self.name = name # <<<<<<<<<<<<<< + * def __repr__(self): + * return self.name */ - PyObject_Free(__pyx_v_self->_shape); + __Pyx_INCREF(__pyx_v_name); + __Pyx_GIVEREF(__pyx_v_name); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = __pyx_v_name; - /* "View.MemoryView":211 - * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") - * - * def __dealloc__(array self): # <<<<<<<<<<<<<< - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) + /* "View.MemoryView":281 + * cdef class Enum(object): + * cdef object name + * def __init__(self, name): # <<<<<<<<<<<<<< + * self.name = name + * def __repr__(self): */ /* function exit code */ + __pyx_r = 0; __Pyx_RefNannyFinishContext(); + return __pyx_r; } -/* "View.MemoryView":222 - * - * @property - * def memview(self): # <<<<<<<<<<<<<< - * return self.get_memview() +/* "View.MemoryView":283 + * def __init__(self, name): + * self.name = name + * def __repr__(self): # <<<<<<<<<<<<<< + * return self.name * */ /* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self) { +static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_15View_dot_MemoryView_5array_7memview___get__(((struct __pyx_array_obj *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self) { +static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__repr__", 0); - /* "View.MemoryView":223 - * @property - * def memview(self): - * return self.get_memview() # <<<<<<<<<<<<<< + /* "View.MemoryView":284 + * self.name = name + * def __repr__(self): + * return self.name # <<<<<<<<<<<<<< * - * @cname('get_memview') + * cdef generic = Enum("") */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = ((struct __pyx_vtabstruct_array *)__pyx_v_self->__pyx_vtab)->get_memview(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 223, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; + __Pyx_INCREF(__pyx_v_self->name); + __pyx_r = __pyx_v_self->name; goto __pyx_L0; - /* "View.MemoryView":222 - * - * @property - * def memview(self): # <<<<<<<<<<<<<< - * return self.get_memview() + /* "View.MemoryView":283 + * def __init__(self, name): + * self.name = name + * def __repr__(self): # <<<<<<<<<<<<<< + * return self.name * */ /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.array.memview.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "View.MemoryView":226 - * - * @cname('get_memview') - * cdef get_memview(self): # <<<<<<<<<<<<<< - * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE - * return memoryview(self, flags, self.dtype_is_object) - */ - -static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) { - int __pyx_v_flags; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - __Pyx_RefNannySetupContext("get_memview", 0); - - /* "View.MemoryView":227 - * @cname('get_memview') - * cdef get_memview(self): - * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE # <<<<<<<<<<<<<< - * return memoryview(self, flags, self.dtype_is_object) - * - */ - __pyx_v_flags = ((PyBUF_ANY_CONTIGUOUS | PyBUF_FORMAT) | PyBUF_WRITABLE); - - /* "View.MemoryView":228 - * cdef get_memview(self): - * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE - * return memoryview(self, flags, self.dtype_is_object) # <<<<<<<<<<<<<< - * - * def __len__(self): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 228, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 228, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 228, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(((PyObject *)__pyx_v_self)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); - PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self)); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); - __pyx_t_1 = 0; - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 228, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":226 - * - * @cname('get_memview') - * cdef get_memview(self): # <<<<<<<<<<<<<< - * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE - * return memoryview(self, flags, self.dtype_is_object) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.array.get_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":230 - * return memoryview(self, flags, self.dtype_is_object) - * - * def __len__(self): # <<<<<<<<<<<<<< - * return self._shape[0] - * - */ - -/* Python wrapper */ -static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self); /*proto*/ -static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self) { - Py_ssize_t __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); - __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(((struct __pyx_array_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self) { - Py_ssize_t __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__len__", 0); - - /* "View.MemoryView":231 - * - * def __len__(self): - * return self._shape[0] # <<<<<<<<<<<<<< - * - * def __getattr__(self, attr): - */ - __pyx_r = (__pyx_v_self->_shape[0]); - goto __pyx_L0; - - /* "View.MemoryView":230 - * return memoryview(self, flags, self.dtype_is_object) - * - * def __len__(self): # <<<<<<<<<<<<<< - * return self._shape[0] - * - */ - - /* function exit code */ - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":233 - * return self._shape[0] - * - * def __getattr__(self, attr): # <<<<<<<<<<<<<< - * return getattr(self.memview, attr) - * +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict */ /* Python wrapper */ -static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr); /*proto*/ -static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr) { +static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0); - __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_attr)); + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_MemviewEnum___reduce_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr) { +static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - __Pyx_RefNannySetupContext("__getattr__", 0); + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); - /* "View.MemoryView":234 - * - * def __getattr__(self, attr): - * return getattr(self.memview, attr) # <<<<<<<<<<<<<< - * - * def __getitem__(self, item): + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.name,) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 234, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_GetAttr(__pyx_t_1, __pyx_v_attr); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 234, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; + __Pyx_INCREF(__pyx_v_self->name); + __Pyx_GIVEREF(__pyx_v_self->name); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->name); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; - /* "View.MemoryView":233 - * return self._shape[0] - * - * def __getattr__(self, attr): # <<<<<<<<<<<<<< - * return getattr(self.memview, attr) - * + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.name,) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.array.__getattr__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "(tree fragment)":7 + * state = (self.name,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { -/* "View.MemoryView":236 - * return getattr(self.memview, attr) - * - * def __getitem__(self, item): # <<<<<<<<<<<<<< - * return self.memview[item] - * + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict); + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 0; -/* Python wrapper */ -static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item); /*proto*/ -static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); - __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item)); + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.name is not None + */ + __pyx_v_use_setstate = 1; - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - __Pyx_RefNannySetupContext("__getitem__", 0); - - /* "View.MemoryView":237 - * - * def __getitem__(self, item): - * return self.memview[item] # <<<<<<<<<<<<<< - * - * def __setitem__(self, item, value): + /* "(tree fragment)":7 + * state = (self.name,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 237, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 237, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; + goto __pyx_L3; + } - /* "View.MemoryView":236 - * return getattr(self.memview, attr) - * - * def __getitem__(self, item): # <<<<<<<<<<<<<< - * return self.memview[item] - * + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.name is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state */ + /*else*/ { + __pyx_t_3 = (__pyx_v_self->name != Py_None); + __pyx_v_use_setstate = __pyx_t_3; + } + __pyx_L3:; - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":239 - * return self.memview[item] - * - * def __setitem__(self, item, value): # <<<<<<<<<<<<<< - * self.memview[item] = value - * + /* "(tree fragment)":12 + * else: + * use_setstate = self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * else: */ + __pyx_t_3 = (__pyx_v_use_setstate != 0); + if (__pyx_t_3) { -/* Python wrapper */ -static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /*proto*/ -static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); - __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item), ((PyObject *)__pyx_v_value)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "(tree fragment)":13 + * use_setstate = self.name is not None + * if use_setstate: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_INCREF(__pyx_int_184977713); + __Pyx_GIVEREF(__pyx_int_184977713); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; -static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { - int __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__setitem__", 0); + /* "(tree fragment)":12 + * else: + * use_setstate = self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * else: + */ + } - /* "View.MemoryView":240 - * - * def __setitem__(self, item, value): - * self.memview[item] = value # <<<<<<<<<<<<<< - * - * + /* "(tree fragment)":15 + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Enum__set_state(self, __pyx_state) */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_v_item, __pyx_v_value) < 0)) __PYX_ERR(2, 240, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_INCREF(__pyx_int_184977713); + __Pyx_GIVEREF(__pyx_int_184977713); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + } - /* "View.MemoryView":239 - * return self.memview[item] - * - * def __setitem__(self, item, value): # <<<<<<<<<<<<<< - * self.memview[item] = value - * + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict */ /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.Enum.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state(self, __pyx_state) */ /* Python wrapper */ -static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf___pyx_array___reduce_cython__(((struct __pyx_array_obj *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self) { +static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 0); - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + /* "(tree fragment)":17 + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * __pyx_unpickle_Enum__set_state(self, __pyx_state) # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 2, __pyx_L1_error) + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(2, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_unpickle_Enum__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(2, 2, __pyx_L1_error) - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state(self, __pyx_state) */ /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.array.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; + __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - */ - -/* Python wrapper */ -static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf___pyx_array_2__setstate_cython__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__setstate_cython__", 0); - - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< - */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(2, 4, __pyx_L1_error) - - /* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":244 +/* "View.MemoryView":298 * - * @cname("__pyx_array_new") - * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< - * char *mode, char *buf): - * cdef array result + * @cname('__pyx_align_pointer') + * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< + * "Align pointer memory on a given boundary" + * cdef Py_intptr_t aligned_p = memory */ -static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, char *__pyx_v_format, char *__pyx_v_mode, char *__pyx_v_buf) { - struct __pyx_array_obj *__pyx_v_result = 0; - struct __pyx_array_obj *__pyx_r = NULL; - __Pyx_RefNannyDeclarations +static void *__pyx_align_pointer(void *__pyx_v_memory, size_t __pyx_v_alignment) { + Py_intptr_t __pyx_v_aligned_p; + size_t __pyx_v_offset; + void *__pyx_r; int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - __Pyx_RefNannySetupContext("array_cwrapper", 0); - /* "View.MemoryView":248 - * cdef array result + /* "View.MemoryView":300 + * cdef void *align_pointer(void *memory, size_t alignment) nogil: + * "Align pointer memory on a given boundary" + * cdef Py_intptr_t aligned_p = memory # <<<<<<<<<<<<<< + * cdef size_t offset * - * if buf == NULL: # <<<<<<<<<<<<<< - * result = array(shape, itemsize, format, mode.decode('ASCII')) - * else: */ - __pyx_t_1 = ((__pyx_v_buf == NULL) != 0); - if (__pyx_t_1) { + __pyx_v_aligned_p = ((Py_intptr_t)__pyx_v_memory); - /* "View.MemoryView":249 + /* "View.MemoryView":304 * - * if buf == NULL: - * result = array(shape, itemsize, format, mode.decode('ASCII')) # <<<<<<<<<<<<<< - * else: - * result = array(shape, itemsize, format, mode.decode('ASCII'), - */ - __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_INCREF(__pyx_v_shape); - __Pyx_GIVEREF(__pyx_v_shape); - PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_shape); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4); - __pyx_t_2 = 0; - __pyx_t_3 = 0; - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_4); - __pyx_t_4 = 0; - - /* "View.MemoryView":248 - * cdef array result + * with cython.cdivision(True): + * offset = aligned_p % alignment # <<<<<<<<<<<<<< * - * if buf == NULL: # <<<<<<<<<<<<<< - * result = array(shape, itemsize, format, mode.decode('ASCII')) - * else: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":251 - * result = array(shape, itemsize, format, mode.decode('ASCII')) - * else: - * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< - * allocate_buffer=False) - * result.data = buf + * if offset > 0: */ - /*else*/ { - __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 251, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 251, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 251, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 251, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_v_shape); - __Pyx_GIVEREF(__pyx_v_shape); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_shape); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_5); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_3); - __pyx_t_4 = 0; - __pyx_t_5 = 0; - __pyx_t_3 = 0; + __pyx_v_offset = (__pyx_v_aligned_p % __pyx_v_alignment); - /* "View.MemoryView":252 - * else: - * result = array(shape, itemsize, format, mode.decode('ASCII'), - * allocate_buffer=False) # <<<<<<<<<<<<<< - * result.data = buf + /* "View.MemoryView":306 + * offset = aligned_p % alignment + * + * if offset > 0: # <<<<<<<<<<<<<< + * aligned_p += alignment - offset * */ - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 252, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_allocate_buffer, Py_False) < 0) __PYX_ERR(2, 252, __pyx_L1_error) + __pyx_t_1 = ((__pyx_v_offset > 0) != 0); + if (__pyx_t_1) { - /* "View.MemoryView":251 - * result = array(shape, itemsize, format, mode.decode('ASCII')) - * else: - * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< - * allocate_buffer=False) - * result.data = buf + /* "View.MemoryView":307 + * + * if offset > 0: + * aligned_p += alignment - offset # <<<<<<<<<<<<<< + * + * return aligned_p */ - __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 251, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_5); - __pyx_t_5 = 0; + __pyx_v_aligned_p = (__pyx_v_aligned_p + (__pyx_v_alignment - __pyx_v_offset)); - /* "View.MemoryView":253 - * result = array(shape, itemsize, format, mode.decode('ASCII'), - * allocate_buffer=False) - * result.data = buf # <<<<<<<<<<<<<< + /* "View.MemoryView":306 + * offset = aligned_p % alignment + * + * if offset > 0: # <<<<<<<<<<<<<< + * aligned_p += alignment - offset * - * return result */ - __pyx_v_result->data = __pyx_v_buf; } - __pyx_L3:; - /* "View.MemoryView":255 - * result.data = buf + /* "View.MemoryView":309 + * aligned_p += alignment - offset * - * return result # <<<<<<<<<<<<<< + * return aligned_p # <<<<<<<<<<<<<< * * */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); - __Pyx_INCREF(((PyObject *)__pyx_v_result)); - __pyx_r = __pyx_v_result; + __pyx_r = ((void *)__pyx_v_aligned_p); goto __pyx_L0; - /* "View.MemoryView":244 + /* "View.MemoryView":298 * - * @cname("__pyx_array_new") - * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< - * char *mode, char *buf): - * cdef array result + * @cname('__pyx_align_pointer') + * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< + * "Align pointer memory on a given boundary" + * cdef Py_intptr_t aligned_p = memory */ /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("View.MemoryView.array_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_result); - __Pyx_XGIVEREF((PyObject *)__pyx_r); - __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "View.MemoryView":281 - * cdef class Enum(object): - * cdef object name - * def __init__(self, name): # <<<<<<<<<<<<<< - * self.name = name - * def __repr__(self): +/* "View.MemoryView":345 + * cdef __Pyx_TypeInfo *typeinfo + * + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< + * self.obj = obj + * self.flags = flags */ /* Python wrapper */ -static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_name = 0; +static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_obj = 0; + int __pyx_v_flags; + int __pyx_v_dtype_is_object; int __pyx_r; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; - PyObject* values[1] = {0}; + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_obj,&__pyx_n_s_flags,&__pyx_n_s_dtype_is_object,0}; + PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; @@ -10828,1493 +9192,974 @@ static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_ar kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_obj)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, 1); __PYX_ERR(2, 345, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dtype_is_object); + if (value) { values[2] = value; kw_args--; } + } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(2, 281, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(2, 345, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { - goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_obj = values[0]; + __pyx_v_flags = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 345, __pyx_L3_error) + if (values[2]) { + __pyx_v_dtype_is_object = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_dtype_is_object == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 345, __pyx_L3_error) + } else { + __pyx_v_dtype_is_object = ((int)0); } - __pyx_v_name = values[0]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 281, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 345, __pyx_L3_error) __pyx_L3_error:; - __Pyx_AddTraceback("View.MemoryView.Enum.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v_name); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_obj, __pyx_v_flags, __pyx_v_dtype_is_object); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name) { +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object) { int __pyx_r; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__", 0); + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + __Pyx_RefNannySetupContext("__cinit__", 0); - /* "View.MemoryView":282 - * cdef object name - * def __init__(self, name): - * self.name = name # <<<<<<<<<<<<<< - * def __repr__(self): - * return self.name + /* "View.MemoryView":346 + * + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): + * self.obj = obj # <<<<<<<<<<<<<< + * self.flags = flags + * if type(self) is memoryview or obj is not None: */ - __Pyx_INCREF(__pyx_v_name); - __Pyx_GIVEREF(__pyx_v_name); - __Pyx_GOTREF(__pyx_v_self->name); - __Pyx_DECREF(__pyx_v_self->name); - __pyx_v_self->name = __pyx_v_name; + __Pyx_INCREF(__pyx_v_obj); + __Pyx_GIVEREF(__pyx_v_obj); + __Pyx_GOTREF(__pyx_v_self->obj); + __Pyx_DECREF(__pyx_v_self->obj); + __pyx_v_self->obj = __pyx_v_obj; - /* "View.MemoryView":281 - * cdef class Enum(object): - * cdef object name - * def __init__(self, name): # <<<<<<<<<<<<<< - * self.name = name - * def __repr__(self): + /* "View.MemoryView":347 + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): + * self.obj = obj + * self.flags = flags # <<<<<<<<<<<<<< + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) */ + __pyx_v_self->flags = __pyx_v_flags; - /* function exit code */ - __pyx_r = 0; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":283 - * def __init__(self, name): - * self.name = name - * def __repr__(self): # <<<<<<<<<<<<<< - * return self.name - * + /* "View.MemoryView":348 + * self.obj = obj + * self.flags = flags + * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: */ + __pyx_t_2 = (((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))) == ((PyObject *)__pyx_memoryview_type)); + __pyx_t_3 = (__pyx_t_2 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = (__pyx_v_obj != Py_None); + __pyx_t_2 = (__pyx_t_3 != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { -/* Python wrapper */ -static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); - __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "View.MemoryView":349 + * self.flags = flags + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) # <<<<<<<<<<<<<< + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None + */ + __pyx_t_4 = __Pyx_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 349, __pyx_L1_error) -static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__repr__", 0); + /* "View.MemoryView":350 + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: # <<<<<<<<<<<<<< + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) + */ + __pyx_t_1 = ((((PyObject *)__pyx_v_self->view.obj) == NULL) != 0); + if (__pyx_t_1) { - /* "View.MemoryView":284 - * self.name = name - * def __repr__(self): - * return self.name # <<<<<<<<<<<<<< + /* "View.MemoryView":351 + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) * - * cdef generic = Enum("") */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->name); - __pyx_r = __pyx_v_self->name; - goto __pyx_L0; + ((Py_buffer *)(&__pyx_v_self->view))->obj = Py_None; - /* "View.MemoryView":283 - * def __init__(self, name): - * self.name = name - * def __repr__(self): # <<<<<<<<<<<<<< - * return self.name + /* "View.MemoryView":352 + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< * + * global __pyx_memoryview_thread_locks_used */ + Py_INCREF(Py_None); - /* function exit code */ - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "View.MemoryView":350 + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: # <<<<<<<<<<<<<< + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) + */ + } -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict + /* "View.MemoryView":348 + * self.obj = obj + * self.flags = flags + * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: */ + } -/* Python wrapper */ -static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf___pyx_MemviewEnum___reduce_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); + /* "View.MemoryView":355 + * + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + */ + __pyx_t_1 = ((__pyx_memoryview_thread_locks_used < 8) != 0); + if (__pyx_t_1) { - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "View.MemoryView":356 + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: + */ + __pyx_v_self->lock = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); -static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { - PyObject *__pyx_v_state = 0; - PyObject *__pyx_v__dict = 0; - int __pyx_v_use_setstate; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - int __pyx_t_3; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - __Pyx_RefNannySetupContext("__reduce_cython__", 0); + /* "View.MemoryView":357 + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 # <<<<<<<<<<<<<< + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + */ + __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used + 1); - /* "(tree fragment)":5 - * cdef object _dict - * cdef bint use_setstate - * state = (self.name,) # <<<<<<<<<<<<<< - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: + /* "View.MemoryView":355 + * + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 */ - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_self->name); - __Pyx_GIVEREF(__pyx_v_self->name); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->name); - __pyx_v_state = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; + } - /* "(tree fragment)":6 - * cdef bint use_setstate - * state = (self.name,) - * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< - * if _dict is not None: - * state += (_dict,) + /* "View.MemoryView":358 + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: # <<<<<<<<<<<<<< + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: */ - __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v__dict = __pyx_t_1; - __pyx_t_1 = 0; + __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); + if (__pyx_t_1) { - /* "(tree fragment)":7 - * state = (self.name,) - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True + /* "View.MemoryView":359 + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() # <<<<<<<<<<<<<< + * if self.lock is NULL: + * raise MemoryError */ - __pyx_t_2 = (__pyx_v__dict != Py_None); - __pyx_t_3 = (__pyx_t_2 != 0); - if (__pyx_t_3) { + __pyx_v_self->lock = PyThread_allocate_lock(); - /* "(tree fragment)":8 - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: - * state += (_dict,) # <<<<<<<<<<<<<< - * use_setstate = True - * else: + /* "View.MemoryView":360 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * */ - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v__dict); - __Pyx_GIVEREF(__pyx_v__dict); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict); - __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); - __pyx_t_4 = 0; + __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); + if (unlikely(__pyx_t_1)) { - /* "(tree fragment)":9 - * if _dict is not None: - * state += (_dict,) - * use_setstate = True # <<<<<<<<<<<<<< - * else: - * use_setstate = self.name is not None + /* "View.MemoryView":361 + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: + * raise MemoryError # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: */ - __pyx_v_use_setstate = 1; + PyErr_NoMemory(); __PYX_ERR(2, 361, __pyx_L1_error) - /* "(tree fragment)":7 - * state = (self.name,) - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True + /* "View.MemoryView":360 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * */ - goto __pyx_L3; - } + } - /* "(tree fragment)":11 - * use_setstate = True - * else: - * use_setstate = self.name is not None # <<<<<<<<<<<<<< - * if use_setstate: - * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + /* "View.MemoryView":358 + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: # <<<<<<<<<<<<<< + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: */ - /*else*/ { - __pyx_t_3 = (__pyx_v_self->name != Py_None); - __pyx_v_use_setstate = __pyx_t_3; } - __pyx_L3:; - /* "(tree fragment)":12 - * else: - * use_setstate = self.name is not None - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state - * else: + /* "View.MemoryView":363 + * raise MemoryError + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') + * else: */ - __pyx_t_3 = (__pyx_v_use_setstate != 0); - if (__pyx_t_3) { + __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); + if (__pyx_t_1) { - /* "(tree fragment)":13 - * use_setstate = self.name is not None - * if use_setstate: - * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state # <<<<<<<<<<<<<< - * else: - * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + /* "View.MemoryView":364 + * + * if flags & PyBUF_FORMAT: + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') # <<<<<<<<<<<<<< + * else: + * self.dtype_is_object = dtype_is_object */ - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_184977713); - __Pyx_GIVEREF(__pyx_int_184977713); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); - __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(Py_None); - PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None); - __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state); - __pyx_t_4 = 0; - __pyx_t_1 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; - goto __pyx_L0; + __pyx_t_2 = (((__pyx_v_self->view.format[0]) == 'O') != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_2 = (((__pyx_v_self->view.format[1]) == '\x00') != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L11_bool_binop_done:; + __pyx_v_self->dtype_is_object = __pyx_t_1; - /* "(tree fragment)":12 - * else: - * use_setstate = self.name is not None - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state - * else: + /* "View.MemoryView":363 + * raise MemoryError + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') + * else: */ + goto __pyx_L10; } - /* "(tree fragment)":15 - * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state - * else: - * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_Enum__set_state(self, __pyx_state) + /* "View.MemoryView":366 + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') + * else: + * self.dtype_is_object = dtype_is_object # <<<<<<<<<<<<<< + * + * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( */ /*else*/ { - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_184977713); - __Pyx_GIVEREF(__pyx_int_184977713); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state); - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); - __pyx_t_5 = 0; - __pyx_t_1 = 0; - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; - goto __pyx_L0; + __pyx_v_self->dtype_is_object = __pyx_v_dtype_is_object; } + __pyx_L10:; - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict + /* "View.MemoryView":368 + * self.dtype_is_object = dtype_is_object + * + * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( # <<<<<<<<<<<<<< + * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) + * self.typeinfo = NULL */ + __pyx_v_self->acquisition_count_aligned_p = ((__pyx_atomic_int *)__pyx_align_pointer(((void *)(&(__pyx_v_self->acquisition_count[0]))), (sizeof(__pyx_atomic_int)))); - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("View.MemoryView.Enum.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_state); - __Pyx_XDECREF(__pyx_v__dict); - __Pyx_XGIVEREF(__pyx_r); + /* "View.MemoryView":370 + * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( + * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) + * self.typeinfo = NULL # <<<<<<<<<<<<<< + * + * def __dealloc__(memoryview self): + */ + __pyx_v_self->typeinfo = NULL; + + /* "View.MemoryView":345 + * cdef __Pyx_TypeInfo *typeinfo + * + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< + * self.obj = obj + * self.flags = flags + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":16 - * else: - * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_Enum__set_state(self, __pyx_state) +/* "View.MemoryView":372 + * self.typeinfo = NULL + * + * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) */ /* Python wrapper */ -static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = 0; +static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self) { __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(((struct __pyx_memoryview_obj *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); - return __pyx_r; } -static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; +static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self) { + int __pyx_v_i; __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - __Pyx_RefNannySetupContext("__setstate_cython__", 0); + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyThread_type_lock __pyx_t_6; + PyThread_type_lock __pyx_t_7; + __Pyx_RefNannySetupContext("__dealloc__", 0); - /* "(tree fragment)":17 - * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_Enum__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + /* "View.MemoryView":373 + * + * def __dealloc__(memoryview self): + * if self.obj is not None: # <<<<<<<<<<<<<< + * __Pyx_ReleaseBuffer(&self.view) + * */ - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(2, 17, __pyx_L1_error) - __pyx_t_1 = __pyx_unpickle_Enum__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 17, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = (__pyx_v_self->obj != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { - /* "(tree fragment)":16 - * else: - * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_Enum__set_state(self, __pyx_state) + /* "View.MemoryView":374 + * def __dealloc__(memoryview self): + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) # <<<<<<<<<<<<<< + * + * cdef int i */ + __Pyx_ReleaseBuffer((&__pyx_v_self->view)); - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":298 + /* "View.MemoryView":373 + * + * def __dealloc__(memoryview self): + * if self.obj is not None: # <<<<<<<<<<<<<< + * __Pyx_ReleaseBuffer(&self.view) * - * @cname('__pyx_align_pointer') - * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< - * "Align pointer memory on a given boundary" - * cdef Py_intptr_t aligned_p = memory */ + } -static void *__pyx_align_pointer(void *__pyx_v_memory, size_t __pyx_v_alignment) { - Py_intptr_t __pyx_v_aligned_p; - size_t __pyx_v_offset; - void *__pyx_r; - int __pyx_t_1; - - /* "View.MemoryView":300 - * cdef void *align_pointer(void *memory, size_t alignment) nogil: - * "Align pointer memory on a given boundary" - * cdef Py_intptr_t aligned_p = memory # <<<<<<<<<<<<<< - * cdef size_t offset - * + /* "View.MemoryView":378 + * cdef int i + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: # <<<<<<<<<<<<<< + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: */ - __pyx_v_aligned_p = ((Py_intptr_t)__pyx_v_memory); + __pyx_t_2 = ((__pyx_v_self->lock != NULL) != 0); + if (__pyx_t_2) { - /* "View.MemoryView":304 - * - * with cython.cdivision(True): - * offset = aligned_p % alignment # <<<<<<<<<<<<<< - * - * if offset > 0: + /* "View.MemoryView":379 + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: + * for i in range(__pyx_memoryview_thread_locks_used): # <<<<<<<<<<<<<< + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 */ - __pyx_v_offset = (__pyx_v_aligned_p % __pyx_v_alignment); + __pyx_t_3 = __pyx_memoryview_thread_locks_used; + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; - /* "View.MemoryView":306 - * offset = aligned_p % alignment - * - * if offset > 0: # <<<<<<<<<<<<<< - * aligned_p += alignment - offset - * + /* "View.MemoryView":380 + * if self.lock != NULL: + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: */ - __pyx_t_1 = ((__pyx_v_offset > 0) != 0); - if (__pyx_t_1) { + __pyx_t_2 = (((__pyx_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock) != 0); + if (__pyx_t_2) { - /* "View.MemoryView":307 - * - * if offset > 0: - * aligned_p += alignment - offset # <<<<<<<<<<<<<< - * - * return aligned_p + /* "View.MemoryView":381 + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 # <<<<<<<<<<<<<< + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( */ - __pyx_v_aligned_p = (__pyx_v_aligned_p + (__pyx_v_alignment - __pyx_v_offset)); + __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used - 1); - /* "View.MemoryView":306 - * offset = aligned_p % alignment - * - * if offset > 0: # <<<<<<<<<<<<<< - * aligned_p += alignment - offset - * + /* "View.MemoryView":382 + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) */ - } + __pyx_t_2 = ((__pyx_v_i != __pyx_memoryview_thread_locks_used) != 0); + if (__pyx_t_2) { - /* "View.MemoryView":309 - * aligned_p += alignment - offset - * - * return aligned_p # <<<<<<<<<<<<<< - * - * + /* "View.MemoryView":384 + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) # <<<<<<<<<<<<<< + * break + * else: */ - __pyx_r = ((void *)__pyx_v_aligned_p); - goto __pyx_L0; + __pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); + __pyx_t_7 = (__pyx_memoryview_thread_locks[__pyx_v_i]); - /* "View.MemoryView":298 - * - * @cname('__pyx_align_pointer') - * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< - * "Align pointer memory on a given boundary" - * cdef Py_intptr_t aligned_p = memory + /* "View.MemoryView":383 + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + * break */ + (__pyx_memoryview_thread_locks[__pyx_v_i]) = __pyx_t_6; + (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_7; - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} + /* "View.MemoryView":382 + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + */ + } -/* "View.MemoryView":345 - * cdef __Pyx_TypeInfo *typeinfo - * - * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< - * self.obj = obj - * self.flags = flags + /* "View.MemoryView":385 + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + * break # <<<<<<<<<<<<<< + * else: + * PyThread_free_lock(self.lock) */ + goto __pyx_L6_break; -/* Python wrapper */ -static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_obj = 0; - int __pyx_v_flags; - int __pyx_v_dtype_is_object; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_obj,&__pyx_n_s_flags,&__pyx_n_s_dtype_is_object,0}; - PyObject* values[3] = {0,0,0}; - if (unlikely(__pyx_kwds)) { - Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { - case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_obj)) != 0)) kw_args--; - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, 1); __PYX_ERR(2, 345, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dtype_is_object); - if (value) { values[2] = value; kw_args--; } - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(2, 345, __pyx_L3_error) - } - } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; + /* "View.MemoryView":380 + * if self.lock != NULL: + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: + */ } } - __pyx_v_obj = values[0]; - __pyx_v_flags = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 345, __pyx_L3_error) - if (values[2]) { - __pyx_v_dtype_is_object = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_dtype_is_object == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 345, __pyx_L3_error) - } else { - __pyx_v_dtype_is_object = ((int)0); + /*else*/ { + + /* "View.MemoryView":387 + * break + * else: + * PyThread_free_lock(self.lock) # <<<<<<<<<<<<<< + * + * cdef char *get_item_pointer(memoryview self, object index) except NULL: + */ + PyThread_free_lock(__pyx_v_self->lock); } + __pyx_L6_break:; + + /* "View.MemoryView":378 + * cdef int i + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: # <<<<<<<<<<<<<< + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: + */ } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 345, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return -1; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_obj, __pyx_v_flags, __pyx_v_dtype_is_object); + + /* "View.MemoryView":372 + * self.typeinfo = NULL + * + * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) + */ /* function exit code */ __Pyx_RefNannyFinishContext(); - return __pyx_r; } -static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object) { - int __pyx_r; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - int __pyx_t_4; - __Pyx_RefNannySetupContext("__cinit__", 0); - - /* "View.MemoryView":346 +/* "View.MemoryView":389 + * PyThread_free_lock(self.lock) * - * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): - * self.obj = obj # <<<<<<<<<<<<<< - * self.flags = flags - * if type(self) is memoryview or obj is not None: + * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< + * cdef Py_ssize_t dim + * cdef char *itemp = self.view.buf */ - __Pyx_INCREF(__pyx_v_obj); - __Pyx_GIVEREF(__pyx_v_obj); - __Pyx_GOTREF(__pyx_v_self->obj); - __Pyx_DECREF(__pyx_v_self->obj); - __pyx_v_self->obj = __pyx_v_obj; - /* "View.MemoryView":347 - * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): - * self.obj = obj - * self.flags = flags # <<<<<<<<<<<<<< - * if type(self) is memoryview or obj is not None: - * __Pyx_GetBuffer(obj, &self.view, flags) +static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { + Py_ssize_t __pyx_v_dim; + char *__pyx_v_itemp; + PyObject *__pyx_v_idx = NULL; + char *__pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *(*__pyx_t_4)(PyObject *); + PyObject *__pyx_t_5 = NULL; + Py_ssize_t __pyx_t_6; + char *__pyx_t_7; + __Pyx_RefNannySetupContext("get_item_pointer", 0); + + /* "View.MemoryView":391 + * cdef char *get_item_pointer(memoryview self, object index) except NULL: + * cdef Py_ssize_t dim + * cdef char *itemp = self.view.buf # <<<<<<<<<<<<<< + * + * for dim, idx in enumerate(index): */ - __pyx_v_self->flags = __pyx_v_flags; + __pyx_v_itemp = ((char *)__pyx_v_self->view.buf); - /* "View.MemoryView":348 - * self.obj = obj - * self.flags = flags - * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< - * __Pyx_GetBuffer(obj, &self.view, flags) - * if self.view.obj == NULL: + /* "View.MemoryView":393 + * cdef char *itemp = self.view.buf + * + * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< + * itemp = pybuffer_index(&self.view, itemp, idx, dim) + * */ - __pyx_t_2 = (((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))) == ((PyObject *)__pyx_memoryview_type)); - __pyx_t_3 = (__pyx_t_2 != 0); - if (!__pyx_t_3) { + __pyx_t_1 = 0; + if (likely(PyList_CheckExact(__pyx_v_index)) || PyTuple_CheckExact(__pyx_v_index)) { + __pyx_t_2 = __pyx_v_index; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; + __pyx_t_4 = NULL; } else { - __pyx_t_1 = __pyx_t_3; - goto __pyx_L4_bool_binop_done; + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 393, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 393, __pyx_L1_error) } - __pyx_t_3 = (__pyx_v_obj != Py_None); - __pyx_t_2 = (__pyx_t_3 != 0); - __pyx_t_1 = __pyx_t_2; - __pyx_L4_bool_binop_done:; - if (__pyx_t_1) { - - /* "View.MemoryView":349 - * self.flags = flags - * if type(self) is memoryview or obj is not None: - * __Pyx_GetBuffer(obj, &self.view, flags) # <<<<<<<<<<<<<< - * if self.view.obj == NULL: - * (<__pyx_buffer *> &self.view).obj = Py_None - */ - __pyx_t_4 = __Pyx_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 349, __pyx_L1_error) + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(2, 393, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 393, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } else { + if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(2, 393, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 393, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } + } else { + __pyx_t_5 = __pyx_t_4(__pyx_t_2); + if (unlikely(!__pyx_t_5)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 393, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_v_dim = __pyx_t_1; + __pyx_t_1 = (__pyx_t_1 + 1); - /* "View.MemoryView":350 - * if type(self) is memoryview or obj is not None: - * __Pyx_GetBuffer(obj, &self.view, flags) - * if self.view.obj == NULL: # <<<<<<<<<<<<<< - * (<__pyx_buffer *> &self.view).obj = Py_None - * Py_INCREF(Py_None) + /* "View.MemoryView":394 + * + * for dim, idx in enumerate(index): + * itemp = pybuffer_index(&self.view, itemp, idx, dim) # <<<<<<<<<<<<<< + * + * return itemp */ - __pyx_t_1 = ((((PyObject *)__pyx_v_self->view.obj) == NULL) != 0); - if (__pyx_t_1) { + __pyx_t_6 = __Pyx_PyIndex_AsSsize_t(__pyx_v_idx); if (unlikely((__pyx_t_6 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 394, __pyx_L1_error) + __pyx_t_7 = __pyx_pybuffer_index((&__pyx_v_self->view), __pyx_v_itemp, __pyx_t_6, __pyx_v_dim); if (unlikely(__pyx_t_7 == ((char *)NULL))) __PYX_ERR(2, 394, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_7; - /* "View.MemoryView":351 - * __Pyx_GetBuffer(obj, &self.view, flags) - * if self.view.obj == NULL: - * (<__pyx_buffer *> &self.view).obj = Py_None # <<<<<<<<<<<<<< - * Py_INCREF(Py_None) + /* "View.MemoryView":393 + * cdef char *itemp = self.view.buf + * + * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< + * itemp = pybuffer_index(&self.view, itemp, idx, dim) * */ - ((Py_buffer *)(&__pyx_v_self->view))->obj = Py_None; - - /* "View.MemoryView":352 - * if self.view.obj == NULL: - * (<__pyx_buffer *> &self.view).obj = Py_None - * Py_INCREF(Py_None) # <<<<<<<<<<<<<< - * - * global __pyx_memoryview_thread_locks_used - */ - Py_INCREF(Py_None); - - /* "View.MemoryView":350 - * if type(self) is memoryview or obj is not None: - * __Pyx_GetBuffer(obj, &self.view, flags) - * if self.view.obj == NULL: # <<<<<<<<<<<<<< - * (<__pyx_buffer *> &self.view).obj = Py_None - * Py_INCREF(Py_None) - */ - } - - /* "View.MemoryView":348 - * self.obj = obj - * self.flags = flags - * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< - * __Pyx_GetBuffer(obj, &self.view, flags) - * if self.view.obj == NULL: - */ - } - - /* "View.MemoryView":355 - * - * global __pyx_memoryview_thread_locks_used - * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< - * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] - * __pyx_memoryview_thread_locks_used += 1 - */ - __pyx_t_1 = ((__pyx_memoryview_thread_locks_used < 8) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":356 - * global __pyx_memoryview_thread_locks_used - * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: - * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] # <<<<<<<<<<<<<< - * __pyx_memoryview_thread_locks_used += 1 - * if self.lock is NULL: - */ - __pyx_v_self->lock = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); - - /* "View.MemoryView":357 - * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: - * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] - * __pyx_memoryview_thread_locks_used += 1 # <<<<<<<<<<<<<< - * if self.lock is NULL: - * self.lock = PyThread_allocate_lock() - */ - __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used + 1); - - /* "View.MemoryView":355 - * - * global __pyx_memoryview_thread_locks_used - * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< - * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] - * __pyx_memoryview_thread_locks_used += 1 - */ - } - - /* "View.MemoryView":358 - * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] - * __pyx_memoryview_thread_locks_used += 1 - * if self.lock is NULL: # <<<<<<<<<<<<<< - * self.lock = PyThread_allocate_lock() - * if self.lock is NULL: - */ - __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":359 - * __pyx_memoryview_thread_locks_used += 1 - * if self.lock is NULL: - * self.lock = PyThread_allocate_lock() # <<<<<<<<<<<<<< - * if self.lock is NULL: - * raise MemoryError - */ - __pyx_v_self->lock = PyThread_allocate_lock(); - - /* "View.MemoryView":360 - * if self.lock is NULL: - * self.lock = PyThread_allocate_lock() - * if self.lock is NULL: # <<<<<<<<<<<<<< - * raise MemoryError - * - */ - __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); - if (unlikely(__pyx_t_1)) { - - /* "View.MemoryView":361 - * self.lock = PyThread_allocate_lock() - * if self.lock is NULL: - * raise MemoryError # <<<<<<<<<<<<<< - * - * if flags & PyBUF_FORMAT: - */ - PyErr_NoMemory(); __PYX_ERR(2, 361, __pyx_L1_error) - - /* "View.MemoryView":360 - * if self.lock is NULL: - * self.lock = PyThread_allocate_lock() - * if self.lock is NULL: # <<<<<<<<<<<<<< - * raise MemoryError - * - */ - } - - /* "View.MemoryView":358 - * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] - * __pyx_memoryview_thread_locks_used += 1 - * if self.lock is NULL: # <<<<<<<<<<<<<< - * self.lock = PyThread_allocate_lock() - * if self.lock is NULL: - */ - } - - /* "View.MemoryView":363 - * raise MemoryError - * - * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< - * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') - * else: - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":364 - * - * if flags & PyBUF_FORMAT: - * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') # <<<<<<<<<<<<<< - * else: - * self.dtype_is_object = dtype_is_object - */ - __pyx_t_2 = (((__pyx_v_self->view.format[0]) == 'O') != 0); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L11_bool_binop_done; - } - __pyx_t_2 = (((__pyx_v_self->view.format[1]) == '\x00') != 0); - __pyx_t_1 = __pyx_t_2; - __pyx_L11_bool_binop_done:; - __pyx_v_self->dtype_is_object = __pyx_t_1; - - /* "View.MemoryView":363 - * raise MemoryError - * - * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< - * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') - * else: - */ - goto __pyx_L10; } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "View.MemoryView":366 - * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') - * else: - * self.dtype_is_object = dtype_is_object # <<<<<<<<<<<<<< + /* "View.MemoryView":396 + * itemp = pybuffer_index(&self.view, itemp, idx, dim) * - * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( - */ - /*else*/ { - __pyx_v_self->dtype_is_object = __pyx_v_dtype_is_object; - } - __pyx_L10:; - - /* "View.MemoryView":368 - * self.dtype_is_object = dtype_is_object + * return itemp # <<<<<<<<<<<<<< * - * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( # <<<<<<<<<<<<<< - * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) - * self.typeinfo = NULL - */ - __pyx_v_self->acquisition_count_aligned_p = ((__pyx_atomic_int *)__pyx_align_pointer(((void *)(&(__pyx_v_self->acquisition_count[0]))), (sizeof(__pyx_atomic_int)))); - - /* "View.MemoryView":370 - * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( - * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) - * self.typeinfo = NULL # <<<<<<<<<<<<<< * - * def __dealloc__(memoryview self): */ - __pyx_v_self->typeinfo = NULL; + __pyx_r = __pyx_v_itemp; + goto __pyx_L0; - /* "View.MemoryView":345 - * cdef __Pyx_TypeInfo *typeinfo + /* "View.MemoryView":389 + * PyThread_free_lock(self.lock) * - * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< - * self.obj = obj - * self.flags = flags + * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< + * cdef Py_ssize_t dim + * cdef char *itemp = self.view.buf */ /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; __pyx_L1_error:; - __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview.get_item_pointer", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; + __Pyx_XDECREF(__pyx_v_idx); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "View.MemoryView":372 - * self.typeinfo = NULL +/* "View.MemoryView":399 * - * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< - * if self.obj is not None: - * __Pyx_ReleaseBuffer(&self.view) + * + * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< + * if index is Ellipsis: + * return self */ /* Python wrapper */ -static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self); /*proto*/ -static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self) { +static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index); /*proto*/ +static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index) { + PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); - __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index)); /* function exit code */ __Pyx_RefNannyFinishContext(); + return __pyx_r; } -static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self) { - int __pyx_v_i; +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { + PyObject *__pyx_v_have_slices = NULL; + PyObject *__pyx_v_indices = NULL; + char *__pyx_v_itemp; + PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; - int __pyx_t_3; - int __pyx_t_4; - int __pyx_t_5; - PyThread_type_lock __pyx_t_6; - PyThread_type_lock __pyx_t_7; - __Pyx_RefNannySetupContext("__dealloc__", 0); + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + char *__pyx_t_6; + __Pyx_RefNannySetupContext("__getitem__", 0); - /* "View.MemoryView":373 + /* "View.MemoryView":400 * - * def __dealloc__(memoryview self): - * if self.obj is not None: # <<<<<<<<<<<<<< - * __Pyx_ReleaseBuffer(&self.view) + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: # <<<<<<<<<<<<<< + * return self * */ - __pyx_t_1 = (__pyx_v_self->obj != Py_None); + __pyx_t_1 = (__pyx_v_index == __pyx_builtin_Ellipsis); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "View.MemoryView":374 - * def __dealloc__(memoryview self): - * if self.obj is not None: - * __Pyx_ReleaseBuffer(&self.view) # <<<<<<<<<<<<<< + /* "View.MemoryView":401 + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: + * return self # <<<<<<<<<<<<<< * - * cdef int i + * have_slices, indices = _unellipsify(index, self.view.ndim) */ - __Pyx_ReleaseBuffer((&__pyx_v_self->view)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; - /* "View.MemoryView":373 + /* "View.MemoryView":400 * - * def __dealloc__(memoryview self): - * if self.obj is not None: # <<<<<<<<<<<<<< - * __Pyx_ReleaseBuffer(&self.view) + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: # <<<<<<<<<<<<<< + * return self * */ } - /* "View.MemoryView":378 - * cdef int i - * global __pyx_memoryview_thread_locks_used - * if self.lock != NULL: # <<<<<<<<<<<<<< - * for i in range(__pyx_memoryview_thread_locks_used): - * if __pyx_memoryview_thread_locks[i] is self.lock: - */ - __pyx_t_2 = ((__pyx_v_self->lock != NULL) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":379 - * global __pyx_memoryview_thread_locks_used - * if self.lock != NULL: - * for i in range(__pyx_memoryview_thread_locks_used): # <<<<<<<<<<<<<< - * if __pyx_memoryview_thread_locks[i] is self.lock: - * __pyx_memoryview_thread_locks_used -= 1 - */ - __pyx_t_3 = __pyx_memoryview_thread_locks_used; - __pyx_t_4 = __pyx_t_3; - for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { - __pyx_v_i = __pyx_t_5; - - /* "View.MemoryView":380 - * if self.lock != NULL: - * for i in range(__pyx_memoryview_thread_locks_used): - * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< - * __pyx_memoryview_thread_locks_used -= 1 - * if i != __pyx_memoryview_thread_locks_used: - */ - __pyx_t_2 = (((__pyx_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":381 - * for i in range(__pyx_memoryview_thread_locks_used): - * if __pyx_memoryview_thread_locks[i] is self.lock: - * __pyx_memoryview_thread_locks_used -= 1 # <<<<<<<<<<<<<< - * if i != __pyx_memoryview_thread_locks_used: - * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( - */ - __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used - 1); - - /* "View.MemoryView":382 - * if __pyx_memoryview_thread_locks[i] is self.lock: - * __pyx_memoryview_thread_locks_used -= 1 - * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< - * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( - * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) - */ - __pyx_t_2 = ((__pyx_v_i != __pyx_memoryview_thread_locks_used) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":384 - * if i != __pyx_memoryview_thread_locks_used: - * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( - * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) # <<<<<<<<<<<<<< - * break - * else: - */ - __pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); - __pyx_t_7 = (__pyx_memoryview_thread_locks[__pyx_v_i]); - - /* "View.MemoryView":383 - * __pyx_memoryview_thread_locks_used -= 1 - * if i != __pyx_memoryview_thread_locks_used: - * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( # <<<<<<<<<<<<<< - * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) - * break + /* "View.MemoryView":403 + * return self + * + * have_slices, indices = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< + * + * cdef char *itemp */ - (__pyx_memoryview_thread_locks[__pyx_v_i]) = __pyx_t_6; - (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_7; + __pyx_t_3 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (likely(__pyx_t_3 != Py_None)) { + PyObject* sequence = __pyx_t_3; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(2, 403, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + #else + __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(2, 403, __pyx_L1_error) + } + __pyx_v_have_slices = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_v_indices = __pyx_t_5; + __pyx_t_5 = 0; - /* "View.MemoryView":382 - * if __pyx_memoryview_thread_locks[i] is self.lock: - * __pyx_memoryview_thread_locks_used -= 1 - * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< - * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( - * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + /* "View.MemoryView":406 + * + * cdef char *itemp + * if have_slices: # <<<<<<<<<<<<<< + * return memview_slice(self, indices) + * else: */ - } + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(2, 406, __pyx_L1_error) + if (__pyx_t_2) { - /* "View.MemoryView":385 - * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( - * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) - * break # <<<<<<<<<<<<<< - * else: - * PyThread_free_lock(self.lock) + /* "View.MemoryView":407 + * cdef char *itemp + * if have_slices: + * return memview_slice(self, indices) # <<<<<<<<<<<<<< + * else: + * itemp = self.get_item_pointer(indices) */ - goto __pyx_L6_break; + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; - /* "View.MemoryView":380 - * if self.lock != NULL: - * for i in range(__pyx_memoryview_thread_locks_used): - * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< - * __pyx_memoryview_thread_locks_used -= 1 - * if i != __pyx_memoryview_thread_locks_used: + /* "View.MemoryView":406 + * + * cdef char *itemp + * if have_slices: # <<<<<<<<<<<<<< + * return memview_slice(self, indices) + * else: */ - } - } - /*else*/ { + } - /* "View.MemoryView":387 - * break - * else: - * PyThread_free_lock(self.lock) # <<<<<<<<<<<<<< + /* "View.MemoryView":409 + * return memview_slice(self, indices) + * else: + * itemp = self.get_item_pointer(indices) # <<<<<<<<<<<<<< + * return self.convert_item_to_object(itemp) * - * cdef char *get_item_pointer(memoryview self, object index) except NULL: */ - PyThread_free_lock(__pyx_v_self->lock); - } - __pyx_L6_break:; + /*else*/ { + __pyx_t_6 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_6 == ((char *)NULL))) __PYX_ERR(2, 409, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_6; - /* "View.MemoryView":378 - * cdef int i - * global __pyx_memoryview_thread_locks_used - * if self.lock != NULL: # <<<<<<<<<<<<<< - * for i in range(__pyx_memoryview_thread_locks_used): - * if __pyx_memoryview_thread_locks[i] is self.lock: + /* "View.MemoryView":410 + * else: + * itemp = self.get_item_pointer(indices) + * return self.convert_item_to_object(itemp) # <<<<<<<<<<<<<< + * + * def __setitem__(memoryview self, object index, object value): */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 410, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; } - /* "View.MemoryView":372 - * self.typeinfo = NULL + /* "View.MemoryView":399 * - * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< - * if self.obj is not None: - * __Pyx_ReleaseBuffer(&self.view) + * + * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< + * if index is Ellipsis: + * return self */ /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_have_slices); + __Pyx_XDECREF(__pyx_v_indices); + __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); + return __pyx_r; } -/* "View.MemoryView":389 - * PyThread_free_lock(self.lock) +/* "View.MemoryView":412 + * return self.convert_item_to_object(itemp) * - * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< - * cdef Py_ssize_t dim - * cdef char *itemp = self.view.buf + * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") */ -static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { - Py_ssize_t __pyx_v_dim; - char *__pyx_v_itemp; - PyObject *__pyx_v_idx = NULL; - char *__pyx_r; +/* Python wrapper */ +static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { + int __pyx_r; __Pyx_RefNannyDeclarations - Py_ssize_t __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - Py_ssize_t __pyx_t_3; - PyObject *(*__pyx_t_4)(PyObject *); - PyObject *__pyx_t_5 = NULL; - Py_ssize_t __pyx_t_6; - char *__pyx_t_7; - __Pyx_RefNannySetupContext("get_item_pointer", 0); - - /* "View.MemoryView":391 - * cdef char *get_item_pointer(memoryview self, object index) except NULL: - * cdef Py_ssize_t dim - * cdef char *itemp = self.view.buf # <<<<<<<<<<<<<< - * - * for dim, idx in enumerate(index): - */ - __pyx_v_itemp = ((char *)__pyx_v_self->view.buf); - - /* "View.MemoryView":393 - * cdef char *itemp = self.view.buf - * - * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< - * itemp = pybuffer_index(&self.view, itemp, idx, dim) - * - */ - __pyx_t_1 = 0; - if (likely(PyList_CheckExact(__pyx_v_index)) || PyTuple_CheckExact(__pyx_v_index)) { - __pyx_t_2 = __pyx_v_index; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; - __pyx_t_4 = NULL; - } else { - __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 393, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 393, __pyx_L1_error) - } - for (;;) { - if (likely(!__pyx_t_4)) { - if (likely(PyList_CheckExact(__pyx_t_2))) { - if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(2, 393, __pyx_L1_error) - #else - __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 393, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - #endif - } else { - if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(2, 393, __pyx_L1_error) - #else - __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 393, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - #endif - } - } else { - __pyx_t_5 = __pyx_t_4(__pyx_t_2); - if (unlikely(!__pyx_t_5)) { - PyObject* exc_type = PyErr_Occurred(); - if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(2, 393, __pyx_L1_error) - } - break; - } - __Pyx_GOTREF(__pyx_t_5); - } - __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_5); - __pyx_t_5 = 0; - __pyx_v_dim = __pyx_t_1; - __pyx_t_1 = (__pyx_t_1 + 1); - - /* "View.MemoryView":394 - * - * for dim, idx in enumerate(index): - * itemp = pybuffer_index(&self.view, itemp, idx, dim) # <<<<<<<<<<<<<< - * - * return itemp - */ - __pyx_t_6 = __Pyx_PyIndex_AsSsize_t(__pyx_v_idx); if (unlikely((__pyx_t_6 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 394, __pyx_L1_error) - __pyx_t_7 = __pyx_pybuffer_index((&__pyx_v_self->view), __pyx_v_itemp, __pyx_t_6, __pyx_v_dim); if (unlikely(__pyx_t_7 == ((char *)NULL))) __PYX_ERR(2, 394, __pyx_L1_error) - __pyx_v_itemp = __pyx_t_7; - - /* "View.MemoryView":393 - * cdef char *itemp = self.view.buf - * - * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< - * itemp = pybuffer_index(&self.view, itemp, idx, dim) - * - */ - } - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "View.MemoryView":396 - * itemp = pybuffer_index(&self.view, itemp, idx, dim) - * - * return itemp # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = __pyx_v_itemp; - goto __pyx_L0; - - /* "View.MemoryView":389 - * PyThread_free_lock(self.lock) - * - * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< - * cdef Py_ssize_t dim - * cdef char *itemp = self.view.buf - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("View.MemoryView.memoryview.get_item_pointer", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_idx); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":399 - * - * - * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< - * if index is Ellipsis: - * return self - */ - -/* Python wrapper */ -static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index); /*proto*/ -static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index)); + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { PyObject *__pyx_v_have_slices = NULL; - PyObject *__pyx_v_indices = NULL; - char *__pyx_v_itemp; - PyObject *__pyx_r = NULL; + PyObject *__pyx_v_obj = NULL; + int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; - int __pyx_t_2; + PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - char *__pyx_t_6; - __Pyx_RefNannySetupContext("__getitem__", 0); + __Pyx_RefNannySetupContext("__setitem__", 0); + __Pyx_INCREF(__pyx_v_index); - /* "View.MemoryView":400 + /* "View.MemoryView":413 * - * def __getitem__(memoryview self, object index): - * if index is Ellipsis: # <<<<<<<<<<<<<< - * return self + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: # <<<<<<<<<<<<<< + * raise TypeError("Cannot assign to read-only memoryview") * */ - __pyx_t_1 = (__pyx_v_index == __pyx_builtin_Ellipsis); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { + __pyx_t_1 = (__pyx_v_self->view.readonly != 0); + if (unlikely(__pyx_t_1)) { - /* "View.MemoryView":401 - * def __getitem__(memoryview self, object index): - * if index is Ellipsis: - * return self # <<<<<<<<<<<<<< + /* "View.MemoryView":414 + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<< * - * have_slices, indices = _unellipsify(index, self.view.ndim) + * have_slices, index = _unellipsify(index, self.view.ndim) */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_self)); - __pyx_r = ((PyObject *)__pyx_v_self); - goto __pyx_L0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(2, 414, __pyx_L1_error) - /* "View.MemoryView":400 + /* "View.MemoryView":413 * - * def __getitem__(memoryview self, object index): - * if index is Ellipsis: # <<<<<<<<<<<<<< - * return self + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: # <<<<<<<<<<<<<< + * raise TypeError("Cannot assign to read-only memoryview") * */ } - /* "View.MemoryView":403 - * return self + /* "View.MemoryView":416 + * raise TypeError("Cannot assign to read-only memoryview") * - * have_slices, indices = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< + * have_slices, index = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< * - * cdef char *itemp + * if have_slices: */ - __pyx_t_3 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 403, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (likely(__pyx_t_3 != Py_None)) { - PyObject* sequence = __pyx_t_3; + __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (likely(__pyx_t_2 != Py_None)) { + PyObject* sequence = __pyx_t_2; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(2, 403, __pyx_L1_error) + __PYX_ERR(2, 416, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); #else - __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 403, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 416, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 403, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); #endif - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { - __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(2, 403, __pyx_L1_error) + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(2, 416, __pyx_L1_error) } - __pyx_v_have_slices = __pyx_t_4; + __pyx_v_have_slices = __pyx_t_3; + __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_4); __pyx_t_4 = 0; - __pyx_v_indices = __pyx_t_5; - __pyx_t_5 = 0; - /* "View.MemoryView":406 + /* "View.MemoryView":418 + * have_slices, index = _unellipsify(index, self.view.ndim) * - * cdef char *itemp * if have_slices: # <<<<<<<<<<<<<< - * return memview_slice(self, indices) - * else: + * obj = self.is_slice(value) + * if obj: */ - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(2, 406, __pyx_L1_error) - if (__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(2, 418, __pyx_L1_error) + if (__pyx_t_1) { - /* "View.MemoryView":407 - * cdef char *itemp + /* "View.MemoryView":419 + * * if have_slices: - * return memview_slice(self, indices) # <<<<<<<<<<<<<< - * else: - * itemp = self.get_item_pointer(indices) - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 407, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L0; - - /* "View.MemoryView":406 - * - * cdef char *itemp - * if have_slices: # <<<<<<<<<<<<<< - * return memview_slice(self, indices) - * else: - */ - } - - /* "View.MemoryView":409 - * return memview_slice(self, indices) - * else: - * itemp = self.get_item_pointer(indices) # <<<<<<<<<<<<<< - * return self.convert_item_to_object(itemp) - * - */ - /*else*/ { - __pyx_t_6 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_6 == ((char *)NULL))) __PYX_ERR(2, 409, __pyx_L1_error) - __pyx_v_itemp = __pyx_t_6; - - /* "View.MemoryView":410 - * else: - * itemp = self.get_item_pointer(indices) - * return self.convert_item_to_object(itemp) # <<<<<<<<<<<<<< - * - * def __setitem__(memoryview self, object index, object value): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 410, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L0; - } - - /* "View.MemoryView":399 - * - * - * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< - * if index is Ellipsis: - * return self - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("View.MemoryView.memoryview.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_have_slices); - __Pyx_XDECREF(__pyx_v_indices); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":412 - * return self.convert_item_to_object(itemp) - * - * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< - * if self.view.readonly: - * raise TypeError("Cannot assign to read-only memoryview") - */ - -/* Python wrapper */ -static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /*proto*/ -static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index), ((PyObject *)__pyx_v_value)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { - PyObject *__pyx_v_have_slices = NULL; - PyObject *__pyx_v_obj = NULL; - int __pyx_r; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - __Pyx_RefNannySetupContext("__setitem__", 0); - __Pyx_INCREF(__pyx_v_index); - - /* "View.MemoryView":413 - * - * def __setitem__(memoryview self, object index, object value): - * if self.view.readonly: # <<<<<<<<<<<<<< - * raise TypeError("Cannot assign to read-only memoryview") - * - */ - __pyx_t_1 = (__pyx_v_self->view.readonly != 0); - if (unlikely(__pyx_t_1)) { - - /* "View.MemoryView":414 - * def __setitem__(memoryview self, object index, object value): - * if self.view.readonly: - * raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<< - * - * have_slices, index = _unellipsify(index, self.view.ndim) - */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 414, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_Raise(__pyx_t_2, 0, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(2, 414, __pyx_L1_error) - - /* "View.MemoryView":413 - * - * def __setitem__(memoryview self, object index, object value): - * if self.view.readonly: # <<<<<<<<<<<<<< - * raise TypeError("Cannot assign to read-only memoryview") - * - */ - } - - /* "View.MemoryView":416 - * raise TypeError("Cannot assign to read-only memoryview") - * - * have_slices, index = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< - * - * if have_slices: - */ - __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 416, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (likely(__pyx_t_2 != Py_None)) { - PyObject* sequence = __pyx_t_2; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(2, 416, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(__pyx_t_4); - #else - __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 416, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 416, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } else { - __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(2, 416, __pyx_L1_error) - } - __pyx_v_have_slices = __pyx_t_3; - __pyx_t_3 = 0; - __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_4); - __pyx_t_4 = 0; - - /* "View.MemoryView":418 - * have_slices, index = _unellipsify(index, self.view.ndim) - * - * if have_slices: # <<<<<<<<<<<<<< - * obj = self.is_slice(value) - * if obj: - */ - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(2, 418, __pyx_L1_error) - if (__pyx_t_1) { - - /* "View.MemoryView":419 - * - * if have_slices: - * obj = self.is_slice(value) # <<<<<<<<<<<<<< - * if obj: - * self.setitem_slice_assignment(self[index], obj) + * obj = self.is_slice(value) # <<<<<<<<<<<<<< + * if obj: + * self.setitem_slice_assignment(self[index], obj) */ __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->is_slice(__pyx_v_self, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 419, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); @@ -22472,11 +20317,6 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_s_Cannot_assign_to_read_only_memor, __pyx_k_Cannot_assign_to_read_only_memor, sizeof(__pyx_k_Cannot_assign_to_read_only_memor), 0, 0, 1, 0}, {&__pyx_kp_s_Cannot_create_writable_memory_vi, __pyx_k_Cannot_create_writable_memory_vi, sizeof(__pyx_k_Cannot_create_writable_memory_vi), 0, 0, 1, 0}, {&__pyx_kp_s_Cannot_index_with_type_s, __pyx_k_Cannot_index_with_type_s, sizeof(__pyx_k_Cannot_index_with_type_s), 0, 0, 1, 0}, - {&__pyx_n_s_D_N, __pyx_k_D_N, sizeof(__pyx_k_D_N), 0, 0, 1, 1}, - {&__pyx_n_s_D_N___init, __pyx_k_D_N___init, sizeof(__pyx_k_D_N___init), 0, 0, 1, 1}, - {&__pyx_n_s_D_N_calculate_means, __pyx_k_D_N_calculate_means, sizeof(__pyx_k_D_N_calculate_means), 0, 0, 1, 1}, - {&__pyx_n_s_D_N_product_sum, __pyx_k_D_N_product_sum, sizeof(__pyx_k_D_N_product_sum), 0, 0, 1, 1}, - {&__pyx_n_s_D_N_squared_sum, __pyx_k_D_N_squared_sum, sizeof(__pyx_k_D_N_squared_sum), 0, 0, 1, 1}, {&__pyx_n_s_Ellipsis, __pyx_k_Ellipsis, sizeof(__pyx_k_Ellipsis), 0, 0, 1, 1}, {&__pyx_kp_s_Empty_shape_tuple_for_cython_arr, __pyx_k_Empty_shape_tuple_for_cython_arr, sizeof(__pyx_k_Empty_shape_tuple_for_cython_arr), 0, 0, 1, 0}, {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, @@ -22485,7 +20325,6 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_s_Incompatible_checksums_s_vs_0xb0, __pyx_k_Incompatible_checksums_s_vs_0xb0, sizeof(__pyx_k_Incompatible_checksums_s_vs_0xb0), 0, 0, 1, 0}, {&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1}, {&__pyx_kp_s_Indirect_dimensions_not_supporte, __pyx_k_Indirect_dimensions_not_supporte, sizeof(__pyx_k_Indirect_dimensions_not_supporte), 0, 0, 1, 0}, - {&__pyx_kp_s_Inner_helper_of_dcov_all_Cache_d, __pyx_k_Inner_helper_of_dcov_all_Cache_d, sizeof(__pyx_k_Inner_helper_of_dcov_all_Cache_d), 0, 0, 1, 0}, {&__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_k_Invalid_mode_expected_c_or_fortr, sizeof(__pyx_k_Invalid_mode_expected_c_or_fortr), 0, 0, 1, 0}, {&__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_k_Invalid_shape_in_axis_d_d, sizeof(__pyx_k_Invalid_shape_in_axis_d_d), 0, 0, 1, 0}, {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, @@ -22510,32 +20349,18 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_base, __pyx_k_base, sizeof(__pyx_k_base), 0, 0, 1, 1}, {&__pyx_n_s_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 0, 1, 1}, {&__pyx_n_u_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 1, 0, 1}, - {&__pyx_n_s_calculate_means, __pyx_k_calculate_means, sizeof(__pyx_k_calculate_means), 0, 0, 1, 1}, {&__pyx_n_s_class, __pyx_k_class, sizeof(__pyx_k_class), 0, 0, 1, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, {&__pyx_kp_s_contiguous_and_direct, __pyx_k_contiguous_and_direct, sizeof(__pyx_k_contiguous_and_direct), 0, 0, 1, 0}, {&__pyx_kp_s_contiguous_and_indirect, __pyx_k_contiguous_and_indirect, sizeof(__pyx_k_contiguous_and_indirect), 0, 0, 1, 0}, {&__pyx_n_s_count, __pyx_k_count, sizeof(__pyx_k_count), 0, 0, 1, 1}, {&__pyx_n_s_d, __pyx_k_d, sizeof(__pyx_k_d), 0, 0, 1, 1}, - {&__pyx_n_s_d_here, __pyx_k_d_here, sizeof(__pyx_k_d_here), 0, 0, 1, 1}, - {&__pyx_n_s_d_there, __pyx_k_d_there, sizeof(__pyx_k_d_there), 0, 0, 1, 1}, - {&__pyx_n_s_dc, __pyx_k_dc, sizeof(__pyx_k_dc), 0, 0, 1, 1}, - {&__pyx_n_s_dcov_all, __pyx_k_dcov_all, sizeof(__pyx_k_dcov_all), 0, 0, 1, 1}, - {&__pyx_n_s_denom, __pyx_k_denom, sizeof(__pyx_k_denom), 0, 0, 1, 1}, {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, {&__pyx_n_s_dim, __pyx_k_dim, sizeof(__pyx_k_dim), 0, 0, 1, 1}, {&__pyx_n_s_dim_x, __pyx_k_dim_x, sizeof(__pyx_k_dim_x), 0, 0, 1, 1}, {&__pyx_n_s_dim_y, __pyx_k_dim_y, sizeof(__pyx_k_dim_y), 0, 0, 1, 1}, - {&__pyx_n_s_dist, __pyx_k_dist, sizeof(__pyx_k_dist), 0, 0, 1, 1}, - {&__pyx_n_s_dnx, __pyx_k_dnx, sizeof(__pyx_k_dnx), 0, 0, 1, 1}, - {&__pyx_n_s_dny, __pyx_k_dny, sizeof(__pyx_k_dny), 0, 0, 1, 1}, - {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1}, - {&__pyx_n_s_double, __pyx_k_double, sizeof(__pyx_k_double), 0, 0, 1, 1}, - {&__pyx_n_s_dr, __pyx_k_dr, sizeof(__pyx_k_dr), 0, 0, 1, 1}, {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, {&__pyx_n_s_dtype_is_object, __pyx_k_dtype_is_object, sizeof(__pyx_k_dtype_is_object), 0, 0, 1, 1}, - {&__pyx_n_s_dvx, __pyx_k_dvx, sizeof(__pyx_k_dvx), 0, 0, 1, 1}, - {&__pyx_n_s_dvy, __pyx_k_dvy, sizeof(__pyx_k_dvy), 0, 0, 1, 1}, {&__pyx_n_s_dx, __pyx_k_dx, sizeof(__pyx_k_dx), 0, 0, 1, 1}, {&__pyx_n_s_dy, __pyx_k_dy, sizeof(__pyx_k_dy), 0, 0, 1, 1}, {&__pyx_n_s_dz, __pyx_k_dz, sizeof(__pyx_k_dz), 0, 0, 1, 1}, @@ -22557,15 +20382,12 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_k_got_differing_extents_in_dimensi, sizeof(__pyx_k_got_differing_extents_in_dimensi), 0, 0, 1, 0}, {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, {&__pyx_n_s_id, __pyx_k_id, sizeof(__pyx_k_id), 0, 0, 1, 1}, - {&__pyx_n_s_ii, __pyx_k_ii, sizeof(__pyx_k_ii), 0, 0, 1, 1}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_index, __pyx_k_index, sizeof(__pyx_k_index), 0, 0, 1, 1}, - {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1}, {&__pyx_n_u_int32, __pyx_k_int32, sizeof(__pyx_k_int32), 0, 1, 0, 1}, {&__pyx_n_s_itemsize, __pyx_k_itemsize, sizeof(__pyx_k_itemsize), 0, 0, 1, 1}, {&__pyx_kp_s_itemsize_0_for_cython_array, __pyx_k_itemsize_0_for_cython_array, sizeof(__pyx_k_itemsize_0_for_cython_array), 0, 0, 1, 0}, {&__pyx_n_s_j, __pyx_k_j, sizeof(__pyx_k_j), 0, 0, 1, 1}, - {&__pyx_n_s_jj, __pyx_k_jj, sizeof(__pyx_k_jj), 0, 0, 1, 1}, {&__pyx_n_s_k, __pyx_k_k, sizeof(__pyx_k_k), 0, 0, 1, 1}, {&__pyx_n_s_k_xz, __pyx_k_k_xz, sizeof(__pyx_k_k_xz), 0, 0, 1, 1}, {&__pyx_n_s_k_yz, __pyx_k_k_yz, sizeof(__pyx_k_k_yz), 0, 0, 1, 1}, @@ -22575,19 +20397,8 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_kz, __pyx_k_kz, sizeof(__pyx_k_kz), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_mask, __pyx_k_mask, sizeof(__pyx_k_mask), 0, 0, 1, 1}, - {&__pyx_n_s_mean, __pyx_k_mean, sizeof(__pyx_k_mean), 0, 0, 1, 1}, - {&__pyx_n_s_mean_0, __pyx_k_mean_0, sizeof(__pyx_k_mean_0), 0, 0, 1, 1}, - {&__pyx_n_s_mean_0_here, __pyx_k_mean_0_here, sizeof(__pyx_k_mean_0_here), 0, 0, 1, 1}, - {&__pyx_n_s_mean_0_there, __pyx_k_mean_0_there, sizeof(__pyx_k_mean_0_there), 0, 0, 1, 1}, - {&__pyx_n_s_mean_1, __pyx_k_mean_1, sizeof(__pyx_k_mean_1), 0, 0, 1, 1}, - {&__pyx_n_s_mean_1_here, __pyx_k_mean_1_here, sizeof(__pyx_k_mean_1_here), 0, 0, 1, 1}, - {&__pyx_n_s_mean_1_there, __pyx_k_mean_1_there, sizeof(__pyx_k_mean_1_there), 0, 0, 1, 1}, - {&__pyx_n_s_mean_here, __pyx_k_mean_here, sizeof(__pyx_k_mean_here), 0, 0, 1, 1}, - {&__pyx_n_s_mean_there, __pyx_k_mean_there, sizeof(__pyx_k_mean_there), 0, 0, 1, 1}, {&__pyx_n_s_memview, __pyx_k_memview, sizeof(__pyx_k_memview), 0, 0, 1, 1}, - {&__pyx_n_s_metaclass, __pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 0, 1, 1}, {&__pyx_n_s_mode, __pyx_k_mode, sizeof(__pyx_k_mode), 0, 0, 1, 1}, - {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1}, {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, @@ -22603,14 +20414,11 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_u_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 1, 0, 0}, {&__pyx_n_s_obj, __pyx_k_obj, sizeof(__pyx_k_obj), 0, 0, 1, 1}, {&__pyx_n_s_order, __pyx_k_order, sizeof(__pyx_k_order), 0, 0, 1, 1}, - {&__pyx_n_s_other, __pyx_k_other, sizeof(__pyx_k_other), 0, 0, 1, 1}, {&__pyx_n_s_p, __pyx_k_p, sizeof(__pyx_k_p), 0, 0, 1, 1}, {&__pyx_n_s_pack, __pyx_k_pack, sizeof(__pyx_k_pack), 0, 0, 1, 1}, {&__pyx_n_s_patt, __pyx_k_patt, sizeof(__pyx_k_patt), 0, 0, 1, 1}, {&__pyx_n_s_patt_mask, __pyx_k_patt_mask, sizeof(__pyx_k_patt_mask), 0, 0, 1, 1}, {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1}, - {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1}, - {&__pyx_n_s_product_sum, __pyx_k_product_sum, sizeof(__pyx_k_product_sum), 0, 0, 1, 1}, {&__pyx_n_s_pyx_PickleError, __pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 0, 1, 1}, {&__pyx_n_s_pyx_checksum, __pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 0, 1, 1}, {&__pyx_n_s_pyx_getbuffer, __pyx_k_pyx_getbuffer, sizeof(__pyx_k_pyx_getbuffer), 0, 0, 1, 1}, @@ -22619,22 +20427,17 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_pyx_type, __pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 0, 1, 1}, {&__pyx_n_s_pyx_unpickle_Enum, __pyx_k_pyx_unpickle_Enum, sizeof(__pyx_k_pyx_unpickle_Enum), 0, 0, 1, 1}, {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, - {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1}, {&__pyx_n_s_random, __pyx_k_random, sizeof(__pyx_k_random), 0, 0, 1, 1}, {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, {&__pyx_n_s_restricted_permutation, __pyx_k_restricted_permutation, sizeof(__pyx_k_restricted_permutation), 0, 0, 1, 1}, - {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, {&__pyx_n_s_shape, __pyx_k_shape, sizeof(__pyx_k_shape), 0, 0, 1, 1}, - {&__pyx_n_s_shuffle, __pyx_k_shuffle, sizeof(__pyx_k_shuffle), 0, 0, 1, 1}, {&__pyx_n_s_shuffle_neighbors, __pyx_k_shuffle_neighbors, sizeof(__pyx_k_shuffle_neighbors), 0, 0, 1, 1}, {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1}, - {&__pyx_n_s_sqrt, __pyx_k_sqrt, sizeof(__pyx_k_sqrt), 0, 0, 1, 1}, - {&__pyx_n_s_squared_sum, __pyx_k_squared_sum, sizeof(__pyx_k_squared_sum), 0, 0, 1, 1}, {&__pyx_n_s_start, __pyx_k_start, sizeof(__pyx_k_start), 0, 0, 1, 1}, {&__pyx_n_s_step, __pyx_k_step, sizeof(__pyx_k_step), 0, 0, 1, 1}, {&__pyx_n_s_stop, __pyx_k_stop, sizeof(__pyx_k_stop), 0, 0, 1, 1}, @@ -22643,9 +20446,6 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_s_strided_and_indirect, __pyx_k_strided_and_indirect, sizeof(__pyx_k_strided_and_indirect), 0, 0, 1, 0}, {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, {&__pyx_n_s_struct, __pyx_k_struct, sizeof(__pyx_k_struct), 0, 0, 1, 1}, - {&__pyx_n_s_sum_0, __pyx_k_sum_0, sizeof(__pyx_k_sum_0), 0, 0, 1, 1}, - {&__pyx_n_s_sum_1, __pyx_k_sum_1, sizeof(__pyx_k_sum_1), 0, 0, 1, 1}, - {&__pyx_n_s_sum_total, __pyx_k_sum_total, sizeof(__pyx_k_sum_total), 0, 0, 1, 1}, {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1}, {&__pyx_n_s_t, __pyx_k_t, sizeof(__pyx_k_t), 0, 0, 1, 1}, {&__pyx_n_s_tau, __pyx_k_tau, sizeof(__pyx_k_tau), 0, 0, 1, 1}, @@ -22662,11 +20462,8 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_use, __pyx_k_use, sizeof(__pyx_k_use), 0, 0, 1, 1}, {&__pyx_n_s_used, __pyx_k_used, sizeof(__pyx_k_used), 0, 0, 1, 1}, {&__pyx_n_s_v, __pyx_k_v, sizeof(__pyx_k_v), 0, 0, 1, 1}, - {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1}, {&__pyx_n_s_var, __pyx_k_var, sizeof(__pyx_k_var), 0, 0, 1, 1}, {&__pyx_n_s_weights, __pyx_k_weights, sizeof(__pyx_k_weights), 0, 0, 1, 1}, - {&__pyx_n_s_x, __pyx_k_x, sizeof(__pyx_k_x), 0, 0, 1, 1}, - {&__pyx_n_s_y, __pyx_k_y, sizeof(__pyx_k_y), 0, 0, 1, 1}, {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; @@ -22995,66 +20792,6 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_GIVEREF(__pyx_tuple__30); __pyx_codeobj__31 = (PyObject*)__Pyx_PyCode_New(4, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__30, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_tigramite_tigramite_cython_code, __pyx_n_s_get_restricted_permutation_cyth, 148, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__31)) __PYX_ERR(0, 148, __pyx_L1_error) - /* "tigramite/tigramite_cython_code.pyx":217 - * ctypedef np.double_t DTYPE_t - * - * def dcov_all(x, y): # <<<<<<<<<<<<<< - * 'Calculate distance covariance, distance correlation, distance variance of x sample and distance variance of y sample' - * x = np.array(x, dtype=np.double) - */ - __pyx_tuple__32 = PyTuple_Pack(9, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_dnx, __pyx_n_s_dny, __pyx_n_s_denom, __pyx_n_s_dc, __pyx_n_s_dvx, __pyx_n_s_dvy, __pyx_n_s_dr); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 217, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__32); - __Pyx_GIVEREF(__pyx_tuple__32); - __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(2, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__32, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_tigramite_tigramite_cython_code, __pyx_n_s_dcov_all, 217, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(0, 217, __pyx_L1_error) - - /* "tigramite/tigramite_cython_code.pyx":236 - * the matrix members on the fly""" - * - * def __init__(self, x): # <<<<<<<<<<<<<< - * self.x = np.array(x) - * self.dim = x.shape[0] - */ - __pyx_tuple__34 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_x); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 236, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__34); - __Pyx_GIVEREF(__pyx_tuple__34); - __pyx_codeobj__35 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__34, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_tigramite_tigramite_cython_code, __pyx_n_s_init, 236, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__35)) __PYX_ERR(0, 236, __pyx_L1_error) - - /* "tigramite/tigramite_cython_code.pyx":243 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * def calculate_means(self): # <<<<<<<<<<<<<< - * cdef int dim = self.dim - * cdef DTYPE_t value - */ - __pyx_tuple__36 = PyTuple_Pack(9, __pyx_n_s_self, __pyx_n_s_dim, __pyx_n_s_value, __pyx_n_s_sum_total, __pyx_n_s_sum_0, __pyx_n_s_sum_1, __pyx_n_s_x, __pyx_n_s_ii, __pyx_n_s_jj); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(0, 243, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__36); - __Pyx_GIVEREF(__pyx_tuple__36); - __pyx_codeobj__37 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__36, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_tigramite_tigramite_cython_code, __pyx_n_s_calculate_means, 243, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__37)) __PYX_ERR(0, 243, __pyx_L1_error) - - /* "tigramite/tigramite_cython_code.pyx":268 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * def squared_sum(self): # <<<<<<<<<<<<<< - * cdef np.ndarray[DTYPE_t, ndim=1] mean_0 = self.mean_0 - * cdef np.ndarray[DTYPE_t, ndim=1] mean_1 = self.mean_1 - */ - __pyx_tuple__38 = PyTuple_Pack(11, __pyx_n_s_self, __pyx_n_s_mean_0, __pyx_n_s_mean_1, __pyx_n_s_mean, __pyx_n_s_squared_sum, __pyx_n_s_dist, __pyx_n_s_d, __pyx_n_s_x, __pyx_n_s_dim, __pyx_n_s_ii, __pyx_n_s_jj); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(0, 268, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__38); - __Pyx_GIVEREF(__pyx_tuple__38); - __pyx_codeobj__39 = (PyObject*)__Pyx_PyCode_New(1, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__38, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_tigramite_tigramite_cython_code, __pyx_n_s_squared_sum, 268, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__39)) __PYX_ERR(0, 268, __pyx_L1_error) - - /* "tigramite/tigramite_cython_code.pyx":288 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * def product_sum(self, other): # <<<<<<<<<<<<<< - * cdef np.ndarray[DTYPE_t, ndim=1] mean_0_here = self.mean_0 - * cdef np.ndarray[DTYPE_t, ndim=1] mean_1_here = self.mean_1 - */ - __pyx_tuple__40 = PyTuple_Pack(16, __pyx_n_s_self, __pyx_n_s_other, __pyx_n_s_mean_0_here, __pyx_n_s_mean_1_here, __pyx_n_s_mean_here, __pyx_n_s_mean_0_there, __pyx_n_s_mean_1_there, __pyx_n_s_mean_there, __pyx_n_s_d_here, __pyx_n_s_d_there, __pyx_n_s_product_sum, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_dim, __pyx_n_s_ii, __pyx_n_s_jj); if (unlikely(!__pyx_tuple__40)) __PYX_ERR(0, 288, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__40); - __Pyx_GIVEREF(__pyx_tuple__40); - __pyx_codeobj__41 = (PyObject*)__Pyx_PyCode_New(2, 0, 16, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__40, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_tigramite_tigramite_cython_code, __pyx_n_s_product_sum, 288, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__41)) __PYX_ERR(0, 288, __pyx_L1_error) - /* "View.MemoryView":286 * return self.name * @@ -23062,9 +20799,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * cdef strided = Enum("") # default * cdef indirect = Enum("") */ - __pyx_tuple__42 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__42)) __PYX_ERR(2, 286, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__42); - __Pyx_GIVEREF(__pyx_tuple__42); + __pyx_tuple__32 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(2, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__32); + __Pyx_GIVEREF(__pyx_tuple__32); /* "View.MemoryView":287 * @@ -23073,9 +20810,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * cdef indirect = Enum("") * */ - __pyx_tuple__43 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(2, 287, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__43); - __Pyx_GIVEREF(__pyx_tuple__43); + __pyx_tuple__33 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(2, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__33); + __Pyx_GIVEREF(__pyx_tuple__33); /* "View.MemoryView":288 * cdef generic = Enum("") @@ -23084,9 +20821,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * * */ - __pyx_tuple__44 = PyTuple_Pack(1, __pyx_kp_s_strided_and_indirect); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(2, 288, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__44); - __Pyx_GIVEREF(__pyx_tuple__44); + __pyx_tuple__34 = PyTuple_Pack(1, __pyx_kp_s_strided_and_indirect); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(2, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__34); + __Pyx_GIVEREF(__pyx_tuple__34); /* "View.MemoryView":291 * @@ -23095,9 +20832,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * cdef indirect_contiguous = Enum("") * */ - __pyx_tuple__45 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(2, 291, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__45); - __Pyx_GIVEREF(__pyx_tuple__45); + __pyx_tuple__35 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(2, 291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__35); + __Pyx_GIVEREF(__pyx_tuple__35); /* "View.MemoryView":292 * @@ -23106,19 +20843,19 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * * */ - __pyx_tuple__46 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_indirect); if (unlikely(!__pyx_tuple__46)) __PYX_ERR(2, 292, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__46); - __Pyx_GIVEREF(__pyx_tuple__46); + __pyx_tuple__36 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_indirect); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(2, 292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__36); + __Pyx_GIVEREF(__pyx_tuple__36); /* "(tree fragment)":1 * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ - __pyx_tuple__47 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__47)) __PYX_ERR(2, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__47); - __Pyx_GIVEREF(__pyx_tuple__47); - __pyx_codeobj__48 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__47, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__48)) __PYX_ERR(2, 1, __pyx_L1_error) + __pyx_tuple__37 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__37)) __PYX_ERR(2, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__37); + __Pyx_GIVEREF(__pyx_tuple__37); + __pyx_codeobj__38 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__37, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__38)) __PYX_ERR(2, 1, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -23137,7 +20874,6 @@ if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_184977713 = PyInt_FromLong(184977713L); if (unlikely(!__pyx_int_184977713)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) return 0; @@ -23390,8 +21126,7 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_tigramite_cython_code(PyObject *__ #endif { PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - static PyThread_type_lock __pyx_t_3[8]; + static PyThread_type_lock __pyx_t_2[8]; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT if (__pyx_m) { @@ -23602,89 +21337,6 @@ if (!__Pyx_RefNanny) { if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_restricted_permutation_cyth, __pyx_t_1) < 0) __PYX_ERR(0, 148, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "tigramite/tigramite_cython_code.pyx":217 - * ctypedef np.double_t DTYPE_t - * - * def dcov_all(x, y): # <<<<<<<<<<<<<< - * 'Calculate distance covariance, distance correlation, distance variance of x sample and distance variance of y sample' - * x = np.array(x, dtype=np.double) - */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_9tigramite_21tigramite_cython_code_7dcov_all, NULL, __pyx_n_s_tigramite_tigramite_cython_code_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 217, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_dcov_all, __pyx_t_1) < 0) __PYX_ERR(0, 217, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "tigramite/tigramite_cython_code.pyx":232 - * - * - * class D_N: # <<<<<<<<<<<<<< - * """Inner helper of dcov_all. Cache different means that are required for calculating - * the matrix members on the fly""" - */ - __pyx_t_1 = __Pyx_Py3MetaclassPrepare((PyObject *) NULL, __pyx_empty_tuple, __pyx_n_s_D_N, __pyx_n_s_D_N, (PyObject *) NULL, __pyx_n_s_tigramite_tigramite_cython_code_2, __pyx_kp_s_Inner_helper_of_dcov_all_Cache_d); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 232, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - - /* "tigramite/tigramite_cython_code.pyx":236 - * the matrix members on the fly""" - * - * def __init__(self, x): # <<<<<<<<<<<<<< - * self.x = np.array(x) - * self.dim = x.shape[0] - */ - __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_9tigramite_21tigramite_cython_code_3D_N_1__init__, 0, __pyx_n_s_D_N___init, NULL, __pyx_n_s_tigramite_tigramite_cython_code_2, __pyx_d, ((PyObject *)__pyx_codeobj__35)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 236, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_init, __pyx_t_2) < 0) __PYX_ERR(0, 236, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "tigramite/tigramite_cython_code.pyx":243 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * def calculate_means(self): # <<<<<<<<<<<<<< - * cdef int dim = self.dim - * cdef DTYPE_t value - */ - __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_9tigramite_21tigramite_cython_code_3D_N_3calculate_means, 0, __pyx_n_s_D_N_calculate_means, NULL, __pyx_n_s_tigramite_tigramite_cython_code_2, __pyx_d, ((PyObject *)__pyx_codeobj__37)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 243, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_calculate_means, __pyx_t_2) < 0) __PYX_ERR(0, 243, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "tigramite/tigramite_cython_code.pyx":268 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * def squared_sum(self): # <<<<<<<<<<<<<< - * cdef np.ndarray[DTYPE_t, ndim=1] mean_0 = self.mean_0 - * cdef np.ndarray[DTYPE_t, ndim=1] mean_1 = self.mean_1 - */ - __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_9tigramite_21tigramite_cython_code_3D_N_5squared_sum, 0, __pyx_n_s_D_N_squared_sum, NULL, __pyx_n_s_tigramite_tigramite_cython_code_2, __pyx_d, ((PyObject *)__pyx_codeobj__39)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 268, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_squared_sum, __pyx_t_2) < 0) __PYX_ERR(0, 268, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "tigramite/tigramite_cython_code.pyx":288 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * def product_sum(self, other): # <<<<<<<<<<<<<< - * cdef np.ndarray[DTYPE_t, ndim=1] mean_0_here = self.mean_0 - * cdef np.ndarray[DTYPE_t, ndim=1] mean_1_here = self.mean_1 - */ - __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_9tigramite_21tigramite_cython_code_3D_N_7product_sum, 0, __pyx_n_s_D_N_product_sum, NULL, __pyx_n_s_tigramite_tigramite_cython_code_2, __pyx_d, ((PyObject *)__pyx_codeobj__41)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 288, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (__Pyx_SetNameInClass(__pyx_t_1, __pyx_n_s_product_sum, __pyx_t_2) < 0) __PYX_ERR(0, 288, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "tigramite/tigramite_cython_code.pyx":232 - * - * - * class D_N: # <<<<<<<<<<<<<< - * """Inner helper of dcov_all. Cache different means that are required for calculating - * the matrix members on the fly""" - */ - __pyx_t_2 = __Pyx_Py3ClassCreate(((PyObject*)&__Pyx_DefaultClassType), __pyx_n_s_D_N, __pyx_empty_tuple, __pyx_t_1, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 232, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_D_N, __pyx_t_2) < 0) __PYX_ERR(0, 232, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "tigramite/tigramite_cython_code.pyx":1 * import numpy # <<<<<<<<<<<<<< * cimport numpy @@ -23715,7 +21367,7 @@ if (!__Pyx_RefNanny) { * cdef strided = Enum("") # default * cdef indirect = Enum("") */ - __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__42, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 286, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__32, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 286, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XGOTREF(generic); __Pyx_DECREF_SET(generic, __pyx_t_1); @@ -23729,7 +21381,7 @@ if (!__Pyx_RefNanny) { * cdef indirect = Enum("") * */ - __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__43, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 287, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__33, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 287, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XGOTREF(strided); __Pyx_DECREF_SET(strided, __pyx_t_1); @@ -23743,7 +21395,7 @@ if (!__Pyx_RefNanny) { * * */ - __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__44, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 288, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__34, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 288, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XGOTREF(indirect); __Pyx_DECREF_SET(indirect, __pyx_t_1); @@ -23757,7 +21409,7 @@ if (!__Pyx_RefNanny) { * cdef indirect_contiguous = Enum("") * */ - __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__45, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 291, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__35, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 291, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XGOTREF(contiguous); __Pyx_DECREF_SET(contiguous, __pyx_t_1); @@ -23771,7 +21423,7 @@ if (!__Pyx_RefNanny) { * * */ - __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__46, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 292, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__36, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 292, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XGOTREF(indirect_contiguous); __Pyx_DECREF_SET(indirect_contiguous, __pyx_t_1); @@ -23794,15 +21446,15 @@ if (!__Pyx_RefNanny) { * PyThread_allocate_lock(), * PyThread_allocate_lock(), */ - __pyx_t_3[0] = PyThread_allocate_lock(); - __pyx_t_3[1] = PyThread_allocate_lock(); - __pyx_t_3[2] = PyThread_allocate_lock(); - __pyx_t_3[3] = PyThread_allocate_lock(); - __pyx_t_3[4] = PyThread_allocate_lock(); - __pyx_t_3[5] = PyThread_allocate_lock(); - __pyx_t_3[6] = PyThread_allocate_lock(); - __pyx_t_3[7] = PyThread_allocate_lock(); - memcpy(&(__pyx_memoryview_thread_locks[0]), __pyx_t_3, sizeof(__pyx_memoryview_thread_locks[0]) * (8)); + __pyx_t_2[0] = PyThread_allocate_lock(); + __pyx_t_2[1] = PyThread_allocate_lock(); + __pyx_t_2[2] = PyThread_allocate_lock(); + __pyx_t_2[3] = PyThread_allocate_lock(); + __pyx_t_2[4] = PyThread_allocate_lock(); + __pyx_t_2[5] = PyThread_allocate_lock(); + __pyx_t_2[6] = PyThread_allocate_lock(); + __pyx_t_2[7] = PyThread_allocate_lock(); + memcpy(&(__pyx_memoryview_thread_locks[0]), __pyx_t_2, sizeof(__pyx_memoryview_thread_locks[0]) * (8)); /* "View.MemoryView":545 * info.obj = self @@ -23853,7 +21505,6 @@ if (!__Pyx_RefNanny) { goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init tigramite.tigramite_cython_code", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -24579,167 +22230,205 @@ static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, #endif } -/* pyobject_as_double */ -static double __Pyx__PyObject_AsDouble(PyObject* obj) { - PyObject* float_value; -#if !CYTHON_USE_TYPE_SLOTS - float_value = PyNumber_Float(obj); if ((0)) goto bad; -#else - PyNumberMethods *nb = Py_TYPE(obj)->tp_as_number; - if (likely(nb) && likely(nb->nb_float)) { - float_value = nb->nb_float(obj); - if (likely(float_value) && unlikely(!PyFloat_Check(float_value))) { - PyErr_Format(PyExc_TypeError, - "__float__ returned non-float (type %.200s)", - Py_TYPE(float_value)->tp_name); - Py_DECREF(float_value); - goto bad; +/* RaiseException */ +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + __Pyx_PyThreadState_declare + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; } - } else if (PyUnicode_CheckExact(obj) || PyBytes_CheckExact(obj)) { -#if PY_MAJOR_VERSION >= 3 - float_value = PyFloat_FromString(obj); -#else - float_value = PyFloat_FromString(obj, 0); -#endif - } else { - PyObject* args = PyTuple_New(1); - if (unlikely(!args)) goto bad; - PyTuple_SET_ITEM(args, 0, obj); - float_value = PyObject_Call((PyObject*)&PyFloat_Type, args, 0); - PyTuple_SET_ITEM(args, 0, 0); - Py_DECREF(args); } -#endif - if (likely(float_value)) { - double value = PyFloat_AS_DOUBLE(float_value); - Py_DECREF(float_value); - return value; - } -bad: - return (double)-1; -} - -/* PyObjectCallNoArg */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { -#if CYTHON_FAST_PYCALL - if (PyFunction_Check(func)) { - return __Pyx_PyFunction_FastCall(func, NULL, 0); - } -#endif -#ifdef __Pyx_CyFunction_USED - if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func))) -#else - if (likely(PyCFunction_Check(func))) -#endif - { - if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { - return __Pyx_PyObject_CallMethO(func, NULL); + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; } - } - return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); -} -#endif - -/* PyObjectSetAttrStr */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) { - PyTypeObject* tp = Py_TYPE(obj); - if (likely(tp->tp_setattro)) - return tp->tp_setattro(obj, attr_name, value); -#if PY_MAJOR_VERSION < 3 - if (likely(tp->tp_setattr)) - return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value); #endif - return PyObject_SetAttr(obj, attr_name, value); -} -#endif - -/* GetItemInt */ -static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { - PyObject *r; - if (!j) return NULL; - r = PyObject_GetItem(o, j); - Py_DECREF(j); - return r; -} -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - Py_ssize_t wrapped_i = i; - if (wraparound & unlikely(i < 0)) { - wrapped_i += PyList_GET_SIZE(o); - } - if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { - PyObject *r = PyList_GET_ITEM(o, wrapped_i); - Py_INCREF(r); - return r; + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } } - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); -#else - return PySequence_GetItem(o, i); -#endif + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; } -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - Py_ssize_t wrapped_i = i; - if (wraparound & unlikely(i < 0)) { - wrapped_i += PyTuple_GET_SIZE(o); - } - if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { - PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); - Py_INCREF(r); - return r; - } - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else - return PySequence_GetItem(o, i); -#endif -} -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS - if (is_list || PyList_CheckExact(o)) { - Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); - if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { - PyObject *r = PyList_GET_ITEM(o, n); - Py_INCREF(r); - return r; - } +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; } - else if (PyTuple_CheckExact(o)) { - Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); - if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { - PyObject *r = PyTuple_GET_ITEM(o, n); - Py_INCREF(r); - return r; + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; } - } else { - PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; - if (likely(m && m->sq_item)) { - if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { - Py_ssize_t l = m->sq_length(o); - if (likely(l >= 0)) { - i += l; + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; } else { - if (!PyErr_ExceptionMatches(PyExc_OverflowError)) - return NULL; - PyErr_Clear(); + type = instance_class; } } - return m->sq_item(o, i); } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); #else - if (is_list || PySequence_Check(o)) { - return PySequence_GetItem(o, i); + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif } +bad: + Py_XDECREF(owned_instance); + return; +} #endif - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); + +/* DictGetItem */ +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (!PyErr_Occurred()) { + if (unlikely(PyTuple_Check(key))) { + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) { + PyErr_SetObject(PyExc_KeyError, args); + Py_DECREF(args); + } + } else { + PyErr_SetObject(PyExc_KeyError, key); + } + } + return NULL; + } + Py_INCREF(value); + return value; +} +#endif + +/* RaiseTooManyValuesToUnpack */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +/* RaiseNeedMoreValuesToUnpack */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +/* RaiseNoneIterError */ +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); } /* ExtTypeTest */ @@ -24755,1019 +22444,258 @@ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { return 0; } -/* IsLittleEndian */ -static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) +/* GetTopmostException */ +#if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * +__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { - union { - uint32_t u32; - uint8_t u8[4]; - } S; - S.u32 = 0x01020304; - return S.u8[0] == 4; -} - -/* BufferFormatCheck */ -static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, - __Pyx_BufFmt_StackElem* stack, - __Pyx_TypeInfo* type) { - stack[0].field = &ctx->root; - stack[0].parent_offset = 0; - ctx->root.type = type; - ctx->root.name = "buffer dtype"; - ctx->root.offset = 0; - ctx->head = stack; - ctx->head->field = &ctx->root; - ctx->fmt_offset = 0; - ctx->head->parent_offset = 0; - ctx->new_packmode = '@'; - ctx->enc_packmode = '@'; - ctx->new_count = 1; - ctx->enc_count = 0; - ctx->enc_type = 0; - ctx->is_complex = 0; - ctx->is_valid_array = 0; - ctx->struct_alignment = 0; - while (type->typegroup == 'S') { - ++ctx->head; - ctx->head->field = type->fields; - ctx->head->parent_offset = 0; - type = type->fields->type; - } -} -static int __Pyx_BufFmt_ParseNumber(const char** ts) { - int count; - const char* t = *ts; - if (*t < '0' || *t > '9') { - return -1; - } else { - count = *t++ - '0'; - while (*t >= '0' && *t <= '9') { - count *= 10; - count += *t++ - '0'; - } + _PyErr_StackItem *exc_info = tstate->exc_info; + while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && + exc_info->previous_item != NULL) + { + exc_info = exc_info->previous_item; } - *ts = t; - return count; -} -static int __Pyx_BufFmt_ExpectNumber(const char **ts) { - int number = __Pyx_BufFmt_ParseNumber(ts); - if (number == -1) - PyErr_Format(PyExc_ValueError,\ - "Does not understand character buffer dtype format string ('%c')", **ts); - return number; + return exc_info; } -static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { - PyErr_Format(PyExc_ValueError, - "Unexpected format string character: '%c'", ch); +#endif + +/* SaveResetException */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + *type = exc_info->exc_type; + *value = exc_info->exc_value; + *tb = exc_info->exc_traceback; + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + #endif + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); } -static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { - switch (ch) { - case 'c': return "'char'"; - case 'b': return "'signed char'"; - case 'B': return "'unsigned char'"; - case 'h': return "'short'"; - case 'H': return "'unsigned short'"; - case 'i': return "'int'"; - case 'I': return "'unsigned int'"; - case 'l': return "'long'"; - case 'L': return "'unsigned long'"; - case 'q': return "'long long'"; - case 'Q': return "'unsigned long long'"; - case 'f': return (is_complex ? "'complex float'" : "'float'"); - case 'd': return (is_complex ? "'complex double'" : "'double'"); - case 'g': return (is_complex ? "'complex long double'" : "'long double'"); - case 'T': return "a struct"; - case 'O': return "Python object"; - case 'P': return "a pointer"; - case 's': case 'p': return "a string"; - case 0: return "end"; - default: return "unparseable format string"; - } +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = type; + exc_info->exc_value = value; + exc_info->exc_traceback = tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); } -static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { - switch (ch) { - case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; - case 'h': case 'H': return 2; - case 'i': case 'I': case 'l': case 'L': return 4; - case 'q': case 'Q': return 8; - case 'f': return (is_complex ? 8 : 4); - case 'd': return (is_complex ? 16 : 8); - case 'g': { - PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); - return 0; +#endif + +/* PyErrExceptionMatches */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; icurexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; + if (unlikely(PyTuple_Check(err))) + return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } -typedef struct { char c; short x; } __Pyx_st_short; -typedef struct { char c; int x; } __Pyx_st_int; -typedef struct { char c; long x; } __Pyx_st_long; -typedef struct { char c; float x; } __Pyx_st_float; -typedef struct { char c; double x; } __Pyx_st_double; -typedef struct { char c; long double x; } __Pyx_st_longdouble; -typedef struct { char c; void *x; } __Pyx_st_void_p; -#ifdef HAVE_LONG_LONG -typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; #endif -static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { - switch (ch) { - case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; - case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); - case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); - case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); -#ifdef HAVE_LONG_LONG - case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); + +/* GetException */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #endif - case 'f': return sizeof(__Pyx_st_float) - sizeof(float); - case 'd': return sizeof(__Pyx_st_double) - sizeof(double); - case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); - case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); - default: - __Pyx_BufFmt_RaiseUnexpectedChar(ch); - return 0; - } -} -/* These are for computing the padding at the end of the struct to align - on the first member of the struct. This will probably the same as above, - but we don't have any guarantees. - */ -typedef struct { short x; char c; } __Pyx_pad_short; -typedef struct { int x; char c; } __Pyx_pad_int; -typedef struct { long x; char c; } __Pyx_pad_long; -typedef struct { float x; char c; } __Pyx_pad_float; -typedef struct { double x; char c; } __Pyx_pad_double; -typedef struct { long double x; char c; } __Pyx_pad_longdouble; -typedef struct { void *x; char c; } __Pyx_pad_void_p; -#ifdef HAVE_LONG_LONG -typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; +{ + PyObject *local_type, *local_value, *local_tb; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); #endif -static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { - switch (ch) { - case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; - case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); - case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); - case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); -#ifdef HAVE_LONG_LONG - case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) #endif - case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); - case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); - case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); - case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); - default: - __Pyx_BufFmt_RaiseUnexpectedChar(ch); - return 0; - } -} -static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { - switch (ch) { - case 'c': - return 'H'; - case 'b': case 'h': case 'i': - case 'l': case 'q': case 's': case 'p': - return 'I'; - case 'B': case 'H': case 'I': case 'L': case 'Q': - return 'U'; - case 'f': case 'd': case 'g': - return (is_complex ? 'C' : 'R'); - case 'O': - return 'O'; - case 'P': - return 'P'; - default: { - __Pyx_BufFmt_RaiseUnexpectedChar(ch); - return 0; + goto bad; + #if PY_MAJOR_VERSION >= 3 + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; } - } -} -static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { - if (ctx->head == NULL || ctx->head->field == &ctx->root) { - const char* expected; - const char* quote; - if (ctx->head == NULL) { - expected = "end"; - quote = ""; - } else { - expected = ctx->head->field->type->name; - quote = "'"; + #endif + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if CYTHON_USE_EXC_INFO_STACK + { + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = local_type; + exc_info->exc_value = local_value; + exc_info->exc_traceback = local_tb; } - PyErr_Format(PyExc_ValueError, - "Buffer dtype mismatch, expected %s%s%s but got %s", - quote, expected, quote, - __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); - } else { - __Pyx_StructField* field = ctx->head->field; - __Pyx_StructField* parent = (ctx->head - 1)->field; - PyErr_Format(PyExc_ValueError, - "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", - field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), - parent->type->name, field->name); - } + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; } -static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { - char group; - size_t size, offset, arraysize = 1; - if (ctx->enc_type == 0) return 0; - if (ctx->head->field->type->arraysize[0]) { - int i, ndim = 0; - if (ctx->enc_type == 's' || ctx->enc_type == 'p') { - ctx->is_valid_array = ctx->head->field->type->ndim == 1; - ndim = 1; - if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { - PyErr_Format(PyExc_ValueError, - "Expected a dimension of size %zu, got %zu", - ctx->head->field->type->arraysize[0], ctx->enc_count); - return -1; - } + +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; } - if (!ctx->is_valid_array) { - PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", - ctx->head->field->type->ndim, ndim); - return -1; + else if (exact) { + #if PY_MAJOR_VERSION == 2 + if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif } - for (i = 0; i < ctx->head->field->type->ndim; i++) { - arraysize *= ctx->head->field->type->arraysize[i]; + else { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; } - ctx->is_valid_array = 0; - ctx->enc_count = 1; - } - group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); - do { - __Pyx_StructField* field = ctx->head->field; - __Pyx_TypeInfo* type = field->type; - if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { - size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); + return 0; +} + +/* BytesEquals */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result; +#if CYTHON_USE_UNICODE_INTERNALS + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + return (equals == Py_NE); + } +#endif + result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); } else { - size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); - } - if (ctx->enc_packmode == '@') { - size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); - size_t align_mod_offset; - if (align_at == 0) return -1; - align_mod_offset = ctx->fmt_offset % align_at; - if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; - if (ctx->struct_alignment == 0) - ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, - ctx->is_complex); + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; } - if (type->size != size || type->typegroup != group) { - if (type->typegroup == 'C' && type->fields != NULL) { - size_t parent_offset = ctx->head->parent_offset + field->offset; - ++ctx->head; - ctx->head->field = type->fields; - ctx->head->parent_offset = parent_offset; - continue; - } - if ((type->typegroup == 'H' || group == 'H') && type->size == size) { - } else { - __Pyx_BufFmt_RaiseExpected(ctx); - return -1; - } +#endif +} + +/* UnicodeEquals */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY + return PyObject_RichCompareBool(s1, s2, equals); +#else +#if PY_MAJOR_VERSION < 3 + PyObject* owned_ref = NULL; +#endif + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + goto return_eq; } - offset = ctx->head->parent_offset + field->offset; - if (ctx->fmt_offset != offset) { - PyErr_Format(PyExc_ValueError, - "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", - (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); - return -1; - } - ctx->fmt_offset += size; - if (arraysize) - ctx->fmt_offset += (arraysize - 1) * size; - --ctx->enc_count; - while (1) { - if (field == &ctx->root) { - ctx->head = NULL; - if (ctx->enc_count != 0) { - __Pyx_BufFmt_RaiseExpected(ctx); - return -1; - } - break; - } - ctx->head->field = ++field; - if (field->type == NULL) { - --ctx->head; - field = ctx->head->field; - continue; - } else if (field->type->typegroup == 'S') { - size_t parent_offset = ctx->head->parent_offset + field->offset; - if (field->type->fields->type == NULL) continue; - field = field->type->fields; - ++ctx->head; - ctx->head->field = field; - ctx->head->parent_offset = parent_offset; - break; - } else { - break; - } - } - } while (ctx->enc_count); - ctx->enc_type = 0; - ctx->is_complex = 0; - return 0; -} -static PyObject * -__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) -{ - const char *ts = *tsp; - int i = 0, number; - int ndim = ctx->head->field->type->ndim; -; - ++ts; - if (ctx->new_count != 1) { - PyErr_SetString(PyExc_ValueError, - "Cannot handle repeated arrays in format string"); - return NULL; - } - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; - while (*ts && *ts != ')') { - switch (*ts) { - case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; - default: break; - } - number = __Pyx_BufFmt_ExpectNumber(&ts); - if (number == -1) return NULL; - if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) - return PyErr_Format(PyExc_ValueError, - "Expected a dimension of size %zu, got %d", - ctx->head->field->type->arraysize[i], number); - if (*ts != ',' && *ts != ')') - return PyErr_Format(PyExc_ValueError, - "Expected a comma in format string, got '%c'", *ts); - if (*ts == ',') ts++; - i++; - } - if (i != ndim) - return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", - ctx->head->field->type->ndim, i); - if (!*ts) { - PyErr_SetString(PyExc_ValueError, - "Unexpected end of format string, expected ')'"); - return NULL; - } - ctx->is_valid_array = 1; - ctx->new_count = 1; - *tsp = ++ts; - return Py_None; -} -static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { - int got_Z = 0; - while (1) { - switch(*ts) { - case 0: - if (ctx->enc_type != 0 && ctx->head == NULL) { - __Pyx_BufFmt_RaiseExpected(ctx); - return NULL; - } - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; - if (ctx->head != NULL) { - __Pyx_BufFmt_RaiseExpected(ctx); - return NULL; - } - return ts; - case ' ': - case '\r': - case '\n': - ++ts; - break; - case '<': - if (!__Pyx_Is_Little_Endian()) { - PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); - return NULL; - } - ctx->new_packmode = '='; - ++ts; - break; - case '>': - case '!': - if (__Pyx_Is_Little_Endian()) { - PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); - return NULL; - } - ctx->new_packmode = '='; - ++ts; - break; - case '=': - case '@': - case '^': - ctx->new_packmode = *ts++; - break; - case 'T': - { - const char* ts_after_sub; - size_t i, struct_count = ctx->new_count; - size_t struct_alignment = ctx->struct_alignment; - ctx->new_count = 1; - ++ts; - if (*ts != '{') { - PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); - return NULL; - } - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; - ctx->enc_type = 0; - ctx->enc_count = 0; - ctx->struct_alignment = 0; - ++ts; - ts_after_sub = ts; - for (i = 0; i != struct_count; ++i) { - ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); - if (!ts_after_sub) return NULL; - } - ts = ts_after_sub; - if (struct_alignment) ctx->struct_alignment = struct_alignment; - } - break; - case '}': - { - size_t alignment = ctx->struct_alignment; - ++ts; - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; - ctx->enc_type = 0; - if (alignment && ctx->fmt_offset % alignment) { - ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); - } - } - return ts; - case 'x': - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; - ctx->fmt_offset += ctx->new_count; - ctx->new_count = 1; - ctx->enc_count = 0; - ctx->enc_type = 0; - ctx->enc_packmode = ctx->new_packmode; - ++ts; - break; - case 'Z': - got_Z = 1; - ++ts; - if (*ts != 'f' && *ts != 'd' && *ts != 'g') { - __Pyx_BufFmt_RaiseUnexpectedChar('Z'); - return NULL; - } - CYTHON_FALLTHROUGH; - case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': - case 'l': case 'L': case 'q': case 'Q': - case 'f': case 'd': case 'g': - case 'O': case 'p': - if (ctx->enc_type == *ts && got_Z == ctx->is_complex && - ctx->enc_packmode == ctx->new_packmode) { - ctx->enc_count += ctx->new_count; - ctx->new_count = 1; - got_Z = 0; - ++ts; - break; - } - CYTHON_FALLTHROUGH; - case 's': - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; - ctx->enc_count = ctx->new_count; - ctx->enc_packmode = ctx->new_packmode; - ctx->enc_type = *ts; - ctx->is_complex = got_Z; - ++ts; - ctx->new_count = 1; - got_Z = 0; - break; - case ':': - ++ts; - while(*ts != ':') ++ts; - ++ts; - break; - case '(': - if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; - break; - default: - { - int number = __Pyx_BufFmt_ExpectNumber(&ts); - if (number == -1) return NULL; - ctx->new_count = (size_t)number; - } - } - } -} - -/* BufferGetAndValidate */ - static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { - if (unlikely(info->buf == NULL)) return; - if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; - __Pyx_ReleaseBuffer(info); -} -static void __Pyx_ZeroBuffer(Py_buffer* buf) { - buf->buf = NULL; - buf->obj = NULL; - buf->strides = __Pyx_zeros; - buf->shape = __Pyx_zeros; - buf->suboffsets = __Pyx_minusones; -} -static int __Pyx__GetBufferAndValidate( - Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, - int nd, int cast, __Pyx_BufFmt_StackElem* stack) -{ - buf->buf = NULL; - if (unlikely(__Pyx_GetBuffer(obj, buf, flags) == -1)) { - __Pyx_ZeroBuffer(buf); - return -1; - } - if (unlikely(buf->ndim != nd)) { - PyErr_Format(PyExc_ValueError, - "Buffer has wrong number of dimensions (expected %d, got %d)", - nd, buf->ndim); - goto fail; - } - if (!cast) { - __Pyx_BufFmt_Context ctx; - __Pyx_BufFmt_Init(&ctx, stack, dtype); - if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; - } - if (unlikely((size_t)buf->itemsize != dtype->size)) { - PyErr_Format(PyExc_ValueError, - "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", - buf->itemsize, (buf->itemsize > 1) ? "s" : "", - dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); - goto fail; - } - if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; - return 0; -fail:; - __Pyx_SafeReleaseBuffer(buf); - return -1; -} - -/* RaiseException */ - #if PY_MAJOR_VERSION < 3 -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, - CYTHON_UNUSED PyObject *cause) { - __Pyx_PyThreadState_declare - Py_XINCREF(type); - if (!value || value == Py_None) - value = NULL; - else - Py_INCREF(value); - if (!tb || tb == Py_None) - tb = NULL; - else { - Py_INCREF(tb); - if (!PyTraceBack_Check(tb)) { - PyErr_SetString(PyExc_TypeError, - "raise: arg 3 must be a traceback or None"); - goto raise_error; - } - } - if (PyType_Check(type)) { -#if CYTHON_COMPILING_IN_PYPY - if (!value) { - Py_INCREF(Py_None); - value = Py_None; - } -#endif - PyErr_NormalizeException(&type, &value, &tb); - } else { - if (value) { - PyErr_SetString(PyExc_TypeError, - "instance exception may not have a separate value"); - goto raise_error; - } - value = type; - type = (PyObject*) Py_TYPE(type); - Py_INCREF(type); - if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { - PyErr_SetString(PyExc_TypeError, - "raise: exception class must be a subclass of BaseException"); - goto raise_error; - } - } - __Pyx_PyThreadState_assign - __Pyx_ErrRestore(type, value, tb); - return; -raise_error: - Py_XDECREF(value); - Py_XDECREF(type); - Py_XDECREF(tb); - return; -} -#else -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { - PyObject* owned_instance = NULL; - if (tb == Py_None) { - tb = 0; - } else if (tb && !PyTraceBack_Check(tb)) { - PyErr_SetString(PyExc_TypeError, - "raise: arg 3 must be a traceback or None"); - goto bad; - } - if (value == Py_None) - value = 0; - if (PyExceptionInstance_Check(type)) { - if (value) { - PyErr_SetString(PyExc_TypeError, - "instance exception may not have a separate value"); - goto bad; - } - value = type; - type = (PyObject*) Py_TYPE(value); - } else if (PyExceptionClass_Check(type)) { - PyObject *instance_class = NULL; - if (value && PyExceptionInstance_Check(value)) { - instance_class = (PyObject*) Py_TYPE(value); - if (instance_class != type) { - int is_subclass = PyObject_IsSubclass(instance_class, type); - if (!is_subclass) { - instance_class = NULL; - } else if (unlikely(is_subclass == -1)) { - goto bad; - } else { - type = instance_class; - } - } - } - if (!instance_class) { - PyObject *args; - if (!value) - args = PyTuple_New(0); - else if (PyTuple_Check(value)) { - Py_INCREF(value); - args = value; - } else - args = PyTuple_Pack(1, value); - if (!args) - goto bad; - owned_instance = PyObject_Call(type, args, NULL); - Py_DECREF(args); - if (!owned_instance) - goto bad; - value = owned_instance; - if (!PyExceptionInstance_Check(value)) { - PyErr_Format(PyExc_TypeError, - "calling %R should have returned an instance of " - "BaseException, not %R", - type, Py_TYPE(value)); - goto bad; - } - } - } else { - PyErr_SetString(PyExc_TypeError, - "raise: exception class must be a subclass of BaseException"); - goto bad; - } - if (cause) { - PyObject *fixed_cause; - if (cause == Py_None) { - fixed_cause = NULL; - } else if (PyExceptionClass_Check(cause)) { - fixed_cause = PyObject_CallObject(cause, NULL); - if (fixed_cause == NULL) - goto bad; - } else if (PyExceptionInstance_Check(cause)) { - fixed_cause = cause; - Py_INCREF(fixed_cause); - } else { - PyErr_SetString(PyExc_TypeError, - "exception causes must derive from " - "BaseException"); - goto bad; - } - PyException_SetCause(value, fixed_cause); - } - PyErr_SetObject(type, value); - if (tb) { -#if CYTHON_COMPILING_IN_PYPY - PyObject *tmp_type, *tmp_value, *tmp_tb; - PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); - Py_INCREF(tb); - PyErr_Restore(tmp_type, tmp_value, tb); - Py_XDECREF(tmp_tb); -#else - PyThreadState *tstate = __Pyx_PyThreadState_Current; - PyObject* tmp_tb = tstate->curexc_traceback; - if (tb != tmp_tb) { - Py_INCREF(tb); - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_tb); - } -#endif - } -bad: - Py_XDECREF(owned_instance); - return; -} -#endif - -/* DictGetItem */ - #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY -static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { - PyObject *value; - value = PyDict_GetItemWithError(d, key); - if (unlikely(!value)) { - if (!PyErr_Occurred()) { - if (unlikely(PyTuple_Check(key))) { - PyObject* args = PyTuple_Pack(1, key); - if (likely(args)) { - PyErr_SetObject(PyExc_KeyError, args); - Py_DECREF(args); - } - } else { - PyErr_SetObject(PyExc_KeyError, key); - } - } - return NULL; - } - Py_INCREF(value); - return value; -} -#endif - -/* RaiseTooManyValuesToUnpack */ - static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { - PyErr_Format(PyExc_ValueError, - "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); -} - -/* RaiseNeedMoreValuesToUnpack */ - static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { - PyErr_Format(PyExc_ValueError, - "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", - index, (index == 1) ? "" : "s"); -} - -/* RaiseNoneIterError */ - static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); -} - -/* GetTopmostException */ - #if CYTHON_USE_EXC_INFO_STACK -static _PyErr_StackItem * -__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) -{ - _PyErr_StackItem *exc_info = tstate->exc_info; - while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && - exc_info->previous_item != NULL) - { - exc_info = exc_info->previous_item; - } - return exc_info; -} -#endif - -/* SaveResetException */ - #if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - #if CYTHON_USE_EXC_INFO_STACK - _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); - *type = exc_info->exc_type; - *value = exc_info->exc_value; - *tb = exc_info->exc_traceback; - #else - *type = tstate->exc_type; - *value = tstate->exc_value; - *tb = tstate->exc_traceback; - #endif - Py_XINCREF(*type); - Py_XINCREF(*value); - Py_XINCREF(*tb); -} -static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - #if CYTHON_USE_EXC_INFO_STACK - _PyErr_StackItem *exc_info = tstate->exc_info; - tmp_type = exc_info->exc_type; - tmp_value = exc_info->exc_value; - tmp_tb = exc_info->exc_traceback; - exc_info->exc_type = type; - exc_info->exc_value = value; - exc_info->exc_traceback = tb; - #else - tmp_type = tstate->exc_type; - tmp_value = tstate->exc_value; - tmp_tb = tstate->exc_traceback; - tstate->exc_type = type; - tstate->exc_value = value; - tstate->exc_traceback = tb; - #endif - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); -} -#endif - -/* PyErrExceptionMatches */ - #if CYTHON_FAST_THREAD_STATE -static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(tuple); -#if PY_MAJOR_VERSION >= 3 - for (i=0; icurexc_type; - if (exc_type == err) return 1; - if (unlikely(!exc_type)) return 0; - if (unlikely(PyTuple_Check(err))) - return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); - return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); -} -#endif - -/* GetException */ - #if CYTHON_FAST_THREAD_STATE -static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) -#else -static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) -#endif -{ - PyObject *local_type, *local_value, *local_tb; -#if CYTHON_FAST_THREAD_STATE - PyObject *tmp_type, *tmp_value, *tmp_tb; - local_type = tstate->curexc_type; - local_value = tstate->curexc_value; - local_tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; -#else - PyErr_Fetch(&local_type, &local_value, &local_tb); -#endif - PyErr_NormalizeException(&local_type, &local_value, &local_tb); -#if CYTHON_FAST_THREAD_STATE - if (unlikely(tstate->curexc_type)) -#else - if (unlikely(PyErr_Occurred())) -#endif - goto bad; - #if PY_MAJOR_VERSION >= 3 - if (local_tb) { - if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) - goto bad; - } - #endif - Py_XINCREF(local_tb); - Py_XINCREF(local_type); - Py_XINCREF(local_value); - *type = local_type; - *value = local_value; - *tb = local_tb; -#if CYTHON_FAST_THREAD_STATE - #if CYTHON_USE_EXC_INFO_STACK - { - _PyErr_StackItem *exc_info = tstate->exc_info; - tmp_type = exc_info->exc_type; - tmp_value = exc_info->exc_value; - tmp_tb = exc_info->exc_traceback; - exc_info->exc_type = local_type; - exc_info->exc_value = local_value; - exc_info->exc_traceback = local_tb; - } - #else - tmp_type = tstate->exc_type; - tmp_value = tstate->exc_value; - tmp_tb = tstate->exc_traceback; - tstate->exc_type = local_type; - tstate->exc_value = local_value; - tstate->exc_traceback = local_tb; - #endif - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); -#else - PyErr_SetExcInfo(local_type, local_value, local_tb); -#endif - return 0; -bad: - *type = 0; - *value = 0; - *tb = 0; - Py_XDECREF(local_type); - Py_XDECREF(local_value); - Py_XDECREF(local_tb); - return -1; -} - -/* ArgTypeTest */ - static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) -{ - if (unlikely(!type)) { - PyErr_SetString(PyExc_SystemError, "Missing type object"); - return 0; - } - else if (exact) { - #if PY_MAJOR_VERSION == 2 - if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; - #endif - } - else { - if (likely(__Pyx_TypeCheck(obj, type))) return 1; - } - PyErr_Format(PyExc_TypeError, - "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", - name, type->tp_name, Py_TYPE(obj)->tp_name); - return 0; -} - -/* BytesEquals */ - static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { -#if CYTHON_COMPILING_IN_PYPY - return PyObject_RichCompareBool(s1, s2, equals); -#else - if (s1 == s2) { - return (equals == Py_EQ); - } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { - const char *ps1, *ps2; - Py_ssize_t length = PyBytes_GET_SIZE(s1); - if (length != PyBytes_GET_SIZE(s2)) - return (equals == Py_NE); - ps1 = PyBytes_AS_STRING(s1); - ps2 = PyBytes_AS_STRING(s2); - if (ps1[0] != ps2[0]) { - return (equals == Py_NE); - } else if (length == 1) { - return (equals == Py_EQ); - } else { - int result; -#if CYTHON_USE_UNICODE_INTERNALS - Py_hash_t hash1, hash2; - hash1 = ((PyBytesObject*)s1)->ob_shash; - hash2 = ((PyBytesObject*)s2)->ob_shash; - if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { - return (equals == Py_NE); - } -#endif - result = memcmp(ps1, ps2, (size_t)length); - return (equals == Py_EQ) ? (result == 0) : (result != 0); - } - } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { - return (equals == Py_NE); - } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { - return (equals == Py_NE); - } else { - int result; - PyObject* py_result = PyObject_RichCompare(s1, s2, equals); - if (!py_result) - return -1; - result = __Pyx_PyObject_IsTrue(py_result); - Py_DECREF(py_result); - return result; - } -#endif -} - -/* UnicodeEquals */ - static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { -#if CYTHON_COMPILING_IN_PYPY - return PyObject_RichCompareBool(s1, s2, equals); -#else -#if PY_MAJOR_VERSION < 3 - PyObject* owned_ref = NULL; -#endif - int s1_is_unicode, s2_is_unicode; - if (s1 == s2) { - goto return_eq; - } - s1_is_unicode = PyUnicode_CheckExact(s1); - s2_is_unicode = PyUnicode_CheckExact(s2); -#if PY_MAJOR_VERSION < 3 - if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { - owned_ref = PyUnicode_FromObject(s2); - if (unlikely(!owned_ref)) - return -1; - s2 = owned_ref; - s2_is_unicode = 1; - } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { - owned_ref = PyUnicode_FromObject(s1); - if (unlikely(!owned_ref)) - return -1; - s1 = owned_ref; - s1_is_unicode = 1; - } else if (((!s2_is_unicode) & (!s1_is_unicode))) { - return __Pyx_PyBytes_Equals(s1, s2, equals); + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); +#if PY_MAJOR_VERSION < 3 + if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { + owned_ref = PyUnicode_FromObject(s2); + if (unlikely(!owned_ref)) + return -1; + s2 = owned_ref; + s2_is_unicode = 1; + } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { + owned_ref = PyUnicode_FromObject(s1); + if (unlikely(!owned_ref)) + return -1; + s1 = owned_ref; + s1_is_unicode = 1; + } else if (((!s2_is_unicode) & (!s1_is_unicode))) { + return __Pyx_PyBytes_Equals(s1, s2, equals); } #endif if (s1_is_unicode & s2_is_unicode) { @@ -25842,7 +22770,7 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) } /* None */ - static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t a, Py_ssize_t b) { +static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t a, Py_ssize_t b) { Py_ssize_t q = a / b; Py_ssize_t r = a - q*b; q -= ((r != 0) & ((r ^ b) < 0)); @@ -25850,7 +22778,7 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) } /* GetAttr */ - static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { #if CYTHON_USE_TYPE_SLOTS #if PY_MAJOR_VERSION >= 3 if (likely(PyUnicode_Check(n))) @@ -25862,8 +22790,95 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) return PyObject_GetAttr(o, n); } +/* GetItemInt */ +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (!j) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyList_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyTuple_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { + PyObject *r = PyList_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return m->sq_item(o, i); + } + } +#else + if (is_list || PySequence_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} + /* ObjectGetItem */ - #if CYTHON_USE_TYPE_SLOTS +#if CYTHON_USE_TYPE_SLOTS static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) { PyObject *runerr; Py_ssize_t key_value; @@ -25892,7 +22907,7 @@ static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) { #endif /* decode_c_string */ - static CYTHON_INLINE PyObject* __Pyx_decode_c_string( +static CYTHON_INLINE PyObject* __Pyx_decode_c_string( const char* cstring, Py_ssize_t start, Py_ssize_t stop, const char* encoding, const char* errors, PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { @@ -25925,7 +22940,7 @@ static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) { } /* GetAttr3 */ - static PyObject *__Pyx_GetAttr3Default(PyObject *d) { +static PyObject *__Pyx_GetAttr3Default(PyObject *d) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) @@ -25940,7 +22955,7 @@ static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject } /* SwapException */ - #if CYTHON_FAST_THREAD_STATE +#if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK @@ -25975,7 +22990,7 @@ static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, #endif /* Import */ - static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; @@ -26040,7 +23055,7 @@ static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, } /* FastTypeChecks */ - #if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { a = a->tp_base; @@ -26140,7 +23155,7 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj #endif /* PyIntBinop */ - #if !CYTHON_COMPILING_IN_PYPY +#if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) { (void)inplace; (void)zerodivision_check; @@ -26264,12 +23279,12 @@ static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED #endif /* None */ - static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { +static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); } /* None */ - static CYTHON_INLINE long __Pyx_div_long(long a, long b) { +static CYTHON_INLINE long __Pyx_div_long(long a, long b) { long q = a / b; long r = a - q*b; q -= ((r != 0) & ((r ^ b) < 0)); @@ -26277,7 +23292,7 @@ static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED } /* ImportFrom */ - static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Format(PyExc_ImportError, @@ -26291,7 +23306,7 @@ static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED } /* HasAttr */ - static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { +static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { PyObject *r; if (unlikely(!__Pyx_PyBaseString_Check(n))) { PyErr_SetString(PyExc_TypeError, @@ -26309,7 +23324,7 @@ static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED } /* PyObject_GenericGetAttrNoDict */ - #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 @@ -26349,7 +23364,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj #endif /* PyObject_GenericGetAttr */ - #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { return PyObject_GenericGetAttr(obj, attr_name); @@ -26359,7 +23374,7 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam #endif /* SetVTable */ - static int __Pyx_SetVtable(PyObject *dict, void *vtable) { +static int __Pyx_SetVtable(PyObject *dict, void *vtable) { #if PY_VERSION_HEX >= 0x02070000 PyObject *ob = PyCapsule_New(vtable, 0, 0); #else @@ -26377,7 +23392,7 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam } /* SetupReduce */ - static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { +static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { int ret; PyObject *name_attr; name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name_2); @@ -26453,7 +23468,7 @@ static int __Pyx_setup_reduce(PyObject* type_obj) { } /* TypeImport */ - #ifndef __PYX_HAVE_RT_ImportType +#ifndef __PYX_HAVE_RT_ImportType #define __PYX_HAVE_RT_ImportType static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size) @@ -26513,1050 +23528,819 @@ static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, } #endif -/* FetchCommonType */ - static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { - PyObject* fake_module; - PyTypeObject* cached_type = NULL; - fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI); - if (!fake_module) return NULL; - Py_INCREF(fake_module); - cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name); - if (cached_type) { - if (!PyType_Check((PyObject*)cached_type)) { - PyErr_Format(PyExc_TypeError, - "Shared Cython type %.200s is not a type object", - type->tp_name); - goto bad; - } - if (cached_type->tp_basicsize != type->tp_basicsize) { - PyErr_Format(PyExc_TypeError, - "Shared Cython type %.200s has the wrong size, try recompiling", - type->tp_name); - goto bad; - } - } else { - if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; - PyErr_Clear(); - if (PyType_Ready(type) < 0) goto bad; - if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0) - goto bad; - Py_INCREF(type); - cached_type = type; - } -done: - Py_DECREF(fake_module); - return cached_type; -bad: - Py_XDECREF(cached_type); - cached_type = NULL; - goto done; -} - -/* CythonFunction */ - #include -static PyObject * -__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure) -{ - if (unlikely(op->func_doc == NULL)) { - if (op->func.m_ml->ml_doc) { -#if PY_MAJOR_VERSION >= 3 - op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc); -#else - op->func_doc = PyString_FromString(op->func.m_ml->ml_doc); -#endif - if (unlikely(op->func_doc == NULL)) - return NULL; - } else { - Py_INCREF(Py_None); - return Py_None; - } - } - Py_INCREF(op->func_doc); - return op->func_doc; -} -static int -__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) -{ - PyObject *tmp = op->func_doc; - if (value == NULL) { - value = Py_None; - } - Py_INCREF(value); - op->func_doc = value; - Py_XDECREF(tmp); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) -{ - if (unlikely(op->func_name == NULL)) { -#if PY_MAJOR_VERSION >= 3 - op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name); -#else - op->func_name = PyString_InternFromString(op->func.m_ml->ml_name); -#endif - if (unlikely(op->func_name == NULL)) - return NULL; - } - Py_INCREF(op->func_name); - return op->func_name; -} -static int -__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) -{ - PyObject *tmp; -#if PY_MAJOR_VERSION >= 3 - if (unlikely(value == NULL || !PyUnicode_Check(value))) -#else - if (unlikely(value == NULL || !PyString_Check(value))) +/* CLineInTraceback */ +#ifndef CYTHON_CLINE_IN_TRACEBACK +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { + PyObject *use_cline; + PyObject *ptype, *pvalue, *ptraceback; +#if CYTHON_COMPILING_IN_CPYTHON + PyObject **cython_runtime_dict; #endif - { - PyErr_SetString(PyExc_TypeError, - "__name__ must be set to a string object"); - return -1; + if (unlikely(!__pyx_cython_runtime)) { + return c_line; } - tmp = op->func_name; - Py_INCREF(value); - op->func_name = value; - Py_XDECREF(tmp); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) -{ - Py_INCREF(op->func_qualname); - return op->func_qualname; -} -static int -__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) -{ - PyObject *tmp; -#if PY_MAJOR_VERSION >= 3 - if (unlikely(value == NULL || !PyUnicode_Check(value))) -#else - if (unlikely(value == NULL || !PyString_Check(value))) + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); +#if CYTHON_COMPILING_IN_CPYTHON + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); + if (likely(cython_runtime_dict)) { + __PYX_PY_DICT_LOOKUP_IF_MODIFIED( + use_cline, *cython_runtime_dict, + __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) + } else #endif { - PyErr_SetString(PyExc_TypeError, - "__qualname__ must be set to a string object"); - return -1; + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + if (use_cline_obj) { + use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_DECREF(use_cline_obj); + } else { + PyErr_Clear(); + use_cline = NULL; + } } - tmp = op->func_qualname; - Py_INCREF(value); - op->func_qualname = value; - Py_XDECREF(tmp); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_self(__pyx_CyFunctionObject *m, CYTHON_UNUSED void *closure) -{ - PyObject *self; - self = m->func_closure; - if (self == NULL) - self = Py_None; - Py_INCREF(self); - return self; -} -static PyObject * -__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) -{ - if (unlikely(op->func_dict == NULL)) { - op->func_dict = PyDict_New(); - if (unlikely(op->func_dict == NULL)) - return NULL; + if (!use_cline) { + c_line = 0; + PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } - Py_INCREF(op->func_dict); - return op->func_dict; + else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + c_line = 0; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + return c_line; } -static int -__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context) -{ - PyObject *tmp; - if (unlikely(value == NULL)) { - PyErr_SetString(PyExc_TypeError, - "function's dictionary may not be deleted"); - return -1; +#endif + +/* CodeObjectCache */ +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; } - if (unlikely(!PyDict_Check(value))) { - PyErr_SetString(PyExc_TypeError, - "setting function's dictionary to a non-dict"); - return -1; + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } } - tmp = op->func_dict; - Py_INCREF(value); - op->func_dict = value; - Py_XDECREF(tmp); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) -{ - Py_INCREF(op->func_globals); - return op->func_globals; -} -static PyObject * -__Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) -{ - Py_INCREF(Py_None); - return Py_None; -} -static PyObject * -__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) -{ - PyObject* result = (op->func_code) ? op->func_code : Py_None; - Py_INCREF(result); - return result; -} -static int -__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { - int result = 0; - PyObject *res = op->defaults_getter((PyObject *) op); - if (unlikely(!res)) - return -1; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - op->defaults_tuple = PyTuple_GET_ITEM(res, 0); - Py_INCREF(op->defaults_tuple); - op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); - Py_INCREF(op->defaults_kwdict); - #else - op->defaults_tuple = PySequence_ITEM(res, 0); - if (unlikely(!op->defaults_tuple)) result = -1; - else { - op->defaults_kwdict = PySequence_ITEM(res, 1); - if (unlikely(!op->defaults_kwdict)) result = -1; + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; } - #endif - Py_DECREF(res); - return result; } -static int -__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) { - PyObject* tmp; - if (!value) { - value = Py_None; - } else if (value != Py_None && !PyTuple_Check(value)) { - PyErr_SetString(PyExc_TypeError, - "__defaults__ must be set to a tuple object"); - return -1; +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; } - Py_INCREF(value); - tmp = op->defaults_tuple; - op->defaults_tuple = value; - Py_XDECREF(tmp); - return 0; + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; } -static PyObject * -__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { - PyObject* result = op->defaults_tuple; - if (unlikely(!result)) { - if (op->defaults_getter) { - if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; - result = op->defaults_tuple; - } else { - result = Py_None; +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); } + return; } - Py_INCREF(result); - return result; -} -static int -__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) { - PyObject* tmp; - if (!value) { - value = Py_None; - } else if (value != Py_None && !PyDict_Check(value)) { - PyErr_SetString(PyExc_TypeError, - "__kwdefaults__ must be set to a dict object"); - return -1; + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; } - Py_INCREF(value); - tmp = op->defaults_kwdict; - op->defaults_kwdict = value; - Py_XDECREF(tmp); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { - PyObject* result = op->defaults_kwdict; - if (unlikely(!result)) { - if (op->defaults_getter) { - if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; - result = op->defaults_kwdict; - } else { - result = Py_None; + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; } - Py_INCREF(result); - return result; + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); } -static int -__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) { - PyObject* tmp; - if (!value || value == Py_None) { - value = NULL; - } else if (!PyDict_Check(value)) { - PyErr_SetString(PyExc_TypeError, - "__annotations__ must be set to a dict object"); - return -1; + +/* AddTraceback */ +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif } - Py_XINCREF(value); - tmp = op->func_annotations; - op->func_annotations = value; - Py_XDECREF(tmp); - return 0; + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; } -static PyObject * -__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) { - PyObject* result = op->func_annotations; - if (unlikely(!result)) { - result = PyDict_New(); - if (unlikely(!result)) return NULL; - op->func_annotations = result; +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + if (c_line) { + c_line = __Pyx_CLineForTraceback(tstate, c_line); } - Py_INCREF(result); - return result; + py_code = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); + } + py_frame = PyFrame_New( + tstate, /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); } -static PyGetSetDef __pyx_CyFunction_getsets[] = { - {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, - {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, - {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, - {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, - {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, - {(char *) "__self__", (getter)__Pyx_CyFunction_get_self, 0, 0, 0}, - {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, - {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, - {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, - {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, - {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, - {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, - {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, - {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, - {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, - {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, - {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, - {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, - {0, 0, 0, 0, 0} -}; -static PyMemberDef __pyx_CyFunction_members[] = { - {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), PY_WRITE_RESTRICTED, 0}, - {0, 0, 0, 0, 0} -}; -static PyObject * -__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args) -{ -#if PY_MAJOR_VERSION >= 3 - return PyUnicode_FromString(m->func.m_ml->ml_name); -#else - return PyString_FromString(m->func.m_ml->ml_name); -#endif + +#if PY_MAJOR_VERSION < 3 +static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { + if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); + if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags); + if (__Pyx_TypeCheck(obj, __pyx_array_type)) return __pyx_array_getbuffer(obj, view, flags); + if (__Pyx_TypeCheck(obj, __pyx_memoryview_type)) return __pyx_memoryview_getbuffer(obj, view, flags); + PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); + return -1; } -static PyMethodDef __pyx_CyFunction_methods[] = { - {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, - {0, 0, 0, 0} -}; -#if PY_VERSION_HEX < 0x030500A0 -#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) -#else -#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist) -#endif -static PyObject *__Pyx_CyFunction_New(PyTypeObject *type, PyMethodDef *ml, int flags, PyObject* qualname, - PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { - __pyx_CyFunctionObject *op = PyObject_GC_New(__pyx_CyFunctionObject, type); - if (op == NULL) - return NULL; - op->flags = flags; - __Pyx_CyFunction_weakreflist(op) = NULL; - op->func.m_ml = ml; - op->func.m_self = (PyObject *) op; - Py_XINCREF(closure); - op->func_closure = closure; - Py_XINCREF(module); - op->func.m_module = module; - op->func_dict = NULL; - op->func_name = NULL; - Py_INCREF(qualname); - op->func_qualname = qualname; - op->func_doc = NULL; - op->func_classobj = NULL; - op->func_globals = globals; - Py_INCREF(op->func_globals); - Py_XINCREF(code); - op->func_code = code; - op->defaults_pyobjects = 0; - op->defaults = NULL; - op->defaults_tuple = NULL; - op->defaults_kwdict = NULL; - op->defaults_getter = NULL; - op->func_annotations = NULL; - PyObject_GC_Track(op); - return (PyObject *) op; +static void __Pyx_ReleaseBuffer(Py_buffer *view) { + PyObject *obj = view->obj; + if (!obj) return; + if (PyObject_CheckBuffer(obj)) { + PyBuffer_Release(view); + return; + } + if ((0)) {} + else if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); + view->obj = NULL; + Py_DECREF(obj); } +#endif + + +/* MemviewSliceIsContig */ static int -__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +__pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim) { - Py_CLEAR(m->func_closure); - Py_CLEAR(m->func.m_module); - Py_CLEAR(m->func_dict); - Py_CLEAR(m->func_name); - Py_CLEAR(m->func_qualname); - Py_CLEAR(m->func_doc); - Py_CLEAR(m->func_globals); - Py_CLEAR(m->func_code); - Py_CLEAR(m->func_classobj); - Py_CLEAR(m->defaults_tuple); - Py_CLEAR(m->defaults_kwdict); - Py_CLEAR(m->func_annotations); - if (m->defaults) { - PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); - int i; - for (i = 0; i < m->defaults_pyobjects; i++) - Py_XDECREF(pydefaults[i]); - PyObject_Free(m->defaults); - m->defaults = NULL; + int i, index, step, start; + Py_ssize_t itemsize = mvs.memview->view.itemsize; + if (order == 'F') { + step = 1; + start = 0; + } else { + step = -1; + start = ndim - 1; } - return 0; -} -static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) -{ - if (__Pyx_CyFunction_weakreflist(m) != NULL) - PyObject_ClearWeakRefs((PyObject *) m); - __Pyx_CyFunction_clear(m); - PyObject_GC_Del(m); -} -static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) -{ - PyObject_GC_UnTrack(m); - __Pyx__CyFunction_dealloc(m); + for (i = 0; i < ndim; i++) { + index = start + step * i; + if (mvs.suboffsets[index] >= 0 || mvs.strides[index] != itemsize) + return 0; + itemsize *= mvs.shape[index]; + } + return 1; } -static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) + +/* OverlappingSlices */ +static void +__pyx_get_array_memory_extents(__Pyx_memviewslice *slice, + void **out_start, void **out_end, + int ndim, size_t itemsize) { - Py_VISIT(m->func_closure); - Py_VISIT(m->func.m_module); - Py_VISIT(m->func_dict); - Py_VISIT(m->func_name); - Py_VISIT(m->func_qualname); - Py_VISIT(m->func_doc); - Py_VISIT(m->func_globals); - Py_VISIT(m->func_code); - Py_VISIT(m->func_classobj); - Py_VISIT(m->defaults_tuple); - Py_VISIT(m->defaults_kwdict); - if (m->defaults) { - PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); - int i; - for (i = 0; i < m->defaults_pyobjects; i++) - Py_VISIT(pydefaults[i]); + char *start, *end; + int i; + start = end = slice->data; + for (i = 0; i < ndim; i++) { + Py_ssize_t stride = slice->strides[i]; + Py_ssize_t extent = slice->shape[i]; + if (extent == 0) { + *out_start = *out_end = start; + return; + } else { + if (stride > 0) + end += stride * (extent - 1); + else + start += stride * (extent - 1); + } } - return 0; + *out_start = start; + *out_end = end + itemsize; } -static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type) +static int +__pyx_slices_overlap(__Pyx_memviewslice *slice1, + __Pyx_memviewslice *slice2, + int ndim, size_t itemsize) { - __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; - if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) { - Py_INCREF(func); - return func; - } - if (m->flags & __Pyx_CYFUNCTION_CLASSMETHOD) { - if (type == NULL) - type = (PyObject *)(Py_TYPE(obj)); - return __Pyx_PyMethod_New(func, type, (PyObject *)(Py_TYPE(type))); - } - if (obj == Py_None) - obj = NULL; - return __Pyx_PyMethod_New(func, obj, type); -} -static PyObject* -__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) + void *start1, *end1, *start2, *end2; + __pyx_get_array_memory_extents(slice1, &start1, &end1, ndim, itemsize); + __pyx_get_array_memory_extents(slice2, &start2, &end2, ndim, itemsize); + return (start1 < end2) && (start2 < end1); +} + +/* Capsule */ +static CYTHON_INLINE PyObject * +__pyx_capsule_create(void *p, CYTHON_UNUSED const char *sig) { -#if PY_MAJOR_VERSION >= 3 - return PyUnicode_FromFormat("", - op->func_qualname, (void *)op); + PyObject *cobj; +#if PY_VERSION_HEX >= 0x02070000 + cobj = PyCapsule_New(p, sig, NULL); #else - return PyString_FromFormat("", - PyString_AsString(op->func_qualname), (void *)op); + cobj = PyCObject_FromVoidPtr(p, NULL); #endif + return cobj; } -static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { - PyCFunctionObject* f = (PyCFunctionObject*)func; - PyCFunction meth = f->m_ml->ml_meth; - Py_ssize_t size; - switch (f->m_ml->ml_flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { - case METH_VARARGS: - if (likely(kw == NULL || PyDict_Size(kw) == 0)) - return (*meth)(self, arg); - break; - case METH_VARARGS | METH_KEYWORDS: - return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw); - case METH_NOARGS: - if (likely(kw == NULL || PyDict_Size(kw) == 0)) { - size = PyTuple_GET_SIZE(arg); - if (likely(size == 0)) - return (*meth)(self, NULL); - PyErr_Format(PyExc_TypeError, - "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - f->m_ml->ml_name, size); - return NULL; - } - break; - case METH_O: - if (likely(kw == NULL || PyDict_Size(kw) == 0)) { - size = PyTuple_GET_SIZE(arg); - if (likely(size == 1)) { - PyObject *result, *arg0; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - arg0 = PyTuple_GET_ITEM(arg, 0); - #else - arg0 = PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; - #endif - result = (*meth)(self, arg0); - #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) - Py_DECREF(arg0); - #endif - return result; - } - PyErr_Format(PyExc_TypeError, - "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - f->m_ml->ml_name, size); - return NULL; - } - break; - default: - PyErr_SetString(PyExc_SystemError, "Bad call flags in " - "__Pyx_CyFunction_Call. METH_OLDARGS is no " - "longer supported!"); - return NULL; - } - PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", - f->m_ml->ml_name); - return NULL; + +/* IsLittleEndian */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) +{ + union { + uint32_t u32; + uint8_t u8[4]; + } S; + S.u32 = 0x01020304; + return S.u8[0] == 4; } -static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { - return __Pyx_CyFunction_CallMethod(func, ((PyCFunctionObject*)func)->m_self, arg, kw); + +/* BufferFormatCheck */ +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type) { + stack[0].field = &ctx->root; + stack[0].parent_offset = 0; + ctx->root.type = type; + ctx->root.name = "buffer dtype"; + ctx->root.offset = 0; + ctx->head = stack; + ctx->head->field = &ctx->root; + ctx->fmt_offset = 0; + ctx->head->parent_offset = 0; + ctx->new_packmode = '@'; + ctx->enc_packmode = '@'; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->is_complex = 0; + ctx->is_valid_array = 0; + ctx->struct_alignment = 0; + while (type->typegroup == 'S') { + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = 0; + type = type->fields->type; + } } -static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { - PyObject *result; - __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; - if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { - Py_ssize_t argc; - PyObject *new_args; - PyObject *self; - argc = PyTuple_GET_SIZE(args); - new_args = PyTuple_GetSlice(args, 1, argc); - if (unlikely(!new_args)) - return NULL; - self = PyTuple_GetItem(args, 0); - if (unlikely(!self)) { - Py_DECREF(new_args); - return NULL; - } - result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); - Py_DECREF(new_args); +static int __Pyx_BufFmt_ParseNumber(const char** ts) { + int count; + const char* t = *ts; + if (*t < '0' || *t > '9') { + return -1; } else { - result = __Pyx_CyFunction_Call(func, args, kw); - } - return result; -} -static PyTypeObject __pyx_CyFunctionType_type = { - PyVarObject_HEAD_INIT(0, 0) - "cython_function_or_method", - sizeof(__pyx_CyFunctionObject), - 0, - (destructor) __Pyx_CyFunction_dealloc, - 0, - 0, - 0, -#if PY_MAJOR_VERSION < 3 - 0, -#else - 0, -#endif - (reprfunc) __Pyx_CyFunction_repr, - 0, - 0, - 0, - 0, - __Pyx_CyFunction_CallAsMethod, - 0, - 0, - 0, - 0, - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, - 0, - (traverseproc) __Pyx_CyFunction_traverse, - (inquiry) __Pyx_CyFunction_clear, - 0, -#if PY_VERSION_HEX < 0x030500A0 - offsetof(__pyx_CyFunctionObject, func_weakreflist), -#else - offsetof(PyCFunctionObject, m_weakreflist), -#endif - 0, - 0, - __pyx_CyFunction_methods, - __pyx_CyFunction_members, - __pyx_CyFunction_getsets, - 0, - 0, - __Pyx_CyFunction_descr_get, - 0, - offsetof(__pyx_CyFunctionObject, func_dict), - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -#if PY_VERSION_HEX >= 0x030400a1 - 0, -#endif -#if PY_VERSION_HEX >= 0x030800b1 - 0, -#endif -}; -static int __pyx_CyFunction_init(void) { - __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); - if (unlikely(__pyx_CyFunctionType == NULL)) { - return -1; - } - return 0; -} -static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { - __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; - m->defaults = PyObject_Malloc(size); - if (unlikely(!m->defaults)) - return PyErr_NoMemory(); - memset(m->defaults, 0, size); - m->defaults_pyobjects = pyobjects; - return m->defaults; -} -static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { - __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; - m->defaults_tuple = tuple; - Py_INCREF(tuple); -} -static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { - __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; - m->defaults_kwdict = dict; - Py_INCREF(dict); -} -static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { - __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; - m->func_annotations = dict; - Py_INCREF(dict); -} - -/* CalculateMetaclass */ - static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) { - Py_ssize_t i, nbases = PyTuple_GET_SIZE(bases); - for (i=0; i < nbases; i++) { - PyTypeObject *tmptype; - PyObject *tmp = PyTuple_GET_ITEM(bases, i); - tmptype = Py_TYPE(tmp); -#if PY_MAJOR_VERSION < 3 - if (tmptype == &PyClass_Type) - continue; -#endif - if (!metaclass) { - metaclass = tmptype; - continue; - } - if (PyType_IsSubtype(metaclass, tmptype)) - continue; - if (PyType_IsSubtype(tmptype, metaclass)) { - metaclass = tmptype; - continue; + count = *t++ - '0'; + while (*t >= '0' && *t <= '9') { + count *= 10; + count += *t++ - '0'; } - PyErr_SetString(PyExc_TypeError, - "metaclass conflict: " - "the metaclass of a derived class " - "must be a (non-strict) subclass " - "of the metaclasses of all its bases"); - return NULL; - } - if (!metaclass) { -#if PY_MAJOR_VERSION < 3 - metaclass = &PyClass_Type; -#else - metaclass = &PyType_Type; -#endif } - Py_INCREF((PyObject*) metaclass); - return (PyObject*) metaclass; + *ts = t; + return count; } - -/* Py3ClassCreate */ - static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, - PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) { - PyObject *ns; - if (metaclass) { - PyObject *prep = __Pyx_PyObject_GetAttrStr(metaclass, __pyx_n_s_prepare); - if (prep) { - PyObject *pargs = PyTuple_Pack(2, name, bases); - if (unlikely(!pargs)) { - Py_DECREF(prep); - return NULL; - } - ns = PyObject_Call(prep, pargs, mkw); - Py_DECREF(prep); - Py_DECREF(pargs); - } else { - if (unlikely(!PyErr_ExceptionMatches(PyExc_AttributeError))) - return NULL; - PyErr_Clear(); - ns = PyDict_New(); - } - } else { - ns = PyDict_New(); - } - if (unlikely(!ns)) - return NULL; - if (unlikely(PyObject_SetItem(ns, __pyx_n_s_module, modname) < 0)) goto bad; - if (unlikely(PyObject_SetItem(ns, __pyx_n_s_qualname, qualname) < 0)) goto bad; - if (unlikely(doc && PyObject_SetItem(ns, __pyx_n_s_doc, doc) < 0)) goto bad; - return ns; -bad: - Py_DECREF(ns); - return NULL; +static int __Pyx_BufFmt_ExpectNumber(const char **ts) { + int number = __Pyx_BufFmt_ParseNumber(ts); + if (number == -1) + PyErr_Format(PyExc_ValueError,\ + "Does not understand character buffer dtype format string ('%c')", **ts); + return number; } -static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, - PyObject *dict, PyObject *mkw, - int calculate_metaclass, int allow_py2_metaclass) { - PyObject *result, *margs; - PyObject *owned_metaclass = NULL; - if (allow_py2_metaclass) { - owned_metaclass = PyObject_GetItem(dict, __pyx_n_s_metaclass); - if (owned_metaclass) { - metaclass = owned_metaclass; - } else if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) { - PyErr_Clear(); - } else { - return NULL; - } - } - if (calculate_metaclass && (!metaclass || PyType_Check(metaclass))) { - metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases); - Py_XDECREF(owned_metaclass); - if (unlikely(!metaclass)) - return NULL; - owned_metaclass = metaclass; - } - margs = PyTuple_Pack(3, name, bases, dict); - if (unlikely(!margs)) { - result = NULL; - } else { - result = PyObject_Call(metaclass, margs, mkw); - Py_DECREF(margs); - } - Py_XDECREF(owned_metaclass); - return result; +static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { + PyErr_Format(PyExc_ValueError, + "Unexpected format string character: '%c'", ch); } - -/* CLineInTraceback */ - #ifndef CYTHON_CLINE_IN_TRACEBACK -static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { - PyObject *use_cline; - PyObject *ptype, *pvalue, *ptraceback; -#if CYTHON_COMPILING_IN_CPYTHON - PyObject **cython_runtime_dict; -#endif - if (unlikely(!__pyx_cython_runtime)) { - return c_line; - } - __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); -#if CYTHON_COMPILING_IN_CPYTHON - cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); - if (likely(cython_runtime_dict)) { - __PYX_PY_DICT_LOOKUP_IF_MODIFIED( - use_cline, *cython_runtime_dict, - __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) - } else -#endif - { - PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); - if (use_cline_obj) { - use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; - Py_DECREF(use_cline_obj); - } else { - PyErr_Clear(); - use_cline = NULL; - } +static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { + switch (ch) { + case 'c': return "'char'"; + case 'b': return "'signed char'"; + case 'B': return "'unsigned char'"; + case 'h': return "'short'"; + case 'H': return "'unsigned short'"; + case 'i': return "'int'"; + case 'I': return "'unsigned int'"; + case 'l': return "'long'"; + case 'L': return "'unsigned long'"; + case 'q': return "'long long'"; + case 'Q': return "'unsigned long long'"; + case 'f': return (is_complex ? "'complex float'" : "'float'"); + case 'd': return (is_complex ? "'complex double'" : "'double'"); + case 'g': return (is_complex ? "'complex long double'" : "'long double'"); + case 'T': return "a struct"; + case 'O': return "Python object"; + case 'P': return "a pointer"; + case 's': case 'p': return "a string"; + case 0: return "end"; + default: return "unparseable format string"; + } +} +static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return 2; + case 'i': case 'I': case 'l': case 'L': return 4; + case 'q': case 'Q': return 8; + case 'f': return (is_complex ? 8 : 4); + case 'd': return (is_complex ? 16 : 8); + case 'g': { + PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); + return 0; } - if (!use_cline) { - c_line = 0; - PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); + case 'O': case 'P': return sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; } - else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { - c_line = 0; +} +static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { + switch (ch) { + case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(short); + case 'i': case 'I': return sizeof(int); + case 'l': case 'L': return sizeof(long); + #ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(PY_LONG_LONG); + #endif + case 'f': return sizeof(float) * (is_complex ? 2 : 1); + case 'd': return sizeof(double) * (is_complex ? 2 : 1); + case 'g': return sizeof(long double) * (is_complex ? 2 : 1); + case 'O': case 'P': return sizeof(void*); + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; } - __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); - return c_line; + } } +typedef struct { char c; short x; } __Pyx_st_short; +typedef struct { char c; int x; } __Pyx_st_int; +typedef struct { char c; long x; } __Pyx_st_long; +typedef struct { char c; float x; } __Pyx_st_float; +typedef struct { char c; double x; } __Pyx_st_double; +typedef struct { char c; long double x; } __Pyx_st_longdouble; +typedef struct { char c; void *x; } __Pyx_st_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; #endif - -/* CodeObjectCache */ - static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { - int start = 0, mid = 0, end = count - 1; - if (end >= 0 && code_line > entries[end].code_line) { - return count; - } - while (start < end) { - mid = start + (end - start) / 2; - if (code_line < entries[mid].code_line) { - end = mid; - } else if (code_line > entries[mid].code_line) { - start = mid + 1; - } else { - return mid; - } - } - if (code_line <= entries[mid].code_line) { - return mid; - } else { - return mid + 1; +static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_st_float) - sizeof(float); + case 'd': return sizeof(__Pyx_st_double) - sizeof(double); + case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; } } -static PyCodeObject *__pyx_find_code_object(int code_line) { - PyCodeObject* code_object; - int pos; - if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { - return NULL; +/* These are for computing the padding at the end of the struct to align + on the first member of the struct. This will probably the same as above, + but we don't have any guarantees. + */ +typedef struct { short x; char c; } __Pyx_pad_short; +typedef struct { int x; char c; } __Pyx_pad_int; +typedef struct { long x; char c; } __Pyx_pad_long; +typedef struct { float x; char c; } __Pyx_pad_float; +typedef struct { double x; char c; } __Pyx_pad_double; +typedef struct { long double x; char c; } __Pyx_pad_longdouble; +typedef struct { void *x; char c; } __Pyx_pad_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); + case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); + case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; } - pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); - if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { - return NULL; +} +static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { + switch (ch) { + case 'c': + return 'H'; + case 'b': case 'h': case 'i': + case 'l': case 'q': case 's': case 'p': + return 'I'; + case 'B': case 'H': case 'I': case 'L': case 'Q': + return 'U'; + case 'f': case 'd': case 'g': + return (is_complex ? 'C' : 'R'); + case 'O': + return 'O'; + case 'P': + return 'P'; + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; } - code_object = __pyx_code_cache.entries[pos].code_object; - Py_INCREF(code_object); - return code_object; + } } -static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { - int pos, i; - __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; - if (unlikely(!code_line)) { - return; +static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { + if (ctx->head == NULL || ctx->head->field == &ctx->root) { + const char* expected; + const char* quote; + if (ctx->head == NULL) { + expected = "end"; + quote = ""; + } else { + expected = ctx->head->field->type->name; + quote = "'"; } - if (unlikely(!entries)) { - entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); - if (likely(entries)) { - __pyx_code_cache.entries = entries; - __pyx_code_cache.max_count = 64; - __pyx_code_cache.count = 1; - entries[0].code_line = code_line; - entries[0].code_object = code_object; - Py_INCREF(code_object); + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected %s%s%s but got %s", + quote, expected, quote, + __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); + } else { + __Pyx_StructField* field = ctx->head->field; + __Pyx_StructField* parent = (ctx->head - 1)->field; + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", + field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), + parent->type->name, field->name); + } +} +static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { + char group; + size_t size, offset, arraysize = 1; + if (ctx->enc_type == 0) return 0; + if (ctx->head->field->type->arraysize[0]) { + int i, ndim = 0; + if (ctx->enc_type == 's' || ctx->enc_type == 'p') { + ctx->is_valid_array = ctx->head->field->type->ndim == 1; + ndim = 1; + if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { + PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %zu", + ctx->head->field->type->arraysize[0], ctx->enc_count); + return -1; } - return; } - pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); - if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { - PyCodeObject* tmp = entries[pos].code_object; - entries[pos].code_object = code_object; - Py_DECREF(tmp); - return; - } - if (__pyx_code_cache.count == __pyx_code_cache.max_count) { - int new_max = __pyx_code_cache.max_count + 64; - entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( - __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); - if (unlikely(!entries)) { - return; - } - __pyx_code_cache.entries = entries; - __pyx_code_cache.max_count = new_max; + if (!ctx->is_valid_array) { + PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", + ctx->head->field->type->ndim, ndim); + return -1; } - for (i=__pyx_code_cache.count; i>pos; i--) { - entries[i] = entries[i-1]; + for (i = 0; i < ctx->head->field->type->ndim; i++) { + arraysize *= ctx->head->field->type->arraysize[i]; } - entries[pos].code_line = code_line; - entries[pos].code_object = code_object; - __pyx_code_cache.count++; - Py_INCREF(code_object); -} - -/* AddTraceback */ - #include "compile.h" -#include "frameobject.h" -#include "traceback.h" -static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( - const char *funcname, int c_line, - int py_line, const char *filename) { - PyCodeObject *py_code = 0; - PyObject *py_srcfile = 0; - PyObject *py_funcname = 0; - #if PY_MAJOR_VERSION < 3 - py_srcfile = PyString_FromString(filename); - #else - py_srcfile = PyUnicode_FromString(filename); - #endif - if (!py_srcfile) goto bad; - if (c_line) { - #if PY_MAJOR_VERSION < 3 - py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); - #else - py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); - #endif + ctx->is_valid_array = 0; + ctx->enc_count = 1; + } + group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); + do { + __Pyx_StructField* field = ctx->head->field; + __Pyx_TypeInfo* type = field->type; + if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { + size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); + } else { + size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); } - else { - #if PY_MAJOR_VERSION < 3 - py_funcname = PyString_FromString(funcname); - #else - py_funcname = PyUnicode_FromString(funcname); - #endif + if (ctx->enc_packmode == '@') { + size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); + size_t align_mod_offset; + if (align_at == 0) return -1; + align_mod_offset = ctx->fmt_offset % align_at; + if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; + if (ctx->struct_alignment == 0) + ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, + ctx->is_complex); } - if (!py_funcname) goto bad; - py_code = __Pyx_PyCode_New( - 0, - 0, - 0, - 0, - 0, - __pyx_empty_bytes, /*PyObject *code,*/ - __pyx_empty_tuple, /*PyObject *consts,*/ - __pyx_empty_tuple, /*PyObject *names,*/ - __pyx_empty_tuple, /*PyObject *varnames,*/ - __pyx_empty_tuple, /*PyObject *freevars,*/ - __pyx_empty_tuple, /*PyObject *cellvars,*/ - py_srcfile, /*PyObject *filename,*/ - py_funcname, /*PyObject *name,*/ - py_line, - __pyx_empty_bytes /*PyObject *lnotab*/ - ); - Py_DECREF(py_srcfile); - Py_DECREF(py_funcname); - return py_code; -bad: - Py_XDECREF(py_srcfile); - Py_XDECREF(py_funcname); - return NULL; -} -static void __Pyx_AddTraceback(const char *funcname, int c_line, - int py_line, const char *filename) { - PyCodeObject *py_code = 0; - PyFrameObject *py_frame = 0; - PyThreadState *tstate = __Pyx_PyThreadState_Current; - if (c_line) { - c_line = __Pyx_CLineForTraceback(tstate, c_line); + if (type->size != size || type->typegroup != group) { + if (type->typegroup == 'C' && type->fields != NULL) { + size_t parent_offset = ctx->head->parent_offset + field->offset; + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = parent_offset; + continue; + } + if ((type->typegroup == 'H' || group == 'H') && type->size == size) { + } else { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } } - py_code = __pyx_find_code_object(c_line ? -c_line : py_line); - if (!py_code) { - py_code = __Pyx_CreateCodeObjectForTraceback( - funcname, c_line, py_line, filename); - if (!py_code) goto bad; - __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); + offset = ctx->head->parent_offset + field->offset; + if (ctx->fmt_offset != offset) { + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", + (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); + return -1; } - py_frame = PyFrame_New( - tstate, /*PyThreadState *tstate,*/ - py_code, /*PyCodeObject *code,*/ - __pyx_d, /*PyObject *globals,*/ - 0 /*PyObject *locals*/ - ); - if (!py_frame) goto bad; - __Pyx_PyFrame_SetLineNumber(py_frame, py_line); - PyTraceBack_Here(py_frame); -bad: - Py_XDECREF(py_code); - Py_XDECREF(py_frame); -} - -#if PY_MAJOR_VERSION < 3 -static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { - if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); - if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags); - if (__Pyx_TypeCheck(obj, __pyx_array_type)) return __pyx_array_getbuffer(obj, view, flags); - if (__Pyx_TypeCheck(obj, __pyx_memoryview_type)) return __pyx_memoryview_getbuffer(obj, view, flags); - PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); - return -1; -} -static void __Pyx_ReleaseBuffer(Py_buffer *view) { - PyObject *obj = view->obj; - if (!obj) return; - if (PyObject_CheckBuffer(obj)) { - PyBuffer_Release(view); - return; + ctx->fmt_offset += size; + if (arraysize) + ctx->fmt_offset += (arraysize - 1) * size; + --ctx->enc_count; + while (1) { + if (field == &ctx->root) { + ctx->head = NULL; + if (ctx->enc_count != 0) { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + break; + } + ctx->head->field = ++field; + if (field->type == NULL) { + --ctx->head; + field = ctx->head->field; + continue; + } else if (field->type->typegroup == 'S') { + size_t parent_offset = ctx->head->parent_offset + field->offset; + if (field->type->fields->type == NULL) continue; + field = field->type->fields; + ++ctx->head; + ctx->head->field = field; + ctx->head->parent_offset = parent_offset; + break; + } else { + break; + } } - if ((0)) {} - else if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); - view->obj = NULL; - Py_DECREF(obj); + } while (ctx->enc_count); + ctx->enc_type = 0; + ctx->is_complex = 0; + return 0; } -#endif - - - /* MemviewSliceIsContig */ - static int -__pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim) +static PyObject * +__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) { - int i, index, step, start; - Py_ssize_t itemsize = mvs.memview->view.itemsize; - if (order == 'F') { - step = 1; - start = 0; - } else { - step = -1; - start = ndim - 1; + const char *ts = *tsp; + int i = 0, number; + int ndim = ctx->head->field->type->ndim; +; + ++ts; + if (ctx->new_count != 1) { + PyErr_SetString(PyExc_ValueError, + "Cannot handle repeated arrays in format string"); + return NULL; } - for (i = 0; i < ndim; i++) { - index = start + step * i; - if (mvs.suboffsets[index] >= 0 || mvs.strides[index] != itemsize) - return 0; - itemsize *= mvs.shape[index]; + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + while (*ts && *ts != ')') { + switch (*ts) { + case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; + default: break; + } + number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) + return PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %d", + ctx->head->field->type->arraysize[i], number); + if (*ts != ',' && *ts != ')') + return PyErr_Format(PyExc_ValueError, + "Expected a comma in format string, got '%c'", *ts); + if (*ts == ',') ts++; + i++; } - return 1; + if (i != ndim) + return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", + ctx->head->field->type->ndim, i); + if (!*ts) { + PyErr_SetString(PyExc_ValueError, + "Unexpected end of format string, expected ')'"); + return NULL; + } + ctx->is_valid_array = 1; + ctx->new_count = 1; + *tsp = ++ts; + return Py_None; } - -/* OverlappingSlices */ - static void -__pyx_get_array_memory_extents(__Pyx_memviewslice *slice, - void **out_start, void **out_end, - int ndim, size_t itemsize) -{ - char *start, *end; - int i; - start = end = slice->data; - for (i = 0; i < ndim; i++) { - Py_ssize_t stride = slice->strides[i]; - Py_ssize_t extent = slice->shape[i]; - if (extent == 0) { - *out_start = *out_end = start; - return; - } else { - if (stride > 0) - end += stride * (extent - 1); - else - start += stride * (extent - 1); +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { + int got_Z = 0; + while (1) { + switch(*ts) { + case 0: + if (ctx->enc_type != 0 && ctx->head == NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + if (ctx->head != NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + return ts; + case ' ': + case '\r': + case '\n': + ++ts; + break; + case '<': + if (!__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '>': + case '!': + if (__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '=': + case '@': + case '^': + ctx->new_packmode = *ts++; + break; + case 'T': + { + const char* ts_after_sub; + size_t i, struct_count = ctx->new_count; + size_t struct_alignment = ctx->struct_alignment; + ctx->new_count = 1; + ++ts; + if (*ts != '{') { + PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + ctx->enc_count = 0; + ctx->struct_alignment = 0; + ++ts; + ts_after_sub = ts; + for (i = 0; i != struct_count; ++i) { + ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); + if (!ts_after_sub) return NULL; + } + ts = ts_after_sub; + if (struct_alignment) ctx->struct_alignment = struct_alignment; + } + break; + case '}': + { + size_t alignment = ctx->struct_alignment; + ++ts; + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + if (alignment && ctx->fmt_offset % alignment) { + ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); + } + } + return ts; + case 'x': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->fmt_offset += ctx->new_count; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->enc_packmode = ctx->new_packmode; + ++ts; + break; + case 'Z': + got_Z = 1; + ++ts; + if (*ts != 'f' && *ts != 'd' && *ts != 'g') { + __Pyx_BufFmt_RaiseUnexpectedChar('Z'); + return NULL; + } + CYTHON_FALLTHROUGH; + case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': + case 'l': case 'L': case 'q': case 'Q': + case 'f': case 'd': case 'g': + case 'O': case 'p': + if (ctx->enc_type == *ts && got_Z == ctx->is_complex && + ctx->enc_packmode == ctx->new_packmode) { + ctx->enc_count += ctx->new_count; + ctx->new_count = 1; + got_Z = 0; + ++ts; + break; + } + CYTHON_FALLTHROUGH; + case 's': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_count = ctx->new_count; + ctx->enc_packmode = ctx->new_packmode; + ctx->enc_type = *ts; + ctx->is_complex = got_Z; + ++ts; + ctx->new_count = 1; + got_Z = 0; + break; + case ':': + ++ts; + while(*ts != ':') ++ts; + ++ts; + break; + case '(': + if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; + break; + default: + { + int number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + ctx->new_count = (size_t)number; } } - *out_start = start; - *out_end = end + itemsize; -} -static int -__pyx_slices_overlap(__Pyx_memviewslice *slice1, - __Pyx_memviewslice *slice2, - int ndim, size_t itemsize) -{ - void *start1, *end1, *start2, *end2; - __pyx_get_array_memory_extents(slice1, &start1, &end1, ndim, itemsize); - __pyx_get_array_memory_extents(slice2, &start2, &end2, ndim, itemsize); - return (start1 < end2) && (start2 < end1); -} - -/* Capsule */ - static CYTHON_INLINE PyObject * -__pyx_capsule_create(void *p, CYTHON_UNUSED const char *sig) -{ - PyObject *cobj; -#if PY_VERSION_HEX >= 0x02070000 - cobj = PyCapsule_New(p, sig, NULL); -#else - cobj = PyCObject_FromVoidPtr(p, NULL); -#endif - return cobj; + } } /* TypeInfoCompare */ @@ -27982,37 +24766,6 @@ static CYTHON_INLINE int __pyx_memview_set_double(const char *itemp, PyObject *o return 1; } -/* CIntToPy */ - static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value) { - const unsigned int neg_one = (unsigned int) ((unsigned int) 0 - (unsigned int) 1), const_zero = (unsigned int) 0; - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(unsigned int) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(unsigned int) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(unsigned int) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif - } - } - { - int one = 1; int little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&value; - return _PyLong_FromByteArray(bytes, sizeof(unsigned int), - little, !is_unsigned); - } -} - /* Declarations */ #if CYTHON_CCOMPLEX #ifdef __cplusplus @@ -28610,195 +25363,6 @@ __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, return (int) -1; } -/* CIntFromPy */ - static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) { - const unsigned int neg_one = (unsigned int) ((unsigned int) 0 - (unsigned int) 1), const_zero = (unsigned int) 0; - const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if (sizeof(unsigned int) < sizeof(long)) { - __PYX_VERIFY_RETURN_INT(unsigned int, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (unsigned int) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { -#if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (unsigned int) 0; - case 1: __PYX_VERIFY_RETURN_INT(unsigned int, digit, digits[0]) - case 2: - if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(unsigned int) >= 2 * PyLong_SHIFT) { - return (unsigned int) (((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); - } - } - break; - case 3: - if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(unsigned int) >= 3 * PyLong_SHIFT) { - return (unsigned int) (((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); - } - } - break; - case 4: - if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(unsigned int) >= 4 * PyLong_SHIFT) { - return (unsigned int) (((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); - } - } - break; - } -#endif -#if CYTHON_COMPILING_IN_CPYTHON - if (unlikely(Py_SIZE(x) < 0)) { - goto raise_neg_overflow; - } -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (unsigned int) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#endif - if (sizeof(unsigned int) <= sizeof(unsigned long)) { - __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG - } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) { - __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif - } - } else { -#if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (unsigned int) 0; - case -1: __PYX_VERIFY_RETURN_INT(unsigned int, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(unsigned int, digit, +digits[0]) - case -2: - if (8 * sizeof(unsigned int) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { - return (unsigned int) (((unsigned int)-1)*(((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); - } - } - break; - case 2: - if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { - return (unsigned int) ((((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); - } - } - break; - case -3: - if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { - return (unsigned int) (((unsigned int)-1)*(((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); - } - } - break; - case 3: - if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { - return (unsigned int) ((((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); - } - } - break; - case -4: - if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) { - return (unsigned int) (((unsigned int)-1)*(((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); - } - } - break; - case 4: - if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) { - return (unsigned int) ((((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); - } - } - break; - } -#endif - if (sizeof(unsigned int) <= sizeof(long)) { - __PYX_VERIFY_RETURN_INT_EXC(unsigned int, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG - } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) { - __PYX_VERIFY_RETURN_INT_EXC(unsigned int, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif - } - } - { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else - unsigned int val; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } - #endif - if (likely(v)) { - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); - Py_DECREF(v); - if (likely(!ret)) - return val; - } -#endif - return (unsigned int) -1; - } - } else { - unsigned int val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (unsigned int) -1; - val = __Pyx_PyInt_As_unsigned_int(tmp); - Py_DECREF(tmp); - return val; - } -raise_overflow: - PyErr_SetString(PyExc_OverflowError, - "value too large to convert to unsigned int"); - return (unsigned int) -1; -raise_neg_overflow: - PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to unsigned int"); - return (unsigned int) -1; -} - /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; From 3e85bfd81487b7d6c7c2d33d24273833dc4582a8 Mon Sep 17 00:00:00 2001 From: jakobrunge Date: Fri, 14 May 2021 19:39:13 +0200 Subject: [PATCH 6/6] fixes on consistency of selected_links, random seed handling, distance correlation fixed GPDCtorch memory issue fixed --- README.md | 11 +- docs/_build/doctrees/environment.pickle | Bin 550700 -> 0 bytes docs/_build/doctrees/index.doctree | Bin 1229760 -> 0 bytes docs/_build/html/.buildinfo | 4 - docs/_build/html/.nojekyll | 0 ...62c26909b3e07ee8f5a6285b2563d69bc979ff.png | Bin 234 -> 0 bytes ...7c1e16a3a8a849bb8ffdcdbf86f65fd1f30438.png | Bin 230 -> 0 bytes ...5be7b4073a96376270557f8b487c5c5c38c42d.png | Bin 1209 -> 0 bytes ...535500db0213985b2cce27db85468b60985da0.png | Bin 299 -> 0 bytes ...f247b2a9ccd480e67621eb0d8a2d7a68a285bd.png | Bin 1718 -> 0 bytes ...2da53015c9d2f2c52257723f812bf512b6818e.png | Bin 247 -> 0 bytes ...5e577d6216dca3af7d87aa122a0b9b360d6cb3.png | Bin 237 -> 0 bytes ...582dab63cb7f6604f5bf70224030ad3411ae16.png | Bin 245 -> 0 bytes ...fc11b715eef698662fe1cc017d7ae2d53320d8.png | Bin 337 -> 0 bytes ...b09a13f97c2e89eb7687980b95a54839775fc8.png | Bin 540 -> 0 bytes ...6f7e256cbddeb81eee42e1efc348f3cb4ab5f8.png | Bin 237 -> 0 bytes ...f86ca220f43e569c6c7aefaf32742919222e6e.png | Bin 299 -> 0 bytes ...5aa019312e1bbc969deab8dca8b00f76025404.png | Bin 228 -> 0 bytes ...c62c02be8e341b7c32727e07b633086e70ba8a.png | Bin 268 -> 0 bytes ...668e57cb798f64d05820e7ec7ed4172b84a5ac.png | Bin 268 -> 0 bytes ...4b0728f25dd84a28e483181038a307ea6e483e.png | Bin 245 -> 0 bytes ...927294dd9fee97ab16ad5032baf0c08cdda4c2.png | Bin 686 -> 0 bytes ...858b59a7270363c15ca14b0d5fc56d33af1f8a.png | Bin 1718 -> 0 bytes ...ad79f4db8277d12b1a6f5def2d30122c89b9b0.png | Bin 258 -> 0 bytes ...9a2ee48b33448e80b97af9df9550828bdbfb59.png | Bin 249 -> 0 bytes ...0d6a1e190158ff6f076a7ea72e63b430fc90c1.png | Bin 524 -> 0 bytes ...55943f593856cb493f5504ec124338cb8c1fd2.png | Bin 816 -> 0 bytes ...3d970dfd19d2f6bfd5f3d3876a74d8816cbf70.png | Bin 1900 -> 0 bytes ...06eadc281dbd20de843b0034c8497320dae5cb.png | Bin 262 -> 0 bytes ...7d5fad862c9046d26e1a930f45a550c146d592.png | Bin 200 -> 0 bytes ...a339d4daf45a810dda332e3c80a0698e526e04.png | Bin 200 -> 0 bytes ...8ff70420eb65f959d5e2a9b244fc565d9ecbd6.png | Bin 441 -> 0 bytes ...8c562c89b6bf12d27dc6cdc9dc090f7bb78e9c.png | Bin 506 -> 0 bytes ...932505aadaa1eac6316ff09c2c3b101b068168.png | Bin 441 -> 0 bytes ...7eda4bf3d5ce33b6cc785cadfef79bb95741ca.png | Bin 417 -> 0 bytes ...5f63bd699c636142cee5bee90f58729f7248bf.png | Bin 1053 -> 0 bytes ...21e0b0899a0d2879d3b8019087fa630bab4ea2.png | Bin 221 -> 0 bytes ...e62736d8aa90101801d7a1416e97e921d1620f.png | Bin 229 -> 0 bytes ...852cea72eb5c4d0a45c0db08b49476f4404426.png | Bin 1324 -> 0 bytes ...6e3543dff2b2b07e3f3373aa7663c49a6afc5f.png | Bin 938 -> 0 bytes ...20e563212e11bf72de255ab82c2a3b97c1a7f5.png | Bin 232 -> 0 bytes ...9735c1db036ea36cd0aa25a3af4b2528ed3abe.png | Bin 476 -> 0 bytes ...b6e77cc610bf56f5c64cb6dcc6d6ee49f886f9.png | Bin 686 -> 0 bytes ...3d0c9264473a58cc3a769f99a662631131377c.png | Bin 262 -> 0 bytes ...7bb470119808e2db2879fc2b2526f467b7a40b.png | Bin 243 -> 0 bytes ...5b384bfd47bd6e8d707b3189aaab3a46c5ed04.png | Bin 1149 -> 0 bytes ...ce831f5eba0d0e0fcb0cced170b2926804500a.png | Bin 506 -> 0 bytes ...af0d4815e763eb90f0d5f1dc406f668c1e21db.png | Bin 234 -> 0 bytes ...8cf20679167faa272d77b997b9de818978cd4f.png | Bin 1213 -> 0 bytes ...7d234f4cec6974ce218fc2e975a486a7972dfd.png | Bin 228 -> 0 bytes ...efcfdee16eaaec575238e2e6df5f731c8609bf.png | Bin 1149 -> 0 bytes ...4b2d4b6659b86d3153d5510839dfb254dfc8a3.png | Bin 200 -> 0 bytes ...d9399f0e09f1b45c437879e8cf96af4735247d.png | Bin 635 -> 0 bytes ...f028ab2b20b895fa12d986e0d9f40f7b6e52d3.png | Bin 246 -> 0 bytes ...30132210b904754c9ab272b61cb527d12263ca.png | Bin 230 -> 0 bytes ...353382eebb42a8a9dec3a426d346d4842bd39d.png | Bin 430 -> 0 bytes ...7f8f771e36601a75e3520845155d09080f6281.png | Bin 476 -> 0 bytes ...3635874ee5c9865debbf9c8686e9367f2850e5.png | Bin 540 -> 0 bytes ...1718d730cd7b17532f760861e9659b68a65156.png | Bin 247 -> 0 bytes ...9afdaf786ce53318d75d81f050af8560822fcd.png | Bin 250 -> 0 bytes ...1900c45d0fc409a321b07099da1b7311e104c0.png | Bin 1134 -> 0 bytes ...2df33f46595ed60c51f255186ee346c1fcc0cb.png | Bin 1950 -> 0 bytes ...c245d487949782a89cab9ee83504a62fdc2337.png | Bin 249 -> 0 bytes ...b2457ac9d8995a4f34d57cadac7ecbbe58f3bd.png | Bin 246 -> 0 bytes ...b2d04d69b82c2288f5ef46664d548355e130af.png | Bin 250 -> 0 bytes ...07aa32325c7a6161c0cef04f9b702054873211.png | Bin 337 -> 0 bytes ...d0f97cd9bb4e6571e2689163f9f2989b304f55.png | Bin 229 -> 0 bytes ...ed4f54ee00448249d2df22ad67f3e281df085b.png | Bin 481 -> 0 bytes ...7734af70861b2bd4dedf5c41c9aad231466f84.png | Bin 232 -> 0 bytes ...26d17c031c4b264fb8f59f953381951cc2e9b4.png | Bin 1900 -> 0 bytes ...d56a5dd20011b190ba97d6f36d154e11c9035c.png | Bin 1950 -> 0 bytes ...43100cd0a02e1e5184694228a7ac41e19e8af2.png | Bin 417 -> 0 bytes ...ee85ac4d75924cdf4b18f5fb3b46550932fc26.png | Bin 222 -> 0 bytes ...3d34854a6f48587cf5b9a41df90ad1c5e332d6.png | Bin 1324 -> 0 bytes ...0deb143e5ac127f00bd248ee8001ecae572adc.png | Bin 200 -> 0 bytes ...3ea88dda29ab6daa19c839ff37b8115e0a10e1.png | Bin 430 -> 0 bytes ...fc28292267f066fee7718c64f4bbfece521f24.png | Bin 221 -> 0 bytes ...86de19dbb61c9a63584f6e4ddd6e92ef03d665.png | Bin 222 -> 0 bytes ...55092ec45224f09927d0ed9e6fcdfbddb67754.png | Bin 938 -> 0 bytes ...ea4b57a39788145fd98faa5d80911b52f3e435.png | Bin 1209 -> 0 bytes ...1ca2f34e7505e1a6ea382d2ac832ec9bba9d06.png | Bin 1322 -> 0 bytes ...38fa24f1c94891bd312012aab3f6673be3eb83.png | Bin 243 -> 0 bytes ...21460f581abe30cc7314e0377909d0fce94f18.png | Bin 1211 -> 0 bytes ...5f28dbcbec776fbe031f8ac923f83f9260bd8a.png | Bin 481 -> 0 bytes ...f7b4153a6590df59f8ed526be56220045b7f3b.png | Bin 258 -> 0 bytes docs/_build/html/_images/mci_schematic.png | Bin 61004 -> 0 bytes docs/_build/html/_modules/abc.html | 247 - docs/_build/html/_modules/index.html | 86 - .../_modules/tigramite/data_processing.html | 1512 --- .../tigramite/independence_tests.html | 2714 ---- .../tigramite/independence_tests/cmiknn.html | 404 - .../tigramite/independence_tests/cmisymb.html | 295 - .../independence_tests_base.html | 1087 -- .../oracle_conditional_independence.html | 845 -- .../tigramite/independence_tests/parcorr.html | 375 - .../html/_modules/tigramite/models.html | 1315 -- .../_build/html/_modules/tigramite/pcmci.html | 3852 ------ .../html/_modules/tigramite/plotting.html | 3230 ----- docs/_build/html/_sources/index.rst.txt | 141 - docs/_build/html/_static/ajax-loader.gif | Bin 673 -> 0 bytes docs/_build/html/_static/alabaster.css | 593 - docs/_build/html/_static/basic.css | 632 - docs/_build/html/_static/comment-bright.png | Bin 756 -> 0 bytes docs/_build/html/_static/comment-close.png | Bin 829 -> 0 bytes docs/_build/html/_static/comment.png | Bin 641 -> 0 bytes docs/_build/html/_static/contents.png | Bin 107 -> 0 bytes docs/_build/html/_static/doctools.js | 287 - .../html/_static/documentation_options.js | 9 - docs/_build/html/_static/down-pressed.png | Bin 222 -> 0 bytes docs/_build/html/_static/down.png | Bin 202 -> 0 bytes docs/_build/html/_static/file.png | Bin 286 -> 0 bytes docs/_build/html/_static/jquery-3.1.0.js | 10074 --------------- docs/_build/html/_static/jquery-3.2.1.js | 10253 ---------------- docs/_build/html/_static/jquery.js | 4 - docs/_build/html/_static/language_data.js | 297 - docs/_build/html/_static/minus.png | Bin 90 -> 0 bytes docs/_build/html/_static/navigation.png | Bin 120 -> 0 bytes docs/_build/html/_static/plus.png | Bin 90 -> 0 bytes docs/_build/html/_static/pygments.css | 65 - docs/_build/html/_static/searchtools.js | 758 -- docs/_build/html/_static/sphinxdoc.css | 345 - docs/_build/html/_static/underscore-1.3.1.js | 999 -- docs/_build/html/_static/underscore.js | 31 - docs/_build/html/_static/up-pressed.png | Bin 214 -> 0 bytes docs/_build/html/_static/up.png | Bin 203 -> 0 bytes docs/_build/html/_static/websupport.js | 808 -- docs/_build/html/genindex.html | 510 - docs/_build/html/index.html | 3361 ----- docs/_build/html/objects.inv | Bin 1234 -> 0 bytes docs/_build/html/py-modindex.html | 105 - docs/_build/html/search.html | 91 - docs/_build/html/searchindex.js | 1 - ...62c26909b3e07ee8f5a6285b2563d69bc979ff.png | Bin 234 -> 243 bytes ...7c1e16a3a8a849bb8ffdcdbf86f65fd1f30438.png | Bin 230 -> 229 bytes ...535500db0213985b2cce27db85468b60985da0.png | Bin 299 -> 295 bytes ...f247b2a9ccd480e67621eb0d8a2d7a68a285bd.png | Bin 1718 -> 1778 bytes ...fc11b715eef698662fe1cc017d7ae2d53320d8.png | Bin 337 -> 337 bytes ...2245485b3bea72829d6ce2616269810aabb84.png} | Bin ...6f7e256cbddeb81eee42e1efc348f3cb4ab5f8.png | Bin 237 -> 239 bytes ...6fe683041026ceda3edd2502ddad36ce781d8.png} | Bin ...a7c48fc45fc824d5f07fdd1436d87c9315666.png} | Bin ...4b0728f25dd84a28e483181038a307ea6e483e.png | Bin 245 -> 242 bytes ...927294dd9fee97ab16ad5032baf0c08cdda4c2.png | Bin 686 -> 720 bytes ...684bc8c0d47bdaf76d0ce45ae7d6da80e5857.png} | Bin ...ad79f4db8277d12b1a6f5def2d30122c89b9b0.png | Bin 258 -> 260 bytes ...9a2ee48b33448e80b97af9df9550828bdbfb59.png | Bin 249 -> 243 bytes ...3d970dfd19d2f6bfd5f3d3876a74d8816cbf70.png | Bin 1900 -> 1976 bytes ...7d5fad862c9046d26e1a930f45a550c146d592.png | Bin 200 -> 192 bytes ...8ff70420eb65f959d5e2a9b244fc565d9ecbd6.png | Bin 441 -> 445 bytes ...6b7e1c217e91ec77d6ca54757d39eb1214518.png} | Bin ...21e0b0899a0d2879d3b8019087fa630bab4ea2.png | Bin 221 -> 219 bytes ...e62736d8aa90101801d7a1416e97e921d1620f.png | Bin 229 -> 233 bytes ...852cea72eb5c4d0a45c0db08b49476f4404426.png | Bin 1324 -> 1380 bytes ...40e3c16ba83566dc457d7fdf79faab34797f6.png} | Bin ...20e563212e11bf72de255ab82c2a3b97c1a7f5.png | Bin 232 -> 234 bytes ...3d0c9264473a58cc3a769f99a662631131377c.png | Bin 262 -> 261 bytes ...7bb470119808e2db2879fc2b2526f467b7a40b.png | Bin 243 -> 254 bytes ...ce831f5eba0d0e0fcb0cced170b2926804500a.png | Bin 506 -> 517 bytes ...7d234f4cec6974ce218fc2e975a486a7972dfd.png | Bin 228 -> 228 bytes ...56d8d049e32afc3747b6113db8709327060e0.png} | Bin ...efcfdee16eaaec575238e2e6df5f731c8609bf.png | Bin 1149 -> 1175 bytes ...7f8f771e36601a75e3520845155d09080f6281.png | Bin 476 -> 499 bytes ...3635874ee5c9865debbf9c8686e9367f2850e5.png | Bin 540 -> 547 bytes ...1718d730cd7b17532f760861e9659b68a65156.png | Bin 247 -> 246 bytes ...b2457ac9d8995a4f34d57cadac7ecbbe58f3bd.png | Bin 246 -> 250 bytes ...b2d04d69b82c2288f5ef46664d548355e130af.png | Bin 250 -> 252 bytes ...d56a5dd20011b190ba97d6f36d154e11c9035c.png | Bin 1950 -> 2028 bytes ...43100cd0a02e1e5184694228a7ac41e19e8af2.png | Bin 417 -> 435 bytes ...0deb143e5ac127f00bd248ee8001ecae572adc.png | Bin 200 -> 200 bytes ...3ea88dda29ab6daa19c839ff37b8115e0a10e1.png | Bin 430 -> 440 bytes ...86de19dbb61c9a63584f6e4ddd6e92ef03d665.png | Bin 222 -> 229 bytes ...313ea5f5a28395ab1dcd07e1e29eeefa1bb75.png} | Bin ...5f28dbcbec776fbe031f8ac923f83f9260bd8a.png | Bin 481 -> 496 bytes docs/_modules/abc.html | 244 +- docs/_modules/index.html | 35 +- docs/_modules/tigramite/data_processing.html | 60 +- .../tigramite/independence_tests/cmiknn.html | 135 +- .../tigramite/independence_tests/cmisymb.html | 40 +- .../tigramite/independence_tests/gpdc.html | 142 +- .../independence_tests/gpdc_torch.html} | 463 +- .../independence_tests_base.html | 53 +- .../oracle_conditional_independence.html | 1249 +- .../tigramite/independence_tests/parcorr.html | 49 +- docs/_modules/tigramite/models.html | 255 +- docs/_modules/tigramite/pcmci.html | 120 +- docs/_modules/tigramite/plotting.html | 134 +- docs/_sources/index.rst.txt | 4 + docs/conf.py | 18 +- docs/genindex.html | 85 +- docs/index.html | 4660 ++++--- docs/index.rst | 4 + docs/objects.inv | Bin 1234 -> 1354 bytes docs/py-modindex.html | 34 +- docs/search.html | 31 +- docs/searchindex.js | 2 +- setup.py | 2 +- tigramite/independence_tests/gpdc.py | 3 - tigramite/independence_tests/gpdc_torch.py | 9 - tigramite/models.py | 10 +- 199 files changed, 5104 insertions(+), 48078 deletions(-) delete mode 100644 docs/_build/doctrees/environment.pickle delete mode 100644 docs/_build/doctrees/index.doctree delete mode 100644 docs/_build/html/.buildinfo delete mode 100644 docs/_build/html/.nojekyll delete mode 100644 docs/_build/html/_images/math/0062c26909b3e07ee8f5a6285b2563d69bc979ff.png delete mode 100644 docs/_build/html/_images/math/0b7c1e16a3a8a849bb8ffdcdbf86f65fd1f30438.png delete mode 100644 docs/_build/html/_images/math/115be7b4073a96376270557f8b487c5c5c38c42d.png delete mode 100644 docs/_build/html/_images/math/12535500db0213985b2cce27db85468b60985da0.png delete mode 100644 docs/_build/html/_images/math/14f247b2a9ccd480e67621eb0d8a2d7a68a285bd.png delete mode 100644 docs/_build/html/_images/math/1a2da53015c9d2f2c52257723f812bf512b6818e.png delete mode 100644 docs/_build/html/_images/math/1b5e577d6216dca3af7d87aa122a0b9b360d6cb3.png delete mode 100644 docs/_build/html/_images/math/20582dab63cb7f6604f5bf70224030ad3411ae16.png delete mode 100644 docs/_build/html/_images/math/21fc11b715eef698662fe1cc017d7ae2d53320d8.png delete mode 100644 docs/_build/html/_images/math/26b09a13f97c2e89eb7687980b95a54839775fc8.png delete mode 100644 docs/_build/html/_images/math/276f7e256cbddeb81eee42e1efc348f3cb4ab5f8.png delete mode 100644 docs/_build/html/_images/math/2bf86ca220f43e569c6c7aefaf32742919222e6e.png delete mode 100644 docs/_build/html/_images/math/2f5aa019312e1bbc969deab8dca8b00f76025404.png delete mode 100644 docs/_build/html/_images/math/2fc62c02be8e341b7c32727e07b633086e70ba8a.png delete mode 100644 docs/_build/html/_images/math/31668e57cb798f64d05820e7ec7ed4172b84a5ac.png delete mode 100644 docs/_build/html/_images/math/334b0728f25dd84a28e483181038a307ea6e483e.png delete mode 100644 docs/_build/html/_images/math/3d927294dd9fee97ab16ad5032baf0c08cdda4c2.png delete mode 100644 docs/_build/html/_images/math/42858b59a7270363c15ca14b0d5fc56d33af1f8a.png delete mode 100644 docs/_build/html/_images/math/44ad79f4db8277d12b1a6f5def2d30122c89b9b0.png delete mode 100644 docs/_build/html/_images/math/499a2ee48b33448e80b97af9df9550828bdbfb59.png delete mode 100644 docs/_build/html/_images/math/4c0d6a1e190158ff6f076a7ea72e63b430fc90c1.png delete mode 100644 docs/_build/html/_images/math/4f55943f593856cb493f5504ec124338cb8c1fd2.png delete mode 100644 docs/_build/html/_images/math/503d970dfd19d2f6bfd5f3d3876a74d8816cbf70.png delete mode 100644 docs/_build/html/_images/math/5406eadc281dbd20de843b0034c8497320dae5cb.png delete mode 100644 docs/_build/html/_images/math/557d5fad862c9046d26e1a930f45a550c146d592.png delete mode 100644 docs/_build/html/_images/math/5aa339d4daf45a810dda332e3c80a0698e526e04.png delete mode 100644 docs/_build/html/_images/math/5c8ff70420eb65f959d5e2a9b244fc565d9ecbd6.png delete mode 100644 docs/_build/html/_images/math/5f8c562c89b6bf12d27dc6cdc9dc090f7bb78e9c.png delete mode 100644 docs/_build/html/_images/math/64932505aadaa1eac6316ff09c2c3b101b068168.png delete mode 100644 docs/_build/html/_images/math/667eda4bf3d5ce33b6cc785cadfef79bb95741ca.png delete mode 100644 docs/_build/html/_images/math/6a5f63bd699c636142cee5bee90f58729f7248bf.png delete mode 100644 docs/_build/html/_images/math/6b21e0b0899a0d2879d3b8019087fa630bab4ea2.png delete mode 100644 docs/_build/html/_images/math/6de62736d8aa90101801d7a1416e97e921d1620f.png delete mode 100644 docs/_build/html/_images/math/70852cea72eb5c4d0a45c0db08b49476f4404426.png delete mode 100644 docs/_build/html/_images/math/736e3543dff2b2b07e3f3373aa7663c49a6afc5f.png delete mode 100644 docs/_build/html/_images/math/7720e563212e11bf72de255ab82c2a3b97c1a7f5.png delete mode 100644 docs/_build/html/_images/math/789735c1db036ea36cd0aa25a3af4b2528ed3abe.png delete mode 100644 docs/_build/html/_images/math/78b6e77cc610bf56f5c64cb6dcc6d6ee49f886f9.png delete mode 100644 docs/_build/html/_images/math/7a3d0c9264473a58cc3a769f99a662631131377c.png delete mode 100644 docs/_build/html/_images/math/7a7bb470119808e2db2879fc2b2526f467b7a40b.png delete mode 100644 docs/_build/html/_images/math/7b5b384bfd47bd6e8d707b3189aaab3a46c5ed04.png delete mode 100644 docs/_build/html/_images/math/7bce831f5eba0d0e0fcb0cced170b2926804500a.png delete mode 100644 docs/_build/html/_images/math/7daf0d4815e763eb90f0d5f1dc406f668c1e21db.png delete mode 100644 docs/_build/html/_images/math/848cf20679167faa272d77b997b9de818978cd4f.png delete mode 100644 docs/_build/html/_images/math/877d234f4cec6974ce218fc2e975a486a7972dfd.png delete mode 100644 docs/_build/html/_images/math/90efcfdee16eaaec575238e2e6df5f731c8609bf.png delete mode 100644 docs/_build/html/_images/math/914b2d4b6659b86d3153d5510839dfb254dfc8a3.png delete mode 100644 docs/_build/html/_images/math/91d9399f0e09f1b45c437879e8cf96af4735247d.png delete mode 100644 docs/_build/html/_images/math/95f028ab2b20b895fa12d986e0d9f40f7b6e52d3.png delete mode 100644 docs/_build/html/_images/math/9630132210b904754c9ab272b61cb527d12263ca.png delete mode 100644 docs/_build/html/_images/math/9c353382eebb42a8a9dec3a426d346d4842bd39d.png delete mode 100644 docs/_build/html/_images/math/9c7f8f771e36601a75e3520845155d09080f6281.png delete mode 100644 docs/_build/html/_images/math/a23635874ee5c9865debbf9c8686e9367f2850e5.png delete mode 100644 docs/_build/html/_images/math/ab1718d730cd7b17532f760861e9659b68a65156.png delete mode 100644 docs/_build/html/_images/math/ab9afdaf786ce53318d75d81f050af8560822fcd.png delete mode 100644 docs/_build/html/_images/math/ae1900c45d0fc409a321b07099da1b7311e104c0.png delete mode 100644 docs/_build/html/_images/math/b62df33f46595ed60c51f255186ee346c1fcc0cb.png delete mode 100644 docs/_build/html/_images/math/b6c245d487949782a89cab9ee83504a62fdc2337.png delete mode 100644 docs/_build/html/_images/math/bcb2457ac9d8995a4f34d57cadac7ecbbe58f3bd.png delete mode 100644 docs/_build/html/_images/math/bdb2d04d69b82c2288f5ef46664d548355e130af.png delete mode 100644 docs/_build/html/_images/math/be07aa32325c7a6161c0cef04f9b702054873211.png delete mode 100644 docs/_build/html/_images/math/c0d0f97cd9bb4e6571e2689163f9f2989b304f55.png delete mode 100644 docs/_build/html/_images/math/c4ed4f54ee00448249d2df22ad67f3e281df085b.png delete mode 100644 docs/_build/html/_images/math/c67734af70861b2bd4dedf5c41c9aad231466f84.png delete mode 100644 docs/_build/html/_images/math/d226d17c031c4b264fb8f59f953381951cc2e9b4.png delete mode 100644 docs/_build/html/_images/math/d6d56a5dd20011b190ba97d6f36d154e11c9035c.png delete mode 100644 docs/_build/html/_images/math/d843100cd0a02e1e5184694228a7ac41e19e8af2.png delete mode 100644 docs/_build/html/_images/math/d8ee85ac4d75924cdf4b18f5fb3b46550932fc26.png delete mode 100644 docs/_build/html/_images/math/db3d34854a6f48587cf5b9a41df90ad1c5e332d6.png delete mode 100644 docs/_build/html/_images/math/df0deb143e5ac127f00bd248ee8001ecae572adc.png delete mode 100644 docs/_build/html/_images/math/e03ea88dda29ab6daa19c839ff37b8115e0a10e1.png delete mode 100644 docs/_build/html/_images/math/e3fc28292267f066fee7718c64f4bbfece521f24.png delete mode 100644 docs/_build/html/_images/math/e486de19dbb61c9a63584f6e4ddd6e92ef03d665.png delete mode 100644 docs/_build/html/_images/math/e655092ec45224f09927d0ed9e6fcdfbddb67754.png delete mode 100644 docs/_build/html/_images/math/e9ea4b57a39788145fd98faa5d80911b52f3e435.png delete mode 100644 docs/_build/html/_images/math/ec1ca2f34e7505e1a6ea382d2ac832ec9bba9d06.png delete mode 100644 docs/_build/html/_images/math/ed38fa24f1c94891bd312012aab3f6673be3eb83.png delete mode 100644 docs/_build/html/_images/math/f321460f581abe30cc7314e0377909d0fce94f18.png delete mode 100644 docs/_build/html/_images/math/f75f28dbcbec776fbe031f8ac923f83f9260bd8a.png delete mode 100644 docs/_build/html/_images/math/fff7b4153a6590df59f8ed526be56220045b7f3b.png delete mode 100644 docs/_build/html/_images/mci_schematic.png delete mode 100644 docs/_build/html/_modules/abc.html delete mode 100644 docs/_build/html/_modules/index.html delete mode 100644 docs/_build/html/_modules/tigramite/data_processing.html delete mode 100644 docs/_build/html/_modules/tigramite/independence_tests.html delete mode 100644 docs/_build/html/_modules/tigramite/independence_tests/cmiknn.html delete mode 100644 docs/_build/html/_modules/tigramite/independence_tests/cmisymb.html delete mode 100644 docs/_build/html/_modules/tigramite/independence_tests/independence_tests_base.html delete mode 100644 docs/_build/html/_modules/tigramite/independence_tests/oracle_conditional_independence.html delete mode 100644 docs/_build/html/_modules/tigramite/independence_tests/parcorr.html delete mode 100644 docs/_build/html/_modules/tigramite/models.html delete mode 100644 docs/_build/html/_modules/tigramite/pcmci.html delete mode 100644 docs/_build/html/_modules/tigramite/plotting.html delete mode 100644 docs/_build/html/_sources/index.rst.txt delete mode 100644 docs/_build/html/_static/ajax-loader.gif delete mode 100644 docs/_build/html/_static/alabaster.css delete mode 100644 docs/_build/html/_static/basic.css delete mode 100644 docs/_build/html/_static/comment-bright.png delete mode 100644 docs/_build/html/_static/comment-close.png delete mode 100644 docs/_build/html/_static/comment.png delete mode 100644 docs/_build/html/_static/contents.png delete mode 100644 docs/_build/html/_static/doctools.js delete mode 100644 docs/_build/html/_static/documentation_options.js delete mode 100644 docs/_build/html/_static/down-pressed.png delete mode 100644 docs/_build/html/_static/down.png delete mode 100644 docs/_build/html/_static/file.png delete mode 100644 docs/_build/html/_static/jquery-3.1.0.js delete mode 100644 docs/_build/html/_static/jquery-3.2.1.js delete mode 100644 docs/_build/html/_static/jquery.js delete mode 100644 docs/_build/html/_static/language_data.js delete mode 100644 docs/_build/html/_static/minus.png delete mode 100644 docs/_build/html/_static/navigation.png delete mode 100644 docs/_build/html/_static/plus.png delete mode 100644 docs/_build/html/_static/pygments.css delete mode 100644 docs/_build/html/_static/searchtools.js delete mode 100644 docs/_build/html/_static/sphinxdoc.css delete mode 100644 docs/_build/html/_static/underscore-1.3.1.js delete mode 100644 docs/_build/html/_static/underscore.js delete mode 100644 docs/_build/html/_static/up-pressed.png delete mode 100644 docs/_build/html/_static/up.png delete mode 100644 docs/_build/html/_static/websupport.js delete mode 100644 docs/_build/html/genindex.html delete mode 100644 docs/_build/html/index.html delete mode 100644 docs/_build/html/objects.inv delete mode 100644 docs/_build/html/py-modindex.html delete mode 100644 docs/_build/html/search.html delete mode 100644 docs/_build/html/searchindex.js rename docs/{_build/html/_images/math/15af846e07c93e1c0d4cdbba8f4cefca67a811cb.png => _images/math/23a2245485b3bea72829d6ce2616269810aabb84.png} (100%) rename docs/{_build/html/_images/math/be38eb4004ec8179f569f36692f9132289acf8b1.png => _images/math/2db6fe683041026ceda3edd2502ddad36ce781d8.png} (100%) rename docs/{_build/html/_images/math/04effbe50a9c1421627153afe77c1c013193dd90.png => _images/math/318a7c48fc45fc824d5f07fdd1436d87c9315666.png} (100%) rename docs/{_build/html/_images/math/2882aa5d9b56c4f42679de5f902a74d8ae88a624.png => _images/math/43b684bc8c0d47bdaf76d0ce45ae7d6da80e5857.png} (100%) rename docs/{_build/html/_images/math/6ecffdf6c6b31ddba452a834568233441411465b.png => _images/math/5df6b7e1c217e91ec77d6ca54757d39eb1214518.png} (100%) rename docs/{_build/html/_images/math/f852990c4a225a95d2c694a9f1351f54bac3ba86.png => _images/math/73840e3c16ba83566dc457d7fdf79faab34797f6.png} (100%) rename docs/{_build/html/_images/math/e676f7877e03a3707387149ce203c5e79ed8f9a9.png => _images/math/8e756d8d049e32afc3747b6113db8709327060e0.png} (100%) rename docs/{_build/html/_images/math/d4ac9b60213cb2ffe02c6d5dacac8796221c73ac.png => _images/math/eb1313ea5f5a28395ab1dcd07e1e29eeefa1bb75.png} (100%) rename docs/{_build/html/_modules/tigramite/independence_tests/gpdc.html => _modules/tigramite/independence_tests/gpdc_torch.html} (55%) diff --git a/README.md b/README.md index 8f4aac0d..8fd59ed2 100644 --- a/README.md +++ b/README.md @@ -34,6 +34,7 @@ Tigramite is a causal time series analysis python package. It allows to - 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 +- 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 - 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 @@ -62,8 +63,10 @@ Tigramite is a causal time series analysis python package. It allows to - scikit-learn (optional, necessary for GPDC test) - matplotlib (optional, only for plotting) - networkx (optional, only for plotting and mediation) -- cython (optional, necessary for CMIknn and GPDC tests) -- mpi4py (optional, necessary for using the parallelized implementation) +- cython (optional, necessary for CMIknn) +- mpi4py (optional, necessary for using the parallelized script) +- dcor (optional, necessary for GPDC) +- gpytorch (optional, necessary for GPDCtorch implementation) ## Installation @@ -76,7 +79,9 @@ To use just the ParCorr and CMIsymb independence tests, only numpy and scipy are - CMIknn: cython can optionally be used for compilation, otherwise the provided ``*.c'' file is used -- GPDC: also based on cython, and additionally, scikit-learn is required for Gaussian Process regression +- GPDC: scikit-learn is required for Gaussian Process regression and dcor for distance correlation + +- GPDCtorch: gpytorch is required for Gaussian Process regression ## User Agreement diff --git a/docs/_build/doctrees/environment.pickle b/docs/_build/doctrees/environment.pickle deleted file mode 100644 index 873c9019b486234d1550db1644987d8ca34b5edf..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 550700 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[I7i70*IVPM-BmYWy#$Xf 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 E0iszcHvj+t diff --git a/docs/_build/html/.buildinfo b/docs/_build/html/.buildinfo deleted file mode 100644 index 46cbef6c..00000000 --- a/docs/_build/html/.buildinfo +++ /dev/null @@ -1,4 +0,0 @@ -# Sphinx build info version 1 -# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done. -config: d517342a7bcee833fecad6691f0139b8 -tags: 645f666f9bcd5a90fca523b33c5a78b7 diff --git a/docs/_build/html/.nojekyll b/docs/_build/html/.nojekyll deleted file mode 100644 index e69de29b..00000000 diff --git a/docs/_build/html/_images/math/0062c26909b3e07ee8f5a6285b2563d69bc979ff.png b/docs/_build/html/_images/math/0062c26909b3e07ee8f5a6285b2563d69bc979ff.png deleted file mode 100644 index 5972dea351db48f3545cf9456e48a8ccbbe33d69..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 234 zcmeAS@N?(olHy`uVBq!ia0vp^d_c^@!VDxAtef}}NErn9gt-3y{~yRC9_Zg)Pz_Yg zUlQaO%wV)%;%>rRkM5Tx=YOyNELU~lFz;kceG z@N4~<0}I}B9pT~OS?LgS|G)t$h9#Ej1}==6Y<>N2cok;-oGigC@y4^^f~7#$L20l5 j4FPZD4~l%=>#q>ZP!Z4bwL1E&ILNu4u6{1-oD!Ms0 zge&F=3{2qy2Pg2USv#^^XP;)v!*fU6?0iDPgGwf$hvAG9g?eHgKJhwps52kVZFBHu eYfET*D=ongs4k0Kqxrfrv?V30HD<} z+SD%flC^`e+}PE(KhlZM9I7CuK%$cGep)`M)prVgHaH&Uj+=N1-yw>zQY@+M4%45i zgO0CPjJ7dZ2$2vz`3B^qoX_VoBsU2a5?LozBijtvL1*wuPrye@C3u555-n8JR+ThY zgCwJEAPWi^Y}Fx>V!yIQg%Ca$h&lWn;DndI!3AIBM~GK%BkpE+az$Nk0w zU3x<<723=mG52P6EcWq}E_im98zEleaBy;R+UBCSoXE0y+CD@S#fJ~<`r@Z%%-|eF z%marSTYbf##Q}R8@w)Z-&$PvwF(o69!PO=J+$UeG3Kz-I6FcfsPn#haA_=$xoqu@n zBm*t5w^?3ls^QPHU9C#GA1rOFFz|m85(fT#nhQO^Q)zKnh$6mvFX5sO%y}Jw-h#CS z6|^Y@)zqQ6+GH$f3fYQdcq+YF0vQiHmBgQd8>|ike`g6TJ}@v*E9j6Y+R0T;+eCo( zc4iT6BI=UKaqPlp28DR3M4OBY4d@xt)j6~noNI$eu!r7@ot-Z` zJL&C|TLkKdt#J7r6K~h%y+$2Z3J|MrSb7F1L{9P4=b+*}dULEf*>;aMX5w|S0XuzQ zd*rz*vyIkGV>e!GuY!|aM^n zm;%XQZ4sl4wl4BI4y-|`X0)OE?tH#mO^SU&5l=j#1&k=w-U5y1nT95{BUoDqeA?n( z$YIVP+P}sa_jp}clXSe$6g^->WRkf^+?$ki-?`|{U~N<4K5dd05=*g$es*W6yQCkS z6is!b`BuP4KeJ{nIV*APO1ONlw#&e?FHAo?DsWJ^(Dfikn8Fkjf6jN6{Bk1)T X+-)}JP|ow&00000NkvXXu0mjfq%0Uc diff --git a/docs/_build/html/_images/math/12535500db0213985b2cce27db85468b60985da0.png b/docs/_build/html/_images/math/12535500db0213985b2cce27db85468b60985da0.png deleted file mode 100644 index 3f14f83e84ead1594bfe18c3f27df530834c928a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 299 zcmeAS@N?(olHy`uVBq!ia0vp^3P8-m!3-o#PWg8ODdPa25ZC|z{{xvMfsYM7JU|Ts zB|(0{3`Q@1@9*}wo3Oq_;`7||i|=pyaTF-WS>O>_%)r2R1cVuM>u@N>WzR$wkv+w_?ChT&?!VGJp(L{R zO$ZR zhkp*T^g_FZjOtQvQ!_)5xG#zX4J392(p7%23_HC$EIr+x_kCyHoq1<=@Pb8nxd(Q4 z=AGyHz3*@4d7nSC04p5v1eeNA@Ra2Ij4>HW zt!W$|yJSnpPuq7z_I)=)aE9Ov!Rge)mfQrjC9hOkL$Fx?>pPUo^?Lp49n4v~D%zmi z5`t#Ehn+s!J$dH{<}nW&$6Mo~>u&~kao|p8d&5iIox#CKs+H+BA-JO+IKNs=n{DLw z*JLI;+xDcvFl>9GSuQx}O(y7D8C79rA58A12YUV6U~CV5R#{DE>rF!!u&ar>iK7U6 z)5O1482GR4lVB==uv7hYqD6hdi@{#ozu)Q1}4I14tvn8-(&MbbBXkdC1hLyW;6gceCrd!BRPv0n z%?M`emPl}O$c{@n4PAgtS_xU`1M%t0Y|ai3OzQ4`a#w!S1BKb?7PMUiI4s(d2SKdb z$t}q<8fGar`QPIrK`Ug(OqAv-P`($J&g&lS~u89%?q32tC>euO~ueCIv_@H_QZ z-3x+@c?|*u?%Y3vX=~JtOwhnG>LC_ZZ}LmaY5_r=R#^oSqV_LFc@hswUFc~?sMS)sB~CXb*mbKB z+#E$4GqJMZb{9@8!|#ngd>{h4zP^@w!PnK@V6KR+hS4O08*af>$PY(hk)Vp9coB^V zea~~llROV%ys?E90PI588nv3_1otmq@+_rar{ceg;pG~2(KZJOay!K{$Q!9=7`(Qc zNG*=uQOO6oS)0wZfT*tJE7366c07#?#vw1jBEfdNx`XJpF>j=@Dj=v`0-Q{6Q5Xi# zu!xmDy2*w#7lm#sM6h6)u!Y;1c+QNAY3OZE4Se0A=%P&5z_Cpvc)Uugmk2BpEL8mo z`k=t?_RWCcwm#4Tg4{)6T(M0$n0E?RDV5-gaFFS+XW<=h*pY{D?+RBSD4-kv(oxh^ zJ~=KDWV$$Z6owU;r`o=10E+~7mRLxBiv>)L1Q~tYCup3(4O)rC@s~{afm-Ff!p2fc znt+TGCYZB4({9+clL{+e6X6AP5(R#ZS4a59`3YE7#Gade5y2 z+&xtV{Wns*T`w_$x$7S;nTluP-lOwfYE^K}eJP0^;QdG*G`@IzBxHAtZ0}q}gcs1w zP7(m9?wVMlXS(Of*8ItX3{6U5SpRkyJ<-ZQEVg5{lp3+}%clf_>S-a-TOm8O9Bl7$ z8v1?NTA(``FV(2-JN`+bBEkmGdw0WPb^<{~>|AC=tmgW+$>({Y|8oB_mf$zpQG$vc zvU|f-YKr@|8H10Yo3=X2bY~l7FPJN;+vc}r9WhuZ-kMmq(=K@_?NY{tKY&(3pz-=? zDW$qSH7S;!Gucd3c0I;}f*+tT8H&5M4AzL!2mW8wWPr{sFE-Nk~M zTIX^@E`q=K&38YSJ#rCT4U)?Z$@%HmxrgM)(~%S&*LKJl&rN^ur=L>2?BIs(FsQ?>b|fr3GvE{-7_*OLAD8x!BXy&t;ucLK6U0?mJ}w diff --git a/docs/_build/html/_images/math/20582dab63cb7f6604f5bf70224030ad3411ae16.png b/docs/_build/html/_images/math/20582dab63cb7f6604f5bf70224030ad3411ae16.png deleted file mode 100644 index 3c953660517a6b6c7e8e9217c0af1459e3a8d241..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 245 zcmeAS@N?(olHy`uVBq!ia0vp^JV4CH!VDx|PJVD7NErn9gt-3y{~yRC9_Zg)Pz_Yg zUlQaO%rJNV?~>2wC0-ic?OyMZ(06c~5>Se>z$3C4Xw?xAW}K?cCk+$~@N{tu;kcfh z(7@zYtIRHNb`^ul5iSc6i*RED?g9-1R)YeS0*wMygAKY50upQw9FRD$@WA^62mVcW uerOo5@;J}g2!*4XcOn?B^BLtZpGjblp2U5WG2HGw$mO1{elF{r5}E+9GC{%s diff --git a/docs/_build/html/_images/math/21fc11b715eef698662fe1cc017d7ae2d53320d8.png b/docs/_build/html/_images/math/21fc11b715eef698662fe1cc017d7ae2d53320d8.png deleted file mode 100644 index e93d6cd8fb58adcf54ab006d8eb6b70e1cb53762..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 337 zcmeAS@N?(olHy`uVBq!ia0vp^`asOX!VDxC41cl%NrM2N5ZC|z|ARz`2KsjwR09?B zmjw9*GnCBjHj+pdXUvqx@!$2`P3Ak3Q=# z2)%PCHB-2^j@zM$IcMd~aD_tY6FF=j1 zmjw9*GkCm|DEYj9{qF>$?(=u&b~H>=0ZMTectjR6Fz_7#VaBQ2e9{aIjOCs#jv*T7 zr%u}Feb_)wy!u93Cey)|V2imp&EeQJ1 zFfq;HSK~8-V>;#;99LRbGw*D0KeO!Fl?63Mh2lnOD_75R*sdYkSZX%Yd(zjfhDOgc zzqzhHu<@+!OVh@HV>9_TPhRNzmT^{Y&P2Ap7hN`ooew^rrt>?g>rm8!eC5+h$99;w zNQJ69__Ztdo>O;ub2e2bsb0X)X6l)mJJ*y2yX6!Ynclzk?qa)bOVIvpXZ8J8+HJL+ wQPUZmdnvI)N!wAD8x!BXy&t;ucLK6U0?mJ}w diff --git a/docs/_build/html/_images/math/2bf86ca220f43e569c6c7aefaf32742919222e6e.png b/docs/_build/html/_images/math/2bf86ca220f43e569c6c7aefaf32742919222e6e.png deleted file mode 100644 index 3f14f83e84ead1594bfe18c3f27df530834c928a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 299 zcmeAS@N?(olHy`uVBq!ia0vp^3P8-m!3-o#PWg8ODdPa25ZC|z{{xvMfsYM7JU|Ts zB|(0{3`Q@1@9*}wo3Oq_;`7||i|=pyaTF-WS>O>_%)r2R1cVuM>u@N>WzR$wkv+w_?ChT&?!VGJp(L{R zO$Z zmjw9*GnCBj-fy&C;`htX9(NPY`s0 zgoKc?R0byVHZC@1wr89?F^i-nEO;a=rbjd6!j8!S2M)~A diTJgGf#J#&F22;ee*GYadb;|#taD0e0swg(Hx2** diff --git a/docs/_build/html/_images/math/2fc62c02be8e341b7c32727e07b633086e70ba8a.png b/docs/_build/html/_images/math/2fc62c02be8e341b7c32727e07b633086e70ba8a.png deleted file mode 100644 index c8c9a4c16520ab2f7682b359dfd8bea156f19df3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 268 zcmeAS@N?(olHy`uVBq!ia0vp^d_XM7!VDzkpEaxjQU(D&A+G=b{|7RO2l{sxR0CD> zmjw9*Gj!igF!Ct*{c`_YiO=WPFLrcL21;=jctjQhtvdq3j8nDwq=ACzo-U3d9M_W* z5)uT23>YWztYLKG zmjw9*Gj!igF!Ct*{c`_YiO=WPFLrcL21;=jctjQhtvdq3j8nDwq=ACzo-U3d9M_W* z5)uT23>YWztYLKG2wC0-ic?OyMZ(06c~5>Se>z$3C4Xw?xAW}K?cCk+$~@N{tu;kcfh z(7@zYtIRHNb`^ul5iSc6i*RED?g9-1R)YeS0*wMygAKY50upQw9FRD$@WA^62mVcW uerOo5@;J}g2!*4XcOn?B^BLtZpGjblp2U5WG2HGw$mO1{elF{r5}E+9GC{%s diff --git a/docs/_build/html/_images/math/3d927294dd9fee97ab16ad5032baf0c08cdda4c2.png b/docs/_build/html/_images/math/3d927294dd9fee97ab16ad5032baf0c08cdda4c2.png deleted file mode 100644 index fb274eb9ee0d62180ce52f2959a40ee56d37a2ec..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 686 zcmeAS@N?(olHy`uVBq!ia0vp^r9iC3!VDzqKXI-FQU(D&A+G=b{|7RO2l{sxR0CD> zmjw9*Gf3?JeZJ%5S33ol_27Y?N0+iw`@Q5sCVBk9f!i-b3`J@>bm^eLM978;g zznyBU!<;B{Z2t7P=v&sRhm-;jCO9M+-6%QWq{JrOe6UPKsI#T*pu-a(rwKnijy$qX z669=VZH~?n^6g=}e``U-`z?F>zgOvYADw*1{_W>)JHPL(|NoX>VX42}yQM5_se8iC z>|IPivbL7`KF1)#mL9N!oV`t~KlV-DH&xoE4<8FyMpuAZ8 z+s#Lk-G_ND^2XjPJ*jltZhd8+wb`r6U^^b2&5`T>)m1)>C}!^37rrhkLy}pn;AdlS z;QYCZ!|$kE(%P&m-zL3ab*RIXZ9S`WE^HCXSfc+b?P$x)R_A4$%8DFWWxO+lc+%AZ zmmc%sJg0nlrl+~V!Zjacw@jV%vGV=Zf2-2$OcyW9<^EHU-!MHugk{s;V>vs6LOwqT zJoc~q{tVmo8n<6Dgx^?ZbLGHZ!`WA_FE*acyEuSuVE%8}l_ghwc)yvY)-g+^eA99u-WL>@g+Z)w4OAoWI zUZZ`e`(?pFF779ZO1gRxiHu(rrS*F3onIIwI({zTmDZcU!D1}-NbV}o-ol40wmf1& za)%mt#mjaoG`F@Kcb}2_HRi;cl#K%4PkdqieDvkc2NNQ6ES7{!e%IBnZY=F*8TxHD tw`Ib{36npGFDq)yPisGS>bIi!K8C-h>q51oc)x>^oTsaw%Q~loCIHuv9DD!( diff --git a/docs/_build/html/_images/math/42858b59a7270363c15ca14b0d5fc56d33af1f8a.png b/docs/_build/html/_images/math/42858b59a7270363c15ca14b0d5fc56d33af1f8a.png deleted file mode 100644 index 57cc10da72b1be8c1ab5171b14b9a392edc29956..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1718 zcmV;n21)seP)R zhkp*T^g_FZjOtQvQ!_)5xG#zX4J392(p7%23_HC$EIr+x_kCyHoq1<=@Pb8nxd(Q4 z=AGyHz3*@4d7nSC04p5v1eeNA@Ra2Ij4>HW zt!W$|yJSnpPuq7z_I)=)aE9Ov!Rge)mfQrjC9hOkL$Fx?>pPUo^?Lp49n4v~D%zmi z5`t#Ehn+s!J$dH{<}nW&$6Mo~>u&~kao|p8d&5iIox#CKs+H+BA-JO+IKNs=n{DLw z*JLI;+xDcvFl>9GSuQx}O(y7D8C79rA58A12YUV6U~CV5R#{DE>rF!!u&ar>iK7U6 z)5O1482GR4lVB==uv7hYqD6hdi@{#ozu)Q1}4I14tvn8-(&MbbBXkdC1hLyW;6gceCrd!BRPv0n z%?M`emPl}O$c{@n4PAgtS_xU`1M%t0Y|ai3OzQ4`a#w!S1BKb?7PMUiI4s(d2SKdb z$t}q<8fGar`QPIrK`Ug(OqAv-P`($J&g&lS~u89%?q32tC>euO~ueCIv_@H_QZ z-3x+@c?|*u?%Y3vX=~JtOwhnG>LC_ZZ}LmaY5_r=R#^oSqV_LFc@hswUFc~?sMS)sB~CXb*mbKB z+#E$4GqJMZb{9@8!|#ngd>{h4zP^@w!PnK@V6KR+hS4O08*af>$PY(hk)Vp9coB^V zea~~llROV%ys?E90PI588nv3_1otmq@+_rar{ceg;pG~2(KZJOay!K{$Q!9=7`(Qc zNG*=uQOO6oS)0wZfT*tJE7366c07#?#vw1jBEfdNx`XJpF>j=@Dj=v`0-Q{6Q5Xi# zu!xmDy2*w#7lm#sM6h6)u!Y;1c+QNAY3OZE4Se0A=%P&5z_Cpvc)Uugmk2BpEL8mo z`k=t?_RWCcwm#4Tg4{)6T(M0$n0E?RDV5-gaFFS+XW<=h*pY{D?+RBSD4-kv(oxh^ zJ~=KDWV$$Z6owU;r`o=10E+~7mRLxBiv>)L1Q~tYCup3(4O)rC@s~{afm-Ff!p2fc znt+TGCYZB4({9+clL{+e6X6AP5(R#ZS4a59`3YE7#Gade5y2 z+&xtV{Wns*T`w_$x$7S;nTluP-lOwfYE^K}eJP0^;QdG*G`@IzBxHAtZ0}q}gcs1w zP7(m9?wVMlXS(Of*8ItX3{6U5SpRkyJ<-ZQEVg5{lp3+}%clf_>S-a-TOm8O9Bl7$ z8v1?NTA(``FV(2-JN`+bBEkmGdw0WPb^<{~>|AC=tmgW+$>({Y|8oB_mf$zpQG$vc zvU|f-YKr@|8H10Yo3=X2bY~l7FPJN;+vc}r9WhuZ-kMmq(=K@_?NY{tKY&(3pz-=? zDW$qSH7S;!Gucd3c0I;}f*+tT8H&5M4AzL!2mW8wWPr{sFE-Nk~M zTIX^@E`q=K&38YSJ#rCT4U)?Z$@%HmxrgM)(~%S&*LDnM?jcysy3fAP%zfh#W95AdU8TS z$iM$LCpI>kZr!)}LVV-Gu7!2X%$LL47W4e(me^5mY+!K0*r4D)%cXD$i3;h4FIH@A z$qrqg&7E5qCZzp&#UzxP;FZA8{8L(Ci$P1$h2~342|^4@Hw&kT8nT`QdBfAy&t;uc GLK6U)yh>C6 diff --git a/docs/_build/html/_images/math/499a2ee48b33448e80b97af9df9550828bdbfb59.png b/docs/_build/html/_images/math/499a2ee48b33448e80b97af9df9550828bdbfb59.png deleted file mode 100644 index 024cb0350d40bab7a4b573cece77b58a83348e15..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 249 zcmeAS@N?(olHy`uVBq!ia0vp^JU}eK!VDxY_&1vXDT4r?5ZC|z{{xxC1O2-Ts)4Hc zOM?7@8A>D)y7&M7>|ykB?)vk0^R8^+14?lgctjR6Fz_7#VaBQ2e9}O{5KkA!5RU7~ z2@Fh(0tXMIFf5ZesKU%GV7%LCgMq5yiVfyx5+cqd7|cJ|n5fQtI8tG2W8=aJ2OBw8 zd{qC;GT~CY4$nLXuhR7$Op_F+37ledYFxv}(DZ`4CBLEB6lgw!r>mdKI;Vst0MZOX Axc~qF diff --git a/docs/_build/html/_images/math/4c0d6a1e190158ff6f076a7ea72e63b430fc90c1.png b/docs/_build/html/_images/math/4c0d6a1e190158ff6f076a7ea72e63b430fc90c1.png deleted file mode 100644 index 4d2a7183b7a20a772956662e52504a0f72789f04..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 524 zcmeAS@N?(olHy`uVBq!ia0vp^{vb9BGmw<((z^tt3<7*YT>t<74`dP#^zSaH2CC*S z3GxeO=$H)D?6 z{w`wbamk!na*s9d>?}QESaWdB2Z{Ozm)CBWmH0U$<}1Urg)i$WCPc41+}mknb93*M zD2DqtiWYGd?B8>{ z9lF0Di~W_KY2-}VEQb}IlQvxT+VhtC>dI60+MW8-PyAkM&AChU`J7e8avgha7hEy( z+E%wK$*}q6q8r~&S}L!=qznRlLR|m<{|{sm5A^RYs0OO$ zFA4GsW{}wb`+Ujgxkh)_dn9zfOg+H15h%r3;1OBOz`%C|gc+x5^GP!>Fm-#nIEGl9 zzB|=F<8pz>@%=CFFY(;1pz$Jc?g_r8*#{>Z968CiyF$Y$)GTH7qtxYGUZrw8D-<5h z@08OCy4Ji`q$S{^!NIKx!2)fP98Eu#tLq+$DYfca{o=i9@5u$ZQT=u=s`tl#{^WV@ zcWwQChP%-_XQ$K){a?KI;;xf*S2H)8rE7lK>iMwb+wG6B-`3~yv!{sPTlSaTpfKi{ zjp3}bCjWTfCi=|@&6L^qxB9Dax7;k2><1B-dY7$H@B7Fq8XeiO!t9%5!K6pQMVAh) zsH<#^t;pW<$-gC{;)2NUJBEE}j$f-2lh-rGYtBt9#y__jqxh4_CE_(#jT9eM%UJ*`Ppp{UF&4v*|>M@^^=`P zIZyeA<-AFfS9)_bsF3wv`I;w=4jyK^Sp3&IzsWn4mQ=rSj$MnKXwy6CV;W)&nhCS^ zE}Oac!&>7tCJzO)6IJ(lNmcO28`*Sje(>tf!Wm074b7bV%Z}T9(mZq8Y?@TH{0;W? zVkh?K9gN@ayxKHhCB}WCFUwWl)2|=ti@mej5XXD^LAHjHm-Vgmb&tiIw?(>~nkIES zaXVvtM1ahV!$Mi%N3_m)25K!jp0m4g*AcV3R!0uDrNXTwUQH-5KfOu z-kZ_8_06QE6%~LvOBaW=!t6<(4pnnk8d$ zNqa4XQ7)xo-nm3l^yTAuzCXS{zw<{fZEt7g4gl;E z?%FU>kzMIonB%dl49+{Dt#@{IcFq5vj!%`w>_*EH++92XN)78gf`H;{xXqp_vMaNS znca1XU$?t>69ABTxySpm^<)kM0Kh(btF!3f=_yQX>cOi@@qz5XK(-2uZcH$8b{vq* zgqDxVRi2qN6j;73N3F?1sx3X_+90~9Qk6CLjM*_1XG`-M|0h1w0BAf@jS8!uoHczT@Z1t@=wr4T*Ofe+SkR1~8aWcSLyv8qX%ub`+qzq2N# z8K~7wXn?Ft%cXjUG$K0s*Mw*CwNW@BfplL%({atgm7jx<#0#;x_&LpNtGr~bD)KLv=Bhk?+kj-Fx!qqUp*k2A^F`H zRqdzV&soa^{%(>THz-*)@Q0|;;f7%+31#Vd`9QF*Ln|mQ#X`D!*;GzA9>;vcWbC^j z`Pq`Lq}CRoepI;5{mR9pid9oaa?y0|o#yxL8*nEtvU*8LSf>H&`dWL^kHW2vo}Fxl z-R)nV5cAu;o$eU6Xi3f~qG!VU6C&Me@6BR9$hGT`bcS>(>~$kvS`zU(D}^xY5HA{@ zr1;~r$+kiWt-8Bk@cg@MO`p?Hwhnf)bv*G|Jr+S`Rh?~@6(LoewfWWMoZFq>Bq!?v zQmt^86KZ|}o2c+*OHo?Z1lKrLs5)}xhVzhqabf+$VFvLJUr?J;kHis~vM>#qVu3ym zGQgrJOMaat$eYw01RQn_iLgBMhEsPm6vr{@Gnt=P8}}Lc*mh4V41fHtJEU<0fGQ)p zc~_9l$ZJ*qlekT#fXCxTFge_t9fI{d$gAZsKiWSL-&~j53Gy>{aanbnSC(?Lvf$o| z@i$fatZ$(@4ha?psQIV$R z4inpY8M>L!m)5T<3KuF^`;!I;O&e~lINE~mCG9!aGnuhsKPN3nt1^9QZN&3iDz6b@ zHg^zV|2j=A7{`=7=-VudLMC^VjAlAPg#R|^sAKMr$}~Kgn7!(KOvk@&?!G=>m$ekd zwwBQe(u$>4brISPrP7tF;kK3Cz_Du`V!d^>Qcs`UdS{h~XWt8u2wYh-`!C3=0#Cht zt8&*Zshu4)qK~EDwe~~i2!&d8(BRu2mJ2p|MTUnCnZWwII`dBaRc}(pcXDzvOFM(> z?-Z(@Mb>BR&BQfaNC1mZ&HB6)-P&Jhtb-2`@BE$21BhV0^v~WPin|`U`WbuW6qk4r zy`}bNOYmby1U^a%9~ds(IFV5c(yDTAp46`lPkfKvI{fkIU_59C4vG<|SD;?uK zX+MdWQ^`ffbYQ~Yp68$^uBHwrdB7|rErdqZd4!&0smq3aB=JdSKaTl>iabqF>mT4~GgCa$5amXk<0xtOI4kNv-4VrxK zz1Icfku9&~d0QpL4psDsT^xelg?4M=4{0Dro{p*O>MsRn6o+^zR8UGW7~}Nf5Pv;a bjYU2?z zmjw9*GjxCceSW{h-Sr7CJxYw``uIHrnZ;S)5n0T@z;^_M8K-LVNdpBFJzX3_IIbrr zFf>=L6`0ldmeHHJ<>=0aLdK8}Oza^&jg2pvdY*D7f5>I%GJN&_|Cs`{?~KgN*-@;_ z@Bjbj<>_JN*{q;7!`wioeS@B{fr~?ggQoF{i99;&3OetOT^C?usJzopr0GHHBkpKVy diff --git a/docs/_build/html/_images/math/557d5fad862c9046d26e1a930f45a550c146d592.png b/docs/_build/html/_images/math/557d5fad862c9046d26e1a930f45a550c146d592.png deleted file mode 100644 index f2860cbcf4f997148222838ec159d58ce48a7df1..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 200 zcmeAS@N?(olHy`uVBq!ia0vp^AT|dJGmtd8Qrrrpv;urWT>t<74`dPpo&|e$0oC!A z1o;Is7`^t<74`dPqN>lyj0TuC- z1o;Isl>C-3O6cD2vHtVio2P$028weQctjR6Fz_7#VaBQ2e9}NceNPw15RU7~2@H&G ztZZy)>}(PVzUc`D$yo^;9~g_4F>hoG$Z=#~e%`{%BXgODAx4??!-Ca4qCl+-p00i_ I>zopr0Gt0ThX4Qo diff --git a/docs/_build/html/_images/math/5c8ff70420eb65f959d5e2a9b244fc565d9ecbd6.png b/docs/_build/html/_images/math/5c8ff70420eb65f959d5e2a9b244fc565d9ecbd6.png deleted file mode 100644 index 394e410c8cd2a85d5aa5761352b26a7462b5a630..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 441 zcmeAS@N?(olHy`uVBq!ia0vp^Ak5Fg3?y5HS{s3sL4Z$)>;M1%flT6o{@n%DK-K&u zL4Lsu68nFjFZtYUwEktnU5~kepPsM)r8o;bB8wRq_>O=u<5X=vX$A&H5lC;TkdV+OvAKI8SK>1tgPVUE z8u^uM8ynv;FmJ!+yupAyM2aQi;KDOAP9C_xK240V?Qc9=Te-nco*iCt2Aazb9M~wP zviJFC*0$LDA`<6}KAfFn`I(XVG~13-wF#g0EIaj!Wr2x|gu~12G7-*a7|tcdFm$S4 sJ7AZ?m3T>E0bghPzyJ0dXRWMbWbhVp;xQ=Bst1L>r>mdKI;Vst00*a-P5=M^ diff --git a/docs/_build/html/_images/math/5f8c562c89b6bf12d27dc6cdc9dc090f7bb78e9c.png b/docs/_build/html/_images/math/5f8c562c89b6bf12d27dc6cdc9dc090f7bb78e9c.png deleted file mode 100644 index d4114f3893f413833c3d34178ba5f0b8cfa2dd31..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 506 zcmeAS@N?(olHy`uVBq!ia0vp^{y;3m!VDx|aLtFtzMdbk^S^q>ZrNvzMzFPDR?qD~K%==wuH%@pY}-oAkCy9v)WrhLTJ9Y_=PU9rt+FOYEqX zkcbdt_?vLxv*?-vE`je&689y{9L_L)+EHgzVC*2W$;@C6d;9k!1v7TTbw$p)EFVh_ zUS!%-RmVJdI@B zf==-JiLBVj?V08p$MaiRQliZ9$c;y=3r_NcAF^$jR=}7g<)fdvZmJR}`aE6zT-G@y GGywo|!>k1W diff --git a/docs/_build/html/_images/math/64932505aadaa1eac6316ff09c2c3b101b068168.png b/docs/_build/html/_images/math/64932505aadaa1eac6316ff09c2c3b101b068168.png deleted file mode 100644 index 394e410c8cd2a85d5aa5761352b26a7462b5a630..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 441 zcmeAS@N?(olHy`uVBq!ia0vp^Ak5Fg3?y5HS{s3sL4Z$)>;M1%flT6o{@n%DK-K&u zL4Lsu68nFjFZtYUwEktnU5~kepPsM)r8o;bB8wRq_>O=u<5X=vX$A&H5lC;TkdV+OvAKI8SK>1tgPVUE z8u^uM8ynv;FmJ!+yupAyM2aQi;KDOAP9C_xK240V?Qc9=Te-nco*iCt2Aazb9M~wP zviJFC*0$LDA`<6}KAfFn`I(XVG~13-wF#g0EIaj!Wr2x|gu~12G7-*a7|tcdFm$S4 sJ7AZ?m3T>E0bghPzyJ0dXRWMbWbhVp;xQ=Bst1L>r>mdKI;Vst00*a-P5=M^ diff --git a/docs/_build/html/_images/math/667eda4bf3d5ce33b6cc785cadfef79bb95741ca.png b/docs/_build/html/_images/math/667eda4bf3d5ce33b6cc785cadfef79bb95741ca.png deleted file mode 100644 index d457103b37702e9d5d786afce654b8df4df62675..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 417 zcmeAS@N?(olHy`uVBq!ia0vp^o6f&SeE)j-w! zB|(0{3=;c)pD+2`ZM6Pn!d;KKfuEkR0Hrt!JR*x382FBWFymBhK53xfA5Ry@5RLQ6 z2?v;WNOmyVaHuW*B+hs(zf0hpox#b4|2-QTU!G^1p!L_)__;j8r8o8x7HS3xtCJFb z9XN1cJ7Z3m9&__729Glxj&m48McLt}d=r-OsqF z%doR?;cF)5!}HFIOO(|HGqnGhX?*(J9LAa2GuQJ59{rp->ALx&weoU T)4KJ;7!=B$u6{1-oD!M<#=VeE diff --git a/docs/_build/html/_images/math/6a5f63bd699c636142cee5bee90f58729f7248bf.png b/docs/_build/html/_images/math/6a5f63bd699c636142cee5bee90f58729f7248bf.png deleted file mode 100644 index 335bc4c0f0e5458affa005f5a8654ea17789d3e9..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1053 zcmeAS@N?(olHy`uVBq!ia0vp^Pk>mQg&9b`tpCReqznRlLR|m<{|{sm5A^RYs0OO$ zFA4GsW{}wb`+Ujgxkh)_dn9zfOg+H15h%r3;1OBOz`%C|gc+x5^GP!>FjsiGIEHu} zUpvh=L)cN|`2XFeC)H->PIqEGTG#PKA#1I<;}tP}C5<(UM54Cz&if+5zchfKZEaK2 ztVIi4uk7uZu^EFWl9l{3)%5SS^cR2sMtrHt|8Z@}{duR1WMV%a{Zbn}uTSK<*8Mvj*ZwYx)SJ?Ch&%Ia#kfgH~Tp zYsmJDlVEb~j8;EhsMq>ni-x-6U9FIe=!pLPMRF%yzviUO6%+ZcdU$@r#3>PC?ic;% z&%U#fRaxzjaguIR*NJS-jbD>DbRJr3H{U(zf7Ogu!&Bcc&0vTU?AfVd^}_hcj=mr( z-v>c`QOef~X5=rcuYI`Yq~{}sLdIK0YAb_y^gkt7Wt8;nwVYS#U~p>NfrX#e^x9ro z$*Ou?NT!BO@8x#E4YHhlaT{L*KC6&pvYK0HIW=AQjp3h4#ghfu+vGeqS%n79_B|pK zrIh73Gq5bu@7HsU^=p$Aw{J7J|5N3?Zqh`f)|A(aWxp6PNS2;DZ(iJZ$@Tn+Dc2+Z z&OfM7$(nprb?cUYlV^E56-ockHB8xZB6HI^L>&Y%s!jltuy0|$se`Tzoy!T^MCuYfp_;d#$P`a+Dl|`u2<%?d}Vl91%b2&RwGS9^B>Yh{@ z{Hh~)M&$JAuY6SUUVP2+IvMb#d71fFVdQ&MBb@0Mr9CO8@`> diff --git a/docs/_build/html/_images/math/6de62736d8aa90101801d7a1416e97e921d1620f.png b/docs/_build/html/_images/math/6de62736d8aa90101801d7a1416e97e921d1620f.png deleted file mode 100644 index 0c909ba299dc1577eea60356a109995823685a53..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 229 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 diff --git a/docs/_build/html/_images/math/7720e563212e11bf72de255ab82c2a3b97c1a7f5.png b/docs/_build/html/_images/math/7720e563212e11bf72de255ab82c2a3b97c1a7f5.png deleted file mode 100644 index 0281a4b3953e767fc53f36b9e44a7f9df1f5334d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 232 zcmeAS@N?(olHy`uVBq!ia0vp^d_c_2!VDz$u3i`jq;vy(LR|m<{|{sm2@Y6oUI0|e zR}$nG%#hH%zT~{oZ;zMzCFXvfZ)TDWl;JG!h%5#wI0C|qQ?>b|fr9RyE{-7_*OLsH8p+`4>gTe~DWM4fb!0gG diff --git a/docs/_build/html/_images/math/789735c1db036ea36cd0aa25a3af4b2528ed3abe.png b/docs/_build/html/_images/math/789735c1db036ea36cd0aa25a3af4b2528ed3abe.png deleted file mode 100644 index 92a247423e205676b0ec43ef46af90ab1dc8b0c4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 476 zcmeAS@N?(olHy`uVBq!ia0vp^o> z#5XPvS1khu$HbHGICweL-uv=S2&m=ZyIZ$FS)#i!tl5e6QD(x5PfmwAM5UaoD;(cF zYKuCp$ zmjw9*Gf3?JeZJ%5S33ol_27Y?N0+iw`@Q5sCVBk9f!i-b3`J@>bm^eLM978;g zznyBU!<;B{Z2t7P=v&sRhm-;jCO9M+-6%QWq{JrOe6UPKsI#T*pu-a(rwKnijy$qX z669=VZH~?n^6g=}e``U-`z?F>zgOvYADw*1{_W>)JHPL(|NoX>VX42}yQM5_se8iC z>|IPivbL7`KF1)#mL9N!oV`t~KlV-DH&xoE4<8FyMpuAZ8 z+s#Lk-G_ND^2XjPJ*jltZhd8+wb`r6U^^b2&5`T>)m1)>C}!^37rrhkLy}pn;AdlS z;QYCZ!|$kE(%P&m-zL3ab*RIXZ9S`WE^HCXSfc+b?P$x)R_A4$%8DFWWxO+lc+%AZ zmmc%sJg0nlrl+~V!Zjacw@jV%vGV=Zf2-2$OcyW9<^EHU-!MHugk{s;V>vs6LOwqT zJoc~q{tVmo8n<6Dgx^?ZbLGHZ!`WA_FE*acyEuSuVE%8}l_ghwc)yvY)-g+^eA99u-WL>@g+Z)w4OAoWI zUZZ`e`(?pFF779ZO1gRxiHu(rrS*F3onIIwI({zTmDZcU!D1}-NbV}o-ol40wmf1& za)%mt#mjaoG`F@Kcb}2_HRi;cl#K%4PkdqieDvkc2NNQ6ES7{!e%IBnZY=F*8TxHD tw`Ib{36npGFDq)yPisGS>bIi!K8C-h>q51oc)x>^oTsaw%Q~loCIHuv9DD!( diff --git a/docs/_build/html/_images/math/7a3d0c9264473a58cc3a769f99a662631131377c.png b/docs/_build/html/_images/math/7a3d0c9264473a58cc3a769f99a662631131377c.png deleted file mode 100644 index 0501afa51de8293582a0f906e39127908b741d1c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 262 zcmeAS@N?(olHy`uVBq!ia0vp^f zmjw9*GjxCceSW{h-Sr7CJxYw``uIHrnZ;S)5n0T@z;^_M8K-LVNdpBFJzX3_IIbrr zFf>=L6`0ldmeHHJ<>=0aLdK8}Oza^&jg2pvdY*D7f5>I%GJN&_|Cs`{?~KgN*-@;_ z@Bjbj<>_JN*{q;7!`wioeS@B{fr~?ggQoF{i99;&3OetOT^C?usJzopr0GHHBkpKVy diff --git a/docs/_build/html/_images/math/7a7bb470119808e2db2879fc2b2526f467b7a40b.png b/docs/_build/html/_images/math/7a7bb470119808e2db2879fc2b2526f467b7a40b.png deleted file mode 100644 index 03832e37653b89b7a6e6f7c823410e8377a49ff5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 243 zcmeAS@N?(olHy`uVBq!ia0vp^0zk~e!VDy5o>bTbq;vy(LR|m<{|{sm2@Y6oUI0|e zR}$nG%pkG<_xX~~-A3zQCfxN2=T906g*soH$fK*1nS7sn8e>&XcT zA$3Xze)&vnY;63?%6y!KO~4>Yfc-MhXBKV+o}DiRW;H%#oTB(e#>v<(f-SMY=*?}0 vG@pb7YlcOx4Q~5bFICIMC*1hz)5yrc?Je*ybXDmqpy>>ru6{1-oD!M<0n zmjw9*Gf3?JeZJ%5S33ol_27Y?N0+iw`@Q5sCVBk9f!i-b3`J@>bm~VKxIEF+V zemlcAL)cN|`2X3n)Cy;thy`A8*6xb3RhcHo5~%$wfjh}T;A24cdaZRq0nxYhl$w;x zI<~O5G(iC@r8m%`KQ#a%yqqOwfpYfl(fyeBO~|RaR1hPbNc^1 zmBur_pJo#Kmd4f3x+7`wi5hnlHRN2&%R7s54%?}nX;L>h zx~6#2%H{Rj8`tSzu&mISTds4q z@vI8l%g6CRHSI~E$w@C`F;zGx?JWPkFfz3O7GJC6#nHB_XmC|^2> zDbclX>2#L=+OHqxFEH|BX7RkSR$Aoi6pjl0c$Xt7EC=h(His@^RI*@fF?w_A&9Rdk z^xwp@uWMU#cFQ|Q?LdZurF~u+iCRH_6FK!=w#*g(`CR(I{hTSbcIuO-OQhZpZ_xvW#s-&`NMx#eMhPus(vx-+$FTW73&rG4mG%R|MjRw;@uTFZAGWq-`E zrqwc$#q;IP^J$juKSO7PPu;Vmq${lDBC}oIx+9_W_tw?N{`;QgDDn1D_LJ~c_9ZFO zSMO;@3c3AUPjNXT4Y!0k7bbOPuPUwB^fkG{YMxVv3i7ktMb#ul) z_h~N;pUTG>6OzTFynJfO%#BJtlV;`IwQ+sA(nG1#So&}i%O6SYLmHwB#B-unGT$jM zV_PR^F?pK;k7{yrWpb9<>7ZnZOYdL&+-1mp=)j`pYzM9~jhQ}a5=-?aX{xbBAL@A4 z%gJ*1hC~jBv;K`$Ld*R(DY97~3g9-A|LL;bT-?F3^`@$AoBfFs#<>;xeVL#V#M9N! JWt~$(696>5@7(|Z diff --git a/docs/_build/html/_images/math/7bce831f5eba0d0e0fcb0cced170b2926804500a.png b/docs/_build/html/_images/math/7bce831f5eba0d0e0fcb0cced170b2926804500a.png deleted file mode 100644 index d4114f3893f413833c3d34178ba5f0b8cfa2dd31..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 506 zcmeAS@N?(olHy`uVBq!ia0vp^{y;3m!VDx|aLtFtzMdbk^S^q>ZrNvzMzFPDR?qD~K%==wuH%@pY}-oAkCy9v)WrhLTJ9Y_=PU9rt+FOYEqX zkcbdt_?vLxv*?-vE`je&689y{9L_L)+EHgzVC*2W$;@C6d;9k!1v7TTbw$p)EFVh_ zUS!%-RmVJdI@B zf==-JiLBVj?V08p$MaiRQliZ9$c;y=3r_NcAF^$jR=}7g<)fdvZmJR}`aE6zT-G@y GGywo|!>k1W diff --git a/docs/_build/html/_images/math/7daf0d4815e763eb90f0d5f1dc406f668c1e21db.png b/docs/_build/html/_images/math/7daf0d4815e763eb90f0d5f1dc406f668c1e21db.png deleted file mode 100644 index 5972dea351db48f3545cf9456e48a8ccbbe33d69..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 234 zcmeAS@N?(olHy`uVBq!ia0vp^d_c^@!VDxAtef}}NErn9gt-3y{~yRC9_Zg)Pz_Yg zUlQaO%wV)%;%>rRkM5Tx=YOyNELU~lFz;kceG z@N4~<0}I}B9pT~OS?LgS|G)t$h9#Ej1}==6Y<>N2cok;-oGigC@y4^^f~7#$L20l5 j4FPZD4~l%=>#q>ZP!Z4bwL1E&ILNu4u6{1-oD!M4}z&npM+4GQlSV6gA$d7nndY?^<@Q1vQX5+SANdy67`D-)BF#b?tX5)rKpJH~AKy@{o>J zz58Fb-+H7dYnuo}vs4udb@hHI(bv-bn>OyIqRaN-P6B(m{FX1q<9YX;EA--m?@HoC zZElPaBzas$fotC#zo|XDOQ8Vk`ic@lJ-=Mz~15R*<%R zR~CQMa5%!3oaiW90fqzGCIZnc`Ect~Aj9DWZe6_O!=3Iy7Y%o8uz3bnYN?gG*`b##m5pHt<);C zDi)FF&s1ETlDiOe75j>yXn&5|dPP~|>SLi=dFB|ngszo_LmRkzfIp}xNN`UZs2FL%#P7F?)4BjjdJHj2Menb z++0ejxF{%>vq=Zfa+>4lGJ~#%pzWY7P%7rL)MIzaeF+KMxEiXJ2o6z}yyoE8jZ!Up zA?+NXZ=A>$P^YGTo0<}9rO)(3zp@Xhq6GKV68g$GHMp>(&F(SrfOwU%g09QZw~@iT zsa}9FJJe?$9$bPt5vr94miG bgU|m3SvO4}OFMWa00000NkvXXu0mjf4O1;Q diff --git a/docs/_build/html/_images/math/877d234f4cec6974ce218fc2e975a486a7972dfd.png b/docs/_build/html/_images/math/877d234f4cec6974ce218fc2e975a486a7972dfd.png deleted file mode 100644 index 6e6726a650b6ec0cefd8912679a6c40a00b67262..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 228 zcmeAS@N?(olHy`uVBq!ia0vp^+(691!VDzuib?DSQU(D&A+G=b{|7RO2l{sxR0CD> zmjw9*GnCBj-fy&C;`htX9(NPY`s0 zgoKc?R0byVHZC@1wr89?F^i-nEO;a=rbjd6!j8!S2M)~A diTJgGf#J#&F22;ee*GYadb;|#taD0e0swg(Hx2** diff --git a/docs/_build/html/_images/math/90efcfdee16eaaec575238e2e6df5f731c8609bf.png b/docs/_build/html/_images/math/90efcfdee16eaaec575238e2e6df5f731c8609bf.png deleted file mode 100644 index 626242f1b79ada9abe274ed260c4d037124c6f56..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1149 zcmeAS@N?(olHy`uVBq!ia0vp^6M@*5g&9bOaLslBQU(D&A+G=b{|7RO2l{sxR0CD> zmjw9*Gf3?JeZJ%5S33ol_27Y?N0+iw`@Q5sCVBk9f!i-b3`J@>bm~VKxIEF+V zemlcAL)cN|`2X3n)Cy;thy`A8*6xb3RhcHo5~%$wfjh}T;A24cdaZRq0nxYhl$w;x zI<~O5G(iC@r8m%`KQ#a%yqqOwfpYfl(fyeBO~|RaR1hPbNc^1 zmBur_pJo#Kmd4f3x+7`wi5hnlHRN2&%R7s54%?}nX;L>h zx~6#2%H{Rj8`tSzu&mISTds4q z@vI8l%g6CRHSI~E$w@C`F;zGx?JWPkFfz3O7GJC6#nHB_XmC|^2> zDbclX>2#L=+OHqxFEH|BX7RkSR$Aoi6pjl0c$Xt7EC=h(His@^RI*@fF?w_A&9Rdk z^xwp@uWMU#cFQ|Q?LdZurF~u+iCRH_6FK!=w#*g(`CR(I{hTSbcIuO-OQhZpZ_xvW#s-&`NMx#eMhPus(vx-+$FTW73&rG4mG%R|MjRw;@uTFZAGWq-`E zrqwc$#q;IP^J$juKSO7PPu;Vmq${lDBC}oIx+9_W_tw?N{`;QgDDn1D_LJ~c_9ZFO zSMO;@3c3AUPjNXT4Y!0k7bbOPuPUwB^fkG{YMxVv3i7ktMb#ul) z_h~N;pUTG>6OzTFynJfO%#BJtlV;`IwQ+sA(nG1#So&}i%O6SYLmHwB#B-unGT$jM zV_PR^F?pK;k7{yrWpb9<>7ZnZOYdL&+-1mp=)j`pYzM9~jhQ}a5=-?aX{xbBAL@A4 z%gJ*1hC~jBv;K`$Ld*R(DY97~3g9-A|LL;bT-?F3^`@$AoBfFs#<>;xeVL#V#M9N! JWt~$(696>5@7(|Z diff --git a/docs/_build/html/_images/math/914b2d4b6659b86d3153d5510839dfb254dfc8a3.png b/docs/_build/html/_images/math/914b2d4b6659b86d3153d5510839dfb254dfc8a3.png deleted file mode 100644 index f2860cbcf4f997148222838ec159d58ce48a7df1..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 200 zcmeAS@N?(olHy`uVBq!ia0vp^AT|dJGmtd8Qrrrpv;urWT>t<74`dPpo&|e$0oC!A z1o;Is7`^ zmjw9*Gf3?JeZJ)LT%)_|JrcTKrXFD12$bS1@Q5sCVBk9f!i-b3`J@>b7_WJ{IEGl9 zPEJse{P1uxPr5`^L%FG)C%cj_XAe^_*NR0wr{Y;6_G`v@s4R&+ac`ocou`9?=$Y9J zf+_X+N(_mA5)$SdIPj5S^|ieoZ+@|{c`AHmIw|t*=AGAy>yrK)J#h5Efl|iRn#U*J z_{1$C#-Pcp65Jv!F@sxS(>VoCv&g1p8zc%E*UWE7IrW!~jc>)9e+3J!&&U%nY5kq8 zsKLNB!KZUR$Mn?A2V|F=SZ1JN&cORH+rg;yrLm2|j5>kLF1rg1=T`HaD7^CXEknqs z7wV6E9(KBWsU!qTNJ^Y@o_j#{0gs?U%Be81fG->hGasEkaNw8tq4%jb_`k@cGb;vL z=oK`VoN<_O=pUoTFX>4!Vg?@=gJp~zw|f{G>}ggP-=OK^Abdk{Uk>B5h4*>xR9!d_ z7j>?nb)i(Zrp$q!vU=vj%eHd_@34=562WTX*pT@AIWN!eeYy!6?H)yWD;}i^S1|VO znQ1)#>>N(t*Pqu)?zo?Ra1yslOqtYvCbr9IE}Q0`J+Lq9>Z+!*JXSnK2I0xfbEE^3 zq2@3#7Xis>ns03hlZrVj0I1Tp{Qa+TlIZ>8_;N p+|Z-BT)`%7nrohj&yk*B$*}iB$)^i%`?W#o$J5o%Wt~$(695^g?}`8b diff --git a/docs/_build/html/_images/math/95f028ab2b20b895fa12d986e0d9f40f7b6e52d3.png b/docs/_build/html/_images/math/95f028ab2b20b895fa12d986e0d9f40f7b6e52d3.png deleted file mode 100644 index 6d61d4f89dccc4cbb6e1cdca49a1d247d338bb82..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 246 zcmeAS@N?(olHy`uVBq!ia0vp^JRr=%3?!FCJ6-`&1_3@HuK)l42QrBV`ga#p16A{v z1o;Is?0>ob?q?5)lHYTUx)aVz+?o0nD8*Ue5n0T@z;^_M8K-LVNdpA~JzX3_IIbrr zB>Yjy`P16iXxi9lIHysux$)qphQ@`BjoD_*9CQ2`Chn;}IOh+Wz{zjzjnW=(V-6fR vdfs0 zge&F=3{2qy2Pg2USv#^^XP;)v!*fU6?0iDPgGwf$hvAG9g?eHgKJhwps52kVZFBHu eYfET*D=ongjv*T7 zlM_P90*efb5*(Ox-pAJX8znFt+w0)?jDby*&5Ti`^DqxjA(O-@SIJk>5?T^B>Wwz| zI!yd=@W6qeqRu~!*`BfU@bdJ?OIR>ZIO^yXS)Zg4o|5pBVaW{f1)ZC15)u;rH@>Wx z@REneNBV-xPCbU)ADyn1HOv!M_&W$cW$$8oo4V=Vng*>xDVGz@H%!wT7<3HeUkKYV zw{`Lqa%w!flaM~gar> z#5XPvS1khu$HbHGICweL-uv=S2&m=ZyIZ$FS)#i!tl5e6QD(x5PfmwAM5UaoD;(cF zYKuCp$ zmjw9*GkCm|DEYj9{qF>$?(=u&b~H>=0ZMTectjR6Fz_7#VaBQ2e9{aIjOCs#jv*T7 zr%u}Feb_)wy!u93Cey)|V2imp&EeQJ1 zFfq;HSK~8-V>;#;99LRbGw*D0KeO!Fl?63Mh2lnOD_75R*sdYkSZX%Yd(zjfhDOgc zzqzhHu<@+!OVh@HV>9_TPhRNzmT^{Y&P2Ap7hN`ooew^rrt>?g>rm8!eC5+h$99;w zNQJ69__Ztdo>O;ub2e2bsb0X)X6l)mJJ*y2yX6!Ynclzk?qa)bOVIvpXZ8J8+HJL+ wQPUZmdnvI)N!wKJl&rN^ur=L>2?BIs(FsQ?>b|fr3GvE{-7_*OL zmjw9*GbD7cFF9}Y+vDZ_&k}d%W*?dH4k*Q0;1O92wCV^5Gfvg!lLiWgdb&7)>6{WCD7dJDC3gLkQ6NNm_filsi7&Khl%GDFV7<%c?+S4J_&=8N(*bF z4+WMEOD%;L@RZGHi<5XPJH>1UTWU;E0t3UQ>wNmX|M{YT7BG0a`njxgN@xNAUWq^+)}o_q~_A$*Y;EO2G?B-b?N|Iq&A)n+N=b zrE5K?U@WZTk3AEwE;|4GnpkcOw4O~)$N#a^sTvO+7srIYeN>m_oxl`1i@=!MW%hUVxOm$v$gT#7A!>9I?HMU^1!17Kj+iO)Fd>b*%(*#KEYJ>5A(6- z%Y+M(=D4LW^RqsTNFGK=K40_)I~+`;%S)!<>g6BC+AqLU2}RmL%nL%Y8*!UmGi>Jj zrb?1zznYgK2w#z)1P_Vh4S&$;!letb=8cT;9XM9x6)2#HRtwT7p^2?hXCGDirmG}p z!s>VtdlGN1qo5(fUS!g8^RZ%b2)JDm>Nynsbexu`>+ICX9{avnQzgl&D;2PT4pOZ> ztfRpEw3)3d$MYcd4(LLoBca$r#}$b>&Q49DV+dayu9D1DTZw?h=hVnRsQ~K<{0OOSS7of}#II5tlx@yrx+v zDQ->0EmmGyZ|{rVURtwxY%a{V8+kh*1zKM8a$AKC!kkCGXDsb0l6|XZT6Q$p>2NkF>B}{>QuceT%y+GWGx&0jG|LrRx4?2x(sV~tJ zM$?i~6zo-?n*Xy8HN#a%NUXbSa>71oYXPS=vCq*~Ey1~4ZDBOpYDGcP4nm*M)vmq6 zxTcUW%*vcOjr#=q1qSgSn_C_{qW}N^07*qoM6N<$g5wth A?*IS* diff --git a/docs/_build/html/_images/math/b62df33f46595ed60c51f255186ee346c1fcc0cb.png b/docs/_build/html/_images/math/b62df33f46595ed60c51f255186ee346c1fcc0cb.png deleted file mode 100644 index 6041d28bffb635ddc7de15c56485ec41208d40a4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1950 zcma)-X*e6$8pqQrE<#IVNh~#5MTb!9jIBk|#!_1iZ5q2Y;i8o>BF(LiR)yBuP&<*N zMcgX2XVIyB84XdC+FENYu~$iF+_<0a$9q1U^FHT&|G)FR=fnR^c6YrhD-Dqb006R% z2$&}TaI9Ap>z@!4?aCkL+eL?wyNeh6@bFL+{{PExl0ptx4^j z#ys7S*jsu?PfWroiF&xM6z{7RC#eB6cg8-A6cd!>koD5bg02m_yK*KlgMTG~;|{e$ zd?Qtcc$Y_%dtss)!-@(<$F_}YxBvXpgzLgu33~hJ)2Brtu^7{0!tGlG%gr#-E2`F| z|GF_*DmX1>m#=#^Itw*T-U&vMP=ZgnQUfq>;Mrg1SzZ^^FM=yL@|0v_`>VXylmYo1 z-^ZG-D%F*ZXBM}xS5YyTN2VTEmcDgz=lN+(tNoIp)D)wdRZ_eHXb`mefRGw5^FC|F zW7U}Hd{J{sK1VfG^IDetc@4-T!|FbRWmXhh0$yiRt-?YHyY!bb`rz^7)DcUBn_(+Z zv44&2N$+D=O0Q?iSB7D2Lo7ez@RSDD@U?T2lEclh;J&=4NT`hyszpj2S5Yj(gMmMr zXIiJgH-b|_7pTwO6s!B{>$A&9Q#=>7}{iJ^C^G(un@16fE1b$l6)n#2&NaAFdaaYV5#vkoza^s{^qshbL}7H^`aWusbvSI zWt~0Mv~UZx&09}KffFeentyHPPEv3j7Jd{$Rh^@MN@boeZs`Lv-5Ko|%3pPA>A4zW9&cn(kg8qF}M>H)JbF zK)i?kRbkc&CBOQa3S6epb)2O-Lj$(6bBuC#Q8-#KW7Bv-oE~^7huF7V~cY*Ex_RECuz z3-yWhGlf)^YU6LkWlKu`^bmAJ{84T9aaFm}hH(54dM|&%S!i1`EABZN|C~qw7ho=Z z1(;$%%_w?AsqCm7@@e9`7TK=WLNF~37`0OY)Sf!+9L9g4IggNElki4DX(0(Nofg%5 zLr>;$?u$&XL#oETdYHHmX7E{96|f`L>a8Ti6e&U2m+!|BPADKv3(D(`w@3yY)1IO$ z8MvhS&=fsktYivDXkf|fS{3fb*OTe|kvJ=j*}Yk#91ve&{~JLiP`TngMSB8b~rcY1|Lf?yoD}x;th>JnlapK@lu@)Rl-zA-bKD`AvEaL-u4r&@& z$u6Sfp_5X}8){X8%g&5uZr~^mY1!B6X;g8GW-m|w60X*#3&_?K4oD+WNejX8ds&e7@a=cSh>d%qrpP&}R zFl$7k`Ic=bBeGO`I2PQlT{`%t?DLDIw53QUhN8h<<@)r5(eNu&at=r^XEu!*i`99( z-vYj?;sV*VmEe!a*4jk-FQjSLI0*|*e+3nR3aMTEp>^1 z9b4BQ)Y!VIPVc#PI5e2C5st3N>V)gOuCzo&uRlCUbP7eKd_OGduBVJ|8fG_S%U!4s RJvbV%j&N64m3_d&{{Vq0sNDbn diff --git a/docs/_build/html/_images/math/b6c245d487949782a89cab9ee83504a62fdc2337.png b/docs/_build/html/_images/math/b6c245d487949782a89cab9ee83504a62fdc2337.png deleted file mode 100644 index 024cb0350d40bab7a4b573cece77b58a83348e15..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 249 zcmeAS@N?(olHy`uVBq!ia0vp^JU}eK!VDxY_&1vXDT4r?5ZC|z{{xxC1O2-Ts)4Hc zOM?7@8A>D)y7&M7>|ykB?)vk0^R8^+14?lgctjR6Fz_7#VaBQ2e9}O{5KkA!5RU7~ z2@Fh(0tXMIFf5ZesKU%GV7%LCgMq5yiVfyx5+cqd7|cJ|n5fQtI8tG2W8=aJ2OBw8 zd{qC;GT~CY4$nLXuhR7$Op_F+37ledYFxv}(DZ`4CBLEB6lgw!r>mdKI;Vst0MZOX Axc~qF diff --git a/docs/_build/html/_images/math/bcb2457ac9d8995a4f34d57cadac7ecbbe58f3bd.png b/docs/_build/html/_images/math/bcb2457ac9d8995a4f34d57cadac7ecbbe58f3bd.png deleted file mode 100644 index 6d61d4f89dccc4cbb6e1cdca49a1d247d338bb82..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 246 zcmeAS@N?(olHy`uVBq!ia0vp^JRr=%3?!FCJ6-`&1_3@HuK)l42QrBV`ga#p16A{v z1o;Is?0>ob?q?5)lHYTUx)aVz+?o0nD8*Ue5n0T@z;^_M8K-LVNdpA~JzX3_IIbrr zB>Yjy`P16iXxi9lIHysux$)qphQ@`BjoD_*9CQ2`Chn;}IOh+Wz{zjzjnW=(V-6fR vdf zmjw9*GbD7cFF9}Y+vDZ_&k}d%W*?dH4k*Q0;1O92wCV^5Gfvg!lLiWgdb&7)>6{WCD7dJDC3gLkQ6NNm_filsi7&Khl%GDFV7<%c?+S4J_&=8N(*bF z4+WMEOD%;L@RZGHi<5XPJH>1UTWU;E0t3UQ>wNmX|M{YT7BG0a`njxgN@xNAUWqdXUvqx@!$2`P3Ak3Q=# z2)%PCHB-2^j@zM$IcMd~aD_tY6FF=j12=T906g*soH$fKtUHz7sn8e>&XcT zA!(cm2?++PXPjYRTEoUO(?P4J@gV~<^KRydGp&ui&JB&OhiZ2olw(V~c9(OF_<=`r i*b=&a8?;>KVo22IoHcpVnH50u7(8A5T-G@yGywp zmjw9*Gj!igF!Ct*{c`_YiO=WPFLrcL21;=jctjR6Fz_7#VaBQ2e9{aIj5eMwjv*T7 zYbWmaKI|ZJ+}<a7N6E8peX7A(C_CHXo|kd*t}Cx+kHJrF-1poYw!UDx~*i+8@?3Ul#dKndUr; zt#W>*^a-8anUVISH$B$>yGoPKrB%QGEJ!|d!?ROs=i0Tths>UBYv=mQ!9UN$UNk2`@rv7T%DQ9-2cZuWTbJYhGHmOGaF`fTVq$tVM mXZD@7OS^k6w?)tJc)+gf?+|mZb|fr9RyE{-7_*OLsH8p+`4>gTe~DWM4fb!0gG diff --git a/docs/_build/html/_images/math/d226d17c031c4b264fb8f59f953381951cc2e9b4.png b/docs/_build/html/_images/math/d226d17c031c4b264fb8f59f953381951cc2e9b4.png deleted file mode 100644 index 20ed40ecd14871fa2dbb0bf8a9c940bbc4b3f211..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1900 zcma)7dpHve7hfOmQE6%~LvOBaW=!t6<(4pnnk8d$ zNqa4XQ7)xo-nm3l^yTAuzCXS{zw<{fZEt7g4gl;E z?%FU>kzMIonB%dl49+{Dt#@{IcFq5vj!%`w>_*EH++92XN)78gf`H;{xXqp_vMaNS znca1XU$?t>69ABTxySpm^<)kM0Kh(btF!3f=_yQX>cOi@@qz5XK(-2uZcH$8b{vq* zgqDxVRi2qN6j;73N3F?1sx3X_+90~9Qk6CLjM*_1XG`-M|0h1w0BAf@jS8!uoHczT@Z1t@=wr4T*Ofe+SkR1~8aWcSLyv8qX%ub`+qzq2N# z8K~7wXn?Ft%cXjUG$K0s*Mw*CwNW@BfplL%({atgm7jx<#0#;x_&LpNtGr~bD)KLv=Bhk?+kj-Fx!qqUp*k2A^F`H zRqdzV&soa^{%(>THz-*)@Q0|;;f7%+31#Vd`9QF*Ln|mQ#X`D!*;GzA9>;vcWbC^j z`Pq`Lq}CRoepI;5{mR9pid9oaa?y0|o#yxL8*nEtvU*8LSf>H&`dWL^kHW2vo}Fxl z-R)nV5cAu;o$eU6Xi3f~qG!VU6C&Me@6BR9$hGT`bcS>(>~$kvS`zU(D}^xY5HA{@ zr1;~r$+kiWt-8Bk@cg@MO`p?Hwhnf)bv*G|Jr+S`Rh?~@6(LoewfWWMoZFq>Bq!?v zQmt^86KZ|}o2c+*OHo?Z1lKrLs5)}xhVzhqabf+$VFvLJUr?J;kHis~vM>#qVu3ym zGQgrJOMaat$eYw01RQn_iLgBMhEsPm6vr{@Gnt=P8}}Lc*mh4V41fHtJEU<0fGQ)p zc~_9l$ZJ*qlekT#fXCxTFge_t9fI{d$gAZsKiWSL-&~j53Gy>{aanbnSC(?Lvf$o| z@i$fatZ$(@4ha?psQIV$R z4inpY8M>L!m)5T<3KuF^`;!I;O&e~lINE~mCG9!aGnuhsKPN3nt1^9QZN&3iDz6b@ zHg^zV|2j=A7{`=7=-VudLMC^VjAlAPg#R|^sAKMr$}~Kgn7!(KOvk@&?!G=>m$ekd zwwBQe(u$>4brISPrP7tF;kK3Cz_Du`V!d^>Qcs`UdS{h~XWt8u2wYh-`!C3=0#Cht zt8&*Zshu4)qK~EDwe~~i2!&d8(BRu2mJ2p|MTUnCnZWwII`dBaRc}(pcXDzvOFM(> z?-Z(@Mb>BR&BQfaNC1mZ&HB6)-P&Jhtb-2`@BE$21BhV0^v~WPin|`U`WbuW6qk4r zy`}bNOYmby1U^a%9~ds(IFV5c(yDTAp46`lPkfKvI{fkIU_59C4vG<|SD;?uK zX+MdWQ^`ffbYQ~Yp68$^uBHwrdB7|rErdqZd4!&0smq3aB=JdSKaTl>iabqF>mT4~GgCa$5amXk<0xtOI4kNv-4VrxK zz1Icfku9&~d0QpL4psDsT^xelg?4M=4{0Dro{p*O>MsRn6o+^zR8UGW7~}Nf5Pv;a bjYU2?zBF(LiR)yBuP&<*N zMcgX2XVIyB84XdC+FENYu~$iF+_<0a$9q1U^FHT&|G)FR=fnR^c6YrhD-Dqb006R% z2$&}TaI9Ap>z@!4?aCkL+eL?wyNeh6@bFL+{{PExl0ptx4^j z#ys7S*jsu?PfWroiF&xM6z{7RC#eB6cg8-A6cd!>koD5bg02m_yK*KlgMTG~;|{e$ zd?Qtcc$Y_%dtss)!-@(<$F_}YxBvXpgzLgu33~hJ)2Brtu^7{0!tGlG%gr#-E2`F| z|GF_*DmX1>m#=#^Itw*T-U&vMP=ZgnQUfq>;Mrg1SzZ^^FM=yL@|0v_`>VXylmYo1 z-^ZG-D%F*ZXBM}xS5YyTN2VTEmcDgz=lN+(tNoIp)D)wdRZ_eHXb`mefRGw5^FC|F zW7U}Hd{J{sK1VfG^IDetc@4-T!|FbRWmXhh0$yiRt-?YHyY!bb`rz^7)DcUBn_(+Z zv44&2N$+D=O0Q?iSB7D2Lo7ez@RSDD@U?T2lEclh;J&=4NT`hyszpj2S5Yj(gMmMr zXIiJgH-b|_7pTwO6s!B{>$A&9Q#=>7}{iJ^C^G(un@16fE1b$l6)n#2&NaAFdaaYV5#vkoza^s{^qshbL}7H^`aWusbvSI zWt~0Mv~UZx&09}KffFeentyHPPEv3j7Jd{$Rh^@MN@boeZs`Lv-5Ko|%3pPA>A4zW9&cn(kg8qF}M>H)JbF zK)i?kRbkc&CBOQa3S6epb)2O-Lj$(6bBuC#Q8-#KW7Bv-oE~^7huF7V~cY*Ex_RECuz z3-yWhGlf)^YU6LkWlKu`^bmAJ{84T9aaFm}hH(54dM|&%S!i1`EABZN|C~qw7ho=Z z1(;$%%_w?AsqCm7@@e9`7TK=WLNF~37`0OY)Sf!+9L9g4IggNElki4DX(0(Nofg%5 zLr>;$?u$&XL#oETdYHHmX7E{96|f`L>a8Ti6e&U2m+!|BPADKv3(D(`w@3yY)1IO$ z8MvhS&=fsktYivDXkf|fS{3fb*OTe|kvJ=j*}Yk#91ve&{~JLiP`TngMSB8b~rcY1|Lf?yoD}x;th>JnlapK@lu@)Rl-zA-bKD`AvEaL-u4r&@& z$u6Sfp_5X}8){X8%g&5uZr~^mY1!B6X;g8GW-m|w60X*#3&_?K4oD+WNejX8ds&e7@a=cSh>d%qrpP&}R zFl$7k`Ic=bBeGO`I2PQlT{`%t?DLDIw53QUhN8h<<@)r5(eNu&at=r^XEu!*i`99( z-vYj?;sV*VmEe!a*4jk-FQjSLI0*|*e+3nR3aMTEp>^1 z9b4BQ)Y!VIPVc#PI5e2C5st3N>V)gOuCzo&uRlCUbP7eKd_OGduBVJ|8fG_S%U!4s RJvbV%j&N64m3_d&{{Vq0sNDbn diff --git a/docs/_build/html/_images/math/d843100cd0a02e1e5184694228a7ac41e19e8af2.png b/docs/_build/html/_images/math/d843100cd0a02e1e5184694228a7ac41e19e8af2.png deleted file mode 100644 index d457103b37702e9d5d786afce654b8df4df62675..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 417 zcmeAS@N?(olHy`uVBq!ia0vp^o6f&SeE)j-w! zB|(0{3=;c)pD+2`ZM6Pn!d;KKfuEkR0Hrt!JR*x382FBWFymBhK53xfA5Ry@5RLQ6 z2?v;WNOmyVaHuW*B+hs(zf0hpox#b4|2-QTU!G^1p!L_)__;j8r8o8x7HS3xtCJFb z9XN1cJ7Z3m9&__729Glxj&m48McLt}d=r-OsqF z%doR?;cF)5!}HFIOO(|HGqnGhX?*(J9LAa2GuQJ59{rp->ALx&weoU T)4KJ;7!=B$u6{1-oD!M<#=VeE diff --git a/docs/_build/html/_images/math/d8ee85ac4d75924cdf4b18f5fb3b46550932fc26.png b/docs/_build/html/_images/math/d8ee85ac4d75924cdf4b18f5fb3b46550932fc26.png deleted file mode 100644 index 050fa0733f6b202d35edab15f3685a17f39431af..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 222 zcmeAS@N?(olHy`uVBq!ia0vp^JV4CH!VDx|PJVD7Na+Ungt-3y{~yRC5*)DFya1?_ zuO!GXn89QH%ezJi65Vsp|1SAF!MyGjP=>R>BeEE%;0OpaPSxg<1`67Gx;Tb#Tu)AD zU~+q^zDi-%Tg{G?{HmLLOSYVvH{HabATOc%+`qQQ+l_B652s47il)q94P&~@aFx%P bhlRnzPwXPciSsjo1~GWL`njxgN@xNAeF!{^ diff --git a/docs/_build/html/_images/math/db3d34854a6f48587cf5b9a41df90ad1c5e332d6.png b/docs/_build/html/_images/math/db3d34854a6f48587cf5b9a41df90ad1c5e332d6.png deleted file mode 100644 index efb8757f7df76a99e3d32905fada708aead6eb54..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1324 zcma)6`!^E`0G>+>v0}<)WSd7($ZMf?vu37Pws~KMmREU9bTNiF@~Up@CLykOE33RR z?^(>Fh)|h^9=n{yMCE!6yYnC1@0{;(&iDQN<+$OTRFt%o004lBGZsydI$g@MaqWwbPb9l;D`WCws<7&N1nwqVc;~j1pi$iC#@7ISf5w` zK(%+5GWjN|+5muDmNVMH-MdHRbv_K@p(z=TvaxJ$v@Dcg0ReNoLFHJoDRp_DwL&dJ z8D{gj+&1Ahfv?+(a!^pF((T-jGj-dtJ=~j=xd$$VDf?Pe2lQ5|MpvRiFl*Nj%y*iz zY#uFoNAM)3^Pdcay?Cy3wqtF0t!s8omim05_nGk1Z&QqQYs^*n&0@2}Y7>M3H7j)= zA_@rJfn46oBu*6+MS43l{8(&id347{v%)+hH)UI0Cm`-%8+i8AnJGlKi7sC&HOAzS zaQPm!p|;7SOPt=M#kU8967sApihai}f9w0w&s%M+i`9m^vgsJD^;2&>M9e#`tY@$s zcNL3wRvj-=m5CFR*%yGJ(8pb}wa$`KvS|^WPBId;vsbDYHQ@>Nok3&QQ3vZ7Jr6Xz ze+gfhphdfi^bqkjz&>MGqUWy-dy#BgOy-k_{<0+!UOwb)XMY+>mpl-#2d=}&j3a4BjKKM7` zqUnvuQ)l_rn2-%&XZMalRfBV*44(B{Jp09b|hhgCove0oT^!UW7pKk3IN{-5{=Hk2TGzO##tHd z;0PyQhNx=0sGsAngdyg|JymVb-_3m^9igd6LUqocS8Q9(al9vBg^>?SUvbp-9Mq^H zz=yx~aWgg`NAY#JR)0TdBvtHHZ9Z^mz1ontTxJB#Fa8JzR~@2rIdCM@yD{6C;=*~kgh3rg9mfaipP1C0eMG2Bw-RvS`ms|&YrJYHP(#VH zvdk^dX&_+h!e$adbw(yLU7c<#X7oG#?B*nuxlxjRs|NU$+#tx%sJ>FOV|LV5@SJ?w&~v?N%=VRKvvcp|-_pwC z(#YCBS7HA3!DGmf;A=Ee`KI_y2DV_xZmI&7cW+ND1MB=wWt)U<6Y$8D5uy4UrJ1%o z+Va3E{%9uEGCl#~S+f6y@u%BMzV8RTD2D2eXtGW#Nlz|n^KKQ>2107NfBwm_S6o!T zMK)~-*xJ-mQKEPAH56hPwzzcc#{de}YbrpH+V-v~o=yH{CO@Jtbd zbA&}xTW&~0*F;Y{-cpoDLkud@)TAXgBv<*aS^zN7$IXtd@>+CpXE8daE*NcCFx%wf zxp*CSO`~9sL3QsiR@*)0gYNb3yc0vG?dV89mlQAfe0du#BH3(yn9n3EH~t<74`dPqN>lyj0TuC- z1o;Isl>C-3O6cD2vHtVio2P$028weQctjR6Fz_7#VaBQ2e9}NceNPw15RU7~2@H&G ztZZy)>}(PVzUc`D$yo^;9~g_4F>hoG$Z=#~e%`{%BXgODAx4??!-Ca4qCl+-p00i_ I>zopr0Gt0ThX4Qo diff --git a/docs/_build/html/_images/math/e03ea88dda29ab6daa19c839ff37b8115e0a10e1.png b/docs/_build/html/_images/math/e03ea88dda29ab6daa19c839ff37b8115e0a10e1.png deleted file mode 100644 index 633ed9aca438874729eb8f32791653f828569ee4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 430 zcmeAS@N?(olHy`uVBq!ia0vp^F+j}E!VDy5-`;8jqznRlLR|m<{|{sm5A^RYs0OO$ zFA4GsX6XKXe!YZ;QAxtfxp((}t_YAx07`KdctjR6Fz_7#VaBQ2e9{aIjGUe>jv*T7 zlM_P90*efb5*(Ox-pAJX8znFt+w0)?jDby*&5Ti`^DqxjA(O-@SIJk>5?T^B>Wwz| zI!yd=@W6qeqRu~!*`BfU@bdJ?OIR>ZIO^yXS)Zg4o|5pBVaW{f1)ZC15)u;rH@>Wx z@REneNBV-xPCbU)ADyn1HOv!M_&W$cW$$8oo4V=Vng*>xDVGz@H%!wT7<3HeUkKYV zw{`Lqa%w!flaM~garFVdQ&MBb@0Mr9CO8@`> diff --git a/docs/_build/html/_images/math/e486de19dbb61c9a63584f6e4ddd6e92ef03d665.png b/docs/_build/html/_images/math/e486de19dbb61c9a63584f6e4ddd6e92ef03d665.png deleted file mode 100644 index 050fa0733f6b202d35edab15f3685a17f39431af..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 222 zcmeAS@N?(olHy`uVBq!ia0vp^JV4CH!VDx|PJVD7Na+Ungt-3y{~yRC5*)DFya1?_ zuO!GXn89QH%ezJi65Vsp|1SAF!MyGjP=>R>BeEE%;0OpaPSxg<1`67Gx;Tb#Tu)AD zU~+q^zDi-%Tg{G?{HmLLOSYVvH{HabATOc%+`qQQ+l_B652s47il)q94P&~@aFx%P bhlRnzPwXPciSsjo1~GWL`njxgN@xNAeF!{^ diff --git a/docs/_build/html/_images/math/e655092ec45224f09927d0ed9e6fcdfbddb67754.png b/docs/_build/html/_images/math/e655092ec45224f09927d0ed9e6fcdfbddb67754.png deleted file mode 100644 index a78d831d9e31d937ba1ebefb501f06d83370c083..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 938 zcmeAS@N?(olHy`uVBq!ia0vp^Z-H2xg&9bSW?elDqznRlLR|m<{|{sm5A^RYs0OO$ zFA4GsW{}wb`+UjgZlm=t6YhG<4gBFtd8PIEHu} zUpmb=ytd*>*M*J_1(D`^EGy$|GrlU>ie%?Ewd*Rmt~6l}{Bmip zC*RR|SsyQm>34PTc7-S|eSO@~Mb%bhuZHf_sFhpKT~ABDeR9$b%QrQDjrY$qe}9(y zLd46?IlhZNUJ9LlYMM3kxyK*YsBQh4xj2CTKwiai$@~SIzr9KS`!tNvapx=7v#$>K zuFsHN?>yzk%S)#?c(;W_r|(*jZ!z_m21D(n13LrQ!@CU+&-zoMe{K4^$yVYKMfN89 z%`a@Mn_`fxb zRkb1ip~2ooDc&m6yFX|?C`(?&kSzLl%jGGH#b+vtbl-J3WE|G8((`U0)3cl3@0l6R z{wH=eRp}4Mjwch2Bz0G~&VK2-YnAJp>4NVT>kF*Q6`RuV{mt#N@VBmtdcr%CjlQc0 ztPi+7$@-6Pc-r>)&nFiqoeq8!XU6!Wpk^VTp0IEEsXN^VBIg&+;){1Y;JeG?NfuD* zTexgYE&)W zyZoy6i0mJWb93T26YiLNwC*^u<|J>Y#q|{bmSb;T2_0uUrebZMe*bL%(~P;XD&G4} zW*0dt1xEC4~e`{!D0i}}Z>cJ`W9T<>l*PbP0l+XkKS|y)k diff --git a/docs/_build/html/_images/math/e9ea4b57a39788145fd98faa5d80911b52f3e435.png b/docs/_build/html/_images/math/e9ea4b57a39788145fd98faa5d80911b52f3e435.png deleted file mode 100644 index 36cde21448ff073c03c42ea14e936828941029f3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1209 zcmV;q1V;ObP)s4k0Kqxrfrv?V30HD<} z+SD%flC^`e+}PE(KhlZM9I7CuK%$cGep)`M)prVgHaH&Uj+=N1-yw>zQY@+M4%45i zgO0CPjJ7dZ2$2vz`3B^qoX_VoBsU2a5?LozBijtvL1*wuPrye@C3u555-n8JR+ThY zgCwJEAPWi^Y}Fx>V!yIQg%Ca$h&lWn;DndI!3AIBM~GK%BkpE+az$Nk0w zU3x<<723=mG52P6EcWq}E_im98zEleaBy;R+UBCSoXE0y+CD@S#fJ~<`r@Z%%-|eF z%marSTYbf##Q}R8@w)Z-&$PvwF(o69!PO=J+$UeG3Kz-I6FcfsPn#haA_=$xoqu@n zBm*t5w^?3ls^QPHU9C#GA1rOFFz|m85(fT#nhQO^Q)zKnh$6mvFX5sO%y}Jw-h#CS z6|^Y@)zqQ6+GH$f3fYQdcq+YF0vQiHmBgQd8>|ike`g6TJ}@v*E9j6Y+R0T;+eCo( zc4iT6BI=UKaqPlp28DR3M4OBY4d@xt)j6~noNI$eu!r7@ot-Z` zJL&C|TLkKdt#J7r6K~h%y+$2Z3J|MrSb7F1L{9P4=b+*}dULEf*>;aMX5w|S0XuzQ zd*rz*vyIkGV>e!GuY!|aM^n zm;%XQZ4sl4wl4BI4y-|`X0)OE?tH#mO^SU&5l=j#1&k=w-U5y1nT95{BUoDqeA?n( z$YIVP+P}sa_jp}clXSe$6g^->WRkf^+?$ki-?`|{U~N<4K5dd05=*g$es*W6yQCkS z6is!b`BuP4KeJ{nIV*APO1ONlw#&e?FHAo?DsWJ^(Dfikn8Fkjf6jN6{Bk1)T X+-)}JP|ow&00000NkvXXu0mjfq%0Uc diff --git a/docs/_build/html/_images/math/ec1ca2f34e7505e1a6ea382d2ac832ec9bba9d06.png b/docs/_build/html/_images/math/ec1ca2f34e7505e1a6ea382d2ac832ec9bba9d06.png deleted file mode 100644 index defd8e06707ec024ac9fda038caffad43707e2c9..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1322 zcmV+_1=aeAP)1h3CEHiYwMt`NxcK<29Ln-_I6hr3XB9b|N z!xN;f)y1CY$(z%0thN~iC3n+aq*jE1>ZSYsFqA8U*fSo!L8Rm8w(`&YtWqEi-Pey zogs9Vwar*Eukjl{X{v2kY;%W9!{Gkifx7cEBp7a}GaJFX-+ncg%X>^%1!yhb?5RU7 zkU6L5b-L)xJ5vjf#&lvX*#CDdmlE^#B#<1SQo70=dK!)|=r#E;O`CG}+pY|px0o)1 zi)_~;iR>G#ZuZuhcHk7`Z`}gfap-9{lJ1aBs8d<`uH+b|MM>0jc4-4Ux={oP+WcumAz zh;-L3x69waAg#izNlA( zr=W9R>COtx8j%iP0ZuPiICG_**%Bx{q!jJq$_tSh8im87XQ36#dLd;YVF4#5$@cUd zQfA1ZXTkTKhbP114Rd7#7o`+i>)uM$TP0E!R+G?JhsgGH5o#gmkXdll_h2~x=DG4V zv9k|j`?lWl4pWUrqs%O7F0}J>XUtISyw&0OeY%h|l=^90 zf52%UN*H%`l*2)X%p&{txpt_@(aHj4S4H4fVewJwFRj(gcgza8ZCouiPiO~8(_;o4 zGRt?qC-atIIH8i`O&$SpUzguo&TKkIoy((-;)AdA{`SKgn^}xoYD(oA?{}NaeGqUL zv~p2Fof)%V_QJ0tTe|2_C$c*>M(bQ!e+jB0|I&3-cP#Gzx zTg~+AYT7-VFFm$NWpyg3oYl&i%g$$ygmpLYDWq~wxV)PJPWqcUwXxB%(oO7?NZX** z2#e=|-fRi?lBQ|1KX+-6l2x>IlYYwpNF%YYCtR|@rYYy1Y}QmYCt5!PkF`94OOCnu zU~AWCSordgi8P6pzTa!@dqG91{zA@YehqDOoz~IeGL|LzLJl2w^n%M1cs$^VcFfLk zS#CnH$iZ1EI7?~i@zDf+98}lSp1HqLAIQx>J4?hI{rHu61o|aoiX1@ZdRAFCpg1|% zT&Lz^(s=Be!hy8r+H diff --git a/docs/_build/html/_images/math/ed38fa24f1c94891bd312012aab3f6673be3eb83.png b/docs/_build/html/_images/math/ed38fa24f1c94891bd312012aab3f6673be3eb83.png deleted file mode 100644 index 03832e37653b89b7a6e6f7c823410e8377a49ff5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 243 zcmeAS@N?(olHy`uVBq!ia0vp^0zk~e!VDy5o>bTbq;vy(LR|m<{|{sm2@Y6oUI0|e zR}$nG%pkG<_xX~~-A3zQCfxN2=T906g*soH$fK*1nS7sn8e>&XcT zA$3Xze)&vnY;63?%6y!KO~4>Yfc-MhXBKV+o}DiRW;H%#oTB(e#>v<(f-SMY=*?}0 vG@pb7YlcOx4Q~5bFICIMC*1hz)5yrc?Je*ybXDmqpy>>ru6{1-oD!M<0nXMlPEq|UskY0tKfhN zZBa8pL4$-2)w~1)L&S#)HdD0~h0=+LV%yj}X%S+#)|S2Hc3Y_QJls2X z<~!f{?!D)pxxkIs>P?09uuK)Vz-~>{|IJR@Hxt&&e(b%xn=SMweH7d<%(H4!h6>){Z75uVq(~)!1-gI!;!l8 z{L8j$4_3q2wy3_FREI!u-t83fW%J>61GiIGG+59H;5mNzH8<)bW%sQM^!9APM6gU_ z4b*XDb?z%X`sUbG`RRWm*l1MWP52ji>J~Z$ecOB}Td=50fd#z{T;!K8aq|YI9OTyh zquyXj1t(v2P~tU^hIvqtH-JNS7`qTxFm`y+CfsB}=?XjJ2>dOhd6Ug@Gm29h)Q!g6 zd?te7(-z4IZgTuNW2-ciQ%)G$7S(rKdXgtGXe0|#F2Bg#WJ6HiOKm?baE>C?kTU`% zg5j$c$zg6vK6#-Aj76|*QGK`U0}0985`<^juX>&Zo$N=ErZqWIL1u*}xrOFm^|q4JIHLj z&v|(iQKm+HIgI=;QZ9z@{K{*TKi@qXgAH#PyS;-YqRbh|f@D{@O5KN^AlijB$aO5C z%)f}Vm*%()Q6@i6NC@TIl%dpwbsjz(iw&<3i?mQ&Z85|Ox&!!=x{4?02^IDIN)4~5 zWu8t+k7e@dGUHBZzp(_#Jm!_I%e|uV_)R*E>rl2d3c}nZ{a;><2$HF)owKpH<_VgY zgqn+r@JAtQ<0&pfY(*`~bO7>pst;DRT%ag@miq!ShI%m;8;W{>s@NqPN3U33@!$$( z@1y?PoO!A3>U*pRay~d(r1@PKV`eGzw$b&Iha5Vj`QS{pw&S8lBi^ z)ad|RXyCfx|8BTRCCoS=AYD5@OXZiH2TH+RVs&Rl+P98F)Lo1lXc zCb4 diff --git a/docs/_build/html/_images/math/f75f28dbcbec776fbe031f8ac923f83f9260bd8a.png b/docs/_build/html/_images/math/f75f28dbcbec776fbe031f8ac923f83f9260bd8a.png deleted file mode 100644 index 01805a4513238f198838ca8eb1c82db4c3729aaa..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 481 zcmeAS@N?(olHy`uVBq!ia0vp^MnEja!VDw}bS^CdQU(D&A+G=b{|7RO2l{sxR0CD> zmjw9*Gj!igF!Ct*{c`_YiO=WPFLrcL21;=jctjR6Fz_7#VaBQ2e9{aIj5eMwjv*T7 zYbWmaKI|ZJ+}<a7N6E8peX7A(C_CHXo|kd*t}Cx+kHJrF-1poYw!UDx~*i+8@?3Ul#dKndUr; zt#W>*^a-8anUVISH$B$>yGoPKrB%QGEJ!|d!?ROs=i0Tths>UBYv=mQ!9UN$UNk2`@rv7T%DQ9-2cZuWTbJYhGHmOGaF`fTVq$tVM mXZD@7OS^k6w?)tJc)+gf?+|mZDnM?jcysy3fAP%zfh#W95AdU8TS z$iM$LCpI>kZr!)}LVV-Gu7!2X%$LL47W4e(me^5mY+!K0*r4D)%cXD$i3;h4FIH@A z$qrqg&7E5qCZzp&#UzxP;FZA8{8L(Ci$P1$h2~342|^4@Hw&kT8nT`QdBfAy&t;uc GLK6U)yh>C6 diff --git a/docs/_build/html/_images/mci_schematic.png b/docs/_build/html/_images/mci_schematic.png deleted file mode 100644 index 8d0d4a0181c099d44325dbe90755f5fc269296bb..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 61004 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 diff --git a/docs/_build/html/_modules/abc.html b/docs/_build/html/_modules/abc.html deleted file mode 100644 index 580b4f31..00000000 --- a/docs/_build/html/_modules/abc.html +++ /dev/null @@ -1,247 +0,0 @@ - - - - - - - abc — Tigramite 4.2 documentation - - - - - - - - - - - - - -
-
-
-
- -

Source code for abc

-# Copyright 2007 Google, Inc. All Rights Reserved.
-# Licensed to PSF under a Contributor Agreement.
-
-"""Abstract Base Classes (ABCs) according to PEP 3119."""
-
-
-def abstractmethod(funcobj):
-    """A decorator indicating abstract methods.
-
-    Requires that the metaclass is ABCMeta or derived from it.  A
-    class that has a metaclass derived from ABCMeta cannot be
-    instantiated unless all of its abstract methods are overridden.
-    The abstract methods can be called using any of the normal
-    'super' call mechanisms.
-
-    Usage:
-
-        class C(metaclass=ABCMeta):
-            @abstractmethod
-            def my_abstract_method(self, ...):
-                ...
-    """
-    funcobj.__isabstractmethod__ = True
-    return funcobj
-
-
-class abstractclassmethod(classmethod):
-    """A decorator indicating abstract classmethods.
-
-    Similar to abstractmethod.
-
-    Usage:
-
-        class C(metaclass=ABCMeta):
-            @abstractclassmethod
-            def my_abstract_classmethod(cls, ...):
-                ...
-
-    'abstractclassmethod' is deprecated. Use 'classmethod' with
-    'abstractmethod' instead.
-    """
-
-    __isabstractmethod__ = True
-
-    def __init__(self, callable):
-        callable.__isabstractmethod__ = True
-        super().__init__(callable)
-
-
-class abstractstaticmethod(staticmethod):
-    """A decorator indicating abstract staticmethods.
-
-    Similar to abstractmethod.
-
-    Usage:
-
-        class C(metaclass=ABCMeta):
-            @abstractstaticmethod
-            def my_abstract_staticmethod(...):
-                ...
-
-    'abstractstaticmethod' is deprecated. Use 'staticmethod' with
-    'abstractmethod' instead.
-    """
-
-    __isabstractmethod__ = True
-
-    def __init__(self, callable):
-        callable.__isabstractmethod__ = True
-        super().__init__(callable)
-
-
-class abstractproperty(property):
-    """A decorator indicating abstract properties.
-
-    Requires that the metaclass is ABCMeta or derived from it.  A
-    class that has a metaclass derived from ABCMeta cannot be
-    instantiated unless all of its abstract properties are overridden.
-    The abstract properties can be called using any of the normal
-    'super' call mechanisms.
-
-    Usage:
-
-        class C(metaclass=ABCMeta):
-            @abstractproperty
-            def my_abstract_property(self):
-                ...
-
-    This defines a read-only property; you can also define a read-write
-    abstract property using the 'long' form of property declaration:
-
-        class C(metaclass=ABCMeta):
-            def getx(self): ...
-            def setx(self, value): ...
-            x = abstractproperty(getx, setx)
-
-    'abstractproperty' is deprecated. Use 'property' with 'abstractmethod'
-    instead.
-    """
-
-    __isabstractmethod__ = True
-
-
-try:
-    from _abc import (get_cache_token, _abc_init, _abc_register,
-                      _abc_instancecheck, _abc_subclasscheck, _get_dump,
-                      _reset_registry, _reset_caches)
-except ImportError:
-    from _py_abc import ABCMeta, get_cache_token
-    ABCMeta.__module__ = 'abc'
-else:
-    class ABCMeta(type):
-        """Metaclass for defining Abstract Base Classes (ABCs).
-
-        Use this metaclass to create an ABC.  An ABC can be subclassed
-        directly, and then acts as a mix-in class.  You can also register
-        unrelated concrete classes (even built-in classes) and unrelated
-        ABCs as 'virtual subclasses' -- these and their descendants will
-        be considered subclasses of the registering ABC by the built-in
-        issubclass() function, but the registering ABC won't show up in
-        their MRO (Method Resolution Order) nor will method
-        implementations defined by the registering ABC be callable (not
-        even via super()).
-        """
-        def __new__(mcls, name, bases, namespace, **kwargs):
-            cls = super().__new__(mcls, name, bases, namespace, **kwargs)
-            _abc_init(cls)
-            return cls
-
-        def register(cls, subclass):
-            """Register a virtual subclass of an ABC.
-
-            Returns the subclass, to allow usage as a class decorator.
-            """
-            return _abc_register(cls, subclass)
-
-        def __instancecheck__(cls, instance):
-            """Override for isinstance(instance, cls)."""
-            return _abc_instancecheck(cls, instance)
-
-        def __subclasscheck__(cls, subclass):
-            """Override for issubclass(subclass, cls)."""
-            return _abc_subclasscheck(cls, subclass)
-
-        def _dump_registry(cls, file=None):
-            """Debug helper to print the ABC registry."""
-            print(f"Class: {cls.__module__}.{cls.__qualname__}", file=file)
-            print(f"Inv. counter: {get_cache_token()}", file=file)
-            (_abc_registry, _abc_cache, _abc_negative_cache,
-             _abc_negative_cache_version) = _get_dump(cls)
-            print(f"_abc_registry: {_abc_registry!r}", file=file)
-            print(f"_abc_cache: {_abc_cache!r}", file=file)
-            print(f"_abc_negative_cache: {_abc_negative_cache!r}", file=file)
-            print(f"_abc_negative_cache_version: {_abc_negative_cache_version!r}",
-                  file=file)
-
-        def _abc_registry_clear(cls):
-            """Clear the registry (for debugging or testing)."""
-            _reset_registry(cls)
-
-        def _abc_caches_clear(cls):
-            """Clear the caches (for debugging or testing)."""
-            _reset_caches(cls)
-
-
-class ABC(metaclass=ABCMeta):
-    """Helper class that provides a standard way to create an ABC using
-    inheritance.
-    """
-    __slots__ = ()
-
- -
-
-
-
-
- - - - \ No newline at end of file diff --git a/docs/_build/html/_modules/index.html b/docs/_build/html/_modules/index.html deleted file mode 100644 index 559e560a..00000000 --- a/docs/_build/html/_modules/index.html +++ /dev/null @@ -1,86 +0,0 @@ - - - - - - - Overview: module code — Tigramite 4.2 documentation - - - - - - - - - - - - - -
-
-
-
- -

All modules for which code is available

- - -
-
-
-
-
- - - - \ No newline at end of file diff --git a/docs/_build/html/_modules/tigramite/data_processing.html b/docs/_build/html/_modules/tigramite/data_processing.html deleted file mode 100644 index 84eb281c..00000000 --- a/docs/_build/html/_modules/tigramite/data_processing.html +++ /dev/null @@ -1,1512 +0,0 @@ - - - - - - - tigramite.data_processing — Tigramite 4.2 documentation - - - - - - - - - - - - - -
-
-
-
- -

Source code for tigramite.data_processing

-"""Tigramite data processing functions."""
-
-# Author: Jakob Runge <jakob@jakob-runge.com>
-#
-# License: GNU General Public License v3.0
-from __future__ import print_function
-from collections import defaultdict, OrderedDict
-import sys
-import warnings
-import copy
-import numpy as np
-import scipy.sparse
-import scipy.sparse.linalg
-
-
[docs]class DataFrame():
-    """Data object containing time series array and optional mask.
-
-    Alternatively, a panda dataframe can be used.
-
-    Parameters
-    ----------
-    data : array-like
-        Numpy array of shape (observations T, variables N)
-    mask : array-like, optional (default: None)
-        Optional mask array, must be of same shape as data
-
-    Attributes
-    ----------
-    data : array-like
-        Numpy array of shape (observations T, variables N)
-    mask : array-like, optional (default: None)
-        Optional mask array, must be of same shape as data
-    missing_flag : number, optional (default: None)
-        Flag for missing values in dataframe. Dismisses all time slices of
-        samples where missing values occur in any variable and also flags
-        samples for all lags up to 2*tau_max. This avoids biases, see
-        section on masking in Supplement of [1]_.
-    var_names : list of strings, optional (default: range(N))
-        Names of variables, must match the number of variables. If None is
-        passed, variables are enumerated as [0, 1, ...]
-    datatime : array-like, optional (default: None)
-        Timelabel array. If None, range(T) is used.
-    """
-    def __init__(self, data, mask=None, missing_flag=None, var_names=None,
-        datatime=None):
-
-        self.values = data
-        self.mask = mask
-        self.missing_flag = missing_flag
-        T, N = data.shape
-        # Set the variable names
-        self.var_names = var_names
-        # Set the default variable names if none are set
-        if self.var_names is None:
-            self.var_names = {i: i for i in range(N)}
-
-        # Set datatime
-        self.datatime = datatime
-        if self.datatime is None:
-            self.datatime = np.arange(T)
-
-        # if type(self.values) != np.ndarray:
-        #     raise TypeError("data is of type %s, " % type(self.values) +
-        #                     "must be np.ndarray")
-        if N > T:
-            warnings.warn("data.shape = %s," % str(self.values.shape) +
-                          " is it of shape (observations, variables) ?")
-        # if np.isnan(data).sum() != 0:
-        #     raise ValueError("NaNs in the data")
-        self._check_mask()
-
-        # If PCMCI.run_bootstrap_of is called, then the
-        # bootstrap random draw can be set here
-        self.bootstrap = None
-
-    def _check_mask(self, mask=None, require_mask=False):
-        """Checks that the mask is:
-            * The same shape as the data
-            * Is an numpy ndarray (or subtype)
-            * Does not contain any NaN entrie
-
-        Parameters
-        ----------
-        require_mask : bool (default : False)
-        """
-        # Check that there is a mask if required
-        _use_mask = mask
-        if _use_mask is None:
-            _use_mask = self.mask
-        if require_mask and _use_mask is None:
-            raise ValueError("Expected a mask, but got nothing!")
-        # If we have a mask, check it
-        if _use_mask is not None:
-            # Check the mask inherets from an ndarray
-            if not isinstance(_use_mask, np.ndarray):
-                raise TypeError("mask is of type %s, " %
-                                type(_use_mask) +
-                                "must be numpy.ndarray")
-            # Check if there is an nan-value in the mask
-            if np.isnan(np.sum(_use_mask)):
-                raise ValueError("NaNs in the data mask")
-            # Check the mask and the values have the same shape
-            if self.values.shape != _use_mask.shape:
-                raise ValueError("shape mismatch: dataframe.values.shape = %s"
-                                 % str(self.values.shape) + \
-                                 " but mask.shape = %s,"
-                                 % str(_use_mask.shape)) + \
-                                 "must identical"
-
-
[docs]    def construct_array(self, X, Y, Z, tau_max,
-                        mask=None,
-                        mask_type=None,
-                        return_cleaned_xyz=False,
-                        do_checks=True,
-                        cut_off='2xtau_max',
-                        verbosity=0):
-        """Constructs array from variables X, Y, Z from data.
-
-        Data is of shape (T, N), where T is the time series length and N the
-        number of variables.
-
-        Parameters
-        ----------
-        X, Y, Z : list of tuples
-            For a dependence measure I(X;Y|Z), Y is of the form [(varY, 0)],
-            where var specifies the variable index. X typically is of the form
-            [(varX, -tau)] with tau denoting the time lag and Z can be
-            multivariate [(var1, -lag), (var2, -lag), ...] .
-        tau_max : int
-            Maximum time lag. This may be used to make sure that estimates for
-            different lags in X and Z all have the same sample size.
-        mask : array-like, optional (default: None)
-            Optional mask array, must be of same shape as data.  If it is set,
-            then it overrides the self.mask assigned to the dataframe. If it is
-            None, then the self.mask is used, if it exists.
-        mask_type : {'y','x','z','xy','xz','yz','xyz'}
-            Masking mode: Indicators for which variables in the dependence
-            measure I(X; Y | Z) the samples should be masked. If None, 'y' is
-            used, which excludes all time slices containing masked samples in Y.
-            Explained in [1]_.
-        return_cleaned_xyz : bool, optional (default: False)
-            Whether to return cleaned X,Y,Z, where possible duplicates are
-            removed.
-        do_checks : bool, optional (default: True)
-            Whether to perform sanity checks on input X,Y,Z
-        cut_off : {'2xtau_max', 'max_lag', 'max_lag_or_tau_max'}
-            How many samples to cutoff at the beginning. The default is
-            '2xtau_max', which guarantees that MCI tests are all conducted on
-            the same samples. For modeling, 'max_lag_or_tau_max' can be used,
-            which uses the maximum of tau_max and the conditions, which is
-            useful to compare multiple models on the same sample.  Last,
-            'max_lag' uses as much samples as possible.
-        verbosity : int, optional (default: 0)
-            Level of verbosity.
-
-        Returns
-        -------
-        array, xyz [,XYZ] : Tuple of data array of shape (dim, time) and xyz
-            identifier array of shape (dim,) identifying which row in array
-            corresponds to X, Y, and Z. For example:: X = [(0, -1)], Y = [(1,
-            0)], Z = [(1, -1), (0, -2)] yields an array of shape (4, T) and
-            xyz is xyz = numpy.array([0,1,2,2]) If return_cleaned_xyz is
-            True, also outputs the cleaned XYZ lists.
-
-        """
-
-        # Get the length in time and the number of nodes
-        T, N = self.values.shape
-
-        # Remove duplicates in X, Y, Z
-        X = list(OrderedDict.fromkeys(X))
-        Y = list(OrderedDict.fromkeys(Y))
-        Z = list(OrderedDict.fromkeys(Z))
-
-        # If a node in Z occurs already in X or Y, remove it from Z
-        Z = [node for node in Z if (node not in X) and (node not in Y)]
-
-        # Check that all lags are non-positive and indices are in [0,N-1]
-        XYZ = X + Y + Z
-        dim = len(XYZ)
-
-        # Ensure that XYZ makes sense
-        if do_checks:
-            self._check_nodes(Y, XYZ, N, dim)
-
-        # Figure out what cut off we will be using
-        if cut_off == '2xtau_max':
-            max_lag = 2*tau_max
-        elif cut_off == 'max_lag':
-            max_lag = abs(np.array(XYZ)[:, 1].min())
-        elif cut_off == 'max_lag_or_tau_max':
-            max_lag = max(abs(np.array(XYZ)[:, 1].min()), tau_max)
-        else:
-            raise ValueError("max_lag must be in {'2xtau_max', 'max_lag', 'max_lag_or_tau_max'}")
-
-        # Setup XYZ identifier
-        index_code = {'x' : 0,
-                      'y' : 1,
-                      'z' : 2}
-        xyz = np.array([index_code[name]
-                        for var, name in zip([X, Y, Z], ['x', 'y', 'z'])
-                        for _ in var])
-
-        # Setup and fill array with lagged time series
-        time_length = T - max_lag
-        array = np.zeros((dim, time_length), dtype=self.values.dtype)
-        # Note, lags are negative here
-        for i, (var, lag) in enumerate(XYZ):
-            if self.bootstrap is None:
-                array[i, :] = self.values[max_lag + lag:T + lag, var]
-            else:
-                array[i, :] = self.values[self.bootstrap + lag, var]
-
-        # Choose which indices to use
-        use_indices = np.ones(time_length, dtype='int')
-
-        # Remove all values that have missing value flag, as well as the time
-        # slices that occur up to max_lag after
-        if self.missing_flag is not None:
-            missing_anywhere = np.any(self.values == self.missing_flag, axis=1)
-            for tau in range(max_lag+1):
-                if self.bootstrap is None:
-                    use_indices[missing_anywhere[tau:T-max_lag+tau]] = 0
-                else:
-                    use_indices[missing_anywhere[self.bootstrap - max_lag + tau]] = 0
-
-        # Use the mask override if needed
-        _use_mask = mask
-        if _use_mask is None:
-            _use_mask = self.mask
-        else:
-            self._check_mask(mask=_use_mask)
-
-        if _use_mask is not None:
-            # Remove samples with mask == 1 conditional on which mask_type is
-            # used Create an array selector that is the same shape as the output
-            # array
-            array_mask = np.zeros((dim, time_length), dtype='int32')
-            # Iterate over all nodes named in X, Y, or Z
-            for i, (var, lag) in enumerate(XYZ):
-                # Transform the mask into the output array shape, i.e. from data
-                # mask to array mask
-                if self.bootstrap is None:
-                    array_mask[i, :] = (_use_mask[max_lag + lag: T + lag, var] == False)
-                else:
-                    array_mask[i, :] = (_use_mask[self.bootstrap + lag, var] == False)
-
-            # Iterate over defined mapping from letter index to number index,
-            # i.e. 'x' -> 0, 'y' -> 1, 'z'-> 2
-            for idx, cde in index_code.items():
-                # Check if the letter index is in the mask type
-                if (mask_type is not None) and (idx in mask_type):
-                    # If so, check if any of the data that correspond to the
-                    # letter index is masked by taking the product along the
-                    # node-data to return a time slice selection, where 0 means
-                    # the time slice will not be used
-                    slice_select = np.prod(array_mask[xyz == cde, :], axis=0)
-                    use_indices *= slice_select
-
-        if (self.missing_flag is not None) or (_use_mask is not None):
-            if use_indices.sum() == 0:
-                raise ValueError("No unmasked samples")
-            array = array[:, use_indices == 1]
-
-        # Print information about the constructed array
-        if verbosity > 2:
-            self.print_array_info(array, X, Y, Z, self.missing_flag, mask_type)
-
-        # Return the array and xyz and optionally (X, Y, Z)
-        if return_cleaned_xyz:
-            return array, xyz, (X, Y, Z)
-        return array, xyz

-
-    def _check_nodes(self, Y, XYZ, N, dim):
-        """
-        Checks that:
-        * The requests XYZ nodes have the correct shape
-        * All lags are non-positive
-        * All indices are less than N
-        * One of the Y nodes has zero lag
-
-        Parameters
-        ----------
-        Y : list of tuples
-            Of the form [(var, -tau)], where var specifies the variable
-            index and tau the time lag.
-        XYZ : list of tuples
-            List of nodes chosen for current independence test
-        N : int
-            Total number of listed nodes
-        dim : int
-            Number of nodes excluding repeated nodes
-        """
-        if np.array(XYZ).shape != (dim, 2):
-            raise ValueError("X, Y, Z must be lists of tuples in format"
-                             " [(var, -lag),...], eg., [(2, -2), (1, 0), ...]")
-        if np.any(np.array(XYZ)[:, 1] > 0):
-            raise ValueError("nodes are %s, " % str(XYZ) +
-                             "but all lags must be non-positive")
-        if (np.any(np.array(XYZ)[:, 0] >= N)
-                or np.any(np.array(XYZ)[:, 0] < 0)):
-            raise ValueError("var indices %s," % str(np.array(XYZ)[:, 0]) +
-                             " but must be in [0, %d]" % (N - 1))
-        if np.all(np.array(Y)[:, 1] != 0):
-            raise ValueError("Y-nodes are %s, " % str(Y) +
-                             "but one of the Y-nodes must have zero lag")
-
-
[docs]    def print_array_info(self, array, X, Y, Z, missing_flag, mask_type):
-        """
-        Print info about the constructed array
-
-        Parameters
-        ----------
-        array : Data array of shape (dim, T)
-            Data array.
-        X, Y, Z : list of tuples
-            For a dependence measure I(X;Y|Z), Y is of the form [(varY, 0)],
-            where var specifies the variable index. X typically is of the form
-            [(varX, -tau)] with tau denoting the time lag and Z can be
-            multivariate [(var1, -lag), (var2, -lag), ...] .
-        missing_flag : number, optional (default: None)
-            Flag for missing values. Dismisses all time slices of samples where
-            missing values occur in any variable and also flags samples for all
-            lags up to 2*tau_max. This avoids biases, see section on masking in
-            Supplement of [1]_.
-        mask_type : {'y','x','z','xy','xz','yz','xyz'}
-            Masking mode: Indicators for which variables in the dependence
-            measure I(X; Y | Z) the samples should be masked. If None, 'y' is
-            used, which excludes all time slices containing masked samples in Y.
-            Explained in [1]_.
-        """
-        indt = " " * 12
-        print(indt + "Constructed array of shape %s from"%str(array.shape) +
-              "\n" + indt + "X = %s" % str(X) +
-              "\n" + indt + "Y = %s" % str(Y) +
-              "\n" + indt + "Z = %s" % str(Z))
-        if self.mask is not None:
-            print(indt+"with masked samples in %s removed" % mask_type)
-        if self.missing_flag is not None:
-            print(indt+"with missing values = %s removed" % self.missing_flag)

-
-
-
-
[docs]def lowhighpass_filter(data, cutperiod, pass_periods='low'):
-    """Butterworth low- or high pass filter.
-
-    This function applies a linear filter twice, once forward and once
-    backwards. The combined filter has linear phase.
-
-    Parameters
-    ----------
-    data : array
-        Data array of shape (time, variables).
-    cutperiod : int
-        Period of cutoff.
-    pass_periods : str, optional (default: 'low')
-        Either 'low' or 'high' to act as a low- or high-pass filter
-
-    Returns
-    -------
-    data : array
-        Filtered data array.
-    """
-    try:
-        from scipy.signal import butter, filtfilt
-    except:
-        print('Could not import scipy.signal for butterworth filtering!')
-
-    fs = 1.
-    order = 3
-    ws = 1. / cutperiod / (0.5 * fs)
-    b, a = butter(order, ws, pass_periods)
-    if np.ndim(data) == 1:
-        data = filtfilt(b, a, data)
-    else:
-        for i in range(data.shape[1]):
-            data[:, i] = filtfilt(b, a, data[:, i])
-
-    return data

-
-
-
[docs]def smooth(data, smooth_width, kernel='gaussian',
-           mask=None, residuals=False):
-    """Returns either smoothed time series or its residuals.
-
-    the difference between the original and the smoothed time series
-    (=residuals) of a kernel smoothing with gaussian (smoothing kernel width =
-    twice the sigma!) or heaviside window, equivalent to a running mean.
-
-    Assumes data of shape (T, N) or (T,)
-    :rtype: array
-    :returns: smoothed/residual data
-
-    Parameters
-    ----------
-    data : array
-        Data array of shape (time, variables).
-    smooth_width : float
-        Window width of smoothing, 2*sigma for a gaussian.
-    kernel : str, optional (default: 'gaussian')
-        Smoothing kernel, 'gaussian' or 'heaviside' for a running mean.
-    mask : bool array, optional (default: None)
-        Data mask where True labels masked samples.
-    residuals : bool, optional (default: False)
-        True if residuals should be returned instead of smoothed data.
-
-    Returns
-    -------
-    data : array-like
-        Smoothed/residual data.
-    """
-
-    print("%s %s smoothing with " % ({True: "Take residuals of a ",
-                                      False: ""}[residuals], kernel) +
-          "window width %.2f (2*sigma for a gaussian!)" % (smooth_width))
-
-    totaltime = len(data)
-    if kernel == 'gaussian':
-        window = np.exp(-(np.arange(totaltime).reshape((1, totaltime)) -
-                             np.arange(totaltime).reshape((totaltime, 1))
-                             ) ** 2 / ((2. * smooth_width / 2.) ** 2))
-    elif kernel == 'heaviside':
-        import scipy.linalg
-        wtmp = np.zeros(totaltime)
-        wtmp[:np.ceil(smooth_width / 2.)] = 1
-        window = scipy.linalg.toeplitz(wtmp)
-
-    if mask is None:
-        if np.ndim(data) == 1:
-            smoothed_data = (data * window).sum(axis=1) / window.sum(axis=1)
-        else:
-            smoothed_data = np.zeros(data.shape)
-            for i in range(data.shape[1]):
-                smoothed_data[:, i] = (
-                    data[:, i] * window).sum(axis=1) / window.sum(axis=1)
-    else:
-        if np.ndim(data) == 1:
-            smoothed_data = ((data * window * (mask==False)).sum(axis=1) /
-                             (window * (mask==False)).sum(axis=1))
-        else:
-            smoothed_data = np.zeros(data.shape)
-            for i in range(data.shape[1]):
-                smoothed_data[:, i] = ((
-                    data[:, i] * window * (mask==False)[:, i]).sum(axis=1) /
-                    (window * (mask==False)[:, i]).sum(axis=1))
-
-    if residuals:
-        return data - smoothed_data
-    else:
-        return smoothed_data

-
-
-
[docs]def weighted_avg_and_std(values, axis, weights):
-    """Returns the weighted average and standard deviation.
-
-    Parameters
-    ---------
-    values : array
-        Data array of shape (time, variables).
-    axis : int
-        Axis to average/std about
-    weights : array
-        Weight array of shape (time, variables).
-
-    Returns
-    -------
-    (average, std) : tuple of arrays
-        Tuple of weighted average and standard deviation along axis.
-    """
-
-    values[np.isnan(values)] = 0.
-    average = np.ma.average(values, axis=axis, weights=weights)
-
-    variance = np.sum(weights * (values - np.expand_dims(average, axis)
-                                    ) ** 2, axis=axis) / weights.sum(axis=axis)
-
-    return (average, np.sqrt(variance))

-
-
-
[docs]def time_bin_with_mask(data, time_bin_length, mask=None):
-    """Returns time binned data where only about non-masked values is averaged.
-
-    Parameters
-    ----------
-    data : array
-        Data array of shape (time, variables).
-    time_bin_length : int
-        Length of time bin.
-    mask : bool array, optional (default: None)
-        Data mask where True labels masked samples.
-
-    Returns
-    -------
-    (bindata, T) : tuple of array and int
-        Tuple of time-binned data array and new length of array.
-    """
-
-    T = len(data)
-
-    time_bin_length = int(time_bin_length)
-
-    if mask is None:
-        sample_selector = np.ones(data.shape)
-    else:
-        # Invert mask
-        sample_selector = (mask == False)
-
-    if np.ndim(data) == 1.:
-        data.shape = (T, 1)
-        mask.shape = (T, 1)
-
-    bindata = np.zeros(
-        (T // time_bin_length,) + data.shape[1:], dtype="float32")
-    for index, i in enumerate(range(0, T - time_bin_length + 1,
-                                    time_bin_length)):
-        # print weighted_avg_and_std(fulldata[i:i+time_bin_length], axis=0,
-        # weights=sample_selector[i:i+time_bin_length])[0]
-        bindata[index] = weighted_avg_and_std(data[i:i + time_bin_length],
-                                              axis=0,
-                                              weights=sample_selector[i:i +
-                                              time_bin_length])[0]
-
-    T, grid_size = bindata.shape
-
-    return (bindata.squeeze(), T)

-
-
-
[docs]def ordinal_patt_array(array, array_mask=None, dim=2, step=1,
-                        weights=False, verbosity=0):
-    """Returns symbolified array of ordinal patterns.
-
-    Each data vector (X_t, ..., X_t+(dim-1)*step) is converted to its rank
-    vector. E.g., (0.2, -.6, 1.2) --> (1,0,2) which is then assigned to a
-    unique integer (see Article). There are faculty(dim) possible rank vectors.
-
-    Note that the symb_array is step*(dim-1) shorter than the original array!
-
-    Reference: B. Pompe and J. Runge (2011). Momentary information transfer as
-    a coupling measure of time series. Phys. Rev. E, 83(5), 1-12.
-    doi:10.1103/PhysRevE.83.051122
-
-    Parameters
-    ----------
-    array : array-like
-        Data array of shape (time, variables).
-    array_mask : bool array
-        Data mask where True labels masked samples.
-    dim : int, optional (default: 2)
-        Pattern dimension
-    step : int, optional (default: 1)
-        Delay of pattern embedding vector.
-    weights : bool, optional (default: False)
-        Whether to return array of variances of embedding vectors as weights.
-    verbosity : int, optional (default: 0)
-        Level of verbosity.
-
-    Returns
-    -------
-    patt, patt_mask [, patt_time] : tuple of arrays
-        Tuple of converted pattern array and new length
-    """
-    from scipy.misc import factorial
-
-    # Import cython code
-    try:
-        import tigramite.tigramite_cython_code as tigramite_cython_code
-    except ImportError:
-        raise ImportError("Could not import tigramite_cython_code, please"
-                          " compile cython code first as described in Readme.")
-
-    array = array.astype('float64')
-
-    if array_mask is not None:
-        assert array_mask.dtype == 'int32'
-    else:
-        array_mask = np.zeros(array.shape, dtype='int32')
-
-
-    if np.ndim(array) == 1:
-        T = len(array)
-        array = array.reshape(T, 1)
-        array_mask = array_mask.reshape(T, 1)
-
-    # Add noise to destroy ties...
-    array += (1E-6 * array.std(axis=0)
-              * np.random.rand(array.shape[0], array.shape[1]).astype('float64'))
-
-
-    patt_time = int(array.shape[0] - step * (dim - 1))
-    T, N = array.shape
-
-    if dim <= 1 or patt_time <= 0:
-        raise ValueError("Dim mist be > 1 and length of delay vector smaller "
-                         "array length.")
-
-    patt = np.zeros((patt_time, N), dtype='int32')
-    weights_array = np.zeros((patt_time, N), dtype='float64')
-
-    patt_mask = np.zeros((patt_time, N), dtype='int32')
-
-    # Precompute factorial for c-code... patterns of dimension
-    # larger than 10 are not supported
-    fac = factorial(np.arange(10)).astype('int32')
-
-    # _get_patterns_cython assumes mask=0 to be a masked value
-    array_mask = (array_mask == False).astype('int32')
-
-    (patt, patt_mask, weights_array) = \
-            tigramite_cython_code._get_patterns_cython(array, array_mask,
-                                                       patt, patt_mask,
-                                                       weights_array, dim,
-                                                       step, fac, N, T)
-
-    weights_array = np.asarray(weights_array)
-    patt = np.asarray(patt)
-    # Transform back to mask=1 implying a masked value
-    patt_mask = np.asarray(patt_mask) == False
-
-    if weights:
-        return (patt, patt_mask, patt_time, weights_array)
-    else:
-        return (patt, patt_mask, patt_time)

-
-
-
[docs]def quantile_bin_array(data, bins=6):
-    """Returns symbolified array with equal-quantile binning.
-
-    Parameters
-    ----------
-    data : array
-        Data array of shape (time, variables).
-    bins : int, optional (default: 6)
-        Number of bins.
-
-    Returns
-    -------
-    symb_array : array
-        Converted data of integer type.
-    """
-    T, N = data.shape
-
-    # get the bin quantile steps
-    bin_edge = int(np.ceil(T / float(bins)))
-
-    symb_array = np.zeros((T, N), dtype='int32')
-
-    # get the lower edges of the bins for every time series
-    edges = np.sort(data, axis=0)[::bin_edge, :].T
-    bins = edges.shape[1]
-
-    # This gives the symbolic time series
-    symb_array = (data.reshape(T, N, 1) >= edges.reshape(1, N, bins)).sum(
-        axis=2) - 1
-
-    return symb_array.astype('int32')

-
-def _generate_noise(covar_matrix, time=1000, use_inverse=False):
-    """
-    Generate a multivariate normal distribution using correlated innovations.
-
-    Parameters
-    ----------
-    covar_matrix : array
-        Covariance matrix of the random variables
-    time : int
-        Sample size
-    use_inverse : bool, optional
-        Negate the off-diagonal elements and invert the covariance matrix
-        before use
-
-    Returns
-    -------
-    noise : array
-        Random noise generated according to covar_matrix
-    """
-    # Pull out the number of nodes from the shape of the covar_matrix
-    n_nodes = covar_matrix.shape[0]
-    # Make a deep copy for use in the inverse case
-    this_covar = covar_matrix
-    # Take the negative inverse if needed
-    if use_inverse:
-        this_covar = copy.deepcopy(covar_matrix)
-        this_covar *= -1
-        this_covar[np.diag_indices_from(this_covar)] *= -1
-        this_covar = np.linalg.inv(this_covar)
-    # Return the noise distribution
-    return np.random.multivariate_normal(mean=np.zeros(n_nodes),
-                                            cov=this_covar,
-                                            size=time)
-
-def _check_stability(graph):
-    """
-    Raises an AssertionError if the input graph corresponds to a non-stationary
-    process.
-
-    Parameters
-    ----------
-    graph : array
-        Lagged connectivity matrices. Shape is (n_nodes, n_nodes, max_delay+1)
-    """
-    # Get the shape from the input graph
-    n_nodes, _, period = graph.shape
-    # Set the top section as the horizontally stacked matrix of
-    # shape (n_nodes, n_nodes * period)
-    stability_matrix = \
-        scipy.sparse.hstack([scipy.sparse.lil_matrix(graph[:, :, t_slice])
-                             for t_slice in range(period)])
-    # Extend an identity matrix of shape
-    # (n_nodes * (period - 1), n_nodes * (period - 1)) to shape
-    # (n_nodes * (period - 1), n_nodes * period) and stack the top section on
-    # top to make the stability matrix of shape
-    # (n_nodes * period, n_nodes * period)
-    stability_matrix = \
-        scipy.sparse.vstack([stability_matrix,
-                             scipy.sparse.eye(n_nodes * (period - 1),
-                                              n_nodes * period)])
-    # Check the number of dimensions to see if we can afford to use a dense
-    # matrix
-    n_eigs = stability_matrix.shape[0]
-    if n_eigs <= 25:
-        # If it is relatively low in dimensionality, use a dense array
-        stability_matrix = stability_matrix.todense()
-        eigen_values, _ = scipy.linalg.eig(stability_matrix)
-    else:
-        # If it is a large dimensionality, convert to a compressed row sorted
-        # matrix, as it may be easier for the linear algebra package
-        stability_matrix = stability_matrix.tocsr()
-        # Get the eigen values of the stability matrix
-        eigen_values = scipy.sparse.linalg.eigs(stability_matrix,
-                                                k=(n_eigs - 2),
-                                                return_eigenvectors=False)
-    # Ensure they all have less than one magnitude
-    assert np.all(np.abs(eigen_values) < 1.), \
-        "Values given by time lagged connectivity matrix corresponds to a "+\
-        " non-stationary process!"
-
-def _check_initial_values(initial_values, shape):
-    """
-    Raises a AssertionError if the input initial values:
-        * Are not a numpy array OR
-        * Do not have the shape (n_nodes, max_delay+1)
-
-    Parameters
-    ----------
-    graph : array
-        Lagged connectivity matrices. Shape is (n_nodes, n_nodes, max_delay+1)
-    """
-    # Ensure it is a numpy array
-    assert isinstance(initial_values, np.ndarray),\
-        "User must provide initial_values as a numpy.ndarray"
-    # Check the shape is correct
-    assert initial_values.shape == shape,\
-        "Initial values must be of shape (n_nodes, max_delay+1)"+\
-        "\n current shape : " + str(initial_values.shape)+\
-        "\n desired shape : " + str(shape)
-
-def _var_network(graph,
-                 add_noise=True,
-                 inno_cov=None,
-                 invert_inno=False,
-                 T=100,
-                 initial_values=None):
-    """Returns a vector-autoregressive process with correlated innovations.
-
-    Useful for testing.
-
-    Example:
-        graph=numpy.array([[[0.2,0.,0.],[0.5,0.,0.]],
-                           [[0.,0.1,0. ],[0.3,0.,0.]]])
-
-        represents a process
-
-        X_1(t) = 0.2 X_1(t-1) + 0.5 X_2(t-1) + eps_1(t)
-        X_2(t) = 0.3 X_2(t-1) + 0.1 X_1(t-2) + eps_2(t)
-
-        with inv_inno_cov being the negative (except for diagonal) inverse
-        covariance matrix of (eps_1(t), eps_2(t)) OR inno_cov being
-        the covariance. Initial values can also be provided.
-
-
-    Parameters
-    ----------
-    graph : array
-        Lagged connectivity matrices. Shape is (n_nodes, n_nodes, max_delay+1)
-    add_noise : bool, optional (default: True)
-        Flag to add random noise or not
-    inno_cov : array, optional (default: None)
-        Covariance matrix of innovations.
-    invert_inno : bool, optional (defualt : False)
-        Flag to negate off-diagonal elements of inno_cov and invert it before
-        using it as the covariance matrix of innovations
-    T : int, optional (default: 100)
-        Sample size.
-
-    initial_values : array, optional (defult: None)
-        Initial values for each node. Shape is (n_nodes, max_delay+1), i.e. must
-        be of shape (graph.shape[1], graph.shape[2]).
-
-    Returns
-    -------
-    X : array
-        Array of realization.
-    """
-    n_nodes, _, period = graph.shape
-
-    time = T
-    # Test stability
-    _check_stability(graph)
-
-    # Generate the returned data
-    data = np.random.randn(n_nodes, time)
-    # Load the initial values
-    if initial_values is not None:
-        # Check the shape of the initial values
-        _check_initial_values(initial_values, data[:, :period].shape)
-        # Input the initial values
-        data[:, :period] = initial_values
-
-    # Check if we are adding noise
-    noise = None
-    if add_noise:
-        # Use inno_cov if it was provided
-        if inno_cov is not None:
-            noise = _generate_noise(inno_cov,
-                                    time=time,
-                                    use_inverse=invert_inno)
-        # Otherwise just use uncorrelated random noise
-        else:
-            noise = np.random.randn(time, n_nodes)
-
-    for a_time in range(period, time):
-        data_past = np.repeat(
-            data[:, a_time-period:a_time][:, ::-1].reshape(1, n_nodes, period),
-            n_nodes, axis=0)
-        data[:, a_time] = (data_past*graph).sum(axis=2).sum(axis=1)
-        if add_noise:
-            data[:, a_time] += noise[a_time]
-
-    return data.transpose()
-
-def _iter_coeffs(parents_neighbors_coeffs):
-    """
-    Iterator through the current parents_neighbors_coeffs structure.  Mainly to
-    save repeated code and make it easier to change this structure.
-
-    Parameters
-    ----------
-    parents_neighbors_coeffs : dict
-        Dictionary of format:
-        {..., j:[((var1, lag1), coef1), ((var2, lag2), coef2), ...], ...} for
-        all variables where vars must be in [0..N-1] and lags <= 0 with number
-        of variables N.
-
-    Yields
-    -------
-    (node_id, parent_id, time_lag, coeff) : tuple
-        Tuple defining the relationship between nodes across time
-    """
-    # Iterate through all defined nodes
-    for node_id in list(parents_neighbors_coeffs):
-        # Iterate over parent nodes and unpack node and coeff
-        for (parent_id, time_lag), coeff in parents_neighbors_coeffs[node_id]:
-            # Yield the entry
-            yield node_id, parent_id, time_lag, coeff
-
-def _check_parent_neighbor(parents_neighbors_coeffs):
-    """
-    Checks to insure input parent-neighbor connectivity input is sane.  This
-    means that:
-        * all time lags are non-positive
-        * all parent nodes are included as nodes themselves
-        * all node indexing is contiguous
-        * all node indexing starts from zero
-    Raises a ValueError if any one of these conditions are not met.
-
-    Parameters
-    ----------
-    parents_neighbors_coeffs : dict
-        Dictionary of format:
-        {..., j:[((var1, lag1), coef1), ((var2, lag2), coef2), ...], ...} for
-        all variables where vars must be in [0..N-1] and lags <= 0 with number
-        of variables N.
-    """
-    # Initialize some lists for checking later
-    all_nodes = set()
-    all_parents = set()
-    # Iterate through variables
-    for j in list(parents_neighbors_coeffs):
-        # Cache all node ids to ensure they are contiguous
-        all_nodes.add(j)
-    # Iterate through all nodes
-    for j, i, tau, _ in _iter_coeffs(parents_neighbors_coeffs):
-        # Check all time lags are equal to or less than zero
-        if tau > 0:
-            raise ValueError("Lag between parent {} and node {}".format(i, j)+\
-                             " is {} > 0, must be <= 0!".format(tau))
-        # Cache all parent ids to ensure they are mentioned as node ids
-        all_parents.add(i)
-    # Check that all nodes are contiguous from zero
-    all_nodes_list = sorted(list(all_nodes))
-    if all_nodes_list != list(range(len(all_nodes_list))):
-        raise ValueError("Node IDs in input dictionary must be contiguous"+\
-                         " and start from zero!\n"+\
-                         " Found IDs : [" +\
-                         ",".join(map(str, all_nodes_list))+ "]")
-    # Check that all parent nodes are mentioned as a node ID
-    if not all_parents.issubset(all_nodes):
-        missing_nodes = sorted(list(all_parents - all_nodes))
-        all_parents_list = sorted(list(all_parents))
-        raise ValueError("Parent IDs in input dictionary must also be in set"+\
-                         " of node IDs."+\
-                         "\n Parent IDs "+" ".join(map(str, all_parents_list))+\
-                         "\n Node IDs "+" ".join(map(str, all_nodes_list)) +\
-                         "\n Missing IDs " + " ".join(map(str, missing_nodes)))
-
-def _check_symmetric_relations(a_matrix):
-    """
-    Check if the argument matrix is symmetric.  Raise a value error with details
-    about the offending elements if it is not.  This is useful for checking the
-    instantaneously linked nodes have the same link strength.
-
-    Parameters
-    ----------
-    a_matrix : 2D numpy array
-        Relationships between nodes at tau = 0. Indexed such that first index is
-        node and second is parent, i.e. node j with parent i has strength
-        a_matrix[j,i]
-    """
-    # Check it is symmetric
-    if not np.allclose(a_matrix, a_matrix.T, rtol=1e-10, atol=1e-10):
-        # Store the disagreement elements
-        bad_elems = ~np.isclose(a_matrix, a_matrix.T, rtol=1e-10, atol=1e-10)
-        bad_idxs = np.argwhere(bad_elems)
-        error_message = ""
-        for node, parent in bad_idxs:
-            # Check that we haven't already printed about this pair
-            if bad_elems[node, parent]:
-                error_message += \
-                    "Parent {:d} of node {:d}".format(parent, node)+\
-                    " has coefficient {:f}.\n".format(a_matrix[node, parent])+\
-                    "Parent {:d} of node {:d}".format(node, parent)+\
-                    " has coefficient {:f}.\n".format(a_matrix[parent, node])
-            # Check if we already printed about this one
-            bad_elems[node, parent] = False
-            bad_elems[parent, node] = False
-        raise ValueError("Relationships between nodes at tau=0 are not"+\
-                         " symmetric!\n"+error_message)
-
-def _find_max_time_lag_and_node_id(parents_neighbors_coeffs):
-    """
-    Function to find the maximum time lag in the parent-neighbors-coefficients
-    object, as well as the largest node ID
-
-    Parameters
-    ----------
-    parents_neighbors_coeffs : dict
-        Dictionary of format:
-        {..., j:[((var1, lag1), coef1), ((var2, lag2), coef2), ...], ...} for
-        all variables where vars must be in [0..N-1] and lags <= 0 with number
-        of variables N.
-
-    Returns
-    -------
-    (max_time_lag, max_node_id) : tuple
-        Tuple of the maximum time lag and maximum node ID
-    """
-    # Default maximum lag and node ID
-    max_time_lag = 0
-    max_node_id = len(parents_neighbors_coeffs.keys()) - 1
-    # Iterate through the keys in parents_neighbors_coeffs
-    for j, _, tau, _ in _iter_coeffs(parents_neighbors_coeffs):
-        # Find max lag time
-        max_time_lag = max(max_time_lag, abs(tau))
-        # Find the max node ID
-        # max_node_id = max(max_node_id, j)
-    # Return these values
-    return max_time_lag, max_node_id
-
-def _get_true_parent_neighbor_dict(parents_neighbors_coeffs):
-    """
-    Function to return the dictionary of true parent neighbor causal
-    connections in time.
-
-    Parameters
-    ----------
-    parents_neighbors_coeffs : dict
-        Dictionary of format:
-        {..., j:[((var1, lag1), coef1), ((var2, lag2), coef2), ...], ...} for
-        all variables where vars must be in [0..N-1] and lags <= 0 with number
-        of variables N.
-
-    Returns
-    -------
-    true_parent_neighbor : dict
-        Dictionary of lists of tuples.  The dictionary is keyed by node ID, the
-        list stores the tuple values (parent_node_id, time_lag)
-    """
-    # Initialize the returned dictionary of lists
-    true_parents_neighbors = defaultdict(list)
-    for j in parents_neighbors_coeffs:
-        for link_props in parents_neighbors_coeffs[j]:
-            i, tau = link_props[0]
-            coeff = link_props[1]
-            # Add parent node id and lag if non-zero coeff
-            if coeff != 0.:
-                true_parents_neighbors[j].append((i, tau))
-    # Return the true relations
-    return true_parents_neighbors
-
-def _get_covariance_matrix(parents_neighbors_coeffs):
-    """
-    Determines the covariance matrix for correlated innovations
-
-    Parameters
-    ----------
-    parents_neighbors_coeffs : dict
-        Dictionary of format:
-        {..., j:[((var1, lag1), coef1), ((var2, lag2), coef2), ...], ...} for
-        all variables where vars must be in [0..N-1] and lags <= 0 with number
-        of variables N.
-
-    Returns
-    -------
-    covar_matrix : numpy array
-        Covariance matrix implied by the parents_neighbors_coeffs.  Used to
-        generate correlated innovations.
-    """
-    # Get the total number of nodes
-    _, max_node_id = \
-            _find_max_time_lag_and_node_id(parents_neighbors_coeffs)
-    n_nodes = max_node_id + 1
-    # Initialize the covariance matrix
-    covar_matrix = np.identity(n_nodes)
-    # Iterate through all the node connections
-    for j, i, tau, coeff in _iter_coeffs(parents_neighbors_coeffs):
-        # Add to covar_matrix if node connection is instantaneous
-        if tau == 0:
-            covar_matrix[j, i] = coeff
-    return covar_matrix
-
-def _get_lag_connect_matrix(parents_neighbors_coeffs):
-    """
-    Generates the lagged connectivity matrix from a parent-neighbor
-    connectivity dictionary.  Used to generate the input for _var_network
-
-    Parameters
-    ----------
-    parents_neighbors_coeffs : dict
-        Dictionary of format:
-        {..., j:[((var1, lag1), coef1), ((var2, lag2), coef2), ...], ...} for
-        all variables where vars must be in [0..N-1] and lags <= 0 with number
-        of variables N.
-
-    Returns
-    -------
-    connect_matrix : numpy array
-        Lagged connectivity matrix. Shape is (n_nodes, n_nodes, max_delay+1)
-    """
-    # Get the total number of nodes and time lag
-    max_time_lag, max_node_id = \
-            _find_max_time_lag_and_node_id(parents_neighbors_coeffs)
-    n_nodes = max_node_id + 1
-    n_times = max_time_lag + 1
-    # Initialize full time graph
-    connect_matrix = np.zeros((n_nodes, n_nodes, n_times))
-    for j, i, tau, coeff in _iter_coeffs(parents_neighbors_coeffs):
-        # If there is a non-zero time lag, add the connection to the matrix
-        if tau != 0:
-            connect_matrix[j, i, -(tau+1)] = coeff
-    # Return the connectivity matrix
-    return connect_matrix
-
-
[docs]def var_process(parents_neighbors_coeffs, T=1000, use='inv_inno_cov',
-                verbosity=0, initial_values=None):
-    """Returns a vector-autoregressive process with correlated innovations.
-
-    Wrapper around var_network with possibly more user-friendly input options.
-
-    Parameters
-    ----------
-    parents_neighbors_coeffs : dict
-        Dictionary of format: {..., j:[((var1, lag1), coef1), ((var2, lag2),
-        coef2), ...], ...} for all variables where vars must be in [0..N-1]
-        and lags <= 0 with number of variables N. If lag=0, a nonzero value
-        in the covariance matrix (or its inverse) is implied. These should be
-        the same for (i, j) and (j, i).
-    use : str, optional (default: 'inv_inno_cov')
-        Specifier, either 'inno_cov' or 'inv_inno_cov'.
-        Any other specifier will result in non-correlated noise.
-        For debugging, 'no_noise' can also be specified, in which case random
-        noise will be disabled.
-    T : int, optional (default: 1000)
-        Sample size.
-    verbosity : int, optional (default: 0)
-        Level of verbosity.
-    initial_values : array, optional (default: None)
-        Initial values for each node. Shape must be (N, max_delay+1)
-
-    Returns
-    -------
-    data : array-like
-        Data generated from this process
-    true_parent_neighbor : dict
-        Dictionary of lists of tuples.  The dictionary is keyed by node ID, the
-        list stores the tuple values (parent_node_id, time_lag)
-    """
-    # Check the input parents_neighbors_coeffs dictionary for sanity
-    _check_parent_neighbor(parents_neighbors_coeffs)
-    # Generate the true parent neighbors graph
-    true_parents_neighbors = \
-        _get_true_parent_neighbor_dict(parents_neighbors_coeffs)
-    # Generate the correlated innovations
-    innos = _get_covariance_matrix(parents_neighbors_coeffs)
-    # Generate the lagged connectivity matrix for _var_network
-    connect_matrix = _get_lag_connect_matrix(parents_neighbors_coeffs)
-    # Default values as per 'inno_cov'
-    add_noise = True
-    invert_inno = False
-    # Use the correlated innovations
-    if use == 'inno_cov':
-        if verbosity > 0:
-            print("\nInnovation Cov =\n%s" % str(innos))
-    # Use the inverted correlated innovations
-    elif use == 'inv_inno_cov':
-        invert_inno = True
-        if verbosity > 0:
-            print("\nInverse Innovation Cov =\n%s" % str(innos))
-    # Do not use any noise
-    elif use == 'no_noise':
-        add_noise = False
-        if verbosity > 0:
-            print("\nInverse Innovation Cov =\n%s" % str(innos))
-    # Use decorrelated noise
-    else:
-        innos = None
-    # Ensure the innovation matrix is symmetric if it is used
-    if (innos is not None) and add_noise:
-        _check_symmetric_relations(innos)
-    # Generate the data using _var_network
-    data = _var_network(graph=connect_matrix,
-                        add_noise=add_noise,
-                        inno_cov=innos,
-                        invert_inno=invert_inno,
-                        T=T,
-                        initial_values=initial_values)
-    # Return the data
-    return data, true_parents_neighbors

-
-
[docs]class Graph():
-    r"""Helper class to handle graph properties.
-
-    Parameters
-    ----------
-    vertices : list
-        List of nodes.
-    """
-    def __init__(self,vertices): 
-        self.graph = defaultdict(list) 
-        self.V = vertices 
-  
-
[docs]    def addEdge(self,u,v):
-        """Adding edge to graph."""
-        self.graph[u].append(v) 

-  
-
[docs]    def isCyclicUtil(self, v, visited, recStack): 
-        """Utility function to return whether graph is cyclic."""
-        # Mark current node as visited and
-        # adds to recursion stack 
-        visited[v] = True
-        recStack[v] = True
-  
-        # Recur for all neighbours 
-        # if any neighbour is visited and in  
-        # recStack then graph is cyclic 
-        for neighbour in self.graph[v]: 
-            if visited[neighbour] == False: 
-                if self.isCyclicUtil(neighbour, visited, recStack) == True: 
-                    return True
-            elif recStack[neighbour] == True: 
-                return True
-  
-        # The node needs to be poped from  
-        # recursion stack before function ends 
-        recStack[v] = False
-        return False

-  
-
[docs]    def isCyclic(self):
-        """Returns whether graph is cyclic."""
-        visited = [False] * self.V 
-        recStack = [False] * self.V 
-        for node in range(self.V): 
-            if visited[node] == False: 
-                if self.isCyclicUtil(node,visited,recStack) == True: 
-                    return True
-        return False

-  
-
[docs]    def topologicalSortUtil(self,v,visited,stack):
-        """A recursive function used by topologicalSort ."""
-        # Mark the current node as visited.
-        visited[v] = True
-
-        # Recur for all the vertices adjacent to this vertex
-        for i in self.graph[v]:
-            if visited[i] == False:
-                self.topologicalSortUtil(i,visited,stack)
-
-        # Push current vertex to stack which stores result
-        stack.insert(0,v)

-
-
[docs]    def topologicalSort(self):
-        """A sorting function. """
-        # Mark all the vertices as not visited 
-        visited = [False]*self.V 
-        stack =[] 
-
-        # Call the recursive helper function to store Topological 
-        # Sort starting from all vertices one by one 
-        for i in range(self.V): 
-          if visited[i] == False: 
-              self.topologicalSortUtil(i,visited,stack) 
-
-        return stack

-
-
[docs]def structural_causal_process(links, T, noises=None, seed=None):
-    """Returns a structural causal process with contemporaneous and lagged
-    dependencies.
-
-    Generates generalized additive noise model process of the form
-
-    .. math:: X^j_t = \\eta^j_t + \\sum_{X^i_{t-\\tau}\\in \\mathcal{P}(X^j_t)}
-              c^i_{\\tau} f^i_{\\tau}(X^i_{t-\\tau})
-
-    Links have the format ``{0:[((i, -tau), coeff, func),...], 1:[...],
-    ...}`` where ``func`` can be an arbitrary (nonlinear) function provided
-    as a python callable with one argument and coeff is the multiplication
-    factor. The noise distributions of :math:`\\eta^j` can be specified in
-    ``noises``.
-
-    Parameters
-    ----------
-    links : dict
-        Dictionary of format: {0:[((i, -tau), coeff, func),...], 1:[...],
-        ...} for all variables where i must be in [0..N-1] and tau >= 0 with
-        number of variables N. coeff must be a float and func a python
-        callable of one argument.
-    T : int
-        Sample size.
-    noises : list of callables, optional (default: 'np.random.randn')
-        Random distribution function that is called with noises[j](T).
-    seed : int, optional (default: None)
-        Random seed.
-
-    Returns
-    -------
-    data : array-like
-        Data generated from this process, shape (T, N).
-    nonstationary : bool
-        Indicates whether data has NaNs or infinities.
-
-    """
-    random_state = np.random.RandomState(seed)
-
-    N = len(links.keys())
-    if noises is None:
-        noises = [random_state.randn for j in range(N)]
-
-    if N != max(links.keys())+1 or N != len(noises):
-        raise ValueError("links and noises keys must match N.")
-
-    # Check parameters
-    max_lag = 0
-    contemp_dag = Graph(N)
-    for j in range(N):
-        for link_props in links[j]:
-            var, lag = link_props[0]
-            coeff = link_props[1]
-            func = link_props[2]
-            if lag == 0: contemp = True
-            if var not in range(N):
-                raise ValueError("var must be in 0..{}.".format(N-1))
-            if 'float' not in str(type(coeff)):
-                raise ValueError("coeff must be float.")
-            if lag > 0 or type(lag) != int:
-                raise ValueError("lag must be non-positive int.")
-            max_lag = max(max_lag, abs(lag))
-
-            # Create contemp DAG
-            if var != j and lag == 0:
-                contemp_dag.addEdge(var, j)
-
-    if contemp_dag.isCyclic() == 1: 
-        raise ValueError("Contemporaneous links must not contain cycle.")
-
-    causal_order = contemp_dag.topologicalSort() 
-
-    transient = int(.2*T)
-
-    data = np.zeros((T+transient, N), dtype='float32')
-    for j in range(N):
-        data[:, j] = noises[j](T+transient)
-
-    for t in range(max_lag, T+transient):
-        for j in causal_order:
-            for link_props in links[j]:
-                var, lag = link_props[0]
-                coeff = link_props[1]
-                func = link_props[2]
-                data[t, j] += coeff * func(data[t + lag, var])
-
-    data = data[transient:]
-
-    nonstationary = (np.any(np.isnan(data)) or np.any(np.isinf(data)))
-
-    return data, nonstationary

-
-def _get_minmax_lag(links):
-    """Helper function to retrieve tau_min and tau_max from links
-    """
-
-    N = len(links)
-
-    # Get maximum time lag
-    min_lag = np.inf
-    max_lag = 0
-    for j in range(N):
-        for link_props in links[j]:
-            var, lag = link_props[0]
-            coeff = link_props[1]
-            # func = link_props[2]
-            if coeff != 0.:
-                min_lag = min(min_lag, abs(lag))
-                max_lag = max(max_lag, abs(lag))
-    return min_lag, max_lag
-
-def _get_parents(links, exclude_contemp=False):
-    """Helper function to parents from links
-    """
-
-    N = len(links)
-
-    # Get maximum time lag
-    parents = {}
-    for j in range(N):
-        parents[j] = []
-        for link_props in links[j]:
-            var, lag = link_props[0]
-            coeff = link_props[1]
-            # func = link_props[2]
-            if coeff != 0.:
-                if not (exclude_contemp and lag == 0):
-                    parents[j].append((var, lag))
-
-    return parents
-
-def _get_children(parents):
-    """Helper function to children from parents
-    """
-
-    N = len(parents)
-    children = dict([(j, []) for j in range(N)])
-
-    for j in range(N):
-        for par in parents[j]:
-            i, tau = par
-            children[i].append((j, abs(tau)))
-
-    return children
-
-
-
-class _Logger(object):
-    """Class to append print output to a string which can be saved"""
-    def __init__(self):
-        self.terminal = sys.stdout
-        self.log = ""       # open("log.dat", "a")
-
-    def write(self, message):
-        self.terminal.write(message)
-        self.log += message  # .write(message)
-
-
-if __name__ == '__main__':
-    
-    ## Generate some time series from a structural causal process
-    def lin_f(x): return x
-    def nonlin_f(x): return (x + 5. * x**2 * np.exp(-x**2 / 20.))
-
-    links = {0: [((0, -1), 0.9, lin_f)],
-             1: [((1, -1), 0.8, lin_f), ((0, -1), 0.3, nonlin_f)],
-             2: [((2, -1), 0.7, lin_f), ((1, 0), -0.2, lin_f)],
-             }
-    noises = [np.random.randn, np.random.randn, np.random.randn]
-    data, nonstat = structural_causal_process(links,
-     T=100, noises=noises)
-    print(data.shape)
-
- -
-
-
-
-
- - - - \ No newline at end of file diff --git a/docs/_build/html/_modules/tigramite/independence_tests.html b/docs/_build/html/_modules/tigramite/independence_tests.html deleted file mode 100644 index d6ff8941..00000000 --- a/docs/_build/html/_modules/tigramite/independence_tests.html +++ /dev/null @@ -1,2714 +0,0 @@ - - - - - - - tigramite.independence_tests — Tigramite 4.2 documentation - - - - - - - - - - - - - -
-
-
-
- -

Source code for tigramite.independence_tests

-"""Tigramite causal discovery for time series."""
-
-# Author: Jakob Runge <jakob@jakob-runge.com>
-#
-# License: GNU General Public License v3.0
-
-from __future__ import print_function
-import warnings
-import math
-import abc
-from scipy import special, stats, spatial
-import numpy as np
-import six
-import sys
-
-try:
-    from sklearn import gaussian_process
-except:
-    print("Could not import sklearn for Gaussian process tests")
-
-try:
-    from tigramite import tigramite_cython_code
-except:
-    print("Could not import packages for CMIknn and GPDC estimation")
-
-try:
-    import rpy2
-    import rpy2.robjects
-    rpy2.robjects.r['options'](warn=-1)
-    from rpy2.robjects.packages import importr
-    import rpy2.robjects.numpy2ri
-    rpy2.robjects.numpy2ri.activate()
-except:
-    print("Could not import rpy package")
-
-try:
-    importr('RCIT')
-except:
-    print("Could not import r-package RCIT")
-
-
[docs]@six.add_metaclass(abc.ABCMeta)
-class CondIndTest():
-    """Base class of conditional independence tests.
-
-    Provides useful general functions for different independence tests such as
-    shuffle significance testing and bootstrap confidence estimation. Also
-    handles masked samples. Other test classes can inherit from this class.
-
-    Parameters
-    ----------
-    mask_type : str, optional (default = None)
-        Must be in {'y','x','z','xy','xz','yz','xyz'}
-        Masking mode: Indicators for which variables in the dependence measure
-        I(X; Y | Z) the samples should be masked. If None, 'y' is used, which
-        excludes all time slices containing masked samples in Y. Explained in
-        [1]_.
-
-    significance : str, optional (default: 'analytic')
-        Type of significance test to use. In this package 'analytic',
-        'fixed_thres' and 'shuffle_test' are available.
-
-    fixed_thres : float, optional (default: 0.1)
-        If significance is 'fixed_thres', this specifies the threshold for the
-        absolute value of the dependence measure.
-
-    sig_samples : int, optional (default: 1000)
-        Number of samples for shuffle significance test.
-
-    sig_blocklength : int, optional (default: None)
-        Block length for block-shuffle significance test. If None, the
-        block length is determined from the decay of the autocovariance as
-        explained in [1]_.
-
-    confidence : str, optional (default: None)
-        Specify type of confidence estimation. If False, numpy.nan is returned.
-        'bootstrap' can be used with any test, for ParCorr also 'analytic' is
-        implemented.
-
-    conf_lev : float, optional (default: 0.9)
-        Two-sided confidence interval.
-
-    conf_samples : int, optional (default: 100)
-        Number of samples for bootstrap.
-
-    conf_blocklength : int, optional (default: None)
-        Block length for block-bootstrap. If None, the block length is
-        determined from the decay of the autocovariance as explained in [1]_.
-
-    recycle_residuals : bool, optional (default: False)
-        Specifies whether residuals should be stored. This may be faster, but
-        can cost considerable memory.
-
-    verbosity : int, optional (default: 0)
-        Level of verbosity.
-    """
-
[docs]    @abc.abstractmethod
-    def get_dependence_measure(self, array, xyz):
-        """
-        Abstract function that all concrete classes must instantiate.
-        """
-        pass

-
-    @abc.abstractproperty
-    def measure(self):
-        """
-        Abstract property to store the type of independence test.
-        """
-        pass
-
-    def __init__(self,
-                 mask_type=None,
-                 significance='analytic',
-                 fixed_thres=0.1,
-                 sig_samples=1000,
-                 sig_blocklength=None,
-                 confidence=None,
-                 conf_lev=0.9,
-                 conf_samples=100,
-                 conf_blocklength=None,
-                 recycle_residuals=False,
-                 verbosity=0):
-        # Set the dataframe to None for now, will be reset during pcmci call
-        self.dataframe = None
-        # Set the options
-        self.significance = significance
-        self.sig_samples = sig_samples
-        self.sig_blocklength = sig_blocklength
-        self.fixed_thres = fixed_thres
-        self.verbosity = verbosity
-        # If we recycle residuals, then set up a residual cache
-        self.recycle_residuals = recycle_residuals
-        if self.recycle_residuals:
-            self.residuals = {}
-        # If we use a mask, we cannot recycle residuals
-        self.set_mask_type(mask_type)
-
-        # Set the confidence type and details
-        self.confidence = confidence
-        self.conf_lev = conf_lev
-        self.conf_samples = conf_samples
-        self.conf_blocklength = conf_blocklength
-
-        # Print information about the
-        if self.verbosity > 0:
-            self.print_info()
-
-
[docs]    def set_mask_type(self, mask_type):
-        """
-        Setter for mask type to ensure that this option does not clash with
-        recycle_residuals.
-
-        Parameters
-        ----------
-        mask_type : str
-            Must be in {'y','x','z','xy','xz','yz','xyz'}
-            Masking mode: Indicators for which variables in the dependence
-            measure I(X; Y | Z) the samples should be masked. If None, 'y' is
-            used, which excludes all time slices containing masked samples in Y.
-            Explained in [1]_.
-        """
-        # Set the mask type
-        self.mask_type = mask_type
-        # Check if this clashes with residual recycling
-        if self.mask_type is not None:
-            if self.recycle_residuals is True:
-                warnings.warn("Using a mask disables recycling residuals.")
-            self.recycle_residuals = False
-        # Check the mask type is keyed correctly
-        self._check_mask_type()

-
-
[docs]    def print_info(self):
-        """
-        Print information about the conditional independence test parameters
-        """
-        info_str = "\n# Initialize conditional independence test\n\nParameters:"
-        info_str += "\nindependence test = %s" % self.measure
-        info_str += "\nsignificance = %s" % self.significance
-        # Check if we are using a shuffle test
-        if self.significance == 'shuffle_test':
-            info_str += "\nsig_samples = %s" % self.sig_samples
-            info_str += "\nsig_blocklength = %s" % self.sig_blocklength
-        # Check if we are using a fixed threshold
-        elif self.significance == 'fixed_thres':
-            info_str += "\nfixed_thres = %s" % self.fixed_thres
-        # Check if we have a confidence type
-        if self.confidence:
-            info_str += "\nconfidence = %s" % self.confidence
-            info_str += "\nconf_lev = %s" % self.conf_lev
-        # Check if this confidence type is boostrapping
-        if self.confidence == 'bootstrap':
-            info_str += "\nconf_samples = %s" % self.conf_samples
-            info_str += "\nconf_blocklength = %s" %self.conf_blocklength
-        # Check if we use a non-trivial mask type
-        if self.mask_type is not None:
-            info_str += "mask_type = %s" % self.mask_type
-        # Check if we are recycling residuals or not
-        if self.recycle_residuals:
-            info_str += "recycle_residuals = %s" % self.recycle_residuals
-        # Print the information string
-        print(info_str)

-
-    def _check_mask_type(self):
-        """
-        mask_type : str, optional (default = None)
-            Must be in {'y','x','z','xy','xz','yz','xyz'}
-            Masking mode: Indicators for which variables in the dependence
-            measure I(X; Y | Z) the samples should be masked. If None, 'y' is
-            used, which excludes all time slices containing masked samples in Y.
-            Explained in [1]_.
-        """
-        if self.mask_type is not None:
-            mask_set = set(self.mask_type) - set(['x', 'y', 'z'])
-            if mask_set:
-                err_msg = "mask_type = %s," % self.mask_type + " but must be" +\
-                          " list containing 'x','y','z', or any combination"
-                raise ValueError(err_msg)
-
-
-
[docs]    def get_analytic_confidence(self, value, df, conf_lev):
-        """
-        Base class assumption that this is not implemented.  Concrete classes
-        should override when possible.
-        """
-        raise NotImplementedError("Analytic confidence not"+\
-                                  " implemented for %s" % self.measure)

-
-
[docs]    def get_model_selection_criterion(self, j, parents, tau_max=0):
-        """
-        Base class assumption that this is not implemented.  Concrete classes
-        should override when possible.
-        """
-        raise NotImplementedError("Model selection not"+\
-                                  " implemented for %s" % self.measure)

-
-
[docs]    def get_analytic_significance(self, value, T, dim):
-        """
-        Base class assumption that this is not implemented.  Concrete classes
-        should override when possible.
-        """
-        raise NotImplementedError("Analytic significance not"+\
-                                  " implemented for %s" % self.measure)

-
-
[docs]    def get_shuffle_significance(self, array, xyz, value,
-                                 return_null_dist=False):
-        """
-        Base class assumption that this is not implemented.  Concrete classes
-        should override when possible.
-        """
-        raise NotImplementedError("Shuffle significance not"+\
-                                  " implemented for %s" % self.measure)

-
-    def _get_single_residuals(self, array, target_var,
-                              standardize=True, return_means=False):
-        """
-        Base class assumption that this is not implemented.  Concrete classes
-        should override when possible.
-        """
-        raise NotImplementedError("Residual calculation not"+\
-                                  " implemented for %s" % self.measure)
-
-
[docs]    def set_dataframe(self, dataframe):
-        """Initialize and check the dataframe.
-
-        Parameters
-        ----------
-        dataframe : data object
-            Set tigramite dataframe object. It must have the attributes
-            dataframe.values yielding a numpy array of shape (observations T,
-            variables N) and optionally a mask of the same shape and a missing
-            values flag.
-
-        """
-        self.dataframe = dataframe
-        if self.mask_type is not None:
-            dataframe._check_mask(require_mask=True)

-
-    def _keyfy(self, x, z):
-        """Helper function to make lists unique."""
-        return (tuple(set(x)), tuple(set(z)))
-
-    def _get_array(self, X, Y, Z, tau_max=0, cut_off='2xtau_max', verbosity=None):
-        """Convencience wrapper around _construct_array."""
-        # Set the verbosity to the default value
-        if verbosity is None:
-            verbosity=self.verbosity
-
-        if self.measure in ['par_corr']:
-            if len(X) > 1 or len(Y) > 1:
-                raise ValueError("X and Y for %s must be univariate." %
-                                        self.measure)
-        # Call the wrapped function
-        return self.dataframe.construct_array(X=X, Y=Y, Z=Z,
-                                              tau_max=tau_max,
-                                              mask_type=self.mask_type,
-                                              return_cleaned_xyz=True,
-                                              do_checks=False,
-                                              cut_off=cut_off,
-                                              verbosity=verbosity)
-
-
[docs]    def run_test(self, X, Y, Z=None, tau_max=0, cut_off='2xtau_max'):
-        """Perform conditional independence test.
-
-        Calls the dependence measure and signficicance test functions. The child
-        classes must specify a function get_dependence_measure and either or
-        both functions get_analytic_significance and  get_shuffle_significance.
-        If recycle_residuals is True, also _get_single_residuals must be
-        available.
-
-        Parameters
-        ----------
-        X, Y, Z : list of tuples
-            X,Y,Z are of the form [(var, -tau)], where var specifies the
-            variable index and tau the time lag.
-
-        tau_max : int, optional (default: 0)
-            Maximum time lag. This may be used to make sure that estimates for
-            different lags in X, Z, all have the same sample size.
-
-        cut_off : {'2xtau_max', 'max_lag', 'max_lag_or_tau_max'}
-            How many samples to cutoff at the beginning. The default is
-            '2xtau_max', which guarantees that MCI tests are all conducted on
-            the same samples. For modeling, 'max_lag_or_tau_max' can be used,
-            which uses the maximum of tau_max and the conditions, which is
-            useful to compare multiple models on the same sample.  Last,
-            'max_lag' uses as much samples as possible.
-
-        Returns
-        -------
-        val, pval : Tuple of floats
-
-            The test statistic value and the p-value.
-        """
-
-        # Get the array to test on
-        array, xyz, XYZ = self._get_array(X, Y, Z, tau_max, cut_off)
-        X, Y, Z = XYZ
-        # Record the dimensions
-        dim, T = array.shape
-        # Ensure it is a valid array
-        if np.isnan(array).sum() != 0:
-            raise ValueError("nans in the array!")
-        # Get the dependence measure, reycling residuals if need be
-        val = self._get_dependence_measure_recycle(X, Y, Z, xyz, array)
-        # Get the p-value
-        pval = self.get_significance(val, array, xyz, T, dim)
-        # Return the value and the pvalue
-        return val, pval

-
-
[docs]    def run_test_raw(self, x, y, z=None):
-        """Perform conditional independence test directly on input arrays x, y, z.
-
-        Calls the dependence measure and signficicance test functions. The child
-        classes must specify a function get_dependence_measure and either or
-        both functions get_analytic_significance and  get_shuffle_significance.
-
-        Parameters
-        ----------
-        x, y, z : arrays
-            x,y,z are of the form (samples, dimension).
-
-        Returns
-        -------
-        val, pval : Tuple of floats
-
-            The test statistic value and the p-value.
-        """
-
-        if np.ndim(x) != 2 or np.ndim(y) != 2:
-            raise ValueError("x,y must be arrays of shape (samples, dimension)"
-                             " where dimension can be 1.")
-
-        if z is not None and np.ndim(z) != 2:
-            raise ValueError("z must be array of shape (samples, dimension)"
-                             " where dimension can be 1.")
-
-        if z is None:
-            # Get the array to test on
-            array = np.vstack((x.T, y.T))
-
-            # xyz is the dimension indicator
-            xyz = np.array([0 for i in range(x.shape[1])] +
-                           [1 for i in range(y.shape[1])])
-
-        else:
-            # Get the array to test on
-            array = np.vstack((x.T, y.T, z.T))
-
-            # xyz is the dimension indicator
-            xyz = np.array([0 for i in range(x.shape[1])] +
-                           [1 for i in range(y.shape[1])] +
-                           [2 for i in range(z.shape[1])])
-
-        # Record the dimensions
-        dim, T = array.shape
-        # Ensure it is a valid array
-        if np.isnan(array).sum() != 0:
-            raise ValueError("nans in the array!")
-        # Get the dependence measure
-        val = self.get_dependence_measure(array, xyz)
-        # Get the p-value
-        pval = self.get_significance(val, array, xyz, T, dim)
-        # Return the value and the pvalue
-        return val, pval

-
-    def _get_dependence_measure_recycle(self, X, Y, Z, xyz, array):
-        """Get the dependence_measure, optionally recycling residuals
-
-        If self.recycle_residuals is True, also _get_single_residuals must be
-        available.
-
-        Parameters
-        ----------
-        X, Y, Z : list of tuples
-            X,Y,Z are of the form [(var, -tau)], where var specifies the
-            variable index and tau the time lag.
-
-        xyz : array of ints
-            XYZ identifier array of shape (dim,).
-
-        array : array
-            Data array of shape (dim, T)
-
-        Return
-        ------
-        val : float
-            Test statistic
-        """
-        # Check if we are recycling residuals
-        if self.recycle_residuals:
-            # Get or calculate the cached residuals
-            x_resid = self._get_cached_residuals(X, Z, array, 0)
-            y_resid = self._get_cached_residuals(Y, Z, array, 1)
-            # Make a new residual array
-            array_resid = np.array([x_resid, y_resid])
-            xyz_resid = np.array([0, 1])
-            # Return the dependence measure
-            return self.get_dependence_measure(array_resid, xyz_resid)
-        # If not, return the dependence measure on the array and xyz
-        return self.get_dependence_measure(array, xyz)
-
-    def _get_cached_residuals(self, x_nodes, z_nodes, array, target_var):
-        """
-        Retrieve or calculate the cached residuals for the given node sets.
-
-        Parameters
-        ----------
-            x_nodes : list of tuples
-                List of nodes, X or Y normally. Used to key the residual cache
-                during lookup
-
-            z_nodes : list of tuples
-                List of nodes, Z normally
-
-            target_var : int
-                Key to differentiate X from Y.
-                x_nodes == X => 0, x_nodes == Y => 1
-
-            array : array
-                Data array of shape (dim, T)
-
-        Returns
-        -------
-            x_resid : array
-                Residuals calculated by _get_single_residual
-        """
-        # Check if we have calculated these residuals
-        if self._keyfy(x_nodes, z_nodes) in list(self.residuals):
-            x_resid = self.residuals[self._keyfy(x_nodes, z_nodes)]
-        # If not, calculate the residuals
-        else:
-            x_resid = self._get_single_residuals(array, target_var=target_var)
-            if z_nodes:
-                self.residuals[self._keyfy(x_nodes, z_nodes)] = x_resid
-        # Return these residuals
-        return x_resid
-
-
[docs]    def get_significance(self, val, array, xyz, T, dim, sig_override=None):
-        """
-        Returns the p-value from whichever significance function is specified
-        for this test.  If an override is used, then it will call a different
-        function then specified by self.significance
-
-        Parameters
-        ----------
-        val : float
-            Test statistic value.
-
-        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,).
-
-        T : int
-            Sample length
-
-        dim : int
-            Dimensionality, ie, number of features.
-
-        sig_override : string
-            Must be in 'analytic', 'shuffle_test', 'fixed_thres'
-
-        Returns
-        -------
-        pval : float or numpy.nan
-            P-value.
-        """
-        # Defaults to the self.signficance memeber value
-        use_sig = self.significance
-        if sig_override is not None:
-            use_sig = sig_override
-        # Check if we are using the analytic significance
-        if use_sig == 'analytic':
-            pval = self.get_analytic_significance(value=val, T=T, dim=dim)
-        # Check if we are using the shuffle significance
-        elif use_sig == 'shuffle_test':
-            pval = self.get_shuffle_significance(array=array,
-                                                 xyz=xyz,
-                                                 value=val)
-        # Check if we are using the fixed_thres significance
-        elif use_sig == 'fixed_thres':
-            pval = self.get_fixed_thres_significance(
-                    value=val,
-                    fixed_thres=self.fixed_thres)
-        else:
-            raise ValueError("%s not known." % self.significance)
-        # Return the calculated value
-        return pval

-
-
[docs]    def get_measure(self, X, Y, Z=None, tau_max=0):
-        """Estimate dependence measure.
-
-        Calls the dependence measure function. The child classes must specify
-        a function get_dependence_measure.
-
-        Parameters
-        ----------
-        X, Y [, Z] : list of tuples
-            X,Y,Z are of the form [(var, -tau)], where var specifies the
-            variable index and tau the time lag.
-
-        tau_max : int, optional (default: 0)
-            Maximum time lag. This may be used to make sure that estimates for
-            different lags in X, Z, all have the same sample size.
-
-        Returns
-        -------
-        val : float
-            The test statistic value.
-
-        """
-        # Make the array
-        array, xyz, (X, Y, Z) = self._get_array(X, Y, Z, tau_max)
-        D, T = array.shape
-        # Check it is valid
-        if np.isnan(array).sum() != 0:
-            raise ValueError("nans in the array!")
-        # Return the dependence measure
-        return self._get_dependence_measure_recycle(X, Y, Z, xyz, array)

-
-
[docs]    def get_confidence(self, X, Y, Z=None, tau_max=0):
-        """Perform confidence interval estimation.
-
-        Calls the dependence measure and confidence test functions. The child
-        classes can specify a function get_dependence_measure and
-        get_analytic_confidence or get_bootstrap_confidence. If confidence is
-        False, (numpy.nan, numpy.nan) is returned.
-
-        Parameters
-        ----------
-        X, Y, Z : list of tuples
-            X,Y,Z are of the form [(var, -tau)], where var specifies the
-            variable index and tau the time lag.
-
-        tau_max : int, optional (default: 0)
-            Maximum time lag. This may be used to make sure that estimates for
-            different lags in X, Z, all have the same sample size.
-
-        Returns
-        -------
-        (conf_lower, conf_upper) : Tuple of floats
-            Upper and lower confidence bound of confidence interval.
-        """
-        # Check if a confidence type has been defined
-        if self.confidence:
-            # Ensure the confidence level given makes sense
-            if self.conf_lev < .5 or self.conf_lev >= 1.:
-                raise ValueError("conf_lev = %.2f, " % self.conf_lev +
-                                 "but must be between 0.5 and 1")
-            half_conf = self.conf_samples * (1. - self.conf_lev)/2.
-            if self.confidence == 'bootstrap' and  half_conf < 1.:
-                raise ValueError("conf_samples*(1.-conf_lev)/2 is %.2f"
-                                 % half_conf + ", must be >> 1")
-        # Make and check the array
-        array, xyz, _ = self._get_array(X, Y, Z, tau_max, verbosity=0)
-        dim, T = array.shape
-        if np.isnan(array).sum() != 0:
-            raise ValueError("nans in the array!")
-
-        # Check if we are using analytic confidence or bootstrapping it
-        if self.confidence == 'analytic':
-            val = self.get_dependence_measure(array, xyz)
-            (conf_lower, conf_upper) = \
-                    self.get_analytic_confidence(df=T-dim,
-                                                 value=val,
-                                                 conf_lev=self.conf_lev)
-        elif self.confidence == 'bootstrap':
-            # Overwrite analytic values
-            (conf_lower, conf_upper) = \
-                    self.get_bootstrap_confidence(
-                        array, xyz,
-                        conf_samples=self.conf_samples,
-                        conf_blocklength=self.conf_blocklength,
-                        conf_lev=self.conf_lev, verbosity=self.verbosity)
-        elif not self.confidence:
-            return None
-        else:
-            raise ValueError("%s confidence estimation not implemented"
-                             % self.confidence)
-        # Cache the confidence interval
-        self.conf = (conf_lower, conf_upper)
-        # Return the confidence interval
-        return (conf_lower, conf_upper)

-
-    def _print_cond_ind_results(self, val, pval=None, conf=None):
-        """Print results from conditional independence test.
-
-        Parameters
-        ----------
-        val : float
-            Test stastistic value.
-
-        pval : float, optional (default: None)
-            p-value
-
-        conf : tuple of floats, optional (default: None)
-            Confidence bounds.
-        """
-
-        if pval is not None:
-            printstr = "        pval = %.5f | val = %.3f" % (
-                pval, val)
-            if conf is not None:
-                printstr += " | conf bounds = (%.3f, %.3f)" % (
-                    conf[0], conf[1])
-        else:
-            printstr = "        val = %.3f" % val
-            if conf is not None:
-                printstr += " | conf bounds = (%.3f, %.3f)" % (
-                    conf[0], conf[1])
-        print(printstr)
-
-
[docs]    def get_bootstrap_confidence(self, array, xyz, dependence_measure=None,
-                                 conf_samples=100, conf_blocklength=None,
-                                 conf_lev=.95, verbosity=0):
-        """Perform bootstrap confidence interval estimation.
-
-        With conf_blocklength > 1 or None a block-bootstrap is performed.
-
-        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,).
-
-        dependence_measure : function (default = self.get_dependence_measure)
-            Dependence measure function must be of form
-            dependence_measure(array, xyz) and return a numeric value
-
-        conf_lev : float, optional (default: 0.9)
-            Two-sided confidence interval.
-
-        conf_samples : int, optional (default: 100)
-            Number of samples for bootstrap.
-
-        conf_blocklength : int, optional (default: None)
-            Block length for block-bootstrap. If None, the block length is
-            determined from the decay of the autocovariance as explained in
-            [1]_.
-
-        verbosity : int, optional (default: 0)
-            Levelof verbosity.
-
-        Returns
-        -------
-        (conf_lower, conf_upper) : Tuple of floats
-            Upper and lower confidence bound of confidence interval.
-        """
-        # Check if a dependence measure if provided or if to use default
-        if not dependence_measure:
-            dependence_measure = self.get_dependence_measure
-
-        # confidence interval is two-sided
-        c_int = 1. - (1. - conf_lev)/2.
-        dim, T = array.shape
-
-        # If not block length is given, determine the optimal block length.
-        # This has a maximum of 10% of the time sample length
-        if conf_blocklength is None:
-            conf_blocklength = \
-                    self._get_block_length(array, xyz, mode='confidence')
-        # Determine the number of blocks total, rounding up for non-integer
-        # amounts
-        n_blks = int(math.ceil(float(T)/conf_blocklength))
-
-        # Print some information
-        if verbosity > 2:
-            print("            block_bootstrap confidence intervals"
-                  " with block-length = %d ..." % conf_blocklength)
-
-        # Generate the block bootstrapped distribution
-        bootdist = np.zeros(conf_samples)
-        for smpl in range(conf_samples):
-            # Get the starting indecies for the blocks
-            blk_strt = np.random.randint(0, T - conf_blocklength + 1, n_blks)
-            # Get the empty array of block resampled values
-            array_bootstrap = \
-                    np.zeros((dim, n_blks*conf_blocklength), dtype=array.dtype)
-            # Fill the array of block resamples
-            for i in range(conf_blocklength):
-                array_bootstrap[:, i::conf_blocklength] = array[:, blk_strt + i]
-            # Cut to proper length
-            array_bootstrap = array_bootstrap[:, :T]
-
-            bootdist[smpl] = dependence_measure(array_bootstrap, xyz)
-
-        # Sort and get quantile
-        bootdist.sort()
-        conf_lower = bootdist[int((1. - c_int) * conf_samples)]
-        conf_upper = bootdist[int(c_int * conf_samples)]
-        # Return the confidance limits as a tuple
-        return (conf_lower, conf_upper)

-
-    def _get_acf(self, 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, ddof=0)[0, 1]
-        return autocorr
-
-    def _get_block_length(self, 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.
-
-        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 = self._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 Pfeifer (2005) 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))
-            except RuntimeError:
-                print("Error - curve_fit failed in block_shuffle, using"
-                      " block_len = %d" % (int(.05 * T)))
-                block_len = max(int(.05 * T), 2)
-        # Limit block length to a maximum of 10% of T
-        block_len = min(block_len, int(0.1 * T))
-        return block_len
-
-    def _get_shuffle_dist(self, array, xyz, dependence_measure,
-                          sig_samples, sig_blocklength=None,
-                          verbosity=0):
-        """Returns shuffle distribution of test statistic.
-
-        The rows in array corresponding to the X-variable are shuffled using
-        a block-shuffle approach.
-
-        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,).
-
-       dependence_measure : object
-           Dependence measure function must be of form
-           dependence_measure(array, xyz) and return a numeric value
-
-        sig_samples : int, optional (default: 100)
-            Number of samples for shuffle significance test.
-
-        sig_blocklength : int, optional (default: None)
-            Block length for block-shuffle significance test. If None, the
-            block length is determined from the decay of the autocovariance as
-            explained in [1]_.
-
-        verbosity : int, optional (default: 0)
-            Level of verbosity.
-
-        Returns
-        -------
-        null_dist : array of shape (sig_samples,)
-            Contains the sorted test statistic values estimated from the
-            shuffled arrays.
-        """
-
-        dim, T = array.shape
-
-        x_indices = np.where(xyz == 0)[0]
-        dim_x = len(x_indices)
-
-        if sig_blocklength is None:
-            sig_blocklength = self._get_block_length(array, xyz,
-                                                     mode='significance')
-
-        n_blks = int(math.floor(float(T)/sig_blocklength))
-        # print 'n_blks ', n_blks
-        if verbosity > 2:
-            print("            Significance test with block-length = %d "
-                  "..." % (sig_blocklength))
-
-        array_shuffled = np.copy(array)
-        block_starts = np.arange(0, T - sig_blocklength + 1, sig_blocklength)
-
-        # Dividing the array up into n_blks of length sig_blocklength may
-        # leave a tail. This tail is later randomly inserted
-        tail = array[x_indices, n_blks*sig_blocklength:]
-
-        null_dist = np.zeros(sig_samples)
-        for sam in range(sig_samples):
-
-            blk_starts = np.random.permutation(block_starts)[:n_blks]
-
-            x_shuffled = np.zeros((dim_x, n_blks*sig_blocklength),
-                                  dtype=array.dtype)
-
-            for i, index in enumerate(x_indices):
-                for blk in range(sig_blocklength):
-                    x_shuffled[i, blk::sig_blocklength] = \
-                            array[index, blk_starts + blk]
-
-            # Insert tail randomly somewhere
-            if tail.shape[1] > 0:
-                insert_tail_at = np.random.choice(block_starts)
-                x_shuffled = np.insert(x_shuffled, insert_tail_at,
-                                       tail.T, axis=1)
-
-            for i, index in enumerate(x_indices):
-                array_shuffled[index] = x_shuffled[i]
-
-            null_dist[sam] = dependence_measure(array=array_shuffled,
-                                                xyz=xyz)
-
-        null_dist.sort()
-
-        return null_dist
-
-
[docs]    def get_fixed_thres_significance(self, value, fixed_thres):
-        """Returns signficance for thresholding test.
-
-        Returns 0 if numpy.abs(value) is smaller than fixed_thres and 1 else.
-
-        Parameters
-        ----------
-        value : number
-            Value of test statistic for unshuffled estimate.
-
-        fixed_thres : number
-            Fixed threshold, is made positive.
-
-        Returns
-        -------
-        pval : bool
-            Returns 0 if numpy.abs(value) is smaller than fixed_thres and 1
-            else.
-
-        """
-        if np.abs(value) < np.abs(fixed_thres):
-            pval = 1.
-        else:
-            pval = 0.
-
-        return pval

-
-    def _trafo2uniform(self, x):
-        """Transforms input array to uniform marginals.
-
-        Assumes x.shape = (dim, T)
-
-        Parameters
-        ----------
-        x : array-like
-            Input array.
-
-        Returns
-        -------
-        u : array-like
-            array with uniform marginals.
-        """
-
-        def trafo(xi):
-            xisorted = np.sort(xi)
-            yi = np.linspace(1. / len(xi), 1, len(xi))
-            return np.interp(xi, xisorted, yi)
-
-        if np.ndim(x) == 1:
-            u = trafo(x)
-        else:
-            u = np.empty(x.shape)
-            for i in range(x.shape[0]):
-                u[i] = trafo(x[i])
-        return u

-
-
-
[docs]class ParCorr(CondIndTest):
-    r"""Partial correlation test.
-
-    Partial correlation is estimated through linear ordinary least squares (OLS)
-    regression and a test for non-zero linear Pearson correlation on the
-    residuals.
-
-    Notes
-    -----
-    To test :math:`X \perp Y | Z`, first :math:`Z` is regressed out from
-    :math:`X` and :math:`Y` assuming the  model
-
-    .. math::  X & =  Z \beta_X + \epsilon_{X} \\
-        Y & =  Z \beta_Y + \epsilon_{Y}
-
-    using OLS regression. Then the dependency of the residuals is tested with
-    the Pearson correlation test.
-
-    .. math::  \rho\left(r_X, r_Y\right)
-
-    For the ``significance='analytic'`` Student's-*t* distribution with
-    :math:`T-D_Z-2` degrees of freedom is implemented.
-
-    Parameters
-    ----------
-    **kwargs :
-        Arguments passed on to Parent class CondIndTest.
-    """
-    # documentation
-    @property
-    def measure(self):
-        """
-        Concrete property to return the measure of the independence test
-        """
-        return self._measure
-
-    def __init__(self, **kwargs):
-        self._measure = 'par_corr'
-        self.two_sided = True
-        self.residual_based = True
-
-        CondIndTest.__init__(self, **kwargs)
-
-    def _get_single_residuals(self, array, target_var,
-                              standardize=True,
-                              return_means=False):
-        """Returns residuals of linear multiple regression.
-
-        Performs a OLS regression of the variable indexed by target_var on the
-        conditions Z. Here array is assumed to contain X and Y as the first two
-        rows with the remaining rows (if present) containing the conditions Z.
-        Optionally returns the estimated regression line.
-
-        Parameters
-        ----------
-        array : array-like
-            data array with X, Y, Z in rows and observations in columns
-
-        target_var : {0, 1}
-            Variable to regress out conditions from.
-
-        standardize : bool, optional (default: True)
-            Whether to standardize the array beforehand. Must be used for
-            partial correlation.
-
-        return_means : bool, optional (default: False)
-            Whether to return the estimated regression line.
-
-        Returns
-        -------
-        resid [, mean] : array-like
-            The residual of the regression and optionally the estimated line.
-        """
-
-        dim, T = array.shape
-        dim_z = dim - 2
-
-        # Standardize
-        if standardize:
-            array -= array.mean(axis=1).reshape(dim, 1)
-            array /= array.std(axis=1).reshape(dim, 1)
-            if np.isnan(array).sum() != 0:
-                raise ValueError("nans after standardizing, "
-                                 "possibly constant array!")
-
-        y = array[target_var, :]
-
-        if dim_z > 0:
-            z = np.fastCopyAndTranspose(array[2:, :])
-            beta_hat = np.linalg.lstsq(z, y, rcond=None)[0]
-            mean = np.dot(z, beta_hat)
-            resid = y - mean
-        else:
-            resid = y
-            mean = None
-
-        if return_means:
-            return (resid, mean)
-        return resid
-
-
[docs]    def get_dependence_measure(self, array, xyz):
-        """Return partial correlation.
-
-        Estimated as the Pearson correlation of the residuals of a linear
-        OLS regression.
-
-        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,).
-
-        Returns
-        -------
-        val : float
-            Partial correlation coefficient.
-        """
-
-        x_vals = self._get_single_residuals(array, target_var=0)
-        y_vals = self._get_single_residuals(array, target_var=1)
-        val, _ = stats.pearsonr(x_vals, y_vals)
-        return val

-
-
[docs]    def get_shuffle_significance(self, array, xyz, value,
-                                 return_null_dist=False):
-        """Returns p-value for shuffle significance test.
-
-        For residual-based test statistics only the residuals are shuffled.
-
-        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,).
-
-        value : number
-            Value of test statistic for unshuffled estimate.
-
-        Returns
-        -------
-        pval : float
-            p-value
-        """
-
-        x_vals = self._get_single_residuals(array, target_var=0)
-        y_vals = self._get_single_residuals(array, target_var=1)
-        array_resid = np.array([x_vals, y_vals])
-        xyz_resid = np.array([0, 1])
-
-        null_dist = self._get_shuffle_dist(array_resid, xyz_resid,
-                                           self.get_dependence_measure,
-                                           sig_samples=self.sig_samples,
-                                           sig_blocklength=self.sig_blocklength,
-                                           verbosity=self.verbosity)
-
-        pval = (null_dist >= np.abs(value)).mean()
-
-        # Adjust p-value for two-sided measures
-        if pval < 1.:
-            pval *= 2.
-
-        if return_null_dist:
-            return pval, null_dist
-        return pval

-
-
[docs]    def get_analytic_significance(self, value, T, dim):
-        """Returns analytic p-value from Student's t-test for the Pearson
-        correlation coefficient.
-
-        Assumes two-sided correlation. If the degrees of freedom are less than
-        1, numpy.nan is returned.
-
-        Parameters
-        ----------
-        value : float
-            Test statistic value.
-
-        T : int
-            Sample length
-
-        dim : int
-            Dimensionality, ie, number of features.
-
-        Returns
-        -------
-        pval : float or numpy.nan
-            P-value.
-        """
-        # Get the number of degrees of freedom
-        deg_f = T - dim
-
-        if deg_f < 1:
-            pval = np.nan
-        elif abs(abs(value) - 1.0) <= sys.float_info.min:
-            pval = 0.0
-        else:
-            trafo_val = value * np.sqrt(deg_f/(1. - value*value))
-            # Two sided significance level
-            pval = stats.t.sf(np.abs(trafo_val), deg_f) * 2
-
-        return pval

-
-
[docs]    def get_analytic_confidence(self, value, df, conf_lev):
-        """Returns analytic confidence interval for correlation coefficient.
-
-        Based on Student's t-distribution.
-
-        Parameters
-        ----------
-        value : float
-            Test statistic value.
-
-        df : int
-            degrees of freedom of the test
-
-        conf_lev : float
-            Confidence interval, eg, 0.9
-
-        Returns
-        -------
-        (conf_lower, conf_upper) : Tuple of floats
-            Upper and lower confidence bound of confidence interval.
-        """
-        # Confidence interval is two-sided
-        c_int = (1. - (1. - conf_lev) / 2.)
-
-        value_tdist = value * np.sqrt(df) / np.sqrt(1. - value**2)
-        conf_lower = (stats.t.ppf(q=1. - c_int, df=df, loc=value_tdist)
-                      / np.sqrt(df + stats.t.ppf(q=1. - c_int, df=df,
-                                                 loc=value_tdist)**2))
-        conf_upper = (stats.t.ppf(q=c_int, df=df, loc=value_tdist)
-                      / np.sqrt(df + stats.t.ppf(q=c_int, df=df,
-                                                 loc=value_tdist)**2))
-        return (conf_lower, conf_upper)

-
-
-
[docs]    def get_model_selection_criterion(self, j, parents, tau_max=0):
-        """Returns Akaike's Information criterion modulo constants.
-
-        Fits a linear model of the parents to variable j and returns the score.
-        I used to determine optimal hyperparameters in PCMCI, in particular
-        the pc_alpha value.
-
-        Parameters
-        ----------
-        j : int
-            Index of target variable in data array.
-
-        parents : list
-            List of form [(0, -1), (3, -2), ...] containing parents.
-
-        tau_max : int, optional (default: 0)
-            Maximum time lag. This may be used to make sure that estimates for
-            different lags in X, Z, all have the same sample size.
-
-        Returns:
-        score : float
-            Model score.
-        """
-
-        Y = [(j, 0)]
-        X = [(j, 0)]   # dummy variable here
-        Z = parents
-        array, xyz = self.dataframe.construct_array(X=X, Y=Y, Z=Z,
-                                                    tau_max=tau_max,
-                                                    mask_type=self.mask_type,
-                                                    return_cleaned_xyz=False,
-                                                    do_checks=False,
-                                                    verbosity=self.verbosity)
-
-        dim, T = array.shape
-
-        y = self._get_single_residuals(array, target_var=1, return_means=False)
-        # Get RSS
-        rss = (y**2).sum()
-        # Number of parameters
-        p = dim - 1
-        # Get AIC
-        score = T * np.log(rss) + 2. * p
-        return score

-
-class GaussProcReg():
-    r"""Gaussian processes abstract base class.
-
-    GP is estimated with scikit-learn and allows to flexibly specify kernels and
-    hyperparameters or let them be optimized automatically. The kernel specifies
-    the covariance function of the GP. Parameters can be passed on to
-    ``GaussianProcessRegressor`` using the gp_params dictionary. If None is
-    passed, the kernel '1.0 * RBF(1.0) + WhiteKernel()' is used with alpha=0 as
-    default. Note that the kernel's hyperparameters are optimized during
-    fitting.
-
-    When the null distribution is not analytically available, but can be
-    precomputed with the function generate_and_save_nulldists(...) which saves
-    a \*.npz file containing the null distribution for different sample sizes.
-    This file can then be supplied as null_dist_filename.
-
-    Parameters
-    ----------
-    null_samples : int
-        Number of null samples to use
-
-    cond_ind_test : CondIndTest
-        Conditional independence test that this Gaussian Proccess Regressor will
-        calculate the null distribution for.  This is used to grab the
-        get_dependence_measure function.
-
-    gp_version : {'new', 'old'}, optional (default: 'new')
-        The older GP version from scikit-learn 0.17 was used for the numerical
-        simulations in [1]_. The newer version from scikit-learn 0.19 is faster
-        and allows more flexibility regarding kernels etc.
-
-    gp_params : dictionary, optional (default: None)
-        Dictionary with parameters for ``GaussianProcessRegressor``.
-
-    null_dist_filename : str, otional (default: None)
-        Path to file containing null distribution.
-
-    verbosity : int, optional (default: 0)
-        Level of verbosity.
-    """
-    def __init__(self,
-                 null_samples,
-                 cond_ind_test,
-                 gp_version='new',
-                 gp_params=None,
-                 null_dist_filename=None,
-                 verbosity=0):
-        # Set the dependence measure function
-        self.cond_ind_test = cond_ind_test
-        # Set member variables
-        self.gp_version = gp_version
-        self.gp_params = gp_params
-        self.verbosity = verbosity
-        # Set the null distribution defaults
-        self.null_samples = null_samples
-        self.null_dists = {}
-        self.null_dist_filename = null_dist_filename
-        # Check if we are loading a null distrubtion from a cached file
-        if self.null_dist_filename is not None:
-            self.null_dists, self.null_samples = \
-                    self._load_nulldist(self.null_dist_filename)
-
-    def _load_nulldist(self, filename):
-        r"""
-        Load a precomputed null distribution from a \*.npz file.  This
-        distribution can be calculated using generate_and_save_nulldists(...).
-
-        Parameters
-        ----------
-        filename : strng
-            Path to the \*.npz file
-
-        Returns
-        -------
-        null_dists, null_samples : dict, int
-            The null distirbution as a dictionary of distributions keyed by
-            sample size, the number of null samples in total.
-        """
-        null_dist_file = np.load(filename)
-        null_dists = dict(zip(null_dist_file['T'],
-                              null_dist_file['exact_dist']))
-        null_samples = len(null_dist_file['exact_dist'][0])
-        return null_dists, null_samples
-
-    def _generate_nulldist(self, df,
-                           add_to_null_dists=True):
-        """Generates null distribution for pairwise independence tests.
-
-        Generates the null distribution for sample size df. Assumes pairwise
-        samples transformed to uniform marginals. Uses get_dependence_measure
-        available in class and generates self.sig_samples random samples. Adds
-        the null distributions to self.null_dists.
-
-        Parameters
-        ----------
-        df : int
-            Degrees of freedom / sample size to generate null distribution for.
-
-        add_to_null_dists : bool, optional (default: True)
-            Whether to add the null dist to the dictionary of null dists or
-            just return it.
-
-        Returns
-        -------
-        null_dist : array of shape [df,]
-            Only returned,if add_to_null_dists is False.
-        """
-
-        if self.verbosity > 0:
-            print("Generating null distribution for df = %d. " % df)
-            if add_to_null_dists:
-                print("For faster computations, run function "
-                      "generate_and_save_nulldists(...) to "
-                      "precompute null distribution and load *.npz file with "
-                      "argument null_dist_filename")
-
-        xyz = np.array([0,1])
-
-        null_dist = np.zeros(self.null_samples)
-        for i in range(self.null_samples):
-            array = np.random.rand(2, df)
-            null_dist[i] = self.cond_ind_test.get_dependence_measure(array, xyz)
-
-        null_dist.sort()
-        if add_to_null_dists:
-            self.null_dists[df] = null_dist
-        return null_dist
-
-    def _generate_and_save_nulldists(self, sample_sizes, null_dist_filename):
-        """Generates and saves null distribution for pairwise independence
-        tests.
-
-        Generates the null distribution for different sample sizes. Calls
-        generate_nulldist. Null dists are saved to disk as
-        self.null_dist_filename.npz. Also adds the null distributions to
-        self.null_dists.
-
-        Parameters
-        ----------
-        sample_sizes : list
-            List of sample sizes.
-
-        null_dist_filename : str
-            Name to save file containing null distributions.
-        """
-
-        self.null_dist_filename = null_dist_filename
-
-        null_dists = np.zeros((len(sample_sizes), self.null_samples))
-
-        for iT, T in enumerate(sample_sizes):
-            null_dists[iT] = self._generate_nulldist(T, add_to_null_dists=False)
-            self.null_dists[T] = null_dists[iT]
-
-        np.savez("%s" % null_dist_filename,
-                 exact_dist=null_dists,
-                 T=np.array(sample_sizes))
-
-    def _get_single_residuals(self, array, target_var,
-                              return_means=False,
-                              standardize=True,
-                              return_likelihood=False):
-        """Returns residuals of Gaussian process regression.
-
-        Performs a GP regression of the variable indexed by target_var on the
-        conditions Z. Here array is assumed to contain X and Y as the first two
-        rows with the remaining rows (if present) containing the conditions Z.
-        Optionally returns the estimated mean and the likelihood.
-
-        Parameters
-        ----------
-        array : array-like
-            data array with X, Y, Z in rows and observations in columns
-
-        target_var : {0, 1}
-            Variable to regress out conditions from.
-
-        standardize : bool, optional (default: True)
-            Whether to standardize the array beforehand.
-
-        return_means : bool, optional (default: False)
-            Whether to return the estimated regression line.
-
-        return_likelihood : bool, optional (default: False)
-            Whether to return the log_marginal_likelihood of the fitted GP
-
-        Returns
-        -------
-        resid [, mean, likelihood] : array-like
-            The residual of the regression and optionally the estimated mean
-            and/or the likelihood.
-        """
-        dim, T = array.shape
-
-        if self.gp_params is None:
-            self.gp_params = {}
-
-        if dim <= 2:
-            if return_likelihood:
-                return array[target_var, :], -np.inf
-            return array[target_var, :]
-
-        # Standardize
-        if standardize:
-            array -= array.mean(axis=1).reshape(dim, 1)
-            array /= array.std(axis=1).reshape(dim, 1)
-            if np.isnan(array).sum() != 0:
-                raise ValueError("nans after standardizing, "
-                                 "possibly constant array!")
-
-        target_series = array[target_var, :]
-        z = np.fastCopyAndTranspose(array[2:])
-        if np.ndim(z) == 1:
-            z = z.reshape(-1, 1)
-
-        if self.gp_version == 'old':
-            # Old GP failed for ties in the data
-            def remove_ties(series, verbosity=0):
-                # Test whether ties exist and add noise to destroy ties...
-                cnt = 0
-                while len(np.unique(series)) < np.size(series):
-                    series += 1E-6 * np.random.rand(*series.shape)
-                    cnt += 1
-                    if cnt > 100:
-                        break
-                return series
-
-            z = remove_ties(z)
-            target_series = remove_ties(target_series)
-
-            gp = gaussian_process.GaussianProcess(
-                nugget=1E-1,
-                thetaL=1E-16,
-                thetaU=np.inf,
-                corr='squared_exponential',
-                optimizer='fmin_cobyla',
-                regr='constant',
-                normalize=False,
-                storage_mode='light')
-
-        elif self.gp_version == 'new':
-            # Overwrite default kernel and alpha values
-            params = self.gp_params.copy()
-            if 'kernel' not in list(self.gp_params):
-                kernel = gaussian_process.kernels.RBF() +\
-                         gaussian_process.kernels.WhiteKernel()
-            else:
-                kernel = self.gp_params['kernel']
-                del params['kernel']
-
-            if 'alpha' not in list(self.gp_params):
-                alpha = 0.
-            else:
-                alpha = self.gp_params['alpha']
-                del params['alpha']
-
-            gp = gaussian_process.GaussianProcessRegressor(kernel=kernel,
-                                                           alpha=alpha,
-                                                           **params)
-
-        gp.fit(z, target_series.reshape(-1, 1))
-
-        if self.verbosity > 3 and self.gp_version == 'new':
-            print(kernel, alpha, gp.kernel_, gp.alpha)
-
-        if self.verbosity > 3 and self.gp_version == 'old':
-            print(gp.get_params)
-
-        if return_likelihood:
-            likelihood = gp.log_marginal_likelihood()
-
-        mean = gp.predict(z).squeeze()
-
-        resid = target_series - mean
-
-        if return_means and not return_likelihood:
-            return (resid, mean)
-        elif return_likelihood and not return_means:
-            return (resid, likelihood)
-        elif return_means and return_likelihood:
-            return resid, mean, likelihood
-        return resid
-
-    def _get_model_selection_criterion(self, j, parents, tau_max=0):
-        """Returns log marginal likelihood for GP regression.
-
-        Fits a GP model of the parents to variable j and returns the negative
-        log marginal likelihood as a model selection score. Is used to determine
-        optimal hyperparameters in PCMCI, in particular the pc_alpha value.
-
-        Parameters
-        ----------
-        j : int
-            Index of target variable in data array.
-
-        parents : list
-            List of form [(0, -1), (3, -2), ...] containing parents.
-
-        tau_max : int, optional (default: 0)
-            Maximum time lag. This may be used to make sure that estimates for
-            different lags in X, Z, all have the same sample size.
-
-        Returns:
-        score : float
-            Model score.
-        """
-
-        Y = [(j, 0)]
-        X = [(j, 0)]   # dummy variable here
-        Z = parents
-        array, xyz = \
-                self.cond_ind_test.dataframe.construct_array(
-                    X=X, Y=Y, Z=Z,
-                    tau_max=tau_max,
-                    mask_type=self.cond_ind_test.mask_type,
-                    return_cleaned_xyz=False,
-                    do_checks=False,
-                    verbosity=self.verbosity)
-
-        dim, T = array.shape
-
-        _, logli = self._get_single_residuals(array,
-                                              target_var=1,
-                                              return_likelihood=True)
-
-        score = -logli
-        return score
-
-
[docs]class GPDC(CondIndTest):
-    r"""GPDC conditional independence test based on Gaussian processes and
-        distance correlation.
-
-    GPDC is based on a Gaussian process (GP) regression and a distance
-    correlation test on the residuals [2]_. GP is estimated with scikit-learn
-    and allows to flexibly specify kernels and hyperparameters or let them be
-    optimized automatically. The distance correlation test is implemented with
-    cython. Here the null distribution is not analytically available, but can be
-    precomputed with the function generate_and_save_nulldists(...) which saves a
-    \*.npz file containing the null distribution for different sample sizes.
-    This file can then be supplied as null_dist_filename.
-
-    Notes
-    -----
-
-    GPDC is based on a Gaussian process (GP) regression and a distance
-    correlation test on the residuals. Distance correlation is described in
-    [2]_. To test :math:`X \perp Y | Z`, first :math:`Z` is regressed out from
-    :math:`X` and :math:`Y` assuming the  model
-
-    .. math::  X & =  f_X(Z) + \epsilon_{X} \\
-        Y & =  f_Y(Z) + \epsilon_{Y}  \\
-        \epsilon_{X,Y} &\sim \mathcal{N}(0, \sigma^2)
-
-    using GP regression. Here :math:`\sigma^2` and the kernel bandwidth are
-    optimzed using ``sklearn``. Then the residuals  are transformed to uniform
-    marginals yielding :math:`r_X,r_Y` and their dependency is tested with
-
-    .. math::  \mathcal{R}\left(r_X, r_Y\right)
-
-    The null distribution of the distance correlation should be pre-computed.
-    Otherwise it is computed during runtime.
-
-    The cython-code for distance correlation is Copyright (c) 2012, Florian
-    Finkernagel (https://gist.github.com/ffinkernagel/2960386).
-
-    References
-    ----------
-    .. [2] Gabor J. Szekely, Maria L. Rizzo, and Nail K. Bakirov: Measuring and
-           testing dependence by correlation of distances,
-           https://arxiv.org/abs/0803.4101
-
-    Parameters
-    ----------
-    null_dist_filename : str, otional (default: None)
-        Path to file containing null distribution.
-
-    gp_version : {'new', 'old'}, optional (default: 'new')
-        The older GP version from scikit-learn 0.17 was used for the numerical
-        simulations in [1]_. The newer version from scikit-learn 0.19 is faster
-        and allows more flexibility regarding kernels etc.
-
-    gp_params : dictionary, optional (default: None)
-        Dictionary with parameters for ``GaussianProcessRegressor``.
-
-    **kwargs :
-        Arguments passed on to parent class GaussProcReg.
-
-    """
-    @property
-    def measure(self):
-        """
-        Concrete property to return the measure of the independence test
-        """
-        return self._measure
-
-    def __init__(self,
-                 null_dist_filename=None,
-                 gp_version='new',
-                 gp_params=None,
-                 **kwargs):
-        self._measure = 'gp_dc'
-        self.two_sided = False
-        self.residual_based = True
-        # Call the parent constructor
-        CondIndTest.__init__(self, **kwargs)
-        # Build the regressor
-        self.gauss_pr = GaussProcReg(self.sig_samples,
-                                     self,
-                                     gp_version=gp_version,
-                                     gp_params=gp_params,
-                                     null_dist_filename=null_dist_filename,
-                                     verbosity=self.verbosity)
-
-        if self.verbosity > 0:
-            print("null_dist_filename = %s" % self.gauss_pr.null_dist_filename)
-            print("gp_version = %s" % self.gauss_pr.gp_version)
-            if self.gauss_pr.gp_params is not None:
-                for key in  list(self.gauss_pr.gp_params):
-                    print("%s = %s" % (key, self.gauss_pr.gp_params[key]))
-            print("")
-
-    def _load_nulldist(self, filename):
-        r"""
-        Load a precomputed null distribution from a \*.npz file.  This
-        distribution can be calculated using generate_and_save_nulldists(...).
-
-        Parameters
-        ----------
-        filename : strng
-            Path to the \*.npz file
-
-        Returns
-        -------
-        null_dists, null_samples : dict, int
-            The null distirbution as a dictionary of distributions keyed by
-            sample size, the number of null samples in total.
-        """
-        return self.gauss_pr._load_nulldist(filename)
-
-
[docs]    def generate_nulldist(self, df, add_to_null_dists=True):
-        """Generates null distribution for pairwise independence tests.
-
-        Generates the null distribution for sample size df. Assumes pairwise
-        samples transformed to uniform marginals. Uses get_dependence_measure
-        available in class and generates self.sig_samples random samples. Adds
-        the null distributions to self.gauss_pr.null_dists.
-
-        Parameters
-        ----------
-        df : int
-            Degrees of freedom / sample size to generate null distribution for.
-
-        add_to_null_dists : bool, optional (default: True)
-            Whether to add the null dist to the dictionary of null dists or
-            just return it.
-
-        Returns
-        -------
-        null_dist : array of shape [df,]
-            Only returned,if add_to_null_dists is False.
-        """
-        return self.gauss_pr._generate_nulldist(df, add_to_null_dists)

-
-
[docs]    def generate_and_save_nulldists(self, sample_sizes, null_dist_filename):
-        """Generates and saves null distribution for pairwise independence
-        tests.
-
-        Generates the null distribution for different sample sizes. Calls
-        generate_nulldist. Null dists are saved to disk as
-        self.null_dist_filename.npz. Also adds the null distributions to
-        self.gauss_pr.null_dists.
-
-        Parameters
-        ----------
-        sample_sizes : list
-            List of sample sizes.
-
-        null_dist_filename : str
-            Name to save file containing null distributions.
-        """
-        self.gauss_pr._generate_and_save_nulldists(sample_sizes,
-                                                   null_dist_filename)

-
-    def _get_single_residuals(self, array, target_var,
-                              return_means=False,
-                              standardize=True,
-                              return_likelihood=False):
-        """Returns residuals of Gaussian process regression.
-
-        Performs a GP regression of the variable indexed by target_var on the
-        conditions Z. Here array is assumed to contain X and Y as the first two
-        rows with the remaining rows (if present) containing the conditions Z.
-        Optionally returns the estimated mean and the likelihood.
-
-        Parameters
-        ----------
-        array : array-like
-            data array with X, Y, Z in rows and observations in columns
-
-        target_var : {0, 1}
-            Variable to regress out conditions from.
-
-        standardize : bool, optional (default: True)
-            Whether to standardize the array beforehand.
-
-        return_means : bool, optional (default: False)
-            Whether to return the estimated regression line.
-
-        return_likelihood : bool, optional (default: False)
-            Whether to return the log_marginal_likelihood of the fitted GP
-
-        Returns
-        -------
-        resid [, mean, likelihood] : array-like
-            The residual of the regression and optionally the estimated mean
-            and/or the likelihood.
-        """
-        return self.gauss_pr._get_single_residuals(
-            array, target_var,
-            return_means,
-            standardize,
-            return_likelihood)
-
-
[docs]    def get_model_selection_criterion(self, j, parents, tau_max=0):
-        """Returns log marginal likelihood for GP regression.
-
-        Fits a GP model of the parents to variable j and returns the negative
-        log marginal likelihood as a model selection score. Is used to determine
-        optimal hyperparameters in PCMCI, in particular the pc_alpha value.
-
-        Parameters
-        ----------
-        j : int
-            Index of target variable in data array.
-
-        parents : list
-            List of form [(0, -1), (3, -2), ...] containing parents.
-
-        tau_max : int, optional (default: 0)
-            Maximum time lag. This may be used to make sure that estimates for
-            different lags in X, Z, all have the same sample size.
-
-        Returns:
-        score : float
-            Model score.
-        """
-        return self.gauss_pr._get_model_selection_criterion(j, parents, tau_max)

-
-
[docs]    def get_dependence_measure(self, array, xyz):
-        """Return GPDC measure.
-
-        Estimated as the distance correlation of the residuals of a GP
-        regression.
-
-        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,).
-
-        Returns
-        -------
-        val : float
-            GPDC test statistic.
-        """
-
-        x_vals = self._get_single_residuals(array, target_var=0)
-        y_vals = self._get_single_residuals(array, target_var=1)
-        val = self._get_dcorr(np.array([x_vals, y_vals]))
-        return val

-
-
-    def _get_dcorr(self, array_resid):
-        """Return distance correlation coefficient.
-
-        The variables are transformed to uniform marginals using the empirical
-        cumulative distribution function beforehand. Here the null distribution
-        is not analytically available, but can be precomputed with the function
-        generate_and_save_nulldists(...) which saves a \*.npz file containing
-        the null distribution for different sample sizes. This file can then be
-        supplied as null_dist_filename.
-
-        Parameters
-        ----------
-        array_resid : array-like
-            data array must be of shape (2, T)
-
-        Returns
-        -------
-        val : float
-            Distance correlation coefficient.
-        """
-        # Remove ties before applying transformation to uniform marginals
-        # array_resid = self._remove_ties(array_resid, verbosity=4)
-        x_vals, y_vals = self._trafo2uniform(array_resid)
-
-        _, val, _, _ = tigramite_cython_code.dcov_all(x_vals, y_vals)
-        return val
-
-
[docs]    def get_shuffle_significance(self, array, xyz, value,
-                                 return_null_dist=False):
-        """Returns p-value for shuffle significance test.
-
-        For residual-based test statistics only the residuals are shuffled.
-
-        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,).
-
-        value : number
-            Value of test statistic for unshuffled estimate.
-
-        Returns
-        -------
-        pval : float
-            p-value
-        """
-
-        x_vals = self._get_single_residuals(array, target_var=0)
-        y_vals = self._get_single_residuals(array, target_var=1)
-        array_resid = np.array([x_vals, y_vals])
-        xyz_resid = np.array([0, 1])
-
-        null_dist = self._get_shuffle_dist(array_resid, xyz_resid,
-                                           self.get_dependence_measure,
-                                           sig_samples=self.sig_samples,
-                                           sig_blocklength=self.sig_blocklength,
-                                           verbosity=self.verbosity)
-
-        pval = (null_dist >= value).mean()
-
-        if return_null_dist:
-            return pval, null_dist
-        return pval

-
-
[docs]    def get_analytic_significance(self, value, T, dim):
-        """Returns p-value for the distance correlation coefficient.
-
-        The null distribution for necessary degrees of freedom (df) is loaded.
-        If not available, the null distribution is generated with the function
-        generate_nulldist(). It is recommended to generate the nulldists for a
-        wide range of sample sizes beforehand with the function
-        generate_and_save_nulldists(...). The distance correlation coefficient
-        is one-sided. If the degrees of freedom are less than 1, numpy.nan is
-        returned.
-
-        Parameters
-        ----------
-        value : float
-            Test statistic value.
-
-        T : int
-            Sample length
-
-        dim : int
-            Dimensionality, ie, number of features.
-
-        Returns
-        -------
-        pval : float or numpy.nan
-            P-value.
-        """
-
-        # GP regression approximately doesn't cost degrees of freedom
-        df = T
-
-        if df < 1:
-            pval = np.nan
-        else:
-            # idx_near = (np.abs(self.sample_sizes - df)).argmin()
-            if int(df) not in list(self.gauss_pr.null_dists):
-            # if np.abs(self.sample_sizes[idx_near] - df) / float(df) > 0.01:
-                if self.verbosity > 0:
-                    print("Null distribution for GPDC not available "
-                          "for deg. of freed. = %d." % df)
-                self.generate_nulldist(df)
-            null_dist_here = self.gauss_pr.null_dists[int(df)]
-            pval = np.mean(null_dist_here > np.abs(value))
-        return pval

-
-
[docs]class CMIknn(CondIndTest):
-    r"""Conditional mutual information test based on nearest-neighbor estimator.
-
-    Conditional mutual information is the most general dependency measure coming
-    from an information-theoretic framework. It makes no assumptions about the
-    parametric form of the dependencies by directly estimating the underlying
-    joint density. The test here is based on the estimator in  S. Frenzel and B.
-    Pompe, Phys. Rev. Lett. 99, 204101 (2007), combined with a shuffle test to
-    generate  the distribution under the null hypothesis of independence first
-    used in [3]_. The knn-estimator is suitable only for variables taking a
-    continuous range of values. For discrete variables use the CMIsymb class.
-
-    Notes
-    -----
-    CMI is given by
-
-    .. math:: I(X;Y|Z) &= \int p(z)  \iint  p(x,y|z) \log
-                \frac{ p(x,y |z)}{p(x|z)\cdot p(y |z)} \,dx dy dz
-
-    Its knn-estimator is given by
-
-    .. math:: \widehat{I}(X;Y|Z)  &=   \psi (k) + \frac{1}{T} \sum_{t=1}^T
-            \left[ \psi(k_{Z,t}) - \psi(k_{XZ,t}) - \psi(k_{YZ,t}) \right]
-
-    where :math:`\psi` is the Digamma function.  This estimator has as a
-    parameter the number of nearest-neighbors :math:`k` which determines the
-    size of hyper-cubes around each (high-dimensional) sample point. Then
-    :math:`k_{Z,},k_{XZ},k_{YZ}` are the numbers of neighbors in the respective
-    subspaces.
-
-    :math:`k` can be viewed as a density smoothing parameter (although it is
-    data-adaptive unlike fixed-bandwidth estimators). For large :math:`k`, the
-    underlying dependencies are more smoothed and CMI has a larger bias,
-    but lower variance, which is more important for significance testing. Note
-    that the estimated CMI values can be slightly negative while CMI is a non-
-    negative quantity.
-
-    This method requires the scipy.spatial.cKDTree package and the tigramite
-    cython module.
-
-    References
-    ----------
-    .. [3] 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
-
-    Parameters
-    ----------
-    knn : int or float, optional (default: 0.2)
-        Number of nearest-neighbors which determines the size of hyper-cubes
-        around each (high-dimensional) sample point. If smaller than 1, this is
-        computed as a fraction of T, hence knn=knn*T. For knn larger or equal to
-        1, this is the absolute number.
-
-    shuffle_neighbors : int, optional (default: 10)
-        Number of nearest-neighbors within Z for the shuffle surrogates which
-        determines the size of hyper-cubes around each (high-dimensional) sample
-        point.
-
-    transform : {'ranks', 'standardize',  'uniform', False}, optional
-        (default: 'ranks')
-        Whether to transform the array beforehand by standardizing
-        or transforming to uniform marginals.
-
-    n_jobs : int (optional, default = -1)
-        Number of jobs to schedule for parallel processing. If -1 is given
-        all processors are used. Default: 1.
-
-    significance : str, optional (default: 'shuffle_test')
-        Type of significance test to use. For CMIknn only 'fixed_thres' and
-        'shuffle_test' are available.
-
-    **kwargs :
-        Arguments passed on to parent class CondIndTest.
-    """
-    @property
-    def measure(self):
-        """
-        Concrete property to return the measure of the independence test
-        """
-        return self._measure
-
-    def __init__(self,
-                 knn=0.2,
-                 shuffle_neighbors=5,
-                 significance='shuffle_test',
-                 transform='ranks',
-                 n_jobs=-1,
-                 **kwargs):
-        # Set the member variables
-        self.knn = knn
-        self.shuffle_neighbors = shuffle_neighbors
-        self.transform = transform
-        self._measure = 'cmi_knn'
-        self.two_sided = False
-        self.residual_based = False
-        self.recycle_residuals = False
-        self.n_jobs = n_jobs
-        # Call the parent constructor
-        CondIndTest.__init__(self, significance=significance, **kwargs)
-        # Print some information about construction
-        if self.verbosity > 0:
-            if self.knn < 1:
-                print("knn/T = %s" % self.knn)
-            else:
-                print("knn = %s" % self.knn)
-            print("shuffle_neighbors = %d\n" % self.shuffle_neighbors)
-
-    def _get_nearest_neighbors(self, array, xyz, knn):
-        """Returns nearest neighbors according to Frenzel and Pompe (2007).
-
-        Retrieves the distances eps to the k-th nearest neighbors for every
-        sample in joint space XYZ and returns the numbers of nearest neighbors
-        within eps in subspaces Z, XZ, YZ.
-
-        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,).
-
-        knn : int or float
-            Number of nearest-neighbors which determines the size of hyper-cubes
-            around each (high-dimensional) sample point. If smaller than 1, this
-            is computed as a fraction of T, hence knn=knn*T. For knn larger or
-            equal to 1, this is the absolute number.
-
-        Returns
-        -------
-        k_xz, k_yz, k_z : tuple of arrays of shape (T,)
-            Nearest neighbors in subspaces.
-        """
-
-        dim, T = array.shape
-        array = array.astype('float')
-
-        # Add noise to destroy ties...
-        array += (1E-6 * array.std(axis=1).reshape(dim, 1)
-                  * np.random.rand(array.shape[0], array.shape[1]))
-
-        if self.transform == 'standardize':
-            # Standardize
-            array = array.astype('float')
-            array -= array.mean(axis=1).reshape(dim, 1)
-            array /= array.std(axis=1).reshape(dim, 1)
-            # FIXME: If the time series is constant, return nan rather than
-            # raising Exception
-            if np.isnan(array).sum() != 0:
-                raise ValueError("nans after standardizing, "
-                                 "possibly constant array!")
-        elif self.transform == 'uniform':
-            array = self._trafo2uniform(array)
-        elif self.transform == 'ranks':
-            array = array.argsort(axis=1).argsort(axis=1).astype('float')
-
-
-        # Use cKDTree to get distances eps to the k-th nearest neighbors for
-        # every sample in joint space XYZ with maximum norm
-        tree_xyz = spatial.cKDTree(array.T)
-        epsarray = tree_xyz.query(array.T, k=knn+1, p=np.inf,
-                                  eps=0., n_jobs=self.n_jobs)[0][:, knn].astype('float')
-
-        # Prepare for fast cython access
-        dim_x = int(np.where(xyz == 0)[0][-1] + 1)
-        dim_y = int(np.where(xyz == 1)[0][-1] + 1 - dim_x)
-
-        k_xz, k_yz, k_z = \
-                tigramite_cython_code._get_neighbors_within_eps_cython(array,
-                                                                       T,
-                                                                       dim_x,
-                                                                       dim_y,
-                                                                       epsarray,
-                                                                       knn,
-                                                                       dim)
-        return k_xz, k_yz, k_z
-
-
[docs]    def get_dependence_measure(self, array, xyz):
-        """Returns CMI estimate as described in Frenzel and Pompe PRL (2007).
-
-        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,).
-
-        Returns
-        -------
-        val : float
-            Conditional mutual information estimate.
-        """
-
-        dim, T = array.shape
-
-        if self.knn < 1:
-            knn_here = max(1, int(self.knn*T))
-        else:
-            knn_here = max(1, int(self.knn))
-
-        k_xz, k_yz, k_z = self._get_nearest_neighbors(array=array,
-                                                      xyz=xyz,
-                                                      knn=knn_here)
-
-        val = special.digamma(knn_here) - (special.digamma(k_xz) +
-                                           special.digamma(k_yz) -
-                                           special.digamma(k_z)).mean()
-
-        return val

-
-
-
[docs]    def get_shuffle_significance(self, array, xyz, value,
-                                 return_null_dist=False):
-        """Returns p-value for nearest-neighbor shuffle significance test.
-
-        For non-empty Z, overwrites get_shuffle_significance from the parent
-        class  which is a block shuffle test, which does not preserve
-        dependencies of X and Y with Z. Here the parameter shuffle_neighbors is
-        used to permute only those values :math:`x_i` and :math:`x_j` for which
-        :math:`z_j` is among the nearest niehgbors of :math:`z_i`. If Z is
-        empty, the block-shuffle test is used.
-
-        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,).
-
-        value : number
-            Value of test statistic for unshuffled estimate.
-
-        Returns
-        -------
-        pval : float
-            p-value
-        """
-        dim, T = array.shape
-
-        # Skip shuffle test if value is above threshold
-        # if value > self.minimum threshold:
-        #     if return_null_dist:
-        #         return 0., None
-        #     else:
-        #         return 0.
-
-        # max_neighbors = max(1, int(max_neighbor_ratio*T))
-        x_indices = np.where(xyz == 0)[0]
-        z_indices = np.where(xyz == 2)[0]
-
-        if len(z_indices) > 0 and self.shuffle_neighbors < T:
-            if self.verbosity > 2:
-                print("            nearest-neighbor shuffle significance "
-                      "test with n = %d and %d surrogates" % (
-                      self.shuffle_neighbors, self.sig_samples))
-
-            # Get nearest neighbors around each sample point in Z
-            z_array = np.fastCopyAndTranspose(array[z_indices, :])
-            tree_xyz = spatial.cKDTree(z_array)
-            neighbors = tree_xyz.query(z_array,
-                                       k=self.shuffle_neighbors,
-                                       p=np.inf,
-                                       eps=0.)[1].astype('int32')
-
-            null_dist = np.zeros(self.sig_samples)
-            for sam in range(self.sig_samples):
-
-                # Generate random order in which to go through indices loop in
-                # next step
-                order = np.random.permutation(T).astype('int32')
-                # print(order[:5])
-                # Select a series of neighbor indices that contains as few as
-                # possible duplicates
-                restricted_permutation = \
-                    tigramite_cython_code._get_restricted_permutation_cython(
-                        T=T,
-                        shuffle_neighbors=self.shuffle_neighbors,
-                        neighbors=neighbors,
-                        order=order)
-
-                array_shuffled = np.copy(array)
-                for i in x_indices:
-                    array_shuffled[i] = array[i, restricted_permutation]
-
-                null_dist[sam] = self.get_dependence_measure(array_shuffled,
-                                                             xyz)
-
-        else:
-            null_dist = \
-                    self._get_shuffle_dist(array, xyz,
-                                           self.get_dependence_measure,
-                                           sig_samples=self.sig_samples,
-                                           sig_blocklength=self.sig_blocklength,
-                                           verbosity=self.verbosity)
-
-        # Sort
-        null_dist.sort()
-        pval = (null_dist >= value).mean()
-
-        if return_null_dist:
-            return pval, null_dist
-        return pval

-
-
-
[docs]class CMIsymb(CondIndTest):
-    r"""Conditional mutual information test based on discrete estimator.
-
-    Conditional mutual information is the most general dependency measure
-    coming from an information-theoretic framework. It makes no assumptions
-    about the parametric form of the dependencies by directly estimating the
-    underlying joint density. The test here is based on directly estimating
-    the joint distribution assuming symbolic input, combined with a
-    shuffle test to generate  the distribution under the null hypothesis of
-    independence. The knn-estimator is suitable only for discrete variables.
-    For continuous variables, either pre-process the data using the functions
-    in data_processing or, better, use the CMIknn class.
-
-    Notes
-    -----
-    CMI and its estimator are given by
-
-    .. math:: I(X;Y|Z) &= \sum p(z)  \sum \sum  p(x,y|z) \log
-                \frac{ p(x,y |z)}{p(x|z)\cdot p(y |z)} \,dx dy dz
-
-    Parameters
-    ----------
-    n_symbs : int, optional (default: None)
-        Number of symbols in input data. Should be at least as large as the
-        maximum array entry + 1. If None, n_symbs is based on the
-        maximum value in the array (array.max() + 1).
-
-    significance : str, optional (default: 'shuffle_test')
-        Type of significance test to use. For CMIsymb only 'fixed_thres' and
-        'shuffle_test' are available.
-
-    sig_blocklength : int, optional (default: 1)
-        Block length for block-shuffle significance test.
-
-    conf_blocklength : int, optional (default: 1)
-        Block length for block-bootstrap.
-
-    **kwargs :
-        Arguments passed on to parent class CondIndTest.
-    """
-    @property
-    def measure(self):
-        """
-        Concrete property to return the measure of the independence test
-        """
-        return self._measure
-
-    def __init__(self,
-                 n_symbs=None,
-                 significance='shuffle_test',
-                 sig_blocklength=1,
-                 conf_blocklength=1,
-                 **kwargs):
-        # Setup the member variables
-        self._measure = 'cmi_symb'
-        self.two_sided = False
-        self.residual_based = False
-        self.recycle_residuals = False
-        self.n_symbs = n_symbs
-        # Call the parent constructor
-        CondIndTest.__init__(self,
-                             significance=significance,
-                             sig_blocklength=sig_blocklength,
-                             conf_blocklength=conf_blocklength,
-                             **kwargs)
-
-        if self.verbosity > 0:
-            print("n_symbs = %s" % self.n_symbs)
-            print("")
-
-        if self.conf_blocklength is None or self.sig_blocklength is None:
-            warnings.warn("Automatic block-length estimations from decay of "
-                          "autocorrelation may not be sensical for discrete "
-                          "data")
-
-    def _bincount_hist(self, symb_array, weights=None):
-        """Computes histogram from symbolic array.
-
-        The maximum of the symbolic array determines the alphabet / number
-        of bins.
-
-        Parameters
-        ----------
-        symb_array : integer array
-            Data array of shape (dim, T).
-
-        weights : float array, optional (default: None)
-            Optional weights array of shape (dim, T).
-
-        Returns
-        -------
-        hist : array
-            Histogram array of shape (base, base, base, ...)*number of
-            dimensions with Z-dimensions coming first.
-        """
-
-        if self.n_symbs is None:
-            n_symbs = int(symb_array.max() + 1)
-        else:
-            n_symbs = self.n_symbs
-            if n_symbs < int(symb_array.max() + 1):
-                raise ValueError("n_symbs must be >= symb_array.max() + 1 = {}".format(symb_array.max() + 1))
-
-        if 'int' not in str(symb_array.dtype):
-            raise ValueError("Input data must of integer type, where each "
-                             "number indexes a symbol.")
-
-        dim, T = symb_array.shape
-
-        flathist = np.zeros((n_symbs ** dim), dtype='int16')
-        multisymb = np.zeros(T, dtype='int64')
-        if weights is not None:
-            flathist = np.zeros((n_symbs ** dim), dtype='float32')
-            multiweights = np.ones(T, dtype='float32')
-
-        for i in range(dim):
-            multisymb += symb_array[i, :] * n_symbs ** i
-            if weights is not None:
-                multiweights *= weights[i, :]
-
-        if weights is None:
-            result = np.bincount(multisymb)
-        else:
-            result = (np.bincount(multisymb, weights=multiweights)
-                      / multiweights.sum())
-
-        flathist[:len(result)] += result
-
-        hist = flathist.reshape(tuple([n_symbs, n_symbs] +
-                                      [n_symbs for i in range(dim - 2)])).T
-
-        return hist
-
-
[docs]    def get_dependence_measure(self, array, xyz):
-        """Returns CMI estimate based on bincount histogram.
-
-        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,).
-
-        Returns
-        -------
-        val : float
-            Conditional mutual information estimate.
-        """
-
-        _, T = array.shape
-
-        # High-dimensional histogram
-        hist = self._bincount_hist(array, weights=None)
-
-        def _plogp_vector(T):
-            """Precalculation of p*log(p) needed for entropies."""
-            gfunc = np.zeros(T + 1)
-            data = np.arange(1, T + 1, 1)
-            gfunc[1:] = data * np.log(data)
-            def plogp_func(time):
-                return gfunc[time]
-            return np.vectorize(plogp_func)
-
-        plogp = _plogp_vector(T)
-        hxyz = (-(plogp(hist)).sum() + plogp(T)) / float(T)
-        hxz = (-(plogp(hist.sum(axis=1))).sum() + plogp(T)) / float(T)
-        hyz = (-(plogp(hist.sum(axis=0))).sum() + plogp(T)) / float(T)
-        hz = (-(plogp(hist.sum(axis=0).sum(axis=0))).sum()+plogp(T)) / float(T)
-        val = hxz + hyz - hz - hxyz
-        return val

-
-
[docs]    def get_shuffle_significance(self, array, xyz, value,
-                                 return_null_dist=False):
-        """Returns p-value for shuffle significance test.
-
-        For residual-based test statistics only the residuals are shuffled.
-
-        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,).
-
-        value : number
-            Value of test statistic for unshuffled estimate.
-
-        Returns
-        -------
-        pval : float
-            p-value
-        """
-
-        null_dist = self._get_shuffle_dist(array, xyz,
-                                           self.get_dependence_measure,
-                                           sig_samples=self.sig_samples,
-                                           sig_blocklength=self.sig_blocklength,
-                                           verbosity=self.verbosity)
-
-        pval = (null_dist >= value).mean()
-
-        if return_null_dist:
-            return pval, null_dist
-        return pval

-
-
[docs]class RCOT(CondIndTest):
-    r"""Randomized Conditional Correlation Test.
-
-    Tests conditional independence in the fully non-parametric setting based on
-    Kernel measures. For not too small sample sizes, the test can utilize an
-    analytic approximation of the null distribution making it very fast. Based
-    on r-package ``rcit``. This test is described in [5]_.
-
-    Notes
-    -----
-
-    RCOT is a fast variant of the Kernel Conditional Independence Test (KCIT)
-    utilizing random Fourier features. Kernel tests measure conditional
-    independence in the fully non-parametric setting. In practice, RCOT tests
-    scale linearly with sample size and return accurate p-values much faster
-    than KCIT in the large sample size context. To use the analytical null
-    approximation, the sample size should be at least ~1000.
-
-    The method is fully described in [5]_ and the r-package documentation. The
-    free parameters are the approximation of the partial kernel cross-covariance
-    matrix and the number of random fourier features for the conditioning set.
-    One caveat is that RCOT is, as the name suggests, based on random fourier
-    features. To get reproducable results, you should fix the seed (default).
-
-    This class requires the rpy package and the prior installation of ``rcit``
-    from https://github.com/ericstrobl/RCIT. This is provided with tigramite
-    as an external package.
-
-    References
-    ----------
-    .. [5] Eric V. Strobl, Kun Zhang, Shyam Visweswaran:
-           Approximate Kernel-based Conditional Independence Tests for Fast Non-
-           Parametric Causal Discovery.
-           https://arxiv.org/abs/1702.03877
-
-    Parameters
-    ----------
-    num_f : int, optional
-        Number of random fourier features for conditioning set. More features
-        better approximate highly structured joint densities, but take more
-        computational time.
-
-    approx : str, optional
-        Which approximation of the partial cross-covariance matrix, options:
-        'lpd4' the Lindsay-Pilla-Basak method (default), 'gamma' for the
-        Satterthwaite-Welch method, 'hbe' for the Hall-Buckley-Eagleson method,
-        'chi2' for a normalized chi-squared statistic, 'perm' for permutation
-        testing (warning: this one is slow).
-
-    seed : int or None, optional
-        Which random fourier feature seed to use. If None, you won't get
-        reproducable results.
-
-    significance : str, optional (default: 'analytic')
-        Type of significance test to use.
-
-    **kwargs :
-        Arguments passed on to parent class CondIndTest.
-    """
-    @property
-    def measure(self):
-        """
-        Concrete property to return the measure of the independence test
-        """
-        return self._measure
-
-    def __init__(self,
-                 num_f=25,
-                 approx="lpd4",
-                 seed=42,
-                 significance='analytic',
-                 **kwargs):
-        # Set the members
-        self.num_f = num_f
-        self.approx = approx
-        self.seed = seed
-        self._measure = 'rcot'
-        self.two_sided = False
-        self.residual_based = False
-        self._pval = None
-        # Call the parent constructor
-        CondIndTest.__init__(self, significance=significance, **kwargs)
-
-        # Print some information
-        if self.verbosity > 0:
-            print("num_f = %s" % self.num_f + "\n")
-            print("approx = %s" % self.approx + "\n\n")
-
-
[docs]    def get_dependence_measure(self, array, xyz):
-        """Returns RCOT estimate.
-
-        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,).
-
-        Returns
-        -------
-        val : float
-            RCOT estimate.
-        """
-        dim, T = array.shape
-        x_vals = array[0]
-        y_vals = array[1]
-        z_vals = np.fastCopyAndTranspose(array[2:])
-
-        rcot = rpy2.robjects.r['RCoT'](x_vals, y_vals, z_vals,
-                                       num_f=self.num_f,
-                                       approx=self.approx,
-                                       seed=self.seed)
-
-        val = float(rcot.rx2('Sta')[0])
-        # Cache the p-value for use later
-        self._pval = float(rcot.rx2('p')[0])
-
-        return val

-
-
[docs]    def get_analytic_significance(self, **args):
-        """
-        Returns analytic p-value from RCoT test statistic.
-        NOTE: Must first run get_dependence_measure, where p-value is determined
-        from RCoT test statistic.
-
-        Returns
-        -------
-        pval : float or numpy.nan
-            P-value.
-        """
-        return self._pval

-
-
[docs]    def get_shuffle_significance(self, array, xyz, value,
-                                 return_null_dist=False):
-        """Returns p-value for shuffle significance test.
-
-        For residual-based test statistics only the residuals are shuffled.
-
-        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,).
-
-        value : number
-            Value of test statistic for unshuffled estimate.
-
-        Returns
-        -------
-        pval : float
-            p-value
-        """
-
-        null_dist = self._get_shuffle_dist(array, xyz,
-                                           self.get_dependence_measure,
-                                           sig_samples=self.sig_samples,
-                                           sig_blocklength=self.sig_blocklength,
-                                           verbosity=self.verbosity)
-
-        pval = (null_dist >= value).mean()
-
-        if return_null_dist:
-            return pval, null_dist
-        return pval

-
- -
-
-
-
-
- - - - \ No newline at end of file diff --git a/docs/_build/html/_modules/tigramite/independence_tests/cmiknn.html b/docs/_build/html/_modules/tigramite/independence_tests/cmiknn.html deleted file mode 100644 index 7c080bff..00000000 --- a/docs/_build/html/_modules/tigramite/independence_tests/cmiknn.html +++ /dev/null @@ -1,404 +0,0 @@ - - - - - - - tigramite.independence_tests.cmiknn — Tigramite 4.2 documentation - - - - - - - - - - - - - -
-
-
-
- -

Source code for tigramite.independence_tests.cmiknn

-"""Tigramite causal discovery for time series."""
-
-# Author: Jakob Runge <jakob@jakob-runge.com>
-#
-# License: GNU General Public License v3.0
-
-from __future__ import print_function
-from scipy import special, stats, spatial
-import numpy as np
-
-from .independence_tests_base import CondIndTest
-
-try:
-    from tigramite import tigramite_cython_code
-except:
-    print("Could not import packages for CMIknn and GPDC estimation")
-
-
-
[docs]class CMIknn(CondIndTest):
-    r"""Conditional mutual information test based on nearest-neighbor estimator.
-
-    Conditional mutual information is the most general dependency measure coming
-    from an information-theoretic framework. It makes no assumptions about the
-    parametric form of the dependencies by directly estimating the underlying
-    joint density. The test here is based on the estimator in  S. Frenzel and B.
-    Pompe, Phys. Rev. Lett. 99, 204101 (2007), combined with a shuffle test to
-    generate  the distribution under the null hypothesis of independence first
-    used in [3]_. The knn-estimator is suitable only for variables taking a
-    continuous range of values. For discrete variables use the CMIsymb class.
-
-    Notes
-    -----
-    CMI is given by
-
-    .. math:: I(X;Y|Z) &= \int p(z)  \iint  p(x,y|z) \log
-                \frac{ p(x,y |z)}{p(x|z)\cdot p(y |z)} \,dx dy dz
-
-    Its knn-estimator is given by
-
-    .. math:: \widehat{I}(X;Y|Z)  &=   \psi (k) + \frac{1}{T} \sum_{t=1}^T
-            \left[ \psi(k_{Z,t}) - \psi(k_{XZ,t}) - \psi(k_{YZ,t}) \right]
-
-    where :math:`\psi` is the Digamma function.  This estimator has as a
-    parameter the number of nearest-neighbors :math:`k` which determines the
-    size of hyper-cubes around each (high-dimensional) sample point. Then
-    :math:`k_{Z,},k_{XZ},k_{YZ}` are the numbers of neighbors in the respective
-    subspaces.
-
-    :math:`k` can be viewed as a density smoothing parameter (although it is
-    data-adaptive unlike fixed-bandwidth estimators). For large :math:`k`, the
-    underlying dependencies are more smoothed and CMI has a larger bias,
-    but lower variance, which is more important for significance testing. Note
-    that the estimated CMI values can be slightly negative while CMI is a non-
-    negative quantity.
-
-    This method requires the scipy.spatial.cKDTree package and the tigramite
-    cython module.
-
-    References
-    ----------
-
-    .. [3] 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
-
-    Parameters
-    ----------
-    knn : int or float, optional (default: 0.2)
-        Number of nearest-neighbors which determines the size of hyper-cubes
-        around each (high-dimensional) sample point. If smaller than 1, this is
-        computed as a fraction of T, hence knn=knn*T. For knn larger or equal to
-        1, this is the absolute number.
-
-    shuffle_neighbors : int, optional (default: 10)
-        Number of nearest-neighbors within Z for the shuffle surrogates which
-        determines the size of hyper-cubes around each (high-dimensional) sample
-        point.
-
-    transform : {'ranks', 'standardize',  'uniform', False}, optional
-        (default: 'ranks')
-        Whether to transform the array beforehand by standardizing
-        or transforming to uniform marginals.
-
-    n_jobs : int (optional, default = -1)
-        Number of jobs to schedule for parallel processing. If -1 is given
-        all processors are used. Default: 1.
-
-    significance : str, optional (default: 'shuffle_test')
-        Type of significance test to use. For CMIknn only 'fixed_thres' and
-        'shuffle_test' are available.
-
-    **kwargs :
-        Arguments passed on to parent class CondIndTest.
-    """
-    @property
-    def measure(self):
-        """
-        Concrete property to return the measure of the independence test
-        """
-        return self._measure
-
-    def __init__(self,
-                 knn=0.2,
-                 shuffle_neighbors=5,
-                 significance='shuffle_test',
-                 transform='ranks',
-                 n_jobs=-1,
-                 **kwargs):
-        # Set the member variables
-        self.knn = knn
-        self.shuffle_neighbors = shuffle_neighbors
-        self.transform = transform
-        self._measure = 'cmi_knn'
-        self.two_sided = False
-        self.residual_based = False
-        self.recycle_residuals = False
-        self.n_jobs = n_jobs
-        # Call the parent constructor
-        CondIndTest.__init__(self, significance=significance, **kwargs)
-        # Print some information about construction
-        if self.verbosity > 0:
-            if self.knn < 1:
-                print("knn/T = %s" % self.knn)
-            else:
-                print("knn = %s" % self.knn)
-            print("shuffle_neighbors = %d\n" % self.shuffle_neighbors)
-
-    def _get_nearest_neighbors(self, array, xyz, knn):
-        """Returns nearest neighbors according to Frenzel and Pompe (2007).
-
-        Retrieves the distances eps to the k-th nearest neighbors for every
-        sample in joint space XYZ and returns the numbers of nearest neighbors
-        within eps in subspaces Z, XZ, YZ.
-
-        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,).
-
-        knn : int or float
-            Number of nearest-neighbors which determines the size of hyper-cubes
-            around each (high-dimensional) sample point. If smaller than 1, this
-            is computed as a fraction of T, hence knn=knn*T. For knn larger or
-            equal to 1, this is the absolute number.
-
-        Returns
-        -------
-        k_xz, k_yz, k_z : tuple of arrays of shape (T,)
-            Nearest neighbors in subspaces.
-        """
-
-        dim, T = array.shape
-        array = array.astype('float')
-
-        # Add noise to destroy ties...
-        array += (1E-6 * array.std(axis=1).reshape(dim, 1)
-                  * np.random.rand(array.shape[0], array.shape[1]))
-
-        if self.transform == 'standardize':
-            # Standardize
-            array = array.astype('float')
-            array -= array.mean(axis=1).reshape(dim, 1)
-            array /= array.std(axis=1).reshape(dim, 1)
-            # FIXME: If the time series is constant, return nan rather than
-            # raising Exception
-            if np.isnan(array).sum() != 0:
-                raise ValueError("nans after standardizing, "
-                                 "possibly constant array!")
-        elif self.transform == 'uniform':
-            array = self._trafo2uniform(array)
-        elif self.transform == 'ranks':
-            array = array.argsort(axis=1).argsort(axis=1).astype('float')
-
-
-        # Use cKDTree to get distances eps to the k-th nearest neighbors for
-        # every sample in joint space XYZ with maximum norm
-        tree_xyz = spatial.cKDTree(array.T)
-        epsarray = tree_xyz.query(array.T, k=knn+1, p=np.inf,
-                                  eps=0., n_jobs=self.n_jobs)[0][:, knn].astype('float')
-
-        # Prepare for fast cython access
-        dim_x = int(np.where(xyz == 0)[0][-1] + 1)
-        dim_y = int(np.where(xyz == 1)[0][-1] + 1 - dim_x)
-
-        k_xz, k_yz, k_z = \
-                tigramite_cython_code._get_neighbors_within_eps_cython(array,
-                                                                       T,
-                                                                       dim_x,
-                                                                       dim_y,
-                                                                       epsarray,
-                                                                       knn,
-                                                                       dim)
-        return k_xz, k_yz, k_z
-
-
[docs]    def get_dependence_measure(self, array, xyz):
-        """Returns CMI estimate as described in Frenzel and Pompe PRL (2007).
-
-        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,).
-
-        Returns
-        -------
-        val : float
-            Conditional mutual information estimate.
-        """
-
-        dim, T = array.shape
-
-        if self.knn < 1:
-            knn_here = max(1, int(self.knn*T))
-        else:
-            knn_here = max(1, int(self.knn))
-
-        k_xz, k_yz, k_z = self._get_nearest_neighbors(array=array,
-                                                      xyz=xyz,
-                                                      knn=knn_here)
-
-        val = special.digamma(knn_here) - (special.digamma(k_xz) +
-                                           special.digamma(k_yz) -
-                                           special.digamma(k_z)).mean()
-
-        return val

-
-
-
[docs]    def get_shuffle_significance(self, array, xyz, value,
-                                 return_null_dist=False):
-        """Returns p-value for nearest-neighbor shuffle significance test.
-
-        For non-empty Z, overwrites get_shuffle_significance from the parent
-        class  which is a block shuffle test, which does not preserve
-        dependencies of X and Y with Z. Here the parameter shuffle_neighbors is
-        used to permute only those values :math:`x_i` and :math:`x_j` for which
-        :math:`z_j` is among the nearest niehgbors of :math:`z_i`. If Z is
-        empty, the block-shuffle test is used.
-
-        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,).
-
-        value : number
-            Value of test statistic for unshuffled estimate.
-
-        Returns
-        -------
-        pval : float
-            p-value
-        """
-        dim, T = array.shape
-
-        # Skip shuffle test if value is above threshold
-        # if value > self.minimum threshold:
-        #     if return_null_dist:
-        #         return 0., None
-        #     else:
-        #         return 0.
-
-        # max_neighbors = max(1, int(max_neighbor_ratio*T))
-        x_indices = np.where(xyz == 0)[0]
-        z_indices = np.where(xyz == 2)[0]
-
-        if len(z_indices) > 0 and self.shuffle_neighbors < T:
-            if self.verbosity > 2:
-                print("            nearest-neighbor shuffle significance "
-                      "test with n = %d and %d surrogates" % (
-                      self.shuffle_neighbors, self.sig_samples))
-
-            # Get nearest neighbors around each sample point in Z
-            z_array = np.fastCopyAndTranspose(array[z_indices, :])
-            tree_xyz = spatial.cKDTree(z_array)
-            neighbors = tree_xyz.query(z_array,
-                                       k=self.shuffle_neighbors,
-                                       p=np.inf,
-                                       eps=0.)[1].astype('int32')
-
-            null_dist = np.zeros(self.sig_samples)
-            for sam in range(self.sig_samples):
-
-                # Generate random order in which to go through indices loop in
-                # next step
-                order = np.random.permutation(T).astype('int32')
-                # print(order[:5])
-                # Select a series of neighbor indices that contains as few as
-                # possible duplicates
-                restricted_permutation = \
-                    tigramite_cython_code._get_restricted_permutation_cython(
-                        T=T,
-                        shuffle_neighbors=self.shuffle_neighbors,
-                        neighbors=neighbors,
-                        order=order)
-
-                array_shuffled = np.copy(array)
-                for i in x_indices:
-                    array_shuffled[i] = array[i, restricted_permutation]
-
-                null_dist[sam] = self.get_dependence_measure(array_shuffled,
-                                                             xyz)
-
-        else:
-            null_dist = \
-                    self._get_shuffle_dist(array, xyz,
-                                           self.get_dependence_measure,
-                                           sig_samples=self.sig_samples,
-                                           sig_blocklength=self.sig_blocklength,
-                                           verbosity=self.verbosity)
-
-        # Sort
-        null_dist.sort()
-        pval = (null_dist >= value).mean()
-
-        if return_null_dist:
-            return pval, null_dist
-        return pval

-
-
- -
-
-
-
-
- - - - \ No newline at end of file diff --git a/docs/_build/html/_modules/tigramite/independence_tests/cmisymb.html b/docs/_build/html/_modules/tigramite/independence_tests/cmisymb.html deleted file mode 100644 index 75c73fee..00000000 --- a/docs/_build/html/_modules/tigramite/independence_tests/cmisymb.html +++ /dev/null @@ -1,295 +0,0 @@ - - - - - - - tigramite.independence_tests.cmisymb — Tigramite 4.2 documentation - - - - - - - - - - - - - -
-
-
-
- -

Source code for tigramite.independence_tests.cmisymb

-"""Tigramite causal discovery for time series."""
-
-# Author: Jakob Runge <jakob@jakob-runge.com>
-#
-# License: GNU General Public License v3.0
-
-from __future__ import print_function
-import warnings
-import numpy as np
-
-from .independence_tests_base import CondIndTest
-
-
[docs]class CMIsymb(CondIndTest):
-    r"""Conditional mutual information test based on discrete estimator.
-
-    Conditional mutual information is the most general dependency measure
-    coming from an information-theoretic framework. It makes no assumptions
-    about the parametric form of the dependencies by directly estimating the
-    underlying joint density. The test here is based on directly estimating
-    the joint distribution assuming symbolic input, combined with a
-    shuffle test to generate  the distribution under the null hypothesis of
-    independence. The knn-estimator is suitable only for discrete variables.
-    For continuous variables, either pre-process the data using the functions
-    in data_processing or, better, use the CMIknn class.
-
-    Notes
-    -----
-    CMI and its estimator are given by
-
-    .. math:: I(X;Y|Z) &= \sum p(z)  \sum \sum  p(x,y|z) \log
-                \frac{ p(x,y |z)}{p(x|z)\cdot p(y |z)} \,dx dy dz
-
-    Parameters
-    ----------
-    n_symbs : int, optional (default: None)
-        Number of symbols in input data. Should be at least as large as the
-        maximum array entry + 1. If None, n_symbs is based on the
-        maximum value in the array (array.max() + 1).
-
-    significance : str, optional (default: 'shuffle_test')
-        Type of significance test to use. For CMIsymb only 'fixed_thres' and
-        'shuffle_test' are available.
-
-    sig_blocklength : int, optional (default: 1)
-        Block length for block-shuffle significance test.
-
-    conf_blocklength : int, optional (default: 1)
-        Block length for block-bootstrap.
-
-    **kwargs :
-        Arguments passed on to parent class CondIndTest.
-    """
-    @property
-    def measure(self):
-        """
-        Concrete property to return the measure of the independence test
-        """
-        return self._measure
-
-    def __init__(self,
-                 n_symbs=None,
-                 significance='shuffle_test',
-                 sig_blocklength=1,
-                 conf_blocklength=1,
-                 **kwargs):
-        # Setup the member variables
-        self._measure = 'cmi_symb'
-        self.two_sided = False
-        self.residual_based = False
-        self.recycle_residuals = False
-        self.n_symbs = n_symbs
-        # Call the parent constructor
-        CondIndTest.__init__(self,
-                             significance=significance,
-                             sig_blocklength=sig_blocklength,
-                             conf_blocklength=conf_blocklength,
-                             **kwargs)
-
-        if self.verbosity > 0:
-            print("n_symbs = %s" % self.n_symbs)
-            print("")
-
-        if self.conf_blocklength is None or self.sig_blocklength is None:
-            warnings.warn("Automatic block-length estimations from decay of "
-                          "autocorrelation may not be sensical for discrete "
-                          "data")
-
-    def _bincount_hist(self, symb_array, weights=None):
-        """Computes histogram from symbolic array.
-
-        The maximum of the symbolic array determines the alphabet / number
-        of bins.
-
-        Parameters
-        ----------
-        symb_array : integer array
-            Data array of shape (dim, T).
-
-        weights : float array, optional (default: None)
-            Optional weights array of shape (dim, T).
-
-        Returns
-        -------
-        hist : array
-            Histogram array of shape (base, base, base, ...)*number of
-            dimensions with Z-dimensions coming first.
-        """
-
-        if self.n_symbs is None:
-            n_symbs = int(symb_array.max() + 1)
-        else:
-            n_symbs = self.n_symbs
-            if n_symbs < int(symb_array.max() + 1):
-                raise ValueError("n_symbs must be >= symb_array.max() + 1 = {}".format(symb_array.max() + 1))
-
-        if 'int' not in str(symb_array.dtype):
-            raise ValueError("Input data must of integer type, where each "
-                             "number indexes a symbol.")
-
-        dim, T = symb_array.shape
-
-        flathist = np.zeros((n_symbs ** dim), dtype='int16')
-        multisymb = np.zeros(T, dtype='int64')
-        if weights is not None:
-            flathist = np.zeros((n_symbs ** dim), dtype='float32')
-            multiweights = np.ones(T, dtype='float32')
-
-        for i in range(dim):
-            multisymb += symb_array[i, :] * n_symbs ** i
-            if weights is not None:
-                multiweights *= weights[i, :]
-
-        if weights is None:
-            result = np.bincount(multisymb)
-        else:
-            result = (np.bincount(multisymb, weights=multiweights)
-                      / multiweights.sum())
-
-        flathist[:len(result)] += result
-
-        hist = flathist.reshape(tuple([n_symbs, n_symbs] +
-                                      [n_symbs for i in range(dim - 2)])).T
-
-        return hist
-
-
[docs]    def get_dependence_measure(self, array, xyz):
-        """Returns CMI estimate based on bincount histogram.
-
-        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,).
-
-        Returns
-        -------
-        val : float
-            Conditional mutual information estimate.
-        """
-
-        _, T = array.shape
-
-        # High-dimensional histogram
-        hist = self._bincount_hist(array, weights=None)
-
-        def _plogp_vector(T):
-            """Precalculation of p*log(p) needed for entropies."""
-            gfunc = np.zeros(T + 1)
-            data = np.arange(1, T + 1, 1)
-            gfunc[1:] = data * np.log(data)
-            def plogp_func(time):
-                return gfunc[time]
-            return np.vectorize(plogp_func)
-
-        plogp = _plogp_vector(T)
-        hxyz = (-(plogp(hist)).sum() + plogp(T)) / float(T)
-        hxz = (-(plogp(hist.sum(axis=1))).sum() + plogp(T)) / float(T)
-        hyz = (-(plogp(hist.sum(axis=0))).sum() + plogp(T)) / float(T)
-        hz = (-(plogp(hist.sum(axis=0).sum(axis=0))).sum()+plogp(T)) / float(T)
-        val = hxz + hyz - hz - hxyz
-        return val

-
-
[docs]    def get_shuffle_significance(self, array, xyz, value,
-                                 return_null_dist=False):
-        """Returns p-value for shuffle significance test.
-
-        For residual-based test statistics only the residuals are shuffled.
-
-        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,).
-
-        value : number
-            Value of test statistic for unshuffled estimate.
-
-        Returns
-        -------
-        pval : float
-            p-value
-        """
-
-        null_dist = self._get_shuffle_dist(array, xyz,
-                                           self.get_dependence_measure,
-                                           sig_samples=self.sig_samples,
-                                           sig_blocklength=self.sig_blocklength,
-                                           verbosity=self.verbosity)
-
-        pval = (null_dist >= value).mean()
-
-        if return_null_dist:
-            return pval, null_dist
-        return pval

-
- -
-
-
-
-
- - - - \ No newline at end of file diff --git a/docs/_build/html/_modules/tigramite/independence_tests/independence_tests_base.html b/docs/_build/html/_modules/tigramite/independence_tests/independence_tests_base.html deleted file mode 100644 index a68fcdad..00000000 --- a/docs/_build/html/_modules/tigramite/independence_tests/independence_tests_base.html +++ /dev/null @@ -1,1087 +0,0 @@ - - - - - - - tigramite.independence_tests.independence_tests_base — Tigramite 4.2 documentation - - - - - - - - - - - - - -
-
-
-
- -

Source code for tigramite.independence_tests.independence_tests_base

-"""Tigramite causal discovery for time series."""
-
-# Author: Jakob Runge <jakob@jakob-runge.com>
-#
-# License: GNU General Public License v3.0
-
-from __future__ import print_function
-import warnings
-import math
-import abc
-import numpy as np
-import six
-from hashlib import sha1
-
-
-
[docs]@six.add_metaclass(abc.ABCMeta)
-class CondIndTest():
-    """Base class of conditional independence tests.
-
-    Provides useful general functions for different independence tests such as
-    shuffle significance testing and bootstrap confidence estimation. Also
-    handles masked samples. Other test classes can inherit from this class.
-
-    Parameters
-    ----------
-    mask_type : str, optional (default = None)
-        Must be in {'y','x','z','xy','xz','yz','xyz'}
-        Masking mode: Indicators for which variables in the dependence measure
-        I(X; Y | Z) the samples should be masked. If None, 'y' is used, which
-        excludes all time slices containing masked samples in Y. Explained in
-        [1]_.
-
-    significance : str, optional (default: 'analytic')
-        Type of significance test to use. In this package 'analytic',
-        'fixed_thres' and 'shuffle_test' are available.
-
-    fixed_thres : float, optional (default: 0.1)
-        If significance is 'fixed_thres', this specifies the threshold for the
-        absolute value of the dependence measure.
-
-    sig_samples : int, optional (default: 1000)
-        Number of samples for shuffle significance test.
-
-    sig_blocklength : int, optional (default: None)
-        Block length for block-shuffle significance test. If None, the
-        block length is determined from the decay of the autocovariance as
-        explained in [1]_.
-
-    confidence : str, optional (default: None)
-        Specify type of confidence estimation. If False, numpy.nan is returned.
-        'bootstrap' can be used with any test, for ParCorr also 'analytic' is
-        implemented.
-
-    conf_lev : float, optional (default: 0.9)
-        Two-sided confidence interval.
-
-    conf_samples : int, optional (default: 100)
-        Number of samples for bootstrap.
-
-    conf_blocklength : int, optional (default: None)
-        Block length for block-bootstrap. If None, the block length is
-        determined from the decay of the autocovariance as explained in [1]_.
-
-    recycle_residuals : bool, optional (default: False)
-        Specifies whether residuals should be stored. This may be faster, but
-        can cost considerable memory.
-
-    verbosity : int, optional (default: 0)
-        Level of verbosity.
-    """
-
[docs]    @abc.abstractmethod
-    def get_dependence_measure(self, array, xyz):
-        """
-        Abstract function that all concrete classes must instantiate.
-        """
-        pass

-
-    @abc.abstractproperty
-    def measure(self):
-        """
-        Abstract property to store the type of independence test.
-        """
-        pass
-
-    def __init__(self,
-                 mask_type=None,
-                 significance='analytic',
-                 fixed_thres=0.1,
-                 sig_samples=1000,
-                 sig_blocklength=None,
-                 confidence=None,
-                 conf_lev=0.9,
-                 conf_samples=100,
-                 conf_blocklength=None,
-                 recycle_residuals=False,
-                 verbosity=0):
-        # Set the dataframe to None for now, will be reset during pcmci call
-        self.dataframe = None
-        # Set the options
-        self.significance = significance
-        self.sig_samples = sig_samples
-        self.sig_blocklength = sig_blocklength
-        self.fixed_thres = fixed_thres
-        self.verbosity = verbosity
-        self.cached_ci_results = {}
-        # If we recycle residuals, then set up a residual cache
-        self.recycle_residuals = recycle_residuals
-        if self.recycle_residuals:
-            self.residuals = {}
-        # If we use a mask, we cannot recycle residuals
-        self.set_mask_type(mask_type)
-
-        # Set the confidence type and details
-        self.confidence = confidence
-        self.conf_lev = conf_lev
-        self.conf_samples = conf_samples
-        self.conf_blocklength = conf_blocklength
-
-        # Print information about the
-        if self.verbosity > 0:
-            self.print_info()
-
-
[docs]    def set_mask_type(self, mask_type):
-        """
-        Setter for mask type to ensure that this option does not clash with
-        recycle_residuals.
-
-        Parameters
-        ----------
-        mask_type : str
-            Must be in {'y','x','z','xy','xz','yz','xyz'}
-            Masking mode: Indicators for which variables in the dependence
-            measure I(X; Y | Z) the samples should be masked. If None, 'y' is
-            used, which excludes all time slices containing masked samples in Y.
-            Explained in [1]_.
-        """
-        # Set the mask type
-        self.mask_type = mask_type
-        # Check if this clashes with residual recycling
-        if self.mask_type is not None:
-            if self.recycle_residuals is True:
-                warnings.warn("Using a mask disables recycling residuals.")
-            self.recycle_residuals = False
-        # Check the mask type is keyed correctly
-        self._check_mask_type()

-
-
[docs]    def print_info(self):
-        """
-        Print information about the conditional independence test parameters
-        """
-        info_str = "\n# Initialize conditional independence test\n\nParameters:"
-        info_str += "\nindependence test = %s" % self.measure
-        info_str += "\nsignificance = %s" % self.significance
-        # Check if we are using a shuffle test
-        if self.significance == 'shuffle_test':
-            info_str += "\nsig_samples = %s" % self.sig_samples
-            info_str += "\nsig_blocklength = %s" % self.sig_blocklength
-        # Check if we are using a fixed threshold
-        elif self.significance == 'fixed_thres':
-            info_str += "\nfixed_thres = %s" % self.fixed_thres
-        # Check if we have a confidence type
-        if self.confidence:
-            info_str += "\nconfidence = %s" % self.confidence
-            info_str += "\nconf_lev = %s" % self.conf_lev
-        # Check if this confidence type is boostrapping
-        if self.confidence == 'bootstrap':
-            info_str += "\nconf_samples = %s" % self.conf_samples
-            info_str += "\nconf_blocklength = %s" %self.conf_blocklength
-        # Check if we use a non-trivial mask type
-        if self.mask_type is not None:
-            info_str += "\nmask_type = %s" % self.mask_type
-        # Check if we are recycling residuals or not
-        if self.recycle_residuals:
-            info_str += "\nrecycle_residuals = %s" % self.recycle_residuals
-        # Print the information string
-        print(info_str)

-
-    def _check_mask_type(self):
-        """
-        mask_type : str, optional (default = None)
-            Must be in {'y','x','z','xy','xz','yz','xyz'}
-            Masking mode: Indicators for which variables in the dependence
-            measure I(X; Y | Z) the samples should be masked. If None, 'y' is
-            used, which excludes all time slices containing masked samples in Y.
-            Explained in [1]_.
-        """
-        if self.mask_type is not None:
-            mask_set = set(self.mask_type) - set(['x', 'y', 'z'])
-            if mask_set:
-                err_msg = "mask_type = %s," % self.mask_type + " but must be" +\
-                          " list containing 'x','y','z', or any combination"
-                raise ValueError(err_msg)
-
-
-
[docs]    def get_analytic_confidence(self, value, df, conf_lev):
-        """
-        Base class assumption that this is not implemented.  Concrete classes
-        should override when possible.
-        """
-        raise NotImplementedError("Analytic confidence not"+\
-                                  " implemented for %s" % self.measure)

-
-
[docs]    def get_model_selection_criterion(self, j, parents, tau_max=0):
-        """
-        Base class assumption that this is not implemented.  Concrete classes
-        should override when possible.
-        """
-        raise NotImplementedError("Model selection not"+\
-                                  " implemented for %s" % self.measure)

-
-
[docs]    def get_analytic_significance(self, value, T, dim):
-        """
-        Base class assumption that this is not implemented.  Concrete classes
-        should override when possible.
-        """
-        raise NotImplementedError("Analytic significance not"+\
-                                  " implemented for %s" % self.measure)

-
-
[docs]    def get_shuffle_significance(self, array, xyz, value,
-                                 return_null_dist=False):
-        """
-        Base class assumption that this is not implemented.  Concrete classes
-        should override when possible.
-        """
-        raise NotImplementedError("Shuffle significance not"+\
-                                  " implemented for %s" % self.measure)

-
-    def _get_single_residuals(self, array, target_var,
-                              standardize=True, return_means=False):
-        """
-        Base class assumption that this is not implemented.  Concrete classes
-        should override when possible.
-        """
-        raise NotImplementedError("Residual calculation not"+\
-                                  " implemented for %s" % self.measure)
-
-
[docs]    def set_dataframe(self, dataframe):
-        """Initialize and check the dataframe.
-
-        Parameters
-        ----------
-        dataframe : data object
-            Set tigramite dataframe object. It must have the attributes
-            dataframe.values yielding a numpy array of shape (observations T,
-            variables N) and optionally a mask of the same shape and a missing
-            values flag.
-
-        """
-        self.dataframe = dataframe
-        if self.mask_type is not None:
-            dataframe._check_mask(require_mask=True)

-
-    def _keyfy(self, x, z):
-        """Helper function to make lists unique."""
-        return (tuple(set(x)), tuple(set(z)))
-
-    def _get_array(self, X, Y, Z, tau_max=0, cut_off='2xtau_max',
-                   verbosity=0):
-        """Convencience wrapper around construct_array."""
-
-        if self.measure in ['par_corr']:
-            if len(X) > 1 or len(Y) > 1:
-                raise ValueError("X and Y for %s must be univariate." %
-                                        self.measure)
-        # Call the wrapped function
-        return self.dataframe.construct_array(X=X, Y=Y, Z=Z,
-                                              tau_max=tau_max,
-                                              mask_type=self.mask_type,
-                                              return_cleaned_xyz=True,
-                                              do_checks=True,
-                                              cut_off=cut_off,
-                                              verbosity=verbosity)
-    
-    def _get_array_hash(self, array, xyz, XYZ):
-        """Helper function to get hash of array.
-
-        For a CI test X _|_ Y | Z the order of variables within X or Y or Z 
-        does not matter and also the order X and Y can be swapped.
-        Hence, to compare hashes of the whole array, we order accordingly
-        to create a unique, order-independent hash. 
-
-        Parameters
-        ----------
-        array : Data array of shape (dim, T)
-            Data array.
-        xyz : array
-            Identifier array of shape (dim,) identifying which row in array
-            corresponds to X, Y, and Z
-        XYZ : list of tuples
-
-        Returns
-        -------
-        combined_hash : str
-            Hash that identifies uniquely an array of XYZ      
-        """
-
-        X, Y, Z = XYZ
-
-        # First check whether CI result was already computed
-        # by checking whether hash of (xyz, array) already exists
-        # Individually sort X, Y, Z since for a CI test it does not matter
-        # how they are aranged
-        x_orderd = sorted(range(len(X)), key=X.__getitem__)
-        arr_x = array[xyz==0][x_orderd]
-        x_hash = sha1(np.ascontiguousarray(arr_x)).hexdigest()
-
-        y_orderd = sorted(range(len(Y)), key=Y.__getitem__)
-        arr_y = array[xyz==1][y_orderd]
-        y_hash = sha1(np.ascontiguousarray(arr_y)).hexdigest()
-
-        z_orderd = sorted(range(len(Z)), key=Z.__getitem__)
-        arr_z = array[xyz==2][z_orderd]
-        z_hash = sha1(np.ascontiguousarray(arr_z)).hexdigest()
-
-        sorted_xy = sorted([x_hash, y_hash])
-        combined_hash = (sorted_xy[0], sorted_xy[1], z_hash)
-        return combined_hash
-
-
-
[docs]    def run_test(self, X, Y, Z=None, tau_max=0, cut_off='2xtau_max'):
-        """Perform conditional independence test.
-
-        Calls the dependence measure and signficicance test functions. The child
-        classes must specify a function get_dependence_measure and either or
-        both functions get_analytic_significance and  get_shuffle_significance.
-        If recycle_residuals is True, also _get_single_residuals must be
-        available.
-
-        Parameters
-        ----------
-        X, Y, Z : list of tuples
-            X,Y,Z are of the form [(var, -tau)], where var specifies the
-            variable index and tau the time lag.
-
-        tau_max : int, optional (default: 0)
-            Maximum time lag. This may be used to make sure that estimates for
-            different lags in X, Z, all have the same sample size.
-
-        cut_off : {'2xtau_max', 'max_lag', 'max_lag_or_tau_max'}
-            How many samples to cutoff at the beginning. The default is
-            '2xtau_max', which guarantees that MCI tests are all conducted on
-            the same samples. For modeling, 'max_lag_or_tau_max' can be used,
-            which uses the maximum of tau_max and the conditions, which is
-            useful to compare multiple models on the same sample.  Last,
-            'max_lag' uses as much samples as possible.
-
-        Returns
-        -------
-        val, pval : Tuple of floats
-            The test statistic value and the p-value.
-        """
-
-        # Get the array to test on
-        array, xyz, XYZ = self._get_array(X, Y, Z, tau_max, cut_off)
-        X, Y, Z = XYZ
-        # Record the dimensions
-        dim, T = array.shape
-        # Ensure it is a valid array
-        if np.any(np.isnan(array)):
-            raise ValueError("nans in the array!")
-
-        combined_hash = self._get_array_hash(array, xyz, XYZ)
-
-        if combined_hash in self.cached_ci_results.keys():
-            cached = True
-            val, pval = self.cached_ci_results[combined_hash]
-        else:
-            cached = False
-            # Get the dependence measure, reycling residuals if need be
-            val = self._get_dependence_measure_recycle(X, Y, Z, xyz, array)
-            # Get the p-value
-            pval = self.get_significance(val, array, xyz, T, dim)
-            self.cached_ci_results[combined_hash] = (val, pval)
-
-        if self.verbosity > 1:
-            self._print_cond_ind_results(val=val, pval=pval, cached=cached,
-                                         conf=None)
-        # Return the value and the pvalue
-        return val, pval

-
-
[docs]    def run_test_raw(self, x, y, z=None):
-        """Perform conditional independence test directly on input arrays x, y, z.
-
-        Calls the dependence measure and signficicance test functions. The child
-        classes must specify a function get_dependence_measure and either or
-        both functions get_analytic_significance and  get_shuffle_significance.
-
-        Parameters
-        ----------
-        x, y, z : arrays
-            x,y,z are of the form (samples, dimension).
-
-        Returns
-        -------
-        val, pval : Tuple of floats
-
-            The test statistic value and the p-value.
-        """
-
-        if np.ndim(x) != 2 or np.ndim(y) != 2:
-            raise ValueError("x,y must be arrays of shape (samples, dimension)"
-                             " where dimension can be 1.")
-
-        if z is not None and np.ndim(z) != 2:
-            raise ValueError("z must be array of shape (samples, dimension)"
-                             " where dimension can be 1.")
-
-        if z is None:
-            # Get the array to test on
-            array = np.vstack((x.T, y.T))
-
-            # xyz is the dimension indicator
-            xyz = np.array([0 for i in range(x.shape[1])] +
-                           [1 for i in range(y.shape[1])])
-
-        else:
-            # Get the array to test on
-            array = np.vstack((x.T, y.T, z.T))
-
-            # xyz is the dimension indicator
-            xyz = np.array([0 for i in range(x.shape[1])] +
-                           [1 for i in range(y.shape[1])] +
-                           [2 for i in range(z.shape[1])])
-
-        # Record the dimensions
-        dim, T = array.shape
-        # Ensure it is a valid array
-        if np.isnan(array).sum() != 0:
-            raise ValueError("nans in the array!")
-        # Get the dependence measure
-        val = self.get_dependence_measure(array, xyz)
-        # Get the p-value
-        pval = self.get_significance(val, array, xyz, T, dim)
-        # Return the value and the pvalue
-        return val, pval

-
-    def _get_dependence_measure_recycle(self, X, Y, Z, xyz, array):
-        """Get the dependence_measure, optionally recycling residuals
-
-        If self.recycle_residuals is True, also _get_single_residuals must be
-        available.
-
-        Parameters
-        ----------
-        X, Y, Z : list of tuples
-            X,Y,Z are of the form [(var, -tau)], where var specifies the
-            variable index and tau the time lag.
-
-        xyz : array of ints
-            XYZ identifier array of shape (dim,).
-
-        array : array
-            Data array of shape (dim, T)
-
-        Return
-        ------
-        val : float
-            Test statistic
-        """
-        # Check if we are recycling residuals
-        if self.recycle_residuals:
-            # Get or calculate the cached residuals
-            x_resid = self._get_cached_residuals(X, Z, array, 0)
-            y_resid = self._get_cached_residuals(Y, Z, array, 1)
-            # Make a new residual array
-            array_resid = np.array([x_resid, y_resid])
-            xyz_resid = np.array([0, 1])
-            # Return the dependence measure
-            return self.get_dependence_measure(array_resid, xyz_resid)
-        # If not, return the dependence measure on the array and xyz
-        return self.get_dependence_measure(array, xyz)
-
-    def _get_cached_residuals(self, x_nodes, z_nodes, array, target_var):
-        """
-        Retrieve or calculate the cached residuals for the given node sets.
-
-        Parameters
-        ----------
-            x_nodes : list of tuples
-                List of nodes, X or Y normally. Used to key the residual cache
-                during lookup
-
-            z_nodes : list of tuples
-                List of nodes, Z normally
-
-            target_var : int
-                Key to differentiate X from Y.
-                x_nodes == X => 0, x_nodes == Y => 1
-
-            array : array
-                Data array of shape (dim, T)
-
-        Returns
-        -------
-            x_resid : array
-                Residuals calculated by _get_single_residual
-        """
-        # Check if we have calculated these residuals
-        if self._keyfy(x_nodes, z_nodes) in list(self.residuals):
-            x_resid = self.residuals[self._keyfy(x_nodes, z_nodes)]
-        # If not, calculate the residuals
-        else:
-            x_resid = self._get_single_residuals(array, target_var=target_var)
-            if z_nodes:
-                self.residuals[self._keyfy(x_nodes, z_nodes)] = x_resid
-        # Return these residuals
-        return x_resid
-
-
[docs]    def get_significance(self, val, array, xyz, T, dim, sig_override=None):
-        """
-        Returns the p-value from whichever significance function is specified
-        for this test.  If an override is used, then it will call a different
-        function then specified by self.significance
-
-        Parameters
-        ----------
-        val : float
-            Test statistic value.
-
-        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,).
-
-        T : int
-            Sample length
-
-        dim : int
-            Dimensionality, ie, number of features.
-
-        sig_override : string
-            Must be in 'analytic', 'shuffle_test', 'fixed_thres'
-
-        Returns
-        -------
-        pval : float or numpy.nan
-            P-value.
-        """
-        # Defaults to the self.significance member value
-        use_sig = self.significance
-        if sig_override is not None:
-            use_sig = sig_override
-        # Check if we are using the analytic significance
-        if use_sig == 'analytic':
-            pval = self.get_analytic_significance(value=val, T=T, dim=dim)
-        # Check if we are using the shuffle significance
-        elif use_sig == 'shuffle_test':
-            pval = self.get_shuffle_significance(array=array,
-                                                 xyz=xyz,
-                                                 value=val)
-        # Check if we are using the fixed_thres significance
-        elif use_sig == 'fixed_thres':
-            pval = self.get_fixed_thres_significance(
-                    value=val,
-                    fixed_thres=self.fixed_thres)
-        else:
-            raise ValueError("%s not known." % self.significance)
-        # Return the calculated value
-        return pval

-
-
[docs]    def get_measure(self, X, Y, Z=None, tau_max=0):
-        """Estimate dependence measure.
-
-        Calls the dependence measure function. The child classes must specify
-        a function get_dependence_measure.
-
-        Parameters
-        ----------
-        X, Y [, Z] : list of tuples
-            X,Y,Z are of the form [(var, -tau)], where var specifies the
-            variable index and tau the time lag.
-
-        tau_max : int, optional (default: 0)
-            Maximum time lag. This may be used to make sure that estimates for
-            different lags in X, Z, all have the same sample size.
-
-        Returns
-        -------
-        val : float
-            The test statistic value.
-
-        """
-        # Make the array
-        array, xyz, (X, Y, Z) = self._get_array(X, Y, Z, tau_max)
-        D, T = array.shape
-        # Check it is valid
-        if np.isnan(array).sum() != 0:
-            raise ValueError("nans in the array!")
-        # Return the dependence measure
-        return self._get_dependence_measure_recycle(X, Y, Z, xyz, array)

-
-
[docs]    def get_confidence(self, X, Y, Z=None, tau_max=0):
-        """Perform confidence interval estimation.
-
-        Calls the dependence measure and confidence test functions. The child
-        classes can specify a function get_dependence_measure and
-        get_analytic_confidence or get_bootstrap_confidence. If confidence is
-        False, (numpy.nan, numpy.nan) is returned.
-
-        Parameters
-        ----------
-        X, Y, Z : list of tuples
-            X,Y,Z are of the form [(var, -tau)], where var specifies the
-            variable index and tau the time lag.
-
-        tau_max : int, optional (default: 0)
-            Maximum time lag. This may be used to make sure that estimates for
-            different lags in X, Z, all have the same sample size.
-
-        Returns
-        -------
-        (conf_lower, conf_upper) : Tuple of floats
-            Upper and lower confidence bound of confidence interval.
-        """
-        # Check if a confidence type has been defined
-        if self.confidence:
-            # Ensure the confidence level given makes sense
-            if self.conf_lev < .5 or self.conf_lev >= 1.:
-                raise ValueError("conf_lev = %.2f, " % self.conf_lev +
-                                 "but must be between 0.5 and 1")
-            half_conf = self.conf_samples * (1. - self.conf_lev)/2.
-            if self.confidence == 'bootstrap' and  half_conf < 1.:
-                raise ValueError("conf_samples*(1.-conf_lev)/2 is %.2f"
-                                 % half_conf + ", must be >> 1")
-        # Make and check the array
-        array, xyz, _ = self._get_array(X, Y, Z, tau_max, verbosity=0)
-        dim, T = array.shape
-        if np.isnan(array).sum() != 0:
-            raise ValueError("nans in the array!")
-
-        # Check if we are using analytic confidence or bootstrapping it
-        if self.confidence == 'analytic':
-            val = self.get_dependence_measure(array, xyz)
-            (conf_lower, conf_upper) = \
-                    self.get_analytic_confidence(df=T-dim,
-                                                 value=val,
-                                                 conf_lev=self.conf_lev)
-        elif self.confidence == 'bootstrap':
-            # Overwrite analytic values
-            (conf_lower, conf_upper) = \
-                    self.get_bootstrap_confidence(
-                        array, xyz,
-                        conf_samples=self.conf_samples,
-                        conf_blocklength=self.conf_blocklength,
-                        conf_lev=self.conf_lev, verbosity=self.verbosity)
-        elif not self.confidence:
-            return None
-        else:
-            raise ValueError("%s confidence estimation not implemented"
-                             % self.confidence)
-        # Cache the confidence interval
-        self.conf = (conf_lower, conf_upper)
-        # Return the confidence interval
-        return (conf_lower, conf_upper)

-
-    def _print_cond_ind_results(self, val, pval=None, cached=None, conf=None):
-        """Print results from conditional independence test.
-
-        Parameters
-        ----------
-        val : float
-            Test stastistic value.
-
-        pval : float, optional (default: None)
-            p-value
-
-        conf : tuple of floats, optional (default: None)
-            Confidence bounds.
-        """
-        printstr = "        val = % .3f" % (val)      
-        if pval is not None:
-            printstr += " | pval = %.5f" % (pval)
-        if conf is not None:
-            printstr += " | conf bounds = (%.3f, %.3f)" % (
-                conf[0], conf[1])
-        if cached is not None:
-            printstr += " %s" % ({0:"", 1:"[cached]"}[cached])
-
-        print(printstr)
-
-
[docs]    def get_bootstrap_confidence(self, array, xyz, dependence_measure=None,
-                                 conf_samples=100, conf_blocklength=None,
-                                 conf_lev=.95, verbosity=0):
-        """Perform bootstrap confidence interval estimation.
-
-        With conf_blocklength > 1 or None a block-bootstrap is performed.
-
-        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,).
-
-        dependence_measure : function (default = self.get_dependence_measure)
-            Dependence measure function must be of form
-            dependence_measure(array, xyz) and return a numeric value
-
-        conf_lev : float, optional (default: 0.9)
-            Two-sided confidence interval.
-
-        conf_samples : int, optional (default: 100)
-            Number of samples for bootstrap.
-
-        conf_blocklength : int, optional (default: None)
-            Block length for block-bootstrap. If None, the block length is
-            determined from the decay of the autocovariance as explained in
-            [1]_.
-
-        verbosity : int, optional (default: 0)
-            Level of verbosity.
-
-        Returns
-        -------
-        (conf_lower, conf_upper) : Tuple of floats
-            Upper and lower confidence bound of confidence interval.
-        """
-        # Check if a dependence measure if provided or if to use default
-        if not dependence_measure:
-            dependence_measure = self.get_dependence_measure
-
-        # confidence interval is two-sided
-        c_int = 1. - (1. - conf_lev)/2.
-        dim, T = array.shape
-
-        # If not block length is given, determine the optimal block length.
-        # This has a maximum of 10% of the time sample length
-        if conf_blocklength is None:
-            conf_blocklength = \
-                    self._get_block_length(array, xyz, mode='confidence')
-        # Determine the number of blocks total, rounding up for non-integer
-        # amounts
-        n_blks = int(math.ceil(float(T)/conf_blocklength))
-
-        # Print some information
-        if verbosity > 2:
-            print("            block_bootstrap confidence intervals"
-                  " with block-length = %d ..." % conf_blocklength)
-
-        # Generate the block bootstrapped distribution
-        bootdist = np.zeros(conf_samples)
-        for smpl in range(conf_samples):
-            # Get the starting indecies for the blocks
-            blk_strt = np.random.randint(0, T - conf_blocklength + 1, n_blks)
-            # Get the empty array of block resampled values
-            array_bootstrap = \
-                    np.zeros((dim, n_blks*conf_blocklength), dtype=array.dtype)
-            # Fill the array of block resamples
-            for i in range(conf_blocklength):
-                array_bootstrap[:, i::conf_blocklength] = array[:, blk_strt + i]
-            # Cut to proper length
-            array_bootstrap = array_bootstrap[:, :T]
-
-            bootdist[smpl] = dependence_measure(array_bootstrap, xyz)
-
-        # Sort and get quantile
-        bootdist.sort()
-        conf_lower = bootdist[int((1. - c_int) * conf_samples)]
-        conf_upper = bootdist[int(c_int * conf_samples)]
-        # Return the confidance limits as a tuple
-        return (conf_lower, conf_upper)

-
-    def _get_acf(self, 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, ddof=0)[0, 1]
-        return autocorr
-
-    def _get_block_length(self, 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.
-
-        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 = self._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 Pfeifer (2005) 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))
-            except RuntimeError:
-                print("Error - curve_fit failed in block_shuffle, using"
-                      " block_len = %d" % (int(.05 * T)))
-                block_len = max(int(.05 * T), 2)
-        # Limit block length to a maximum of 10% of T
-        block_len = min(block_len, int(0.1 * T))
-        return block_len
-
-    def _get_shuffle_dist(self, array, xyz, dependence_measure,
-                          sig_samples, sig_blocklength=None,
-                          verbosity=0):
-        """Returns shuffle distribution of test statistic.
-
-        The rows in array corresponding to the X-variable are shuffled using
-        a block-shuffle approach.
-
-        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,).
-
-       dependence_measure : object
-           Dependence measure function must be of form
-           dependence_measure(array, xyz) and return a numeric value
-
-        sig_samples : int, optional (default: 100)
-            Number of samples for shuffle significance test.
-
-        sig_blocklength : int, optional (default: None)
-            Block length for block-shuffle significance test. If None, the
-            block length is determined from the decay of the autocovariance as
-            explained in [1]_.
-
-        verbosity : int, optional (default: 0)
-            Level of verbosity.
-
-        Returns
-        -------
-        null_dist : array of shape (sig_samples,)
-            Contains the sorted test statistic values estimated from the
-            shuffled arrays.
-        """
-
-        dim, T = array.shape
-
-        x_indices = np.where(xyz == 0)[0]
-        dim_x = len(x_indices)
-
-        if sig_blocklength is None:
-            sig_blocklength = self._get_block_length(array, xyz,
-                                                     mode='significance')
-
-        n_blks = int(math.floor(float(T)/sig_blocklength))
-        # print 'n_blks ', n_blks
-        if verbosity > 2:
-            print("            Significance test with block-length = %d "
-                  "..." % (sig_blocklength))
-
-        array_shuffled = np.copy(array)
-        block_starts = np.arange(0, T - sig_blocklength + 1, sig_blocklength)
-
-        # Dividing the array up into n_blks of length sig_blocklength may
-        # leave a tail. This tail is later randomly inserted
-        tail = array[x_indices, n_blks*sig_blocklength:]
-
-        null_dist = np.zeros(sig_samples)
-        for sam in range(sig_samples):
-
-            blk_starts = np.random.permutation(block_starts)[:n_blks]
-
-            x_shuffled = np.zeros((dim_x, n_blks*sig_blocklength),
-                                  dtype=array.dtype)
-
-            for i, index in enumerate(x_indices):
-                for blk in range(sig_blocklength):
-                    x_shuffled[i, blk::sig_blocklength] = \
-                            array[index, blk_starts + blk]
-
-            # Insert tail randomly somewhere
-            if tail.shape[1] > 0:
-                insert_tail_at = np.random.choice(block_starts)
-                x_shuffled = np.insert(x_shuffled, insert_tail_at,
-                                       tail.T, axis=1)
-
-            for i, index in enumerate(x_indices):
-                array_shuffled[index] = x_shuffled[i]
-
-            null_dist[sam] = dependence_measure(array=array_shuffled,
-                                                xyz=xyz)
-
-        null_dist.sort()
-
-        return null_dist
-
-
[docs]    def get_fixed_thres_significance(self, value, fixed_thres):
-        """Returns signficance for thresholding test.
-
-        Returns 0 if numpy.abs(value) is smaller than fixed_thres and 1 else.
-
-        Parameters
-        ----------
-        value : number
-            Value of test statistic for unshuffled estimate.
-
-        fixed_thres : number
-            Fixed threshold, is made positive.
-
-        Returns
-        -------
-        pval : bool
-            Returns 0 if numpy.abs(value) is smaller than fixed_thres and 1
-            else.
-
-        """
-        if np.abs(value) < np.abs(fixed_thres):
-            pval = 1.
-        else:
-            pval = 0.
-
-        return pval

-
-    def _trafo2uniform(self, x):
-        """Transforms input array to uniform marginals.
-
-        Assumes x.shape = (dim, T)
-
-        Parameters
-        ----------
-        x : array-like
-            Input array.
-
-        Returns
-        -------
-        u : array-like
-            array with uniform marginals.
-        """
-
-        def trafo(xi):
-            xisorted = np.sort(xi)
-            yi = np.linspace(1. / len(xi), 1, len(xi))
-            return np.interp(xi, xisorted, yi)
-
-        if np.ndim(x) == 1:
-            u = trafo(x)
-        else:
-            u = np.empty(x.shape)
-            for i in range(x.shape[0]):
-                u[i] = trafo(x[i])
-        return u

-
- -
-
-
-
-
- - - - \ No newline at end of file diff --git a/docs/_build/html/_modules/tigramite/independence_tests/oracle_conditional_independence.html b/docs/_build/html/_modules/tigramite/independence_tests/oracle_conditional_independence.html deleted file mode 100644 index 2d2863b4..00000000 --- a/docs/_build/html/_modules/tigramite/independence_tests/oracle_conditional_independence.html +++ /dev/null @@ -1,845 +0,0 @@ - - - - - - - tigramite.independence_tests.oracle_conditional_independence — Tigramite 4.2 documentation - - - - - - - - - - - - - -
-
-
-
- -

Source code for tigramite.independence_tests.oracle_conditional_independence

-"""Tigramite causal discovery for time series."""
-
-# Author: Jakob Runge <jakob@jakob-runge.com>
-#
-# License: GNU General Public License v3.0
-
-from __future__ import print_function
-import numpy as np
-
-from collections import defaultdict, OrderedDict
-
-
-
[docs]class OracleCI:
-    r"""Oracle of conditional independence test X _|_ Y | Z given a graph.
-
-    Class around link_coeff causal ground truth. X _|_ Y | Z is based on
-    assessing whether X and Y are d-separated given Z in the graph.
-
-    Class can be used just like a Tigramite conditional independence class
-    (e.g., ParCorr). The main use is for unit testing of PCMCI methods.
-
-    Parameters
-    ----------
-    link_coeffs : dict
-        Dictionary of form {0:[((0, -1), coeff, func), ...], 1:[...], ...}.
-    verbosity : int, optional (default: 0)
-        Level of verbosity.
-    """
-
-    # documentation
-    @property
-    def measure(self):
-        """
-        Concrete property to return the measure of the independence test
-        """
-        return self._measure
-
-    def __init__(self,
-                 link_coeffs,
-                 observed_vars=None,
-                 verbosity=0):
-        self.verbosity = verbosity
-        self._measure = 'oracle_ci'
-        self.confidence = None
-        self.link_coeffs = link_coeffs
-        self.N = len(link_coeffs)
-
-        # Initialize already computed dsepsets of X, Y, Z
-        self.dsepsets = {}
-
-        # Initialize observed vars
-        self.observed_vars = observed_vars
-        if self.observed_vars is None:
-            self.observed_vars = range(self.N)
-        else:
-            if not set(self.observed_vars).issubset(set(range(self.N))):
-                raise ValueError("observed_vars must be subset of range(N).")
-            if self.observed_vars != sorted(self.observed_vars):
-                raise ValueError("observed_vars must ordered.")
-            if len(self.observed_vars) != len(set(self.observed_vars)):
-                raise ValueError("observed_vars must not contain duplicates.")
-
-
[docs]    def set_dataframe(self, dataframe):
-        """Dummy function."""
-        pass

-
-    def _check_XYZ(self, X, Y, Z):
-        """Checks variables X, Y, Z.
-
-        Parameters
-        ----------
-        X, Y, Z : list of tuples
-            For a dependence measure I(X;Y|Z), Y is of the form [(varY, 0)],
-            where var specifies the variable index. X typically is of the form
-            [(varX, -tau)] with tau denoting the time lag and Z can be
-            multivariate [(var1, -lag), (var2, -lag), ...] .
-
-        Returns
-        -------
-        X, Y, Z : tuple
-            Cleaned X, Y, Z.
-        """
-        # Get the length in time and the number of nodes
-        N = self.N
-
-        # Remove duplicates in X, Y, Z
-        X = list(OrderedDict.fromkeys(X))
-        Y = list(OrderedDict.fromkeys(Y))
-        Z = list(OrderedDict.fromkeys(Z))
-
-        # If a node in Z occurs already in X or Y, remove it from Z
-        Z = [node for node in Z if (node not in X) and (node not in Y)]
-
-        # Check that all lags are non-positive and indices are in [0,N-1]
-        XYZ = X + Y + Z
-        dim = len(XYZ)
-        # Ensure that XYZ makes sense
-        if np.array(XYZ).shape != (dim, 2):
-            raise ValueError("X, Y, Z must be lists of tuples in format"
-                             " [(var, -lag),...], eg., [(2, -2), (1, 0), ...]")
-        if np.any(np.array(XYZ)[:, 1] > 0):
-            raise ValueError("nodes are %s, " % str(XYZ) +
-                             "but all lags must be non-positive")
-        if (np.any(np.array(XYZ)[:, 0] >= N)
-                or np.any(np.array(XYZ)[:, 0] < 0)):
-            raise ValueError("var indices %s," % str(np.array(XYZ)[:, 0]) +
-                             " but must be in [0, %d]" % (N - 1))
-        if np.all(np.array(Y)[:, 1] != 0):
-            raise ValueError("Y-nodes are %s, " % str(Y) +
-                             "but one of the Y-nodes must have zero lag")
-
-        return (X, Y, Z)
-
-    def _get_lagged_parents(self, var_lag, exclude_contemp=False):
-        """Helper function to yield lagged parents for var_lag from
-        self.links_coeffs.
-
-        Parameters
-        ----------
-        var_lag : tuple
-            Tuple of variable and lag which is assumed <= 0.
-        exclude_contemp : bool
-            Whether contemporaneous links should be exluded.
-
-        Yields
-        ------
-        Next lagged parent.
-        """
-
-        var, lag = var_lag
-
-        for link_props in self.link_coeffs[var]:
-            i, tau = link_props[0]
-            coeff = link_props[1]
-            if coeff != 0.:
-                if not (exclude_contemp and lag == 0):
-                    yield (i, lag + tau)
-
-    def _get_children(self):
-        """Helper function to get children from links.
-
-        Note that for children the lag is positive.
-
-        Returns
-        -------
-        children : dict
-            Dictionary of form {0:[(0, 1), (3, 0), ...], 1:[], ...}.
-        """
-
-        N = len(self.link_coeffs)
-        children = dict([(j, []) for j in range(N)])
-
-        for j in range(N):
-            for link_props in self.link_coeffs[j]:
-                        i, tau = link_props[0]
-                        coeff = link_props[1]
-                        if coeff != 0.:
-                            children[i].append((j, abs(tau)))
-
-        return children
-
-    def _get_lagged_children(self, var_lag, children, exclude_contemp=False):
-        """Helper function to yield lagged children for var_lag from children.
-
-        Parameters
-        ----------
-        var_lag : tuple
-            Tuple of variable and lag which is assumed <= 0.
-        children : dict
-            Dictionary of form {0:[(0, 1), (3, 0), ...], 1:[], ...}.
-        exclude_contemp : bool
-            Whether contemporaneous links should be exluded.
-
-        Yields
-        ------
-        Next lagged child.
-        """
-
-        var, lag = var_lag
-        # lagged_parents = []
-
-        for child in children[var]:
-            k, tau = child
-            if not (exclude_contemp and tau == 0):
-                # lagged_parents.append((i, lag + tau))
-                yield (k, lag + tau)
-
-    def _get_non_blocked_ancestors(self, Y, conds=None, mode='non_repeating',
-                                    max_lag=None):
-        """Helper function to return the non-blocked ancestors of variables Y.
-
-        Returns a dictionary of ancestors for every y in Y. y is a tuple (
-        var, lag) where lag <= 0. All ancestors with directed paths towards y
-        that are not blocked by conditions in conds are included. In mode
-        'non_repeating' an ancestor X^i_{t-\tau_i} with link X^i_{t-\tau_i}
-        --> X^j_{ t-\tau_j} is only included if X^i_{t'-\tau_i} --> X^j_{
-        t'-\tau_j} is not already part of the ancestors. The most lagged
-        ancestor for every variable X^i defines the maximum ancestral time
-        lag, which is also returned. In mode 'max_lag' ancestors are included
-        up to the maximum time lag max_lag.
-
-        It's main use is to return the maximum ancestral time lag max_lag of
-        y in Y for every variable in self.links_coeffs.
-
-        Parameters
-        ----------
-        Y : list of tuples
-            Of the form [(var, -tau)], where var specifies the variable
-            index and tau the time lag.
-        conds : list of tuples
-            Of the form [(var, -tau)], where var specifies the variable
-            index and tau the time lag.
-        mode : {'non_repeating', 'max_lag'}
-            Whether repeating links should be excluded or ancestors should be
-            followed up to max_lag.
-        max_lag : int
-            Maximum time lag to include ancestors.
-
-        Returns
-        -------
-        ancestors : dict
-            Includes ancestors for every y in Y.
-        max_lag : int
-            Maximum time lag to include ancestors.
-        """
-
-        def _repeating(link, seen_links):
-            """Returns True if a link or its time-shifted version is already
-            included in seen_links."""
-            i, taui = link[0]
-            j, tauj = link[1]
-
-            for seen_link in seen_links:
-                seen_i, seen_taui = seen_link[0]
-                seen_j, seen_tauj = seen_link[1]
-
-                if (i == seen_i and j == seen_j
-                    and abs(tauj-taui) == abs(seen_tauj-seen_taui)):
-                    return True
-
-            return False
-
-        if conds is None:
-            conds = []
-        conds = [z for z in conds if z not in Y]
-
-        N = len(self.link_coeffs)
-
-        # Initialize max. ancestral time lag for every N
-        if mode == 'non_repeating':
-            max_lag = 0
-        else:
-            if max_lag is None:
-                raise ValueError("max_lag must be set in mode = 'max_lag'")
-
-        ancestors = dict([(y, []) for y in Y])
-
-        for y in Y:
-            j, tau = y   # tau <= 0
-            if mode == 'non_repeating':
-                max_lag = max(max_lag, abs(tau))
-            seen_links = []
-            this_level = [y]
-            while len(this_level) > 0:
-                next_level = []
-                for varlag in this_level:
-                    for par in self._get_lagged_parents(varlag):
-                        i, tau = par
-                        if par not in conds and par not in ancestors[y]:
-                            if ((mode == 'non_repeating' and
-                                not _repeating((par, varlag), seen_links)) or
-                                (mode == 'max_lag' and
-                                 abs(tau) <= abs(max_lag))):
-                                    ancestors[y].append(par)
-                                    if mode == 'non_repeating':
-                                        max_lag = max(max_lag,
-                                                         abs(tau))
-                                    next_level.append(par)
-                                    seen_links.append((par, varlag))
-
-                this_level = next_level
-
-        return ancestors, max_lag
-
-    def _has_any_path(self, X, Y, conds, max_lag):
-        """Returns True if X and Y are d-connected by any open path.
-
-        Does breadth-first search from both X and Y and meets in the middle.
-        Paths are walked according to the d-separation rules where paths can
-        only traverse motifs <-- v <-- or <-- v --> or --> v --> or
-        --> [v] <-- where [.] indicates that v is conditioned on.
-        Furthermore, paths nodes (v, t) need to fulfill max_lag <= t <= 0
-        and links cannot be traversed backwards.
-
-        Parameters
-        ----------
-        X, Y : lists of tuples
-            Of the form [(var, -tau)], where var specifies the variable
-            index and tau the time lag.
-        conds : list of tuples
-            Of the form [(var, -tau)], where var specifies the variable
-            index and tau the time lag.
-        max_lag : int
-            Maximum time lag.
-
-        """
-
-        def _walk_to_parents(v, fringe, this_path, other_path):
-            """Helper function to update paths when walking to parents."""
-            found_path = False
-            for w in self._get_lagged_parents(v):
-                # Cannot walk into conditioned parents and
-                # cannot walk beyond t or max_lag
-                i, t = w
-                if (w not in conds and
-                    # (w, v) not in seen_links and
-                    t <= 0 and abs(t) <= max_lag):
-                    if ((w, 'tail') not in this_path and 
-                        (w, None) not in this_path):
-                        if self.verbosity > 1:
-                            print("Walk parent: %s --> %s  " %(v, w))
-                        fringe.append((w, 'tail'))
-                        this_path[(w, 'tail')] = (v, 'arrowhead')
-                        # seen_links.append((v, w))
-                    # Determine whether X and Y are connected
-                    # (w, None) indicates the start or end node X/Y
-                    if ((w, 'tail') in other_path 
-                       or (w, 'arrowhead') in other_path
-                       or (w, None) in other_path):
-                        if self.verbosity > 1:
-                            print("Found connection: ", w)
-                        found_path = True   
-                        break
-            return found_path, fringe, this_path
-
-        def _walk_to_children(v, fringe, this_path, other_path):
-            """Helper function to update paths when walking to children."""
-            found_path = False
-            for w in self._get_lagged_children(v, children):
-                # You can also walk into conditioned children,
-                # but cannot walk beyond t or max_lag
-                i, t = w
-                if (
-                    # (w, v) not in seen_links and
-                    t <= 0 and abs(t) <= max_lag):
-                    if ((w, 'arrowhead') not in this_path and 
-                        (w, None) not in this_path):
-                        if self.verbosity > 1:
-                            print("Walk child:  %s --> %s  " %(v, w))
-                        fringe.append((w, 'arrowhead'))
-                        this_path[(w, 'arrowhead')] = (v, 'tail')
-                        # seen_links.append((v, w))
-                    # Determine whether X and Y are connected
-                    # If the other_path contains w with a tail, then w must
-                    # NOT be conditioned on. Alternatively, if the other_path
-                    # contains w with an arrowhead, then w must be
-                    # conditioned on.
-                    if (((w, 'tail') in other_path and w not in conds)
-                       or ((w, 'arrowhead') in other_path and w in conds)
-                       or (w, None) in other_path):
-                        if self.verbosity > 1:
-                            print("Found connection: ", w)
-                        found_path = True   
-                        break
-            return found_path, fringe, this_path
-
-        def _walk_fringe(this_level, fringe, this_path, other_path):
-            """Helper function to walk each fringe, i.e., the path from X and Y,
-            respectively."""
-            found_path = False
-            for v, mark in this_level:
-                if v in conds:
-                    if (mark == 'arrowhead' or mark == None):
-                        # Motif: --> [v] <--
-                        # If standing on a condition and coming from an
-                        # arrowhead, you can only walk into parents
-                        (found_path, fringe,
-                         this_path) = _walk_to_parents(v, fringe, 
-                                                       this_path, other_path)
-                        if found_path: break            
-                else:
-                    if (mark == 'tail' or mark == None):
-                        # Motif: <-- v <-- or <-- v -->
-                        # If NOT standing on a condition and coming from
-                        # a tail mark, you can walk into parents or 
-                        # children
-                        (found_path, fringe,
-                         this_path) = _walk_to_parents(v, fringe, 
-                                                       this_path, other_path)
-                        if found_path: break 
-                        
-                        (found_path, fringe,
-                         this_path) = _walk_to_children(v, fringe, 
-                                                       this_path, other_path)
-                        if found_path: break 
-                      
-                    elif mark == 'arrowhead':
-                        # Motif: --> v -->
-                        # If NOT standing on a condition and coming from
-                        # an arrowhead mark, you can only walk into
-                        # children
-                        (found_path, fringe,
-                         this_path) = _walk_to_children(v, fringe, 
-                                                       this_path, other_path)
-                        if found_path: break 
-            if self.verbosity > 1:
-                print("Updated fringe: ", fringe)
-            return found_path, fringe, this_path, other_path
-
-        if conds is None:
-            conds = []
-        conds = [z for z in conds if z not in Y and z not in X]
-
-        N = len(self.link_coeffs)
-        children = self._get_children()
-
-        # Iterate through nodes in X and Y
-        for x in X:
-          for y in Y:
-
-            seen_links = []
-            # predecessor and successors in search
-            # (x, None) where None indicates start/end nodes, later (v,
-            # 'tail') or (w, 'arrowhead') indicate how a link ends at a node
-            pred = {(x, None): None}
-            succ = {(y, None): None}
-
-            # initialize fringes, start with forward from X
-            forward_fringe = [(x, None)]
-            reverse_fringe = [(y, None)]
-
-            while forward_fringe and reverse_fringe:
-                if len(forward_fringe) <= len(reverse_fringe):
-                    if self.verbosity > 1:
-                        print("Walk from X since len(X_fringe)=%d "
-                              "<= len(Y_fringe)=%d" % (len(forward_fringe), 
-                                len(reverse_fringe)))
-                    this_level = forward_fringe
-                    forward_fringe = []    
-                    (found_path, forward_fringe, pred, 
-                     succ) = _walk_fringe(this_level, forward_fringe, pred, 
-                                                succ)
-                    # print(pred)
-                    if found_path: return True
-                else:
-                    if self.verbosity > 1:
-                        print("Walk from Y since len(X_fringe)=%d "
-                              "> len(Y_fringe)=%d" % (len(forward_fringe), 
-                                len(reverse_fringe)))
-                    this_level = reverse_fringe
-                    reverse_fringe = []
-                    (found_path, reverse_fringe, succ, 
-                     pred) = _walk_fringe(this_level, reverse_fringe, succ, 
-                                                pred)
-                    if found_path: return True
-
-                if self.verbosity > 1:
-                    print("X_fringe = %s \n" % str(forward_fringe) +
-                          "Y_fringe = %s" % str(reverse_fringe))           
-
-        return False
-
-    def _is_dsep(self, X, Y, Z, max_lag=None, compute_ancestors=False):
-        """Returns whether X and Y are d-separated given Z in the graph.
-
-        X, Y, Z are of the form (var, lag) for lag <= 0. D-separation is
-        based on:
-
-        1. Assessing maximum time lag max_lag of last ancestor of any X, Y, Z
-        with non-blocked (by Z), non-repeating directed path towards X, Y, Z
-        in the graph. 'non_repeating' means that an ancestor X^i_{ t-\tau_i}
-        with link X^i_{t-\tau_i} --> X^j_{ t-\tau_j} is only included if
-        X^i_{t'-\tau_i} --> X^j_{ t'-\tau_j} for t'!=t is not already part of
-        the ancestors.
-
-        2. Using the time series graph truncated at max_lag we then test
-        d-separation between X and Y conditional on Z using breadth-first
-        search of non-blocked paths according to d-separation rules.
-
-        Optionally makes available the ancestors up to max_lag of X, Y,
-        Z. This may take a very long time, however.
-
-        Parameters
-        ----------
-        X, Y, Z : list of tuples
-            List of variables chosen for current independence test.
-        max_lag : int, optional (default: None)
-            Used here to constrain the _is_dsep function to the graph
-            truncated at max_lag instead of identifying the max_lag from
-            ancestral search.
-        compute_ancestors : bool
-            Whether to also make available the ancestors for X, Y, Z as
-            self.anc_all_x, self.anc_all_y, and self.anc_all_z, respectively.
-
-        Returns
-        -------
-        dseparated : bool
-            True if X and Y are d-separated given Z in the graph.
-        """
-
-        N = len(self.link_coeffs)
-
-        if self.verbosity > 0:
-            print("Testing X=%s d-sep Y=%s given Z=%s in TSG" %(X, Y, Z))
-
-        if max_lag is not None:
-            # max_lags = dict([(j, max_lag) for j in range(N)])
-            if self.verbosity > 0:
-                print("Set max. time lag to: ", max_lag)
-
-        else:
-            # Get maximum non-repeated ancestral time lag
-            _, max_lag_X = self._get_non_blocked_ancestors(X, conds=Z, 
-                                                           mode='non_repeating')
-            _, max_lag_Y = self._get_non_blocked_ancestors(Y, conds=Z, 
-                                                           mode='non_repeating')
-            _, max_lag_Z = self._get_non_blocked_ancestors(Z, conds=Z, 
-                                                           mode='non_repeating')
-
-            # Get max time lag among the ancestors
-            max_lag = max(max_lag_X, max_lag_Y, max_lag_Z)
-
-            if self.verbosity > 0:
-                print("Max. non-repeated ancestral time lag: ", max_lag)
-
-        # Store overall max. lag 
-        self.max_lag = max_lag
-
-
-        # _has_any_path is the main function that searches open paths
-        any_path = self._has_any_path(X, Y, conds=Z, max_lag=max_lag)
-        if self.verbosity > 0:
-            print("_has_any_path = ", any_path)
-
-        if any_path:
-            dseparated = False
-        else:
-            dseparated = True
-
-        if compute_ancestors:
-            if self.verbosity > 0:
-                print("Compute ancestors.")
-
-            # Get ancestors up to maximum ancestral time lag incl. repeated
-            # links
-            self.anc_all_x, _ = self._get_non_blocked_ancestors(X, conds=Z,
-                                            mode='max_lag', max_lag=max_lag)
-            self.anc_all_y, _ = self._get_non_blocked_ancestors(Y, conds=Z,
-                                            mode='max_lag', max_lag=max_lag)
-            self.anc_all_z, _ = self._get_non_blocked_ancestors(Z, conds=Z,
-                                            mode='max_lag', max_lag=max_lag)
-
-        return dseparated
-
-
[docs]    def run_test(self, X, Y, Z=None, tau_max=0, cut_off='2xtau_max',
-                 compute_ancestors=False,
-                 verbosity=0):
-        """Perform oracle conditional independence test.
-
-        Calls the d-separation function.
-
-        Parameters
-        ----------
-        X, Y, Z : list of tuples
-            X,Y,Z are of the form [(var, -tau)], where var specifies the
-            variable index in the observed_vars and tau the time lag.
-        tau_max : int, optional (default: 0)
-            Not used here.
-        cut_off : {'2xtau_max', 'max_lag', 'max_lag_or_tau_max'}
-            Not used here.
-
-        Returns
-        -------
-        val, pval : Tuple of floats
-            The test statistic value and the p-value.
-        """
-
-        # Translate from observed_vars index to full variable set index
-        X = [(self.observed_vars[x[0]], x[1]) for x in X]
-        Y = [(self.observed_vars[y[0]], y[1]) for y in Y]
-        Z = [(self.observed_vars[z[0]], z[1]) for z in Z]
-
-        # Get the array to test on
-        X, Y, Z = self._check_XYZ(X, Y, Z)
-
-        if not str((X, Y, Z)) in self.dsepsets:
-            self.dsepsets[str((X, Y, Z))] = self._is_dsep(X, Y, Z, 
-                max_lag=None,
-                compute_ancestors=compute_ancestors)
-
-        if self.dsepsets[str((X, Y, Z))]:
-            val = 0.
-            pval = 1.
-        else:
-            val = 1.
-            pval = 0.
-
-        if verbosity > 1:
-            self._print_cond_ind_results(val=val, pval=pval, cached=False,
-                                         conf=None)
-        # Return the value and the pvalue
-        return val, pval

-
-
[docs]    def get_measure(self, X, Y, Z=None, tau_max=0):
-        """Returns dependence measure.
-
-        Returns 0 if X and Y are d-separated given Z in the graph and 1 else.
-
-        Parameters
-        ----------
-        X, Y [, Z] : list of tuples
-            X,Y,Z are of the form [(var, -tau)], where var specifies the
-            variable index in the observed_vars and tau the time lag.
-
-        tau_max : int, optional (default: 0)
-            Maximum time lag. This may be used to make sure that estimates for
-            different lags in X, Z, all have the same sample size.
-
-        Returns
-        -------
-        val : float
-            The test statistic value.
-
-        """
-
-        # Translate from observed_vars index to full variable set index
-        X = [(self.observed_vars[x[0]], x[1]) for x in X]
-        Y = [(self.observed_vars[y[0]], y[1]) for y in Y]
-        Z = [(self.observed_vars[z[0]], z[1]) for z in Z]
-
-        # Check XYZ
-        X, Y, Z = _check_XYZ(X, Y, Z)
-
-        if not str((X, Y, Z)) in self.dsepsets:
-            self.dsepsets[str((X, Y, Z))] = self._is_dsep(X, Y, Z, 
-                max_lag=None)
-
-        if self.dsepsets[str((X, Y, Z))]:
-            return 0.
-        else:
-            return 1.

-
-    def _print_cond_ind_results(self, val, pval=None, cached=None, conf=None):
-        """Print results from conditional independence test.
-
-        Parameters
-        ----------
-        val : float
-            Test stastistic value.
-        pval : float, optional (default: None)
-            p-value
-        conf : tuple of floats, optional (default: None)
-            Confidence bounds.
-        """
-        printstr = "        val = %.3f" % (val)      
-        if pval is not None:
-            printstr += " | pval = %.5f" % (pval)
-        if conf is not None:
-            printstr += " | conf bounds = (%.3f, %.3f)" % (
-                conf[0], conf[1])
-        if cached is not None:
-            printstr += " %s" % ({0:"", 1:"[cached]"}[cached])
-
-        print(printstr)
-
-
[docs]    def get_model_selection_criterion(self, j, parents, tau_max=0):
-        """
-        Base class assumption that this is not implemented.  Concrete classes
-        should override when possible.
-        """
-        raise NotImplementedError("Model selection not"+\
-                                  " implemented for %s" % self.measure)

-
-if __name__ == '__main__':
-
-    import tigramite.plotting as tp
-    from matplotlib import pyplot as plt
-    def lin_f(x): return x
-
-    # N = 20
-    # links = tests.a_random_process(
-    #  N=N, L=2*N, coupling_coeffs=[0.7, -0.7],
-    #  coupling_funcs=[lin_f, lin_f], auto_coeffs=[0., 0.5],
-    #  tau_max=5, contemp_fraction=0.3, num_trials=1,
-    #  model_seed=3)
-
-    # N = 50
-    # links = {0: [((0, -1), 0.5)]}
-    # for j in range(1, N):
-    #     links[j] = [((j, -1), 0.6), ((j-1, -1), 0.5)]
-
-    # links = {0: [((0, -1), 0.5)],
-    #          1: [((0, -1), 0.5), ((2, -1), 0.5)],
-    #          2: [((2, -1), 0.)],
-    #          3: [((3, -1), 0.), ((2, -1), 0.5), ((4, -1), 0.5)],
-    #          4: [((4, -1), 0.5),],
-    #          }
-
-    # links = {0: [((0, -1), 0.)],
-    #          1: [((1, -1), 0.)],
-    #          2: [((2, -1), 0.), ((1, 0), 0.6), ((0, 0), 0.6)],
-    #          3: [((3, -1), 0.), ((2, 0), -0.5)],
-    #          }
-
-    # links = {0: [((0, -1), 0.9)],
-    #          1: [((1, -1), 0.8, lin_f), ((0, -1), 0.8, lin_f)],
-    #          2: [((2, -1), 0.7, lin_f), ((1, 0), 0.6, lin_f)],
-    #          3: [((3, -1), 0.7, lin_f), ((2, 0), -0.5, lin_f)],
-    #          }
-
-    # links = {0: [((0, -1), 0.5)],
-    #          1: [((0, -1), 0.5), ((2, -1), 0.5)],
-    #          2: [],
-    #          3: [((2, -1), 0.4), ((4, -1), -0.5)],
-    #          4: [((4, -1), 0.4)],
-    #          }
-
-    # def setup_nodes(auto_coeff, N):
-    #     link_coeffs = {}
-    #     for j in range(N):
-    #        link_coeffs[j] = [((j, -1), auto_coeff, lin_f)]
-    #     return link_coeffs
-    # coeff = 0.5
-
-    # link_coeffs = setup_nodes(0.7, N=3)
-    # for i in [0, 2]:
-    #     links[1].append(((i, 0), coeff, lin_f))
-
-
-    # links = setup_nodes(0., N=3)
-    # links[1].append(((1, -1), coeff, lin_f))
-    # links[1].append(((0, 0), coeff, lin_f))
-    # links[2].append(((1, 0), coeff, lin_f))
-    # links[2].append(((0, 0), coeff, lin_f))
-    coeff = 0.5
-    links ={
-            0: [],
-            1: [((0, 0), coeff, lin_f), ((2, 0), coeff, lin_f)],
-            2: [],
-            3: [((1, 0), coeff, lin_f)],                                
-            }
-    observed_vars = [0, 1, 2, 3]
-
-    X = [(0, 0)]
-    Y = [(2, 0)]
-    Z = [(3, 0)] #(1, -3), (1, -2), (0, -2), (0, -1), (0, -3)]
-  #(j, -2) for j in range(N)] + [(j, 0) for j in range(N)]
-
-    # print(oracle._get_non_blocked_ancestors(Z, Z=None, mode='max_lag',
-    #                                     max_lag=2))
-    cond_ind_test = OracleCI(links, observed_vars=observed_vars, verbosity=2)
-
-    print(cond_ind_test.run_test(X=X, Y=Y, Z=Z))
-   
-    # anc_x=None  #oracle.anc_all_x[X[0]]
-    # anc_y=None #oracle.anc_all_y[Y[0]]
-    # anc_xy=None # []
-    # # for z in Z:
-    # #     anc_xy += oracle.anc_all_z[z]
-    
-    # fig, ax = tp.plot_tsg(links, 
-    #             X=[(observed_vars[x[0]], x[1]) for x in X], 
-    #             Y=[(observed_vars[y[0]], y[1]) for y in Y], 
-    #             Z=[(observed_vars[z[0]], z[1]) for z in Z],
-    #     anc_x=anc_x, anc_y=anc_y, 
-    #     anc_xy=anc_xy)
-
-    # fig.savefig("/home/rung_ja/Downloads/tsg.pdf")
-
- -
-
-
-
-
- - - - \ No newline at end of file diff --git a/docs/_build/html/_modules/tigramite/independence_tests/parcorr.html b/docs/_build/html/_modules/tigramite/independence_tests/parcorr.html deleted file mode 100644 index 3c860372..00000000 --- a/docs/_build/html/_modules/tigramite/independence_tests/parcorr.html +++ /dev/null @@ -1,375 +0,0 @@ - - - - - - - tigramite.independence_tests.parcorr — Tigramite 4.2 documentation - - - - - - - - - - - - - -
-
-
-
- -

Source code for tigramite.independence_tests.parcorr

-"""Tigramite causal discovery for time series."""
-
-# Author: Jakob Runge <jakob@jakob-runge.com>
-#
-# License: GNU General Public License v3.0
-
-from __future__ import print_function
-from scipy import stats
-import numpy as np
-import sys
-
-from .independence_tests_base import CondIndTest
-
-
[docs]class ParCorr(CondIndTest):
-    r"""Partial correlation test.
-
-    Partial correlation is estimated through linear ordinary least squares (OLS)
-    regression and a test for non-zero linear Pearson correlation on the
-    residuals.
-
-    Notes
-    -----
-    To test :math:`X \perp Y | Z`, first :math:`Z` is regressed out from
-    :math:`X` and :math:`Y` assuming the  model
-
-    .. math::  X & =  Z \beta_X + \epsilon_{X} \\
-        Y & =  Z \beta_Y + \epsilon_{Y}
-
-    using OLS regression. Then the dependency of the residuals is tested with
-    the Pearson correlation test.
-
-    .. math::  \rho\left(r_X, r_Y\right)
-
-    For the ``significance='analytic'`` Student's-*t* distribution with
-    :math:`T-D_Z-2` degrees of freedom is implemented.
-
-    Parameters
-    ----------
-    **kwargs :
-        Arguments passed on to Parent class CondIndTest.
-    """
-    # documentation
-    @property
-    def measure(self):
-        """
-        Concrete property to return the measure of the independence test
-        """
-        return self._measure
-
-    def __init__(self, **kwargs):
-        self._measure = 'par_corr'
-        self.two_sided = True
-        self.residual_based = True
-
-        CondIndTest.__init__(self, **kwargs)
-
-    def _get_single_residuals(self, array, target_var,
-                              standardize=True,
-                              return_means=False):
-        """Returns residuals of linear multiple regression.
-
-        Performs a OLS regression of the variable indexed by target_var on the
-        conditions Z. Here array is assumed to contain X and Y as the first two
-        rows with the remaining rows (if present) containing the conditions Z.
-        Optionally returns the estimated regression line.
-
-        Parameters
-        ----------
-        array : array-like
-            data array with X, Y, Z in rows and observations in columns
-
-        target_var : {0, 1}
-            Variable to regress out conditions from.
-
-        standardize : bool, optional (default: True)
-            Whether to standardize the array beforehand. Must be used for
-            partial correlation.
-
-        return_means : bool, optional (default: False)
-            Whether to return the estimated regression line.
-
-        Returns
-        -------
-        resid [, mean] : array-like
-            The residual of the regression and optionally the estimated line.
-        """
-
-        dim, T = array.shape
-        dim_z = dim - 2
-
-        # Standardize
-        if standardize:
-            array -= array.mean(axis=1).reshape(dim, 1)
-            array /= array.std(axis=1).reshape(dim, 1)
-            if np.isnan(array).sum() != 0:
-                raise ValueError("nans after standardizing, "
-                                 "possibly constant array!")
-
-        y = array[target_var, :]
-
-        if dim_z > 0:
-            z = np.fastCopyAndTranspose(array[2:, :])
-            beta_hat = np.linalg.lstsq(z, y, rcond=None)[0]
-            mean = np.dot(z, beta_hat)
-            resid = y - mean
-        else:
-            resid = y
-            mean = None
-
-        if return_means:
-            return (resid, mean)
-        return resid
-
-
[docs]    def get_dependence_measure(self, array, xyz):
-        """Return partial correlation.
-
-        Estimated as the Pearson correlation of the residuals of a linear
-        OLS regression.
-
-        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,).
-
-        Returns
-        -------
-        val : float
-            Partial correlation coefficient.
-        """
-
-        x_vals = self._get_single_residuals(array, target_var=0)
-        y_vals = self._get_single_residuals(array, target_var=1)
-        val, _ = stats.pearsonr(x_vals, y_vals)
-        return val

-
-
[docs]    def get_shuffle_significance(self, array, xyz, value,
-                                 return_null_dist=False):
-        """Returns p-value for shuffle significance test.
-
-        For residual-based test statistics only the residuals are shuffled.
-
-        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,).
-
-        value : number
-            Value of test statistic for unshuffled estimate.
-
-        Returns
-        -------
-        pval : float
-            p-value
-        """
-
-        x_vals = self._get_single_residuals(array, target_var=0)
-        y_vals = self._get_single_residuals(array, target_var=1)
-        array_resid = np.array([x_vals, y_vals])
-        xyz_resid = np.array([0, 1])
-
-        null_dist = self._get_shuffle_dist(array_resid, xyz_resid,
-                                           self.get_dependence_measure,
-                                           sig_samples=self.sig_samples,
-                                           sig_blocklength=self.sig_blocklength,
-                                           verbosity=self.verbosity)
-
-        pval = (null_dist >= np.abs(value)).mean()
-
-        # Adjust p-value for two-sided measures
-        if pval < 1.:
-            pval *= 2.
-
-        if return_null_dist:
-            return pval, null_dist
-        return pval

-
-
[docs]    def get_analytic_significance(self, value, T, dim):
-        """Returns analytic p-value from Student's t-test for the Pearson
-        correlation coefficient.
-
-        Assumes two-sided correlation. If the degrees of freedom are less than
-        1, numpy.nan is returned.
-
-        Parameters
-        ----------
-        value : float
-            Test statistic value.
-
-        T : int
-            Sample length
-
-        dim : int
-            Dimensionality, ie, number of features.
-
-        Returns
-        -------
-        pval : float or numpy.nan
-            P-value.
-        """
-        # Get the number of degrees of freedom
-        deg_f = T - dim
-
-        if deg_f < 1:
-            pval = np.nan
-        elif abs(abs(value) - 1.0) <= sys.float_info.min:
-            pval = 0.0
-        else:
-            trafo_val = value * np.sqrt(deg_f/(1. - value*value))
-            # Two sided significance level
-            pval = stats.t.sf(np.abs(trafo_val), deg_f) * 2
-
-        return pval

-
-
[docs]    def get_analytic_confidence(self, value, df, conf_lev):
-        """Returns analytic confidence interval for correlation coefficient.
-
-        Based on Student's t-distribution.
-
-        Parameters
-        ----------
-        value : float
-            Test statistic value.
-
-        df : int
-            degrees of freedom of the test
-
-        conf_lev : float
-            Confidence interval, eg, 0.9
-
-        Returns
-        -------
-        (conf_lower, conf_upper) : Tuple of floats
-            Upper and lower confidence bound of confidence interval.
-        """
-        # Confidence interval is two-sided
-        c_int = (1. - (1. - conf_lev) / 2.)
-
-        value_tdist = value * np.sqrt(df) / np.sqrt(1. - value**2)
-        conf_lower = (stats.t.ppf(q=1. - c_int, df=df, loc=value_tdist)
-                      / np.sqrt(df + stats.t.ppf(q=1. - c_int, df=df,
-                                                 loc=value_tdist)**2))
-        conf_upper = (stats.t.ppf(q=c_int, df=df, loc=value_tdist)
-                      / np.sqrt(df + stats.t.ppf(q=c_int, df=df,
-                                                 loc=value_tdist)**2))
-        return (conf_lower, conf_upper)

-
-
-
[docs]    def get_model_selection_criterion(self, j, parents, tau_max=0):
-        """Returns Akaike's Information criterion modulo constants.
-
-        Fits a linear model of the parents to variable j and returns the
-        score. Leave-one-out cross-validation is asymptotically equivalent to
-        AIC for ordinary linear regression models. Here used to determine
-        optimal hyperparameters in PCMCI, in particular the pc_alpha value.
-
-        Parameters
-        ----------
-        j : int
-            Index of target variable in data array.
-
-        parents : list
-            List of form [(0, -1), (3, -2), ...] containing parents.
-
-        tau_max : int, optional (default: 0)
-            Maximum time lag. This may be used to make sure that estimates for
-            different lags in X, Z, all have the same sample size.
-
-        Returns:
-        score : float
-            Model score.
-        """
-
-        Y = [(j, 0)]
-        X = [(j, 0)]   # dummy variable here
-        Z = parents
-        array, xyz = self.dataframe.construct_array(X=X, Y=Y, Z=Z,
-                                                    tau_max=tau_max,
-                                                    mask_type=self.mask_type,
-                                                    return_cleaned_xyz=False,
-                                                    do_checks=True,
-                                                    verbosity=self.verbosity)
-
-        dim, T = array.shape
-
-        y = self._get_single_residuals(array, target_var=1, return_means=False)
-        # Get RSS
-        rss = (y**2).sum()
-        # Number of parameters
-        p = dim - 1
-        # Get AIC
-        score = T * np.log(rss) + 2. * p
-        return score

-
- -
-
-
-
-
- - - - \ No newline at end of file diff --git a/docs/_build/html/_modules/tigramite/models.html b/docs/_build/html/_modules/tigramite/models.html deleted file mode 100644 index d7b1ad59..00000000 --- a/docs/_build/html/_modules/tigramite/models.html +++ /dev/null @@ -1,1315 +0,0 @@ - - - - - - - tigramite.models — Tigramite 4.2 documentation - - - - - - - - - - - - - -
-
-
-
- -

Source code for tigramite.models

-"""Tigramite causal discovery for time series."""
-
-# Author: Jakob Runge <jakob@jakob-runge.com>
-#
-# License: GNU General Public License v3.0
-
-from __future__ import print_function
-from copy import deepcopy
-
-import numpy as np
-
-from tigramite.data_processing import DataFrame
-from tigramite.pcmci import PCMCI
-
-try:
-    import sklearn
-    import sklearn.linear_model
-except:
-    print("Could not import sklearn...")
-
-try:
-    import networkx
-except:
-    print("Could not import networkx, LinearMediation plots not possible...")
-
-
-
[docs]class Models():
-    """Base class for time series models.
-
-    Allows to fit any model from sklearn to the parents of a target variable.
-    Also takes care of missing values, masking and preprocessing.
-
-    Parameters
-    ----------
-    dataframe : data object
-        Tigramite dataframe object. It must have the attributes dataframe.values
-        yielding a numpy array of shape (observations T, variables N) and
-        optionally a mask of the same shape and a missing values flag.
-    model : sklearn model object
-        For example, sklearn.linear_model.LinearRegression() for a linear
-        regression model.
-    data_transform : sklearn preprocessing object, optional (default: None)
-        Used to transform data prior to fitting. For example,
-        sklearn.preprocessing.StandardScaler for simple standardization. The
-        fitted parameters are stored.
-    mask_type : {'y','x','z','xy','xz','yz','xyz'}
-        Masking mode: Indicators for which variables in the dependence measure
-        I(X; Y | Z) the samples should be masked. If None, 'y' is used, which
-        excludes all time slices containing masked samples in Y. Explained in
-        [1]_.
-    verbosity : int, optional (default: 0)
-        Level of verbosity.
-    """
-
-    def __init__(self,
-                 dataframe,
-                 model,
-                 data_transform=sklearn.preprocessing.StandardScaler(),
-                 mask_type=None,
-                 verbosity=0):
-        # Set the mask type and dataframe object
-        self.mask_type = mask_type
-        self.dataframe = dataframe
-        # Get the number of nodes for this dataset
-        self.N = self.dataframe.values.shape[1]
-        # Set the model to be used
-        self.model = model
-        # Set the data_transform object and verbosity
-        self.data_transform = data_transform
-        self.verbosity = verbosity
-        # Initialize the object that will be set later
-        self.all_parents = None
-        self.selected_variables = None
-        self.tau_max = None
-        self.fit_results = None
-
-
[docs]    def get_fit(self, all_parents,
-                selected_variables=None,
-                tau_max=None,
-                cut_off='max_lag_or_tau_max',
-                return_data=False):
-        """Fit time series model.
-
-        For each variable in selected_variables, the sklearn model is fitted
-        with :math:`y` given by the target variable, and :math:`X` given by its
-        parents. The fitted model class is returned for later use.
-
-        Parameters
-        ----------
-        all_parents : dictionary
-            Dictionary of form {0:[(0, -1), (3, 0), ...], 1:[], ...} containing
-            the parents estimated with PCMCI.
-        selected_variables : list of integers, optional (default: range(N))
-            Specify to estimate parents only for selected variables. If None is
-            passed, parents are estimated for all variables.
-        tau_max : int, optional (default: None)
-            Maximum time lag. If None, the maximum lag in all_parents is used.
-        cut_off : {'max_lag_or_tau_max', '2xtau_max', 'max_lag'}
-            How many samples to cutoff at the beginning. The default is
-            'max_lag_or_tau_max', which uses the maximum of tau_max and the
-            conditions. This is useful to compare multiple models on the same
-            sample. Other options are '2xtau_max', which guarantees that MCI
-            tests are all conducted on the same samples. Last, 'max_lag' uses
-            as much samples as possible.
-        return_data : bool, optional (default: False)
-            Whether to save the data array.
-
-        Returns
-        -------
-        fit_results : dictionary of sklearn model objects for each variable
-            Returns the sklearn model after fitting. Also returns the data
-            transformation parameters.
-        """
-        # Initialize the fit by setting the instance's all_parents attribute
-        self.all_parents = all_parents
-        # Set the default selected variables to all variables and check if this
-        # should be overwritten
-        self.selected_variables = range(self.N)
-        if selected_variables is not None:
-            self.selected_variables = selected_variables
-        # Find the maximal parents lag
-        max_parents_lag = 0
-        for j in self.selected_variables:
-            if all_parents[j]:
-                this_parent_lag = np.abs(np.array(all_parents[j])[:, 1]).max()
-                max_parents_lag = max(max_parents_lag, this_parent_lag)
-        # Set the default tau max and check if it shoudl be overwritten
-        self.tau_max = max_parents_lag
-        if tau_max is not None:
-            self.tau_max = tau_max
-            if self.tau_max < max_parents_lag:
-                raise ValueError("tau_max = %d, but must be at least "
-                                 " max_parents_lag = %d"
-                                 "" % (self.tau_max, max_parents_lag))
-        # Initialize the fit results
-        fit_results = {}
-        for j in self.selected_variables:
-            Y = [(j, 0)]
-            X = [(j, 0)]  # dummy
-            Z = self.all_parents[j]
-            array, xyz = \
-                self.dataframe.construct_array(X, Y, Z,
-                                               tau_max=self.tau_max,
-                                               mask_type=self.mask_type,
-                                               cut_off=cut_off,
-                                               verbosity=self.verbosity)
-            # Get the dimensions out of the constructed array
-            dim, T = array.shape
-            dim_z = dim - 2
-            # Transform the data if needed
-            if self.data_transform is not None:
-                array = self.data_transform.fit_transform(X=array.T).T
-            # Fit the model if there are any parents for this variable to fit
-            if dim_z > 0:
-                # Copy and fit the model
-                a_model = deepcopy(self.model)
-                a_model.fit(X=array[2:].T, y=array[1])
-                # Cache the results
-                fit_results[j] = {}
-                fit_results[j]['model'] = a_model
-                # Cache the data transform
-                fit_results[j]['data_transform'] = deepcopy(self.data_transform)
-                # Cache the data if needed
-                if return_data:
-                    fit_results[j]['data'] = array
-            # If there are no parents, skip this variable
-            else:
-                fit_results[j] = None
-
-        # Cache and return the fit results
-        self.fit_results = fit_results
-        return fit_results

-
-
[docs]    def get_coefs(self):
-        """Returns dictionary of coefficients for linear models.
-
-        Only for models from sklearn.linear_model
-
-        Returns
-        -------
-        coeffs : dictionary
-            Dictionary of dictionaries for each variable with keys given by the
-            parents and the regression coefficients as values.
-        """
-        coeffs = {}
-        for j in self.selected_variables:
-            coeffs[j] = {}
-            for ipar, par in enumerate(self.all_parents[j]):
-                coeffs[j][par] = self.fit_results[j]['model'].coef_[ipar]
-        return coeffs

-
-
[docs]    def get_val_matrix(self):
-        """Returns the coefficient array for different lags.
-
-        Requires fit_model() before. An entry val_matrix[i,j,tau] gives the
-        coefficient of the link from i to j at lag tau, including tau=0.
-
-        Returns
-        -------
-        val_matrix : array-like, shape (N, N, tau_max + 1)
-            Array of coefficients for each time lag, including lag-zero.
-        """
-
-        coeffs = self.get_coefs()
-        val_matrix = np.zeros((self.N, self.N, self.tau_max + 1, ))
-
-        for j in list(coeffs):
-            for par in list(coeffs[j]):
-                i, tau = par
-                val_matrix[i,j,abs(tau)] = coeffs[j][par]
-
-        return val_matrix

-
-
[docs]class LinearMediation(Models):
-    r"""Linear mediation analysis for time series models.
-
-    Fits linear model to parents and provides functions to return measures such
-    as causal effect, mediated causal effect, average causal effect, etc. as
-    described in [4]_.
-
-    Notes
-    -----
-    This class implements the following causal mediation measures introduced in
-    [4]_:
-
-      * causal effect (CE)
-      * mediated causal effect (MCE)
-      * average causal effect (ACE)
-      * average causal susceptibility (ACS)
-      * average mediated causal effect (AMCE)
-
-    Consider a simple model of a causal chain as given in the Example with
-
-    .. math:: X_t &= \eta^X_t \\
-              Y_t &= 0.5 X_{t-1} +  \eta^Y_t \\
-              Z_t &= 0.5 Y_{t-1} +  \eta^Z_t
-
-    Here the link coefficient of :math:`X_{t-2} \to Z_t` is zero while the
-    causal effect is 0.25. MCE through :math:`Y` is 0.25 implying that *all*
-    of the the CE is explained by :math:`Y`. ACE from :math:`X` is 0.37 since it
-    has CE 0.5 on :math:`Y` and 0.25 on :math:`Z`.
-
-    Examples
-    --------
-    >>> numpy.random.seed(42)
-    >>> links_coeffs = {0: [], 1: [((0, -1), 0.5)], 2: [((1, -1), 0.5)]}
-    >>> data, true_parents = pp.var_process(links_coeffs, T=1000)
-    >>> dataframe = pp.DataFrame(data)
-    >>> med = LinearMediation(dataframe=dataframe)
-    >>> med.fit_model(all_parents=true_parents, tau_max=3)
-    >>> print "Link coefficient (0, -2) --> 2: ", med.get_coeff(
-    i=0, tau=-2, j=2)
-    >>> print "Causal effect (0, -2) --> 2: ", med.get_ce(i=0, tau=-2, j=2)
-    >>> print "Mediated Causal effect (0, -2) --> 2 through 1: ", med.get_mce(
-    i=0, tau=-2, j=2, k=1)
-    >>> print "Average Causal Effect: ", med.get_all_ace()
-    >>> print "Average Causal Susceptibility: ", med.get_all_acs()
-    >>> print "Average Mediated Causal Effect: ", med.get_all_amce()
-    Link coefficient (0, -2) --> 2:  0.0
-    Causal effect (0, -2) --> 2:  0.250648072987
-    Mediated Causal effect (0, -2) --> 2 through 1:  0.250648072987
-    Average Causal Effect:  [ 0.36897445  0.25718002  0.        ]
-    Average Causal Susceptibility:  [ 0.          0.24365041  0.38250406]
-    Average Mediated Causal Effect:  [ 0.          0.12532404  0.        ]
-
-    References
-    ----------
-    .. [4]  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
-
-    Parameters
-    ----------
-    dataframe : data object
-        Tigramite dataframe object. It must have the attributes dataframe.values
-        yielding a numpy array of shape (observations T, variables N) and
-        optionally a mask of the same shape and a missing values flag.
-    model_params : dictionary, optional (default: None)
-        Optional parameters passed on to sklearn model
-    data_transform : sklearn preprocessing object, optional (default: None)
-        Used to transform data prior to fitting. For example,
-        sklearn.preprocessing.StandardScaler for simple standardization. The
-        fitted parameters are stored.
-    mask_type : {'y','x','z','xy','xz','yz','xyz'}
-        Masking mode: Indicators for which variables in the dependence measure
-        I(X; Y | Z) the samples should be masked. If None, 'y' is used, which
-        excludes all time slices containing masked samples in Y. Explained in
-        [1]_.
-    verbosity : int, optional (default: 0)
-        Level of verbosity.
-    """
-
-    def __init__(self,
-                 dataframe,
-                 model_params=None,
-                 data_transform=sklearn.preprocessing.StandardScaler(),
-                 mask_type=None,
-                 verbosity=0):
-        # Initialize the member variables to None
-        self.phi = None
-        self.psi = None
-        self.all_psi_k = None
-
-        # Build the model using the parameters
-        if model_params is None:
-            model_params = {}
-        this_model = sklearn.linear_model.LinearRegression(**model_params)
-        Models.__init__(self,
-                        dataframe=dataframe,
-                        model=this_model,
-                        data_transform=data_transform,
-                        mask_type=mask_type,
-                        verbosity=verbosity)
-
-
[docs]    def fit_model(self, all_parents, tau_max=None):
-        """Fit linear time series model.
-
-        Fits a sklearn.linear_model.LinearRegression model to the parents of
-        each variable and computes the coefficient matrices :math:`\Phi` and
-        :math:`\Psi` as described in [4]_. Does not accepted
-        contemporaneous links.
-
-        Parameters
-        ----------
-        all_parents : dictionary
-            Dictionary of form {0:[(0, -1), (3, -2), ...], 1:[], ...} containing
-            the parents estimated with PCMCI.
-        tau_max : int, optional (default: None)
-            Maximum time lag. If None, the maximum lag in all_parents is used.
-        """
-        for j in all_parents.keys():
-            for parent in all_parents[j]:
-                var, lag = parent
-                if lag == 0:
-                    raise ValueError("all_parents cannot contain "
-                                     "contemporaneous links. Remove these.")
-
-        # Fit the model using the base class
-        self.fit_results = self.get_fit(all_parents=all_parents,
-                                        selected_variables=None,
-                                        tau_max=tau_max)
-        # Cache the results in the member variables
-        coeffs = self.get_coefs()
-        self.phi = self._get_phi(coeffs)
-        self.psi = self._get_psi(self.phi)
-        self.all_psi_k = self._get_all_psi_k(self.phi)

-
-    def _check_sanity(self, X, Y, k=None):
-        """Checks validity of some parameters."""
-
-        if len(X) != 1 or len(Y) != 1:
-            raise ValueError("X must be of form [(i, -tau)] and Y = [(j, 0)], "
-                             "but are X = %s, Y=%s" % (X, Y))
-
-        i, tau = X[0]
-
-        if abs(tau) > self.tau_max:
-            raise ValueError("X must be of form [(i, -tau)] with"
-                             " tau <= tau_max")
-
-        if k is not None and (k < 0 or k >= self.N):
-            raise ValueError("k must be in [0, N)")
-
-    def _get_phi(self, coeffs):
-        """Returns the linear coefficient matrices for different lags.
-
-        Parameters
-        ----------
-        coeffs : dictionary
-            Dictionary of coefficients for each parent.
-
-        Returns
-        -------
-        phi : array-like, shape (tau_max + 1, N, N)
-            Matrices of coefficients for each time lag.
-        """
-
-        phi = np.zeros((self.tau_max + 1, self.N, self.N))
-        phi[0] = np.identity(self.N)
-
-        for j in list(coeffs):
-            for par in list(coeffs[j]):
-                i, tau = par
-                phi[abs(tau), j, i] = coeffs[j][par]
-
-        return phi
-
-    def _get_psi(self, phi):
-        """Returns the linear causal effect matrices for different lags.
-
-        Parameters
-        ----------
-        phi : array-like
-            Coefficient matrices at different lags.
-
-        Returns
-        -------
-        psi : array-like, shape (tau_max + 1, N, N)
-            Matrices of causal effects for each time lag.
-        """
-
-        psi = np.zeros((self.tau_max + 1, self.N, self.N))
-
-        psi[0] = np.identity(self.N)
-        for n in range(1, self.tau_max + 1):
-            psi[n] = np.zeros((self.N, self.N))
-            for s in range(1, n + 1):
-                psi[n] += np.dot(phi[s], psi[n - s])
-
-        return psi
-
-    def _get_psi_k(self, phi, k):
-        """Returns the linear causal effect matrices excluding variable k.
-
-        Parameters
-        ----------
-        phi : array-like
-            Coefficient matrices at different lags.
-        k : int
-            Variable index to exclude causal effects through.
-
-        Returns
-        -------
-        psi_k : array-like, shape (tau_max + 1, N, N)
-            Matrices of causal effects excluding k.
-        """
-
-        psi_k = np.zeros((self.tau_max + 1, self.N, self.N))
-
-        psi_k[0] = np.identity(self.N)
-        phi_k = np.copy(phi)
-        phi_k[1:, k, :] = 0.
-        for n in range(1, self.tau_max + 1):
-            psi_k[n] = np.zeros((self.N, self.N))
-            for s in range(1, n + 1):
-                psi_k[n] += np.dot(phi_k[s], psi_k[n - s])
-
-        return psi_k
-
-    def _get_all_psi_k(self, phi):
-        """Returns the linear causal effect matrices excluding variables.
-
-        Parameters
-        ----------
-        phi : array-like
-            Coefficient matrices at different lags.
-
-        Returns
-        -------
-        all_psi_k : array-like, shape (N, tau_max + 1, N, N)
-            Matrices of causal effects where for each row another variable is
-            excluded.
-        """
-
-        all_psi_k = np.zeros((self.N, self.tau_max + 1, self.N, self.N))
-
-        for k in range(self.N):
-            all_psi_k[k] = self._get_psi_k(phi, k)
-
-        return all_psi_k
-
-
[docs]    def get_val_matrix(self, ):
-        """Returns the matrix of linear coefficients.
-
-        Requires fit_model() before. An entry val_matrix[i,j,tau] gives the
-        coefficient of the link from i to j at lag tau. Lag=0 is always set
-        to zero for LinearMediation, use Models class for contemporaneous 
-        models.
-
-        Returns
-        -------
-        val_matrix : array
-            Matrix of linear coefficients, shape (N, N, tau_max + 1).
-        """
-        return self.phi.transpose()

-
-
[docs]    def net_to_tsg(self, row, lag, max_lag):
-        """Helper function to translate from network to time series graph."""
-        return row * max_lag + lag

-
-
[docs]    def tsg_to_net(self, node, max_lag):
-        """Helper function to translate from time series graph to network."""
-        row = node // max_lag
-        lag = node % max_lag
-        return (row, -lag)

-
-
[docs]    def get_tsg(self, link_matrix, val_matrix=None, include_neighbors=False):
-        """Returns time series graph matrix.
-
-        Constructs a matrix of shape (N*tau_max, N*tau_max) from link_matrix.
-        This matrix can be used for plotting the time series graph and analyzing
-        causal pathways.
-
-        Parameters
-        ----------
-        link_matrix : bool array-like, optional (default: None)
-            Matrix of significant links. Must be of same shape as val_matrix.
-            Either sig_thres or link_matrix has to be provided.
-        val_matrix : array_like
-            Matrix of shape (N, N, tau_max+1) containing test statistic values.
-        include_neighbors : bool, optional (default: False)
-            Whether to include causal paths emanating from neighbors of i
-
-        Returns
-        -------
-        tsg : array of shape (N*tau_max, N*tau_max)
-            Time series graph matrix.
-        """
-
-        N = len(link_matrix)
-        max_lag = link_matrix.shape[2] + 1
-
-        # Create TSG
-        tsg = np.zeros((N * max_lag, N * max_lag))
-        for i, j, tau in np.column_stack(np.where(link_matrix)):
-            if tau > 0 or include_neighbors:
-                for t in range(max_lag):
-                    link_start = self.net_to_tsg(i, t - tau, max_lag)
-                    link_end = self.net_to_tsg(j, t, max_lag)
-                    if (0 <= link_start and
-                            (link_start % max_lag) <= (link_end % max_lag)):
-                        if val_matrix is not None:
-                            tsg[link_start, link_end] = val_matrix[i, j, tau]
-                        else:
-                            tsg[link_start, link_end] = 1
-        return tsg

-
-
[docs]    def get_mediation_graph_data(self, i, tau, j, include_neighbors=False):
-        r"""Returns link and node weights for mediation analysis.
-
-        Returns array with non-zero entries for links that are on causal
-        paths between :math:`i` and :math:`j` at lag :math:`\tau`.
-        ``path_val_matrix`` contains the corresponding path coefficients and
-        ``path_node_array`` the MCE values. ``tsg_path_val_matrix`` contains the
-        corresponding values in the time series graph format.
-
-        Parameters
-        ----------
-        i : int
-            Index of cause variable.
-        tau : int
-            Lag of cause variable.
-        j : int
-            Index of effect variable.
-        include_neighbors : bool, optional (default: False)
-            Whether to include causal paths emanating from neighbors of i
-
-        Returns
-        -------
-        graph_data : dictionary
-            Dictionary of matrices for coloring mediation graph plots.
-        """
-
-        path_link_matrix = np.zeros((self.N, self.N, self.tau_max + 1))
-        path_val_matrix = np.zeros((self.N, self.N, self.tau_max + 1))
-
-        # Get mediation of path variables
-        path_node_array = (self.psi.reshape(1, self.tau_max + 1, self.N, self.N)
-                           - self.all_psi_k)[:, abs(tau), j, i]
-
-        # Get involved links
-        val_matrix = self.phi.transpose()
-        link_matrix = val_matrix != 0.
-
-        max_lag = link_matrix.shape[2] + 1
-
-        # include_neighbors = False because True would allow
-        # --> o -- motifs in networkx.all_simple_paths as paths, but
-        # these are blocked...
-        tsg = self.get_tsg(link_matrix, val_matrix=val_matrix,
-                           include_neighbors=False)
-
-        if include_neighbors:
-            # Add contemporaneous links only at source node
-            for m, n in zip(*np.where(link_matrix[:, :, 0])):
-                # print m,n
-                if m != n:
-                    tsg[self.net_to_tsg(m, max_lag - tau - 1, max_lag),
-                        self.net_to_tsg(n, max_lag - tau - 1, max_lag)
-                    ] = val_matrix[m, n, 0]
-
-        tsg_path_val_matrix = np.zeros(tsg.shape)
-
-        graph = networkx.DiGraph(tsg)
-        pathways = []
-
-        for path in networkx.all_simple_paths(graph,
-                                              source=self.net_to_tsg(i,
-                                                                     max_lag - tau - 1,
-                                                                     max_lag),
-                                              target=self.net_to_tsg(j,
-                                                                     max_lag - 0 - 1,
-                                                                     max_lag)):
-            pathways.append([self.tsg_to_net(p, max_lag) for p in path])
-            for ip, p in enumerate(path[1:]):
-                tsg_path_val_matrix[path[ip], p] = tsg[path[ip], p]
-
-                k, tau_k = self.tsg_to_net(p, max_lag)
-                link_start = self.tsg_to_net(path[ip], max_lag)
-                link_end = self.tsg_to_net(p, max_lag)
-                delta_tau = abs(link_end[1] - link_start[1])
-                path_val_matrix[link_start[0],
-                                link_end[0],
-                                delta_tau] = val_matrix[link_start[0],
-                                                        link_end[0],
-                                                        delta_tau]
-
-        graph_data = {'path_node_array': path_node_array,
-                      'path_val_matrix': path_val_matrix,
-                      'tsg_path_val_matrix': tsg_path_val_matrix}
-
-        return graph_data

-
-
[docs]    def get_coeff(self, i, tau, j):
-        """Returns link coefficient.
-
-        This is the direct causal effect for a particular link (i, tau) --> j.
-
-        Parameters
-        ----------
-        i : int
-            Index of cause variable.
-        tau : int
-            Lag of cause variable.
-        j : int
-            Index of effect variable.
-
-        Returns
-        -------
-        coeff : float
-        """
-        return self.phi[abs(tau), j, i]

-
-
[docs]    def get_ce(self, i, tau, j):
-        """Returns the causal effect.
-
-        This is the causal effect for  (i, tau) -- --> j.
-
-        Parameters
-        ----------
-        i : int
-            Index of cause variable.
-        tau : int
-            Lag of cause variable.
-        j : int
-            Index of effect variable.
-
-        Returns
-        -------
-        ce : float
-        """
-        return self.psi[abs(tau), j, i]

-
-
[docs]    def get_ce_max(self, i, j):
-        """Returns the causal effect.
-
-        This is the maximum absolute causal effect for  i --> j across all lags.
-
-        Parameters
-        ----------
-        i : int
-            Index of cause variable.
-        j : int
-            Index of effect variable.
-
-        Returns
-        -------
-        ce : float
-        """
-        argmax = np.abs(self.psi[1:, j, i]).argmax()
-        return self.psi[1:, j, i][argmax]

-
-
[docs]    def get_mce(self, i, tau, j, k):
-        """Returns the mediated causal effect.
-
-        This is the causal effect for  i --> j minus the causal effect not going
-        through k.
-
-        Parameters
-        ----------
-        i : int
-            Index of cause variable.
-        tau : int
-            Lag of cause variable.
-        j : int
-            Index of effect variable.
-        k : int
-            Index of mediator variable.
-
-        Returns
-        -------
-        mce : float
-        """
-        mce = self.psi[abs(tau), j, i] - self.all_psi_k[k, abs(tau), j, i]
-        return mce

-
-
[docs]    def get_ace(self, i, lag_mode='absmax', exclude_i=True):
-        """Returns the average causal effect.
-
-        This is the average causal effect (ACE) emanating from variable i to any
-        other variable. With lag_mode='absmax' this is based on the lag of
-        maximum CE for each pair.
-
-        Parameters
-        ----------
-        i : int
-            Index of cause variable.
-        lag_mode : {'absmax', 'all_lags'}
-            Lag mode. Either average across all lags between each pair or only
-            at the lag of maximum absolute causal effect.
-        exclude_i : bool, optional (default: True)
-            Whether to exclude causal effects on the variable itself at later
-            lags.
-
-        Returns
-        -------
-        ace :float
-            Average Causal Effect.
-        """
-
-        all_but_i = np.ones(self.N, dtype='bool')
-        if exclude_i:
-            all_but_i[i] = False
-
-        if lag_mode == 'absmax':
-            return np.abs(self.psi[1:, all_but_i, i]).max(axis=0).mean()
-        elif lag_mode == 'all_lags':
-            return np.abs(self.psi[1:, all_but_i, i]).mean()
-        else:
-            raise ValueError("lag_mode = %s not implemented" % lag_mode)

-
-
[docs]    def get_all_ace(self, lag_mode='absmax', exclude_i=True):
-        """Returns the average causal effect for all variables.
-
-        This is the average causal effect (ACE) emanating from variable i to any
-        other variable. With lag_mode='absmax' this is based on the lag of
-        maximum CE for each pair.
-
-        Parameters
-        ----------
-        lag_mode : {'absmax', 'all_lags'}
-            Lag mode. Either average across all lags between each pair or only
-            at the lag of maximum absolute causal effect.
-        exclude_i : bool, optional (default: True)
-            Whether to exclude causal effects on the variable itself at later
-            lags.
-
-        Returns
-        -------
-        ace : array of shape (N,)
-            Average Causal Effect for each variable.
-        """
-
-        ace = np.zeros(self.N)
-        for i in range(self.N):
-            ace[i] = self.get_ace(i, lag_mode=lag_mode, exclude_i=exclude_i)
-
-        return ace

-
-
[docs]    def get_acs(self, j, lag_mode='absmax', exclude_j=True):
-        """Returns the average causal susceptibility.
-
-        This is the Average Causal Susceptibility (ACS) affecting a variable j
-        from any other variable. With lag_mode='absmax' this is based on the lag
-        of maximum CE for each pair.
-
-        Parameters
-        ----------
-        j : int
-            Index of variable.
-        lag_mode : {'absmax', 'all_lags'}
-            Lag mode. Either average across all lags between each pair or only
-            at the lag of maximum absolute causal effect.
-        exclude_j : bool, optional (default: True)
-            Whether to exclude causal effects on the variable itself at previous
-            lags.
-
-        Returns
-        -------
-        acs : float
-            Average Causal Susceptibility.
-        """
-
-        all_but_j = np.ones(self.N, dtype='bool')
-        if exclude_j:
-            all_but_j[j] = False
-
-        if lag_mode == 'absmax':
-            return np.abs(self.psi[1:, j, all_but_j]).max(axis=0).mean()
-        elif lag_mode == 'all_lags':
-            return np.abs(self.psi[1:, j, all_but_j]).mean()
-        else:
-            raise ValueError("lag_mode = %s not implemented" % lag_mode)

-
-
[docs]    def get_all_acs(self, lag_mode='absmax', exclude_j=True):
-        """Returns the average causal susceptibility.
-
-        This is the Average Causal Susceptibility (ACS) for each variable from
-        any other variable. With lag_mode='absmax' this is based on the lag of
-        maximum CE for each pair.
-
-        Parameters
-        ----------
-        lag_mode : {'absmax', 'all_lags'}
-            Lag mode. Either average across all lags between each pair or only
-            at the lag of maximum absolute causal effect.
-        exclude_j : bool, optional (default: True)
-            Whether to exclude causal effects on the variable itself at previous
-            lags.
-
-        Returns
-        -------
-        acs : array of shape (N,)
-            Average Causal Susceptibility.
-        """
-
-        acs = np.zeros(self.N)
-        for j in range(self.N):
-            acs[j] = self.get_acs(j, lag_mode=lag_mode, exclude_j=exclude_j)
-
-        return acs

-
-
[docs]    def get_amce(self, k, lag_mode='absmax',
-                 exclude_k=True, exclude_self_effects=True):
-        """Returns the average mediated causal effect.
-
-        This is the Average Mediated Causal Effect (AMCE) through a variable k
-        With lag_mode='absmax' this is based on the lag of maximum CE for each
-        pair.
-
-        Parameters
-        ----------
-        k : int
-            Index of variable.
-        lag_mode : {'absmax', 'all_lags'}
-            Lag mode. Either average across all lags between each pair or only
-            at the lag of maximum absolute causal effect.
-        exclude_k : bool, optional (default: True)
-            Whether to exclude causal effects through the variable itself at
-            previous lags.
-        exclude_self_effects : bool, optional (default: True)
-            Whether to exclude causal self effects of variables on themselves.
-
-        Returns
-        -------
-        amce : float
-            Average Mediated Causal Effect.
-        """
-
-        all_but_k = np.ones(self.N, dtype='bool')
-        if exclude_k:
-            all_but_k[k] = False
-            N_new = self.N - 1
-        else:
-            N_new = self.N
-
-        if exclude_self_effects:
-            weights = np.identity(N_new) == False
-        else:
-            weights = np.ones((N_new, N_new), dtype='bool')
-
-        if self.tau_max < 2:
-            raise ValueError("Mediation only nonzero for tau_max >= 2")
-
-        all_mce = self.psi[2:, :, :] - self.all_psi_k[k, 2:, :, :]
-        # all_mce[:, range(self.N), range(self.N)] = 0.
-
-        if lag_mode == 'absmax':
-            return np.average(np.abs(all_mce[:, all_but_k, :]
-                                     [:, :, all_but_k]
-                                     ).max(axis=0), weights=weights)
-        elif lag_mode == 'all_lags':
-            return np.abs(all_mce[:, all_but_k, :][:, :, all_but_k]).mean()
-        else:
-            raise ValueError("lag_mode = %s not implemented" % lag_mode)

-
-
[docs]    def get_all_amce(self, lag_mode='absmax',
-                     exclude_k=True, exclude_self_effects=True):
-        """Returns the average mediated causal effect.
-
-        This is the Average Mediated Causal Effect (AMCE) through all variables
-        With lag_mode='absmax' this is based on the lag of maximum CE for each
-        pair.
-
-        Parameters
-        ----------
-        lag_mode : {'absmax', 'all_lags'}
-            Lag mode. Either average across all lags between each pair or only
-            at the lag of maximum absolute causal effect.
-        exclude_k : bool, optional (default: True)
-            Whether to exclude causal effects through the variable itself at
-            previous lags.
-        exclude_self_effects : bool, optional (default: True)
-            Whether to exclude causal self effects of variables on themselves.
-
-        Returns
-        -------
-        amce : array of shape (N,)
-            Average Mediated Causal Effect.
-        """
-        amce = np.zeros(self.N)
-        for k in range(self.N):
-            amce[k] = self.get_amce(k,
-                                    lag_mode=lag_mode,
-                                    exclude_k=exclude_k,
-                                    exclude_self_effects=exclude_self_effects)
-
-        return amce

-
-
-
[docs]class Prediction(Models, PCMCI):
-    r"""Prediction class for time series models.
-
-    Allows to fit and predict from any sklearn model. The optimal predictors can
-    be estimated using PCMCI. Also takes care of missing values, masking and
-    preprocessing.
-
-    Parameters
-    ----------
-    dataframe : data object
-        Tigramite dataframe object. It must have the attributes dataframe.values
-        yielding a numpy array of shape (observations T, variables N) and
-        optionally a mask of the same shape and a missing values flag.
-    train_indices : array-like
-        Either boolean array or time indices marking the training data.
-    test_indices : array-like
-        Either boolean array or time indices marking the test data.
-    prediction_model : sklearn model object
-        For example, sklearn.linear_model.LinearRegression() for a linear
-        regression model.
-    cond_ind_test : Conditional independence test object, optional
-        Only needed if predictors are estimated with causal algorithm.
-        The class will be initialized with masking set to the training data.
-    data_transform : sklearn preprocessing object, optional (default: None)
-        Used to transform data prior to fitting. For example,
-        sklearn.preprocessing.StandardScaler for simple standardization. The
-        fitted parameters are stored.
-    verbosity : int, optional (default: 0)
-        Level of verbosity.
-    """
-
-    def __init__(self,
-                 dataframe,
-                 train_indices,
-                 test_indices,
-                 prediction_model,
-                 cond_ind_test=None,
-                 data_transform=None,
-                 verbosity=0):
-
-        # Default value for the mask
-        mask = dataframe.mask
-        if mask is None:
-            mask = np.zeros(dataframe.values.shape, dtype='bool')
-        # Get the dataframe shape
-        T = len(dataframe.values)
-        # Have the default dataframe be the training data frame
-        train_mask = np.copy(mask)
-        train_mask[[t for t in range(T) if t not in train_indices]] = True
-        self.dataframe = DataFrame(dataframe.values,
-                                   mask=train_mask,
-                                   missing_flag=dataframe.missing_flag)
-        # Initialize the models baseclass with the training dataframe
-        Models.__init__(self,
-                        dataframe=self.dataframe,
-                        model=prediction_model,
-                        data_transform=data_transform,
-                        mask_type='y',
-                        verbosity=verbosity)
-
-        # Build the testing dataframe as well
-        self.test_mask = np.copy(mask)
-        self.test_mask[[t for t in range(T) if t not in test_indices]] = True
-
-        # Setup the PCMCI instance
-        if cond_ind_test is not None:
-            # Force the masking
-            cond_ind_test.set_mask_type('y')
-            cond_ind_test.verbosity = verbosity
-            PCMCI.__init__(self,
-                           dataframe=self.dataframe,
-                           cond_ind_test=cond_ind_test,
-                           selected_variables=None,
-                           verbosity=verbosity)
-
-        # Set the member variables
-        self.cond_ind_test = cond_ind_test
-        # Initialize member varialbes that are set outside
-        self.target_predictors = None
-        self.selected_targets = None
-        self.fitted_model = None
-        self.test_array = None
-
-
[docs]    def get_predictors(self,
-                       selected_targets=None,
-                       selected_links=None,
-                       steps_ahead=1,
-                       tau_max=1,
-                       pc_alpha=0.2,
-                       max_conds_dim=None,
-                       max_combinations=1):
-        """Estimate predictors using PC1 algorithm.
-
-        Wrapper around PCMCI.run_pc_stable that estimates causal predictors.
-        The lead time can be specified by ``steps_ahead``.
-
-        Parameters
-        ----------
-        selected_targets : list of ints, optional (default: None)
-            List of variables to estimate predictors of. If None, predictors of
-            all variables are estimated.
-        selected_links : dict or None
-            Dictionary of form {0:[(0, -1), (3, -2), ...], 1:[], ...}
-            specifying whether only selected links should be tested. If None is
-            passed, all links are tested
-        steps_ahead : int, default: 1
-            Minimum time lag to test. Useful for multi-step ahead predictions.
-        tau_max : int, default: 1
-            Maximum time lag. Must be larger or equal to tau_min.
-        pc_alpha : float or list of floats, default: 0.2
-            Significance level in algorithm. If a list or None is passed, the
-            pc_alpha level is optimized for every variable across the given
-            pc_alpha values using the score computed in
-            cond_ind_test.get_model_selection_criterion()
-        max_conds_dim : int or None
-            Maximum number of conditions to test. If None is passed, this number
-            is unrestricted.
-        max_combinations : int, default: 1
-            Maximum number of combinations of conditions of current cardinality
-            to test. Defaults to 1 for PC_1 algorithm. For original PC algorithm
-            a larger number, such as 10, can be used.
-
-        Returns
-        -------
-        predictors : dict
-            Dictionary of form {0:[(0, -1), (3, -2), ...], 1:[], ...}
-            containing estimated predictors.
-        """
-        # Ensure an independence model is given
-        if self.cond_ind_test is None:
-            raise ValueError("No cond_ind_test given!")
-        # Set the selected variables
-        self.selected_variables = range(self.N)
-        if selected_targets is not None:
-            self.selected_variables = selected_targets
-        predictors = self.run_pc_stable(selected_links=selected_links,
-                                        tau_min=steps_ahead,
-                                        tau_max=tau_max,
-                                        save_iterations=False,
-                                        pc_alpha=pc_alpha,
-                                        max_conds_dim=max_conds_dim,
-                                        max_combinations=max_combinations)
-        return predictors

-
-
[docs]    def fit(self, target_predictors,
-            selected_targets=None, tau_max=None, return_data=False):
-        r"""Fit time series model.
-
-        Wrapper around ``Models.get_fit()``. To each variable in
-        ``selected_targets``, the sklearn model is fitted with :math:`y` given
-        by the target variable, and :math:`X` given by its predictors. The
-        fitted model class is returned for later use.
-
-        Parameters
-        ----------
-        target_predictors : dictionary
-            Dictionary of form {0:[(0, -1), (3, -2), ...], 1:[], ...} containing
-            the predictors estimated with PCMCI.
-        selected_targets : list of integers, optional (default: range(N))
-            Specify to fit model only for selected targets. If None is
-            passed, models are estimated for all variables.
-        tau_max : int, optional (default: None)
-            Maximum time lag. If None, the maximum lag in target_predictors is
-            used.
-        return_data : bool, optional (default: False)
-            Whether to save the data array.
-
-        Returns
-        -------
-        self : instance of self
-        """
-
-        self.target_predictors = target_predictors
-
-        if selected_targets is None:
-            self.selected_targets = range(self.N)
-        else:
-            self.selected_targets = selected_targets
-
-        for target in self.selected_targets:
-            if target not in list(self.target_predictors):
-                raise ValueError("No predictors given for target %s" % target)
-
-        self.fitted_model = \
-            self.get_fit(all_parents=self.target_predictors,
-                         selected_variables=self.selected_targets,
-                         tau_max=tau_max,
-                         return_data=return_data)
-        return self

-
-
[docs]    def predict(self, target,
-                new_data=None,
-                pred_params=None,
-                cut_off='max_lag_or_tau_max'):
-        r"""Predict target variable with fitted model.
-
-        Uses the model.predict() function of the sklearn model.
-
-        If target is an int, the predicted time series is returned. If target
-        is a list of integers, then a list of predicted time series is returned.
-        If the list of integers equals range(N), then an array of shape (T, N)
-        of the predicted series is returned.
-
-        Parameters
-        ----------
-        target : int or list of integers
-            Index or indices of target variable(s).
-        new_data : data object, optional
-            New Tigramite dataframe object with optional new mask.
-        pred_params : dict, optional
-            Optional parameters passed on to sklearn prediction function.
-        cut_off : {'2xtau_max', 'max_lag', 'max_lag_or_tau_max'}
-            How many samples to cutoff at the beginning. The default is
-            '2xtau_max', which guarantees that MCI tests are all conducted on
-            the same samples.  For modeling, 'max_lag_or_tau_max' can be used,
-            which uses the maximum of tau_max and the conditions, which is
-            useful to compare multiple models on the same sample. Last,
-            'max_lag' uses as much samples as possible.
-
-        Returns
-        -------
-        Results from prediction.
-        """
-
-        if isinstance(target, int):
-            target_list = [target]
-        elif isinstance(target, list):
-            target_list = target
-        else:
-            raise ValueError("target must be either int or list of integers "
-                             "indicating the index of the variables to "
-                             "predict.")
-
-        if target_list == range(self.N):
-            return_type = 'array'
-        elif len(target_list) == 1:
-            return_type = 'series'
-        else:
-            return_type = 'list'
-
-        pred_list = []
-        for target in target_list:
-            # Print message
-            if self.verbosity > 0:
-                print("\n##\n## Predicting target %s\n##" % target)
-                if pred_params is not None:
-                    for key in list(pred_params):
-                        print("%s = %s" % (key, pred_params[key]))
-            # Default value for pred_params
-            if pred_params is None:
-                pred_params = {}
-            # Check this is a valid target
-            if target not in self.selected_targets:
-                raise ValueError("Target %s not yet fitted" % target)
-            # Construct the array form of the data
-            Y = [(target, 0)]
-            X = [(target, 0)]  # dummy
-            Z = self.target_predictors[target]
-            # Check if we've passed a new dataframe object
-            test_array = None
-            if new_data is not None:
-                test_array, _ = new_data.construct_array(X, Y, Z,
-                                                         tau_max=self.tau_max,
-                                                         mask_type=self.mask_type,
-                                                         cut_off=cut_off,
-                                                         verbosity=self.verbosity)
-            # Otherwise use the default values
-            else:
-                test_array, _ = \
-                    self.dataframe.construct_array(X, Y, Z,
-                                                   tau_max=self.tau_max,
-                                                   mask=self.test_mask,
-                                                   mask_type=self.mask_type,
-                                                   cut_off=cut_off,
-                                                   verbosity=self.verbosity)
-            # Transform the data if needed
-            a_transform = self.fitted_model[target]['data_transform']
-            if a_transform is not None:
-                test_array = a_transform.transform(X=test_array.T).T
-            # Cache the test array
-            self.test_array = test_array
-            # Run the predictor
-            pred_list.append(self.fitted_model[target]['model'].predict(
-                X=test_array[2:].T, **pred_params))
-
-        if return_type == 'series':
-            return pred_list[0]
-        elif return_type == 'list':
-            return pred_list
-        elif return_type == 'array':
-            return np.array(pred_list).transpose()

-
-
[docs]    def get_train_array(self, j):
-        """Returns training array."""
-        return self.fitted_model[j]['data']

-
-
[docs]    def get_test_array(self):
-        """Returns test array."""
-        return self.test_array

-
-if __name__ == '__main__':
-   
-    import tigramite.data_processing as pp
-
-    np.random.seed(6)
-
-    def lin_f(x): return x
- 
-    links = {0: [((0, -1), 0.8, lin_f)],
-             1: [((1, -1), 0.8, lin_f), ((0, -1), 0.5, lin_f)],
-             2: [((2, -1), 0.8, lin_f), ((1, 0), -0.6, lin_f)]}
-    # noises = [np.random.randn for j in links.keys()]
-    data, nonstat = pp.structural_causal_process(links, T=10000)
-    true_parents = pp._get_true_parent_neighbor_dict(links)
-    dataframe = pp.DataFrame(data)
- 
-    med = Models(dataframe=dataframe, model=sklearn.linear_model.LinearRegression(), data_transform=None)
-    # Fit the model
-    med.get_fit(all_parents=true_parents, tau_max=3)
-
-    print(med.get_val_matrix())
-
-    # for j, i, tau, coeff in pp._iter_coeffs(links):
-    #     print(i, j, tau, coeff, med.get_coeff(i=i, tau=tau, j=j))
-
-    # for causal_coeff in [med.get_ce(i=0, tau=-2, j=2),
-    #                      med.get_mce(i=0, tau=-2, j=2, k=1)]:
-    #     print(causal_coeff)
-
- -
-
-
-
-
- - - - \ No newline at end of file diff --git a/docs/_build/html/_modules/tigramite/pcmci.html b/docs/_build/html/_modules/tigramite/pcmci.html deleted file mode 100644 index ad66f34a..00000000 --- a/docs/_build/html/_modules/tigramite/pcmci.html +++ /dev/null @@ -1,3852 +0,0 @@ - - - - - - - tigramite.pcmci — Tigramite 4.2 documentation - - - - - - - - - - - - - -
-
-
-
- -

Source code for tigramite.pcmci

-"""Tigramite causal discovery for time series."""
-
-# Author: Jakob Runge <jakob@jakob-runge.com>
-#
-# License: GNU General Public License v3.0
-
-from __future__ import print_function
-import warnings
-import itertools
-from collections import defaultdict
-from copy import deepcopy
-import numpy as np
-import scipy.stats
-
-
-def _create_nested_dictionary(depth=0, lowest_type=dict):
-    """Create a series of nested dictionaries to a maximum depth.  The first
-    depth - 1 nested dictionaries are defaultdicts, the last is a normal
-    dictionary.
-
-    Parameters
-    ----------
-    depth : int
-        Maximum depth argument.
-    lowest_type: callable (optional)
-        Type contained in leaves of tree.  Ex: list, dict, tuple, int, float ...
-    """
-    new_depth = depth - 1
-    if new_depth <= 0:
-        return defaultdict(lowest_type)
-    return defaultdict(lambda: _create_nested_dictionary(new_depth))
-
-
-def _nested_to_normal(nested_dict):
-    """Transforms the nested default dictionary into a standard dictionaries
-
-    Parameters
-    ----------
-    nested_dict : default dictionary of default dictionaries of ... etc.
-    """
-    if isinstance(nested_dict, defaultdict):
-        nested_dict = {k: _nested_to_normal(v) for k, v in nested_dict.items()}
-    return nested_dict
-
-
-
[docs]class PCMCI():
-    r"""PCMCI causal discovery for time series datasets.
-
-    PCMCI is a causal discovery framework for large-scale time series
-    datasets. This class contains several methods. The standard PCMCI method
-    addresses time-lagged causal discovery and is described in [1]_ where
-    also further sub-variants are discussed. Lagged as well as contemporaneous
-    causal discovery is addressed with PCMCIplus and described in [5]_. See the
-    tutorials for guidance in applying these methods.
-
-    PCMCI has:
-
-    * different conditional independence tests adapted to linear or
-      nonlinear dependencies, and continuously-valued or discrete data (
-      implemented in ``tigramite.independence_tests``)
-    * (mostly) hyperparameter optimization
-    * easy parallelization (separate script)
-    * handling of masked time series data
-    * false discovery control and confidence interval estimation
-
-
-    Notes
-    -----
-
-    .. image:: mci_schematic.*
-       :width: 200pt
-
-    In the PCMCI framework, the dependency structure of a set of time series
-    variables is represented in a *time series graph* as shown in the Figure.
-    The nodes of a time series graph are defined as the variables at
-    different times and a link indicates a conditional dependency that can be
-    interpreted as a causal dependency under certain assumptions (see paper).
-    Assuming stationarity, the links are repeated in time. The parents
-    :math:`\mathcal{P}` of a variable are defined as the set of all nodes
-    with a link towards it (blue and red boxes in Figure).
-
-    The different PCMCI methods estimate causal links by iterative
-    conditional independence testing. PCMCI can be flexibly combined with
-    any kind of conditional independence test statistic adapted to the kind
-    of data (continuous or discrete) and its assumed dependency types.
-    These are available in ``tigramite.independence_tests``.
-
-    References
-    ----------
-
-    .. [1] 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
-
-    .. [5] J. Runge,
-           Discovering contemporaneous and lagged causal relations in 
-           autocorrelated nonlinear time series datasets
-           http://www.auai.org/~w-auai/uai2020/proceedings/579_main_paper.pdf
-
-    Parameters
-    ----------
-    dataframe : data object
-        This is the Tigramite dataframe object. Among others, it has the
-        attributes dataframe.values yielding a numpy array of shape (
-        observations T, variables N) and optionally a mask of the same shape.
-    cond_ind_test : conditional independence test object
-        This can be ParCorr or other classes from
-        ``tigramite.independence_tests`` or an external test passed as a
-        callable. This test can be based on the class
-        tigramite.independence_tests.CondIndTest.
-    selected_variables : list
-        Deprecated, just here to raise Error if not None.
-    verbosity : int, optional (default: 0)
-        Verbose levels 0, 1, ...
-
-    Attributes
-    ----------
-    all_parents : dictionary
-        Dictionary of form {0:[(0, -1), (3, -2), ...], 1:[], ...} containing
-        the conditioning-parents estimated with PC algorithm.
-    val_min : dictionary
-        Dictionary of form val_min[j][(i, -tau)] = float
-        containing the minimum test statistic value for each link estimated in
-        the PC algorithm.
-    pval_max : dictionary
-        Dictionary of form pval_max[j][(i, -tau)] = float containing the maximum
-        p-value for each link estimated in the PC algorithm.
-    iterations : dictionary
-        Dictionary containing further information on algorithm steps.
-    N : int
-        Number of variables.
-    T : int
-        Time series sample length.
-    """
-
-    def __init__(self, dataframe,
-                 cond_ind_test,
-                 selected_variables=None,
-                 verbosity=0):
-        # Set the data for this iteration of the algorithm
-        self.dataframe = dataframe
-        # Set the conditional independence test to be used
-        self.cond_ind_test = cond_ind_test
-        self.cond_ind_test.set_dataframe(self.dataframe)
-        # Set the verbosity for debugging/logging messages
-        self.verbosity = verbosity
-        # Set the variable names 
-        self.var_names = self.dataframe.var_names
-
-        # Raise error if selected_variables is set
-        if selected_variables is not None:
-            raise ValueError("selected_variables is deprecated, use "
-                             "the selected_links parameter in the respective "
-                             "functions run_pcmci() etc.")
-
-        # Store the shape of the data in the T and N variables
-        self.T, self.N = self.dataframe.values.shape
-
-    def _set_sel_links(self, selected_links, tau_min, tau_max,
-                       remove_contemp=False):
-        """Helper function to set and check the selected links argument
-
-        Parameters
-        ----------
-        selected_links : dict or None
-            Dictionary of form {0:[(0, -1), (3, -2), ...], 1:[], ...}
-            specifying whether only selected links should be tested. If None is
-            passed, all links are returned.
-        tau_mix : int
-            Minimum time delay to test.
-        tau_max : int
-            Maximum time delay to test.
-        remove_contemp : bool
-            Whether contemporaneous links (at lag zero) should be removed.
-
-        Returns
-        -------
-        selected_links : dict
-            Cleaned links.
-        """
-        # Copy and pass into the function
-        _int_sel_links = deepcopy(selected_links)
-        # Set the default selected links if none are set
-        _vars = list(range(self.N))
-        _lags = list(range(-(tau_max), -tau_min + 1, 1))
-        if _int_sel_links is None:
-            _int_sel_links = {}
-            # Set the default as all combinations of the selected variables
-            for j in _vars:
-                _int_sel_links[j] = [(var, -lag) for var in _vars
-                                     for lag in range(tau_min, tau_max + 1)]
-        else:
-            if remove_contemp:
-                for j in _int_sel_links.keys():
-                    _int_sel_links[j] = [link for link in _int_sel_links[j]
-                                         if link[1] != 0]
-        # Otherwise, check that our selection is sane
-        # Check that the selected links refer to links that are inside the
-        # data range
-        _key_set = set(_int_sel_links.keys())
-        valid_entries = _key_set == set(range(self.N))
-
-        valid_entries = valid_entries and \
-                        set(var for parents in _int_sel_links.values()
-                            for var, _ in parents).issubset(_vars)
-        valid_entries = valid_entries and \
-                        set(lag for parents in _int_sel_links.values()
-                            for _, lag in parents).issubset(_lags)
-        if not valid_entries:
-            raise ValueError("selected_links"
-                             " must be dictionary with keys for all [0,...,N-1]"
-                             " variables and contain only links from "
-                             "these variables in range [tau_min, tau_max]")
-
-        # Return the selected links
-        return _int_sel_links
-
-    def _iter_conditions(self, parent, conds_dim, all_parents):
-        """Yield next condition.
-
-        Yields next condition from lexicographically ordered conditions.
-
-        Parameters
-        ----------
-        parent : tuple
-            Tuple of form (i, -tau).
-        conds_dim : int
-            Cardinality in current step.
-        all_parents : list
-            List of form [(0, -1), (3, -2), ...].
-
-        Yields
-        -------
-        cond :  list
-            List of form [(0, -1), (3, -2), ...] for the next condition.
-        """
-        all_parents_excl_current = [p for p in all_parents if p != parent]
-        for cond in itertools.combinations(all_parents_excl_current, conds_dim):
-            yield list(cond)
-
-    def _sort_parents(self, parents_vals):
-        """Sort current parents according to test statistic values.
-
-        Sorting is from strongest to weakest absolute values.
-
-        Parameters
-        ---------
-        parents_vals : dict
-            Dictionary of form {(0, -1):float, ...} containing the minimum test
-            statistic value of a link.
-
-        Returns
-        -------
-        parents : list
-            List of form [(0, -1), (3, -2), ...] containing sorted parents.
-        """
-        if self.verbosity > 1:
-            print("\n    Sorting parents in decreasing order with "
-                  "\n    weight(i-tau->j) = min_{iterations} |val_{ij}(tau)| ")
-        # Get the absolute value for all the test statistics
-        abs_values = {k: np.abs(parents_vals[k]) for k in list(parents_vals)}
-        return sorted(abs_values, key=abs_values.get, reverse=True)
-
-    def _dict_to_matrix(self, val_dict, tau_max, n_vars, default=1):
-        """Helper function to convert dictionary to matrix format.
-
-        Parameters
-        ---------
-        val_dict : dict
-            Dictionary of form {0:{(0, -1):float, ...}, 1:{...}, ...}.
-        tau_max : int
-            Maximum lag.
-        n_vars : int
-            Number of variables.
-        default : int
-            Default value for entries not part of val_dict.
-
-        Returns
-        -------
-        matrix : array of shape (N, N, tau_max+1)
-            Matrix format of p-values and test statistic values.
-        """
-        matrix = np.ones((n_vars, n_vars, tau_max + 1))
-        matrix *= default
-
-        for j in val_dict.keys():
-            for link in val_dict[j].keys():
-                k, tau = link
-                matrix[k, j, abs(tau)] = val_dict[j][link]
-        return matrix
-
-    def _print_link_info(self, j, index_parent, parent, num_parents,
-                         already_removed=False):
-        """Print info about the current link being tested.
-
-        Parameters
-        ----------
-        j : int
-            Index of current node being tested.
-        index_parent : int
-            Index of the current parent.
-        parent : tuple
-            Standard (i, tau) tuple of parent node id and time delay
-        num_parents : int
-            Total number of parents.
-        already_removed : bool
-            Whether parent was already removed.
-        """
-        link_marker = {True:"o-o", False:"-->"}
-
-        abstau = abs(parent[1])
-        if self.verbosity > 1:
-            print("\n    Link (%s % d) %s %s (%d/%d):" % (
-                self.var_names[parent[0]], parent[1], link_marker[abstau==0],
-                self.var_names[j],
-                index_parent + 1, num_parents))
-
-            if already_removed:
-                print("    Already removed.")
-
-    def _print_cond_info(self, Z, comb_index, pval, val):
-        """Print info about the condition
-
-        Parameters
-        ----------
-        Z : list
-            The current condition being tested.
-        comb_index : int
-            Index of the combination yielding this condition.
-        pval : float
-            p-value from this condition.
-        val : float
-            value from this condition.
-        """
-        var_name_z = ""
-        for i, tau in Z:
-            var_name_z += "(%s % .2s) " % (self.var_names[i], tau)
-        if len(Z) == 0: var_name_z = "()"
-        print("    Subset %d: %s gives pval = %.5f / val = % .3f" %
-              (comb_index, var_name_z, pval, val))
-
-    def _print_a_pc_result(self, nonsig, conds_dim, max_combinations):
-        """Print the results from the current iteration of conditions.
-
-        Parameters
-        ----------
-        nonsig : bool
-            Indicate non-significance.
-        conds_dim : int
-            Cardinality of the current step.
-        max_combinations : int
-            Maximum number of combinations of conditions of current cardinality
-            to test.
-        """
-        # Start with an indent
-        print_str = "    "
-        # Determine the body of the text
-        if nonsig:
-            print_str += "Non-significance detected."
-        elif conds_dim > max_combinations:
-            print_str += "Still subsets of dimension" + \
-                         " %d left," % (conds_dim) + \
-                         " but q_max = %d reached." % (max_combinations)
-        else:
-            print_str += "No conditions of dimension %d left." % (conds_dim)
-        # Print the message
-        print(print_str)
-
-    def _print_converged_pc_single(self, converged, j, max_conds_dim):
-        """
-        Print statement about the convergence of the pc_stable_single algorithm.
-
-        Parameters
-        ----------
-        convergence : bool
-            true if convergence was reached.
-        j : int
-            Variable index.
-        max_conds_dim : int
-            Maximum number of conditions to test.
-        """
-        if converged:
-            print("\nAlgorithm converged for variable %s" %
-                  self.var_names[j])
-        else:
-            print(
-                "\nAlgorithm not yet converged, but max_conds_dim = %d"
-                " reached." % max_conds_dim)
-
-    def _run_pc_stable_single(self, j,
-                              selected_links=None,
-                              tau_min=1,
-                              tau_max=1,
-                              save_iterations=False,
-                              pc_alpha=0.2,
-                              max_conds_dim=None,
-                              max_combinations=1):
-        """Lagged PC algorithm for estimating lagged parents of single variable.
-
-        Parameters
-        ----------
-        j : int
-            Variable index.
-        selected_links : list, optional (default: None)
-            List of form [(0, -1), (3, -2), ...]
-            specifying whether only selected links should be tested. If None is
-            passed, all links are tested.
-        tau_min : int, optional (default: 1)
-            Minimum time lag to test. Useful for variable selection in
-            multi-step ahead predictions. Must be greater zero.
-        tau_max : int, optional (default: 1)
-            Maximum time lag. Must be larger or equal to tau_min.
-        save_iterations : bool, optional (default: False)
-            Whether to save iteration step results such as conditions used.
-        pc_alpha : float or None, optional (default: 0.2)
-            Significance level in algorithm. If a list is given, pc_alpha is
-            optimized using model selection criteria provided in the
-            cond_ind_test class as get_model_selection_criterion(). If None,
-            a default list of values is used.
-        max_conds_dim : int, optional (default: None)
-            Maximum number of conditions to test. If None is passed, this number
-            is unrestricted.
-        max_combinations : int, optional (default: 1)
-            Maximum number of combinations of conditions of current cardinality
-            to test. Defaults to 1 for PC_1 algorithm. For original PC algorithm
-            a larger number, such as 10, can be used.
-
-        Returns
-        -------
-        parents : list
-            List of estimated parents.
-        val_min : dict
-            Dictionary of form {(0, -1):float, ...} containing the minimum test
-            statistic value of a link.
-        pval_max : dict
-            Dictionary of form {(0, -1):float, ...} containing the maximum
-            p-value of a link across different conditions.
-        iterations : dict
-            Dictionary containing further information on algorithm steps.
-        """
-        # Initialize the dictionaries for the pval_max, val_min parents_values
-        # results
-        pval_max = dict()
-        val_min = dict()
-        parents_values = dict()
-        # Initialize the parents values from the selected links, copying to
-        # ensure this initial argument is unchanged.
-        parents = deepcopy(selected_links)
-        val_min = {(p[0], p[1]): None for p in parents}
-        pval_max = {(p[0], p[1]): None for p in parents}
-
-        # Define a nested defaultdict of depth 4 to save all information about
-        # iterations
-        iterations = _create_nested_dictionary(4)
-        # Ensure tau_min is at least 1
-        tau_min = max(1, tau_min)
-
-        # Loop over all possible condition dimensions
-        max_conds_dim = self._set_max_condition_dim(max_conds_dim,
-                                                    tau_min, tau_max)
-        # Iteration through increasing number of conditions, i.e. from 
-        # [0, max_conds_dim] inclusive
-        converged = False
-        for conds_dim in range(max_conds_dim + 1):
-            # (Re)initialize the list of non-significant links
-            nonsig_parents = list()
-            # Check if the algorithm has converged
-            if len(parents) - 1 < conds_dim:
-                converged = True
-                break
-            # Print information about
-            if self.verbosity > 1:
-                print("\nTesting condition sets of dimension %d:" % conds_dim)
-
-            # Iterate through all possible pairs (that have not converged yet)
-            for index_parent, parent in enumerate(parents):
-                # Print info about this link
-                if self.verbosity > 1:
-                    self._print_link_info(j, index_parent, parent, len(parents))
-                # Iterate through all possible combinations
-                nonsig = False
-                for comb_index, Z in \
-                        enumerate(self._iter_conditions(parent, conds_dim,
-                                                        parents)):
-                    # Break if we try too many combinations
-                    if comb_index >= max_combinations:
-                        break
-                    # Perform independence test
-                    val, pval = self.cond_ind_test.run_test(X=[parent],
-                                                    Y=[(j, 0)],
-                                                    Z=Z,
-                                                    tau_max=tau_max,
-                                                    # verbosity=self.verbosity
-                                                    )
-                    # Print some information if needed
-                    if self.verbosity > 1:
-                        self._print_cond_info(Z, comb_index, pval, val)
-                    # Keep track of maximum p-value and minimum estimated value
-                    # for each pair (across any condition)
-                    parents_values[parent] = \
-                        min(np.abs(val), parents_values.get(parent,
-                                                            float("inf")))
-
-                    if pval_max[parent] is None or pval > pval_max[parent]:
-                        pval_max[parent] = pval
-                        val_min[parent] = val
-
-                    # Save the iteration if we need to
-                    if save_iterations:
-                        a_iter = iterations['iterations'][conds_dim][parent]
-                        a_iter[comb_index]['conds'] = deepcopy(Z)
-                        a_iter[comb_index]['val'] = val
-                        a_iter[comb_index]['pval'] = pval
-                    # Delete link later and break while-loop if non-significant
-                    if pval > pc_alpha:
-                        nonsig_parents.append((j, parent))
-                        nonsig = True
-                        break
-
-                # Print the results if needed
-                if self.verbosity > 1:
-                    self._print_a_pc_result(nonsig,
-                                            conds_dim, max_combinations)
-
-            # Remove non-significant links
-            for _, parent in nonsig_parents:
-                del parents_values[parent]
-            # Return the parents list sorted by the test metric so that the
-            # updated parents list is given to the next cond_dim loop
-            parents = self._sort_parents(parents_values)
-            # Print information about the change in possible parents
-            if self.verbosity > 1:
-                print("\nUpdating parents:")
-                self._print_parents_single(j, parents, parents_values, pval_max)
-
-        # Print information about if convergence was reached
-        if self.verbosity > 1:
-            self._print_converged_pc_single(converged, j, max_conds_dim)
-        # Return the results
-        return {'parents': parents,
-                'val_min': val_min,
-                'pval_max': pval_max,
-                'iterations': _nested_to_normal(iterations)}
-
-    def _print_pc_params(self, selected_links, tau_min, tau_max, pc_alpha,
-                         max_conds_dim, max_combinations):
-        """Print the setup of the current pc_stable run.
-
-        Parameters
-        ----------
-        selected_links : dict or None
-            Dictionary of form specifying which links should be tested.
-        tau_min : int, default: 1
-            Minimum time lag to test.
-        tau_max : int, default: 1
-            Maximum time lag to test.
-        pc_alpha : float or list of floats
-            Significance level in algorithm.
-        max_conds_dim : int
-            Maximum number of conditions to test.
-        max_combinations : int
-            Maximum number of combinations of conditions to test.
-        """
-        print("\n##\n## Step 1: PC1 algorithm with lagged conditions\n##"
-              "\n\nParameters:")
-        if selected_links is not None:
-            print("selected_links = %s" % selected_links)
-        print("independence test = %s" % self.cond_ind_test.measure
-              + "\ntau_min = %d" % tau_min
-              + "\ntau_max = %d" % tau_max
-              + "\npc_alpha = %s" % pc_alpha
-              + "\nmax_conds_dim = %s" % max_conds_dim
-              + "\nmax_combinations = %d" % max_combinations)
-        print("\n")
-
-    def _print_pc_sel_results(self, pc_alpha, results, j, score, optimal_alpha):
-        """Print the results from the pc_alpha selection.
-
-        Parameters
-        ----------
-        pc_alpha : list
-            Tested significance levels in algorithm.
-        results : dict
-            Results from the tested pc_alphas.
-        score : array of floats
-            scores from each pc_alpha.
-        j : int
-            Index of current variable.
-        optimal_alpha : float
-            Optimal value of pc_alpha.
-        """
-        print("\n# Condition selection results:")
-        for iscore, pc_alpha_here in enumerate(pc_alpha):
-            names_parents = "[ "
-            for pari in results[pc_alpha_here]['parents']:
-                names_parents += "(%s % d) " % (
-                    self.var_names[pari[0]], pari[1])
-            names_parents += "]"
-            print("    pc_alpha=%s got score %.4f with parents %s" %
-                  (pc_alpha_here, score[iscore], names_parents))
-        print("\n--> optimal pc_alpha for variable %s is %s" %
-              (self.var_names[j], optimal_alpha))
-
-    def _check_tau_limits(self, tau_min, tau_max):
-        """Check the tau limits adhere to 0 <= tau_min <= tau_max.
-
-        Parameters
-        ----------
-        tau_min : float
-            Minimum tau value.
-        tau_max : float
-            Maximum tau value.
-        """
-        if not 0 <= tau_min <= tau_max:
-            raise ValueError("tau_max = %d, " % (tau_max) + \
-                             "tau_min = %d, " % (tau_min) + \
-                             "but 0 <= tau_min <= tau_max")
-
-    def _set_max_condition_dim(self, max_conds_dim, tau_min, tau_max):
-        """
-        Set the maximum dimension of the conditions. Defaults to self.N*tau_max.
-
-        Parameters
-        ----------
-        max_conds_dim : int
-            Input maximum condition dimension.
-        tau_max : int
-            Maximum tau.
-
-        Returns
-        -------
-        max_conds_dim : int
-            Input maximum condition dimension or default.
-        """
-        # Check if an input was given
-        if max_conds_dim is None:
-            max_conds_dim = self.N * (tau_max - tau_min + 1)
-        # Check this is a valid
-        if max_conds_dim < 0:
-            raise ValueError("maximum condition dimension must be >= 0")
-        return max_conds_dim
-
-
[docs]    def run_pc_stable(self,
-                      selected_links=None,
-                      tau_min=1,
-                      tau_max=1,
-                      save_iterations=False,
-                      pc_alpha=0.2,
-                      max_conds_dim=None,
-                      max_combinations=1):
-        """Lagged PC algorithm for estimating lagged parents of all variables.
-
-        Parents are made available as self.all_parents
-
-        Parameters
-        ----------
-        selected_links : dict or None
-            Dictionary of form {0:[(0, -1), (3, -2), ...], 1:[], ...}
-            specifying whether only selected links should be tested. If None is
-            passed, all links are tested.
-        tau_min : int, default: 1
-            Minimum time lag to test. Useful for multi-step ahead predictions.
-            Must be greater zero.
-        tau_max : int, default: 1
-            Maximum time lag. Must be larger or equal to tau_min.
-        save_iterations : bool, default: False
-            Whether to save iteration step results such as conditions used.
-        pc_alpha : float or list of floats, default: [0.05, 0.1, 0.2, ..., 0.5]
-            Significance level in algorithm. If a list or None is passed, the
-            pc_alpha level is optimized for every variable across the given
-            pc_alpha values using the score computed in
-            cond_ind_test.get_model_selection_criterion().
-        max_conds_dim : int or None
-            Maximum number of conditions to test. If None is passed, this number
-            is unrestricted.
-        max_combinations : int, default: 1
-            Maximum number of combinations of conditions of current cardinality
-            to test. Defaults to 1 for PC_1 algorithm. For original PC algorithm
-            a larger number, such as 10, can be used.
-
-        Returns
-        -------
-        all_parents : dict
-            Dictionary of form {0:[(0, -1), (3, -2), ...], 1:[], ...}
-            containing estimated parents.
-        """
-        # Create an internal copy of pc_alpha
-        _int_pc_alpha = deepcopy(pc_alpha)
-        # Check if we are selecting an optimal alpha value
-        select_optimal_alpha = True
-        # Set the default values for pc_alpha
-        if _int_pc_alpha is None:
-            _int_pc_alpha = [0.05, 0.1, 0.2, 0.3, 0.4, 0.5]
-        elif not isinstance(_int_pc_alpha, (list, tuple, np.ndarray)):
-            _int_pc_alpha = [_int_pc_alpha]
-            select_optimal_alpha = False
-        # Check the limits on tau_min
-        self._check_tau_limits(tau_min, tau_max)
-        tau_min = max(1, tau_min)
-        # Check that the maximum combinations variable is correct
-        if max_combinations <= 0:
-            raise ValueError("max_combinations must be > 0")
-        # Implement defaultdict for all pval_max, val_max, and iterations
-        pval_max = defaultdict(dict)
-        val_min = defaultdict(dict)
-        iterations = defaultdict(dict)
-
-        if self.verbosity > 0:
-            self._print_pc_params(selected_links, tau_min, tau_max,
-                              _int_pc_alpha, max_conds_dim,
-                              max_combinations)
-
-        # Set the selected links
-        _int_sel_links = self._set_sel_links(selected_links, tau_min, tau_max,
-                                             remove_contemp=True)
-
-        # Initialize all parents
-        all_parents = dict()
-        # Set the maximum condition dimension
-        max_conds_dim = self._set_max_condition_dim(max_conds_dim,
-                                                    tau_min, tau_max)
-
-        # Loop through the selected variables
-        for j in range(self.N):
-            # Print the status of this variable
-            if self.verbosity > 1:
-                print("\n## Variable %s" % self.var_names[j])
-                print("\nIterating through pc_alpha = %s:" % _int_pc_alpha)
-            # Initialize the scores for selecting the optimal alpha
-            score = np.zeros_like(_int_pc_alpha)
-            # Initialize the result
-            results = {}
-            for iscore, pc_alpha_here in enumerate(_int_pc_alpha):
-                # Print statement about the pc_alpha being tested
-                if self.verbosity > 1:
-                    print("\n# pc_alpha = %s (%d/%d):" % (pc_alpha_here,
-                                                          iscore + 1,
-                                                          score.shape[0]))
-                # Get the results for this alpha value
-                results[pc_alpha_here] = \
-                    self._run_pc_stable_single(j,
-                                               selected_links=_int_sel_links[j],
-                                               tau_min=tau_min,
-                                               tau_max=tau_max,
-                                               save_iterations=save_iterations,
-                                               pc_alpha=pc_alpha_here,
-                                               max_conds_dim=max_conds_dim,
-                                               max_combinations=max_combinations)
-                # Figure out the best score if there is more than one pc_alpha
-                # value
-                if select_optimal_alpha:
-                    score[iscore] = \
-                        self.cond_ind_test.get_model_selection_criterion(
-                            j, results[pc_alpha_here]['parents'], tau_max)
-            # Record the optimal alpha value
-            optimal_alpha = _int_pc_alpha[score.argmin()]
-            # Only print the selection results if there is more than one
-            # pc_alpha
-            if self.verbosity > 1 and select_optimal_alpha:
-                self._print_pc_sel_results(_int_pc_alpha, results, j,
-                                           score, optimal_alpha)
-            # Record the results for this variable
-            all_parents[j] = results[optimal_alpha]['parents']
-            val_min[j] = results[optimal_alpha]['val_min']
-            pval_max[j] = results[optimal_alpha]['pval_max']
-            iterations[j] = results[optimal_alpha]['iterations']
-            # Only save the optimal alpha if there is more than one pc_alpha
-            if select_optimal_alpha:
-                iterations[j]['optimal_pc_alpha'] = optimal_alpha
-        # Save the results in the current status of the algorithm
-        self.all_parents = all_parents
-        self.val_matrix = self._dict_to_matrix(val_min, tau_max, self.N, 
-                                               default=0.)
-        self.p_matrix = self._dict_to_matrix(pval_max, tau_max, self.N,
-                                            default=1.)
-        self.iterations = iterations
-        self.val_min = val_min
-        self.pval_max = pval_max
-        # Print the results
-        if self.verbosity > 0:
-            print("\n## Resulting lagged parent (super)sets:")
-            self._print_parents(all_parents, val_min, pval_max)
-        # Return the parents
-        return all_parents

-
-    def _print_parents_single(self, j, parents, val_min, pval_max):
-        """Print current parents for variable j.
-
-        Parameters
-        ----------
-        j : int
-            Index of current variable.
-        parents : list
-            List of form [(0, -1), (3, -2), ...].
-        val_min : dict
-            Dictionary of form {(0, -1):float, ...} containing the minimum test
-            statistic value of a link.
-        pval_max : dict
-            Dictionary of form {(0, -1):float, ...} containing the maximum
-            p-value of a link across different conditions.
-        """
-        if len(parents) < 20 or hasattr(self, 'iterations'):
-            print("\n    Variable %s has %d parent(s):" % (
-                self.var_names[j], len(parents)))
-            if (hasattr(self, 'iterations')
-                    and 'optimal_pc_alpha' in list(self.iterations[j])):
-                print("    [pc_alpha = %s]" % (
-                    self.iterations[j]['optimal_pc_alpha']))
-            if val_min is None or pval_max is None:
-                for p in parents:
-                    print("        (%s % .d)" % (
-                        self.var_names[p[0]], p[1]))
-            else:
-                for p in parents:
-                    print("        (%s % .d): max_pval = %.5f, min_val = % .3f" % (
-                        self.var_names[p[0]], p[1], pval_max[p],
-                        val_min[p]))
-        else:
-            print("\n    Variable %s has %d parent(s):" % (
-                self.var_names[j], len(parents)))
-
-    def _print_parents(self, all_parents, val_min, pval_max):
-        """Print current parents.
-
-        Parameters
-        ----------
-        all_parents : dictionary
-            Dictionary of form {0:[(0, -1), (3, -2), ...], 1:[], ...} containing
-            the conditioning-parents estimated with PC algorithm.
-        val_min : dict
-            Dictionary of form {0:{(0, -1):float, ...}} containing the minimum
-            test statistic value of a link.
-        pval_max : dict
-            Dictionary of form {0:{(0, -1):float, ...}} containing the maximum
-            p-value of a link across different conditions.
-        """
-        for j in [var for var in list(all_parents)]:
-            if val_min is None or pval_max is None:
-                self._print_parents_single(j, all_parents[j],
-                                           None, None)
-            else:
-                self._print_parents_single(j, all_parents[j],
-                                           val_min[j], pval_max[j])
-
-    def _mci_condition_to_string(self, conds):
-        """Convert the list of conditions into a string.
-
-        Parameters
-        ----------
-        conds : list
-            List of conditions.
-        """
-        cond_string = "[ "
-        for k, tau_k in conds:
-            cond_string += "(%s % d) " % (self.var_names[k], tau_k)
-        cond_string += "]"
-        return cond_string
-
-    def _print_mci_conditions(self, conds_y, conds_x_lagged,
-                              j, i, tau, count, n_parents):
-        """Print information about the conditions for the MCI algorithm.
-
-        Parameters
-        ----------
-        conds_y : list
-            Conditions on node.
-        conds_x_lagged : list
-            Conditions on parent.
-        j : int
-            Current node.
-        i : int
-            Parent node.
-        tau : int
-            Parent time delay.
-        count : int
-            Index of current parent.
-        n_parents : int
-            Total number of parents.
-        """
-        # Remove the current parent from the conditions
-        conds_y_no_i = [node for node in conds_y if node != (i, tau)]
-        # Get the condition string for parent
-        condy_str = self._mci_condition_to_string(conds_y_no_i)
-        # Get the condition string for node
-        condx_str = self._mci_condition_to_string(conds_x_lagged)
-        # Formate and print the information
-        indent = "\n        "
-        print_str = indent + "link (%s % d) " % (self.var_names[i], tau)
-        print_str += "--> %s (%d/%d):" % (
-            self.var_names[j], count + 1, n_parents)
-        print_str += indent + "with conds_y = %s" % (condy_str)
-        print_str += indent + "with conds_x = %s" % (condx_str)
-        print(print_str)
-
-    def _print_pcmciplus_conditions(self, lagged_parents, i, j, abstau,
-                                    max_conds_py, max_conds_px, 
-                                    max_conds_px_lagged):
-        """Print information about the conditions for PCMCIplus.
-
-        Parameters
-        ----------
-        lagged_parents : dictionary of lists
-            Dictionary of lagged parents for each node.
-        j : int
-            Current node.
-        i : int
-            Parent node.
-        abstau : int
-            Parent time delay.
-        max_conds_py : int
-            Max number of parents for node j.
-        max_conds_px : int
-            Max number of parents for lagged node i.
-        max_conds_px_lagged : int
-            Maximum number of lagged conditions of X when X is lagged in MCI 
-            tests. If None is passed, this number is equal to max_conds_px.
-        """
-        conds_y = lagged_parents[j][:max_conds_py]
-        conds_y_no_i = [node for node in conds_y if node != (i, -abstau)]
-        if abstau == 0:
-            conds_x = lagged_parents[i][:max_conds_px]
-        else:
-            if max_conds_px_lagged is None:
-                conds_x = lagged_parents[i][:max_conds_px]
-            else:
-                conds_x = lagged_parents[i][:max_conds_px_lagged]
-
-        # Shift the conditions for X by tau
-        conds_x_lagged = [(k, -abstau + k_tau) for k, k_tau in conds_x]
-        condy_str = self._mci_condition_to_string(conds_y_no_i)
-        condx_str = self._mci_condition_to_string(conds_x_lagged)
-        print_str = "    with conds_y = %s" % (condy_str)
-        print_str += "\n    with conds_x = %s" % (condx_str)
-        print(print_str)
-
-    def _get_int_parents(self, parents):
-        """Get the input parents dictionary.
-
-        Parameters
-        ----------
-        parents : dict or None
-            Dictionary of form {0:[(0, -1), (3, -2), ...], 1:[], ...}
-            specifying the conditions for each variable. If None is
-            passed, no conditions are used.
-
-        Returns
-        -------
-        int_parents : defaultdict of lists
-            Internal copy of parents, respecting default options
-        """
-        int_parents = deepcopy(parents)
-        if int_parents is None:
-            int_parents = defaultdict(list)
-        else:
-            int_parents = defaultdict(list, int_parents)
-        return int_parents
-
-    def _iter_indep_conds(self,
-                          parents,
-                          selected_links,
-                          max_conds_py,
-                          max_conds_px):
-        """Iterate through the conditions dictated by the arguments, yielding
-        the needed arguments for conditional independence functions.
-
-        Parameters
-        ----------
-        parents : dict
-            Dictionary of form {0:[(0, -1), (3, -2), ...], 1:[], ...}
-            specifying the conditions for each variable.
-        selected_links : dict
-            Dictionary of form {0:[(0, -1), (3, -2), ...], 1:[], ...}
-            specifying whether only selected links should be tested.
-        max_conds_py : int
-            Maximum number of conditions of Y to use.
-        max_conds_px : int
-            Maximum number of conditions of Z to use.
-
-        Yields
-        ------
-        i, j, tau, Z : list of tuples
-            (i, tau) is the parent node, (j, 0) is the current node, and Z is of
-            the form [(var, tau + tau')] and specifies the condition to test
-        """
-        # Loop over the selected variables
-        for j in range(self.N):
-            # Get the conditions for node j
-            conds_y = parents[j][:max_conds_py]
-            # Create a parent list from links seperated in time and by node
-            parent_list = [(i, tau) for i, tau in selected_links[j]
-                           if (i, tau) != (j, 0)]
-            # Iterate through parents (except those in conditions)
-            for cnt, (i, tau) in enumerate(parent_list):
-                # Get the conditions for node i
-                conds_x = parents[i][:max_conds_px]
-                # Shift the conditions for X by tau
-                conds_x_lagged = [(k, tau + k_tau) for k, k_tau in conds_x]
-                # Print information about the mci conditions if requested
-                if self.verbosity > 1:
-                    self._print_mci_conditions(conds_y, conds_x_lagged, j, i,
-                                               tau, cnt, len(parent_list))
-                # Construct lists of tuples for estimating
-                # I(X_t-tau; Y_t | Z^Y_t, Z^X_t-tau)
-                # with conditions for X shifted by tau
-                Z = [node for node in conds_y if node != (i, tau)]
-                # Remove overlapped nodes between conds_x_lagged and conds_y
-                Z += [node for node in conds_x_lagged if node not in Z]
-                # Yield these list
-                yield j, i, tau, Z
-
-    def _run_mci_or_variants(self,
-                             selected_links=None,
-                             tau_min=0,
-                             tau_max=1,
-                             parents=None,
-                             max_conds_py=None,
-                             max_conds_px=None,
-                             val_only=False):
-        """Base function for MCI method and variants.
-
-        Returns the matrices of test statistic values, p-values,
-        and (optionally) confidence intervals.
-
-        Parameters
-        ----------
-        selected_links : dict or None
-            Dictionary of form {0: [(3, -2), ...], 1:[], ...}
-            specifying whether only selected links should be tested. If None is
-            passed, all links are tested.
-        tau_min : int, default: 0
-            Minimum time lag to test. Note that zero-lags are undirected.
-        tau_max : int, default: 1
-            Maximum time lag. Must be larger or equal to tau_min.
-        parents : dict or None
-            Dictionary of form {0:[(0, -1), (3, -2), ...], 1:[], ...}
-            specifying the conditions for each variable. If None is
-            passed, no conditions are used.
-        max_conds_py : int or None
-            Maximum number of conditions of Y to use. If None is passed, this
-            number is unrestricted.
-        max_conds_px : int or None
-            Maximum number of conditions of Z to use. If None is passed, this
-            number is unrestricted.
-        val_only : bool, default: False
-            Option to only compute dependencies and not p-values.
-
-        Returns
-        -------
-        val_matrix : array of shape [N, N, tau_max+1]
-            Estimated matrix of test statistic values.
-        p_matrix : array of shape [N, N, tau_max+1]
-            Estimated matrix of p-values. Set to 1 if val_only=True.
-        conf_matrix : array of shape [N, N, tau_max+1,2]
-            Estimated matrix of confidence intervals of test statistic values.
-            Only computed if set in cond_ind_test, where also the percentiles
-            are set.
-        """
-        # Check the limits on tau
-        self._check_tau_limits(tau_min, tau_max)
-        # Set the selected links
-        _int_sel_links = self._set_sel_links(selected_links, tau_min, tau_max)
-
-        # Set the maximum condition dimension for Y and X
-        max_conds_py = self._set_max_condition_dim(max_conds_py,
-                                                   tau_min, tau_max)
-        max_conds_px = self._set_max_condition_dim(max_conds_px,
-                                                   tau_min, tau_max)
-        # Get the parents that will be checked
-        _int_parents = self._get_int_parents(parents)
-        # Initialize the return values
-        val_matrix = np.zeros((self.N, self.N, tau_max + 1))
-        p_matrix = np.ones((self.N, self.N, tau_max + 1))
-        # Initialize the optional return of the confidance matrix
-        conf_matrix = None
-        if self.cond_ind_test.confidence is not None:
-            conf_matrix = np.zeros((self.N, self.N, tau_max + 1, 2))
-
-        # Get the conditions as implied by the input arguments
-        for j, i, tau, Z in self._iter_indep_conds(_int_parents,
-                                                   _int_sel_links,
-                                                   max_conds_py,
-                                                   max_conds_px):
-            # Set X and Y (for clarity of code)
-            X = [(i, tau)]
-            Y = [(j, 0)]
-
-            if val_only is False:
-                # Run the independence tests and record the results
-                val, pval = self.cond_ind_test.run_test(X, Y, Z=Z,
-                                                        tau_max=tau_max,
-                                                        # verbosity=
-                                                        # self.verbosity
-                                                        )
-                val_matrix[i, j, abs(tau)] = val
-                p_matrix[i, j, abs(tau)] = pval
-            else:
-                val = self.cond_ind_test.get_measure(X, Y, Z=Z, tau_max=tau_max)
-                val_matrix[i, j, abs(tau)] = val
-
-            # Get the confidence value, returns None if cond_ind_test.confidence
-            # is False
-            conf = self.cond_ind_test.get_confidence(X, Y, Z=Z, tau_max=tau_max)
-            # Record the value if the conditional independence requires it
-            if self.cond_ind_test.confidence:
-                conf_matrix[i, j, abs(tau)] = conf
-
-        # Return the values as a dictionary and store in class
-        results = {'val_matrix': val_matrix,
-                   'p_matrix': p_matrix,
-                   'conf_matrix': conf_matrix}
-        self.results = results
-        return results
-
-
[docs]    def run_mci(self,
-                selected_links=None,
-                tau_min=0,
-                tau_max=1,
-                parents=None,
-                max_conds_py=None,
-                max_conds_px=None,
-                val_only=False):
-        """MCI conditional independence tests.
-
-        Implements the MCI test (Algorithm 2 in [1]_). Returns the matrices of
-        test statistic values,  p-values, and (optionally) confidence intervals.
-
-        Parameters
-        ----------
-        selected_links : dict or None
-            Dictionary of form {0: [(3, -2), ...], 1:[], ...}
-            specifying whether only selected links should be tested. If None is
-            passed, all links are tested.
-        tau_min : int, default: 0
-            Minimum time lag to test. Note that zero-lags are undirected.
-        tau_max : int, default: 1
-            Maximum time lag. Must be larger or equal to tau_min.
-        parents : dict or None
-            Dictionary of form {0:[(0, -1), (3, -2), ...], 1:[], ...}
-            specifying the conditions for each variable. If None is
-            passed, no conditions are used.
-        max_conds_py : int or None
-            Maximum number of conditions of Y to use. If None is passed, this
-            number is unrestricted.
-        max_conds_px : int or None
-            Maximum number of conditions of Z to use. If None is passed, this
-            number is unrestricted.
-        val_only : bool, default: False
-            Option to only compute dependencies and not p-values.
-
-        Returns
-        -------
-        val_matrix : array of shape [N, N, tau_max+1]
-            Estimated matrix of test statistic values.
-        p_matrix : array of shape [N, N, tau_max+1]
-            Estimated matrix of p-values. Set to 1 if val_only=True.
-        conf_matrix : array of shape [N, N, tau_max+1,2]
-            Estimated matrix of confidence intervals of test statistic values.
-            Only computed if set in cond_ind_test, where also the percentiles
-            are set.
-        """
-
-        if self.verbosity > 0:
-            print("\n##\n## Step 2: MCI algorithm\n##"
-                  "\n\nParameters:")
-            print("\nindependence test = %s" % self.cond_ind_test.measure
-                  + "\ntau_min = %d" % tau_min
-                  + "\ntau_max = %d" % tau_max
-                  + "\nmax_conds_py = %s" % max_conds_py
-                  + "\nmax_conds_px = %s" % max_conds_px)
-
-        return self._run_mci_or_variants(
-            selected_links=selected_links,
-            tau_min=tau_min,
-            tau_max=tau_max,
-            parents=parents,
-            max_conds_py=max_conds_py,
-            max_conds_px=max_conds_px,
-            val_only=val_only)

-
-
[docs]    def get_lagged_dependencies(self,
-                                selected_links=None,
-                                tau_min=0,
-                                tau_max=1,
-                                val_only=False):
-        """Unconditional lagged independence tests.
-
-        Implements the unconditional lagged independence test (see [ 1]_).
-        Returns the matrices of test statistic values,  p-values,
-        and confidence intervals.
-
-        Parameters
-        ----------
-        selected_links : dict or None
-            Dictionary of form {0: [(3, -2), ...], 1:[], ...}
-            specifying whether only selected links should be tested. If None is
-            passed, all links are tested.
-        tau_min : int, default: 0
-            Minimum time lag to test. Note that zero-lags are undirected.
-        tau_max : int, default: 1
-            Maximum time lag. Must be larger or equal to tau_min.
-        val_only : bool, default: False
-            Option to only compute dependencies and not p-values.
-
-        Returns
-        -------
-        val_matrix : array of shape [N, N, tau_max+1]
-            Estimated matrix of test statistic values.
-        p_matrix : array of shape [N, N, tau_max+1]
-            Estimated matrix of p-values. Set to 1 if val_only=True.
-        conf_matrix : array of shape [N, N, tau_max+1,2]
-            Estimated matrix of confidence intervals of test statistic values.
-            Only computed if set in cond_ind_test, where also the percentiles
-            are set.
-        """
-
-        if self.verbosity > 0:
-            print("\n##\n## Estimating lagged dependencies \n##"
-                  "\n\nParameters:")
-            print("\nindependence test = %s" % self.cond_ind_test.measure
-                  + "\ntau_min = %d" % tau_min
-                  + "\ntau_max = %d" % tau_max)
-
-        return self._run_mci_or_variants(
-            selected_links=selected_links,
-            tau_min=tau_min,
-            tau_max=tau_max,
-            parents=None,
-            max_conds_py=0,
-            max_conds_px=0,
-            val_only=val_only)

-
-
[docs]    def run_fullci(self,
-                   selected_links=None,
-                   tau_min=0,
-                   tau_max=1,
-                   val_only=False):
-        """FullCI conditional independence tests.
-
-        Implements the FullCI test (see [1]_). Returns the matrices of
-        test statistic values,  p-values, and confidence intervals.
-
-        Parameters
-        ----------
-        selected_links : dict or None
-            Dictionary of form {0: [(3, -2), ...], 1:[], ...}
-            specifying whether only selected links should be tested. If None is
-            passed, all links are tested.
-        tau_min : int, default: 0
-            Minimum time lag to test. Note that zero-lags are undirected.
-        tau_max : int, default: 1
-            Maximum time lag. Must be larger or equal to tau_min.
-        val_only : bool, default: False
-            Option to only compute dependencies and not p-values.
-
-        Returns
-        -------
-        val_matrix : array of shape [N, N, tau_max+1]
-            Estimated matrix of test statistic values.
-        p_matrix : array of shape [N, N, tau_max+1]
-            Estimated matrix of p-values. Set to 1 if val_only=True.
-        conf_matrix : array of shape [N, N, tau_max+1,2]
-            Estimated matrix of confidence intervals of test statistic values.
-            Only computed if set in cond_ind_test, where also the percentiles
-            are set.
-        """
-
-        if self.verbosity > 0:
-            print("\n##\n## Running Tigramite FullCI algorithm\n##"
-                  "\n\nParameters:")
-            print("\nindependence test = %s" % self.cond_ind_test.measure
-                  + "\ntau_min = %d" % tau_min
-                  + "\ntau_max = %d" % tau_max)
-
-        full_past = dict([(j, [(i, -tau)
-                               for i in range(self.N)
-                               for tau in range(max(1, tau_min), tau_max + 1)])
-                          for j in range(self.N)])
-
-        return self._run_mci_or_variants(
-            selected_links=selected_links,
-            tau_min=tau_min,
-            tau_max=tau_max,
-            parents=full_past,
-            max_conds_py=None,
-            max_conds_px=0,
-            val_only=val_only)

-
-
[docs]    def run_bivci(self,
-                  selected_links=None,
-                  tau_min=0,
-                  tau_max=1,
-                  val_only=False):
-        """BivCI conditional independence tests.
-
-        Implements the BivCI test (see [1]_). Returns the matrices of
-        test statistic values,  p-values, and confidence intervals.
-
-        Parameters
-        ----------
-        selected_links : dict or None
-            Dictionary of form {0: [(3, -2), ...], 1:[], ...}
-            specifying whether only selected links should be tested. If None is
-            passed, all links are tested.
-        tau_min : int, default: 0
-            Minimum time lag to test. Note that zero-lags are undirected.
-        tau_max : int, default: 1
-            Maximum time lag. Must be larger or equal to tau_min.
-        val_only : bool, default: False
-            Option to only compute dependencies and not p-values.
-
-        Returns
-        -------
-        val_matrix : array of shape [N, N, tau_max+1]
-            Estimated matrix of test statistic values.
-        p_matrix : array of shape [N, N, tau_max+1]
-            Estimated matrix of p-values. Set to 1 if val_only=True.
-        conf_matrix : array of shape [N, N, tau_max+1,2]
-            Estimated matrix of confidence intervals of test statistic values.
-            Only computed if set in cond_ind_test, where also the percentiles
-            are set.
-        """
-
-        if self.verbosity > 0:
-            print("\n##\n## Running Tigramite BivCI algorithm\n##"
-                  "\n\nParameters:")
-            print("\nindependence test = %s" % self.cond_ind_test.measure
-                  + "\ntau_min = %d" % tau_min
-                  + "\ntau_max = %d" % tau_max)
-
-        auto_past = dict([(j, [(j, -tau)
-                               for tau in range(max(1, tau_min), tau_max + 1)])
-                          for j in range(self.N)])
-
-        return self._run_mci_or_variants(
-            selected_links=selected_links,
-            tau_min=tau_min,
-            tau_max=tau_max,
-            parents=auto_past,
-            max_conds_py=None,
-            max_conds_px=0,
-            val_only=val_only)

-
-
[docs]    def get_corrected_pvalues(self, p_matrix,
-                              fdr_method='fdr_bh',
-                              exclude_contemporaneous=True):
-        """Returns p-values corrected for multiple testing.
-
-        Currently implemented is Benjamini-Hochberg False Discovery Rate
-        method. Correction is performed either among all links if
-        exclude_contemporaneous==False, or only among lagged links.
-
-        Parameters
-        ----------
-        p_matrix : array-like
-            Matrix of p-values. Must be of shape (N, N, tau_max + 1).
-        fdr_method : str, optional (default: 'fdr_bh')
-            Correction method, currently implemented is Benjamini-Hochberg
-            False Discovery Rate method.     
-        exclude_contemporaneous : bool, optional (default: True)
-            Whether to include contemporaneous links in correction.
-
-        Returns
-        -------
-        q_matrix : array-like
-            Matrix of shape (N, N, tau_max + 1) containing corrected p-values.
-        """
-
-        def _ecdf(x):
-            """No frills empirical cdf used in fdr correction.
-            """
-            nobs = len(x)
-            return np.arange(1, nobs + 1) / float(nobs)
-
-        # Get the shape paramters from the p_matrix
-        _, N, tau_max_plusone = p_matrix.shape
-        # Create a mask for these values
-        mask = np.ones((N, N, tau_max_plusone), dtype='bool')
-        # Ignore values from autocorrelation indices
-        mask[range(N), range(N), 0] = False
-        # Exclude all contemporaneous values if requested
-        if exclude_contemporaneous:
-            mask[:, :, 0] = False
-        # Create the return value
-        q_matrix = np.array(p_matrix)
-        # Use the multiple tests function
-        if fdr_method is None or fdr_method == 'none':
-            pass
-        elif fdr_method == 'fdr_bh':
-            pvs = p_matrix[mask]
-            pvals_sortind = np.argsort(pvs)
-            pvals_sorted = np.take(pvs, pvals_sortind)
-
-            ecdffactor = _ecdf(pvals_sorted)
-
-            pvals_corrected_raw = pvals_sorted / ecdffactor
-            pvals_corrected = np.minimum.accumulate(
-                pvals_corrected_raw[::-1])[::-1]
-            del pvals_corrected_raw
-
-            pvals_corrected[pvals_corrected > 1] = 1
-            pvals_corrected_ = np.empty_like(pvals_corrected)
-            pvals_corrected_[pvals_sortind] = pvals_corrected
-            del pvals_corrected
-
-            q_matrix[mask] = pvals_corrected_
-
-        else:
-            raise ValueError('Only FDR method fdr_bh implemented')
-
-        # Return the new matrix
-        return q_matrix

-
-
[docs]    def return_significant_parents(self,
-                                 pq_matrix,
-                                 val_matrix,
-                                 alpha_level=0.05,
-                                 include_lagzero_parents=False):
-        """DEPRECATED: use return_significant_links() instead.
-
-        Parameters
-        ----------
-        pq_matrix : array-like
-            p-matrix, or q-value matrix with corrected p-values. Must be of
-            shape (N, N, tau_max + 1).
-        val_matrix : array-like
-            Matrix of test statistic values. Must be of shape (N, N, tau_max +
-            1).
-        alpha_level : float, optional (default: 0.05)
-            Significance level.
-        include_lagzero_parents : bool (default: False)
-            Whether the dictionary should also return parents at lag
-            zero. Note that the link_matrix always contains those.
-
-        Returns
-        -------
-        link_dict : dict
-            Dictionary of form {0:[(0, -1), (3, -2), ...], 1:[], ...}
-            containing estimated links.
-        link_dict : array, shape [N, N, tau_max+1]
-            Boolean array with True entries for significant links at alpha_level
-        """
-        warnings.warn("return_significant_parents is DEPRECATED: use "
-              "return_significant_links() instead and check updated key names.")
-
-        siglinks = self.return_significant_links(pq_matrix=pq_matrix,
-                                 val_matrix=val_matrix,
-                                 alpha_level=alpha_level,
-                                 include_lagzero_links=include_lagzero_parents)
-        siglinks['parents'] = siglinks.pop('link_dict')
-        return siglinks

-
-
-
-
-
-
[docs]    def print_results(self,
-                      return_dict,
-                      alpha_level=0.05):
-        """Prints significant parents from output of MCI or PCMCI algorithms.
-
-        Parameters
-        ----------
-        return_dict : dict
-            Dictionary of return values, containing keys
-                * 'p_matrix'
-                * 'val_matrix'
-                * 'conf_matrix'
-                * 'q_matrix' can also be included in keys, but is not necessary.
-
-        alpha_level : float, optional (default: 0.05)
-            Significance level.
-        """
-        # Check if q_matrix is defined.  It is returned for PCMCI but not for
-        # MCI
-        q_matrix = None
-        q_key = 'q_matrix'
-        if q_key in return_dict:
-            q_matrix = return_dict[q_key]
-        # Check if conf_matrix is defined
-        conf_matrix = None
-        conf_key = 'conf_matrix'
-        if conf_key in return_dict:
-            conf_matrix = return_dict[conf_key]
-        # Wrap the already defined function
-        if 'graph' in return_dict:
-            graph = return_dict['graph']
-        else:
-            graph = None
-        if 'ambiguous_triples' in return_dict:
-            ambiguous_triples = return_dict['ambiguous_triples']
-        else:
-            ambiguous_triples = None
-        self.print_significant_links(return_dict['p_matrix'],
-                                     return_dict['val_matrix'],
-                                     conf_matrix=conf_matrix,
-                                     q_matrix=q_matrix,
-                                     graph=graph,
-                                     ambiguous_triples=ambiguous_triples,
-                                     alpha_level=alpha_level)

-
-
[docs]    def run_pcmci(self,
-                  selected_links=None,
-                  tau_min=0,
-                  tau_max=1,
-                  save_iterations=False,
-                  pc_alpha=0.05,
-                  max_conds_dim=None,
-                  max_combinations=1,
-                  max_conds_py=None,
-                  max_conds_px=None,
-                  fdr_method='none'):
-        """Runs PCMCI time-lagged causal discovery for time series.
-
-        Wrapper around PC-algorithm function and MCI function.
-
-        Notes
-        -----
-
-        The PCMCI causal discovery method is comprehensively described in [
-        1]_, where also analytical and numerical results are presented. Here
-        we briefly summarize the method.
-
-        PCMCI estimates time-lagged causal links by a two-step procedure:
-
-        1.  Condition-selection: For each variable :math:`j`, estimate a
-            *superset* of parents :math:`\\tilde{\mathcal{P}}(X^j_t)` with the
-            iterative PC1 algorithm, implemented as ``run_pc_stable``. The
-            condition-selection step reduces the dimensionality and avoids
-            conditioning on irrelevant variables.
-
-        2.  *Momentary conditional independence* (MCI)
-
-        .. math:: X^i_{t-\\tau} \perp X^j_{t} | \\tilde{\\mathcal{P}}(
-                  X^j_t), \\tilde{\mathcal{P}}(X^i_{t-\\tau})
-
-        here implemented as ``run_mci``. This step estimates the p-values and
-        test statistic values for all links accounting for common drivers,
-        indirect links, and autocorrelation.
-
-        PCMCI can be flexibly combined with any kind of conditional
-        independence test statistic adapted to the kind of data (continuous
-        or discrete) and its assumed dependency types. These are available in
-        ``tigramite.independence_tests``.
-
-        The main free parameters of PCMCI (in addition to free parameters of
-        the conditional independence test statistic) are the maximum time
-        delay :math:`\\tau_{\\max}` (``tau_max``) and the significance
-        threshold in the condition-selection step :math:`\\alpha` (
-        ``pc_alpha``). The maximum time delay depends on the application and
-        should be chosen according to the maximum causal time lag expected in
-        the complex system. We recommend a rather large choice that includes
-        peaks in the ``get_lagged_dependencies`` function. :math:`\\alpha`
-        should not be seen as a significance test level in the
-        condition-selection step since the iterative hypothesis tests do not
-        allow for a precise assessment. :math:`\\alpha` rather takes the role
-        of a regularization parameter in model-selection techniques. If a
-        list of values is given or ``pc_alpha=None``, :math:`\\alpha` is
-        optimized using model selection criteria implemented in the respective
-        ``tigramite.independence_tests``.
-
-        Further optional parameters are discussed in [1]_.
-
-        Examples
-        --------
-        >>> import numpy
-        >>> from tigramite.pcmci import PCMCI
-        >>> from tigramite.independence_tests import ParCorr
-        >>> import tigramite.data_processing as pp
-        >>> numpy.random.seed(7)
-        >>> # Example process to play around with
-        >>> # Each key refers to a variable and the incoming links are supplied
-        >>> # as a list of format [((driver, -lag), coeff), ...]
-        >>> links_coeffs = {0: [((0, -1), 0.8)],
-                            1: [((1, -1), 0.8), ((0, -1), 0.5)],
-                            2: [((2, -1), 0.8), ((1, -2), -0.6)]}
-        >>> data, _ = pp.var_process(links_coeffs, T=1000)
-        >>> # Data must be array of shape (time, variables)
-        >>> print (data.shape)
-        (1000, 3)
-        >>> dataframe = pp.DataFrame(data)
-        >>> cond_ind_test = ParCorr()
-        >>> pcmci = PCMCI(dataframe=dataframe, cond_ind_test=cond_ind_test)
-        >>> results = pcmci.run_pcmci(tau_max=2, pc_alpha=None)
-        >>> pcmci.print_significant_links(p_matrix=results['p_matrix'],
-                                             val_matrix=results['val_matrix'],
-                                             alpha_level=0.05)
-        ## Significant parents at alpha = 0.05:
-
-            Variable 0 has 1 link(s):
-                (0 -1): pval = 0.00000 | val =  0.588
-
-            Variable 1 has 2 link(s):
-                (1 -1): pval = 0.00000 | val =  0.606
-                (0 -1): pval = 0.00000 | val =  0.447
-
-            Variable 2 has 2 link(s):
-                (2 -1): pval = 0.00000 | val =  0.618
-                (1 -2): pval = 0.00000 | val = -0.499
-
-
-        Parameters
-        ----------
-        selected_links : dict or None
-            Dictionary of form {0: [(3, -2), ...], 1:[], ...}
-            specifying whether only selected links should be tested. If None is
-            passed, all links are tested.
-        tau_min : int, optional (default: 0)
-            Minimum time lag to test. Note that zero-lags are undirected.
-        tau_max : int, optional (default: 1)
-            Maximum time lag. Must be larger or equal to tau_min.
-        save_iterations : bool, optional (default: False)
-            Whether to save iteration step results such as conditions used.
-        pc_alpha : float, optional (default: 0.05)
-            Significance level in algorithm.
-        max_conds_dim : int, optional (default: None)
-            Maximum number of conditions to test. If None is passed, this number
-            is unrestricted.
-        max_combinations : int, optional (default: 1)
-            Maximum number of combinations of conditions of current cardinality
-            to test. Defaults to 1 for PC_1 algorithm. For original PC algorithm
-            a larger number, such as 10, can be used.
-        max_conds_py : int, optional (default: None)
-            Maximum number of conditions of Y to use. If None is passed, this
-            number is unrestricted.
-        max_conds_px : int, optional (default: None)
-            Maximum number of conditions of Z to use. If None is passed, this
-            number is unrestricted.
-        fdr_method : str, optional (default: 'none')
-            Correction method, default is Benjamini-Hochberg False Discovery
-            Rate method.
-
-        Returns
-        -------
-        val_matrix : array of shape [N, N, tau_max+1]
-            Estimated matrix of test statistic values.
-        p_matrix : array of shape [N, N, tau_max+1]
-            Estimated matrix of p-values. Set to 1 if val_only=True.
-        conf_matrix : array of shape [N, N, tau_max+1,2]
-            Estimated matrix of confidence intervals of test statistic values.
-            Only computed if set in cond_ind_test, where also the percentiles
-            are set.
-
-        """
-
-        # Get the parents from run_pc_stable
-        all_parents = self.run_pc_stable(selected_links=selected_links,
-                                         tau_min=tau_min,
-                                         tau_max=tau_max,
-                                         save_iterations=save_iterations,
-                                         pc_alpha=pc_alpha,
-                                         max_conds_dim=max_conds_dim,
-                                         max_combinations=max_combinations)
-        # Get the results from run_mci, using the parents as the input
-        results = self.run_mci(selected_links=selected_links,
-                               tau_min=tau_min,
-                               tau_max=tau_max,
-                               parents=all_parents,
-                               max_conds_py=max_conds_py,
-                               max_conds_px=max_conds_px)
-        # Get the values and p-values
-        val_matrix = results['val_matrix']
-        p_matrix = results['p_matrix']
-        # Initialize and fill the the confidance matrix if the confidance test
-        # says it should be returned
-
-        conf_matrix = None
-        if self.cond_ind_test.confidence is not None:
-            conf_matrix = results['conf_matrix']
-        # Initialize and fill the q_matrix if there is a fdr_method
-        q_matrix = None
-        if fdr_method != 'none':
-            q_matrix = self.get_corrected_pvalues(p_matrix,
-                                                  fdr_method=fdr_method)
-        # Store the parents in the pcmci member
-        self.all_parents = all_parents
-        # Cache the resulting values in the return dictionary
-        return_dict = {'val_matrix': val_matrix,
-                       'p_matrix': p_matrix,
-                       'q_matrix': q_matrix,
-                       'conf_matrix': conf_matrix}
-        # Print the information
-        if self.verbosity > 0:
-            self.print_results(return_dict)
-        # Return the dictionary
-        self.results = return_dict
-        return return_dict

-
-
[docs]    def run_pcmciplus(self,
-                      selected_links=None,
-                      tau_min=0,
-                      tau_max=1,
-                      pc_alpha=0.01,
-                      contemp_collider_rule='majority',
-                      conflict_resolution=True,
-                      reset_lagged_links=False,
-                      max_conds_dim=None,
-                      max_conds_py=None,
-                      max_conds_px=None,
-                      max_conds_px_lagged=None,
-                      fdr_method='none',
-                      ):
-        """Runs PCMCIplus time-lagged and contemporaneous causal discovery for
-        time series.
-
-        Method described in [5]_: 
-        http://www.auai.org/~w-auai/uai2020/proceedings/579_main_paper.pdf
-
-        Notes
-        -----
-
-        The PCMCIplus causal discovery method is described in [5]_, where
-        also analytical and numerical results are presented. In contrast to
-        PCMCI, PCMCIplus can identify the full, lagged and contemporaneous,
-        causal graph (up to the Markov equivalence class for contemporaneous
-        links) under the standard assumptions of Causal Sufficiency,
-        Faithfulness and the Markov condition.
-
-        PCMCIplus estimates time-lagged and contemporaneous causal links by a
-        four-step procedure:
-
-        1.  Condition-selection (same as for PCMCI): For each variable
-        :math:`j`, estimate a *superset* of lagged parents :math:`\\widehat{
-        \\mathcal{B}}_t^-( X^j_t)` with the iterative PC1 algorithm,
-        implemented as ``run_pc_stable``. The condition-selection step
-        reduces the dimensionality and avoids conditioning on irrelevant
-        variables.
-
-        2.   PC skeleton phase with contemporaneous conditions and *Momentary
-        conditional independence* (MCI) tests: Iterate through subsets
-        :math:`\\mathcal{S}` of contemporaneous adjacencies and conduct MCI
-        conditional independence tests:
-
-        .. math:: X^i_{t-\\tau} ~\\perp~ X^j_{t} ~|~ \\mathcal{S},
-                  \\widehat{\\mathcal{B}}_t^-(X^j_t),
-                  \\widehat{\\mathcal{B}}_{t-\\tau}^-(X^i_{t-{\\tau}})
-
-        here implemented as ``run_pcalg``. This step estimates the p-values and
-        test statistic values for all lagged and contemporaneous adjacencies
-        accounting for common drivers, indirect links, and autocorrelation.
-
-        3.   PC collider orientation phase: Orient contemporaneous collider
-        motifs based on unshielded triples. Optionally apply conservative or
-        majority rule (also based on MCI tests).
-
-        4.   PC rule orientation phase: Orient remaining contemporaneous
-        links based on PC rules.
-
-        In contrast to PCMCI, the relevant output of PCMCIplus is the
-        array ``graph``. Its string entries are interpreted as follows:
-
-        * ``graph[i,j,tau]=-->`` for :math:`\\tau>0` denotes a directed, lagged
-          causal link from :math:`i` to :math:`j` at lag :math:`\\tau`
-
-        * ``graph[i,j,0]=-->`` (and ``graph[j,i,0]=<--``) denotes a directed,
-          contemporaneous causal link from :math:`i` to :math:`j`
-
-        * ``graph[i,j,0]=o-o`` (and ``graph[j,i,0]=o-o``) denotes an unoriented,
-          contemporaneous adjacency between :math:`i` and :math:`j` indicating
-          that the collider and orientation rules could not be applied (Markov
-          equivalence)
-
-        * ``graph[i,j,0]=x-x`` and (``graph[j,i,0]=x-x``) denotes a conflicting,
-          contemporaneous adjacency between :math:`i` and :math:`j` indicating
-          that the directionality is undecided due to conflicting orientation
-          rules
-
-        Importantly, ``p_matrix`` and ``val_matrix`` for PCMCIplus quantify
-        the uncertainty and strength, respectively, only for the
-        adjacencies, but not for the directionality of contemporaneous links.
-        Note that lagged links are always oriented due to time order.
-
-        PCMCIplus can be flexibly combined with any kind of conditional
-        independence test statistic adapted to the kind of data (continuous
-        or discrete) and its assumed dependency types. These are available in
-        ``tigramite.independence_tests``.
-
-        The main free parameters of PCMCIplus (in addition to free parameters of
-        the conditional independence tests) are the maximum time delay
-        :math:`\\tau_{\\max}` (``tau_max``) and the significance threshold
-        :math:`\\alpha` ( ``pc_alpha``). 
-
-        If a list or None is passed for ``pc_alpha``, the significance level is
-        optimized for every graph across the given ``pc_alpha`` values using the
-        score computed in ``cond_ind_test.get_model_selection_criterion()``.
-        Since PCMCIplus outputs not a DAG, but an equivalence class of DAGs,
-        first one member of this class is computed and then the score is
-        computed as the average over all models fits for each variable in ``[0,
-        ..., N]`` for that member. The score is the same for all members of the
-        class.
-
-        The maximum time delay depends on the application and should be chosen
-        according to the maximum causal time lag expected in the complex system.
-        We recommend a rather large choice that includes peaks in the
-        ``get_lagged_dependencies`` function. Another important parameter is
-        ``contemp_collider_rule``. Only if set to ``majority`` or
-        ``conservative'' and together with ``conflict_resolution=True``,
-        PCMCIplus is fully *order independent* meaning that the order of the N
-        variables in the dataframe does not matter. Last, the default option
-        ``reset_lagged_links=False`` restricts the detection of lagged causal
-        links in Step 2 to the significant adjacencies found in Step 1, given by
-        :math:`\\widehat{ \\mathcal{B}}_t^-( X^j_t)`. For
-        ``reset_lagged_links=True``, *all* lagged links are considered again,
-        which improves detection power for lagged links, but also leads to
-        larger runtimes.
-
-        Further optional parameters are discussed in [5]_.
-
-        Examples
-        --------
-        >>> import numpy as np
-        >>> from tigramite.pcmci import PCMCI
-        >>> from tigramite.independence_tests import ParCorr
-        >>> import tigramite.data_processing as pp
-        >>> # Example process to play around with
-        >>> # Each key refers to a variable and the incoming links are supplied
-        >>> # as a list of format [((var, -lag), coeff, function), ...]
-        >>> def lin_f(x): return x
-        >>> links = {0: [((0, -1), 0.9, lin_f)],
-                     1: [((1, -1), 0.8, lin_f), ((0, -1), 0.8, lin_f)],
-                     2: [((2, -1), 0.7, lin_f), ((1, 0), 0.6, lin_f)],
-                     3: [((3, -1), 0.7, lin_f), ((2, 0), -0.5, lin_f)],
-                     }
-        >>> data, nonstat = pp.structural_causal_process(links,
-                            T=1000, seed=7)
-        >>> # Data must be array of shape (time, variables)
-        >>> print (data.shape)
-        (1000, 4)
-        >>> dataframe = pp.DataFrame(data)
-        >>> cond_ind_test = ParCorr()
-        >>> pcmci = PCMCI(dataframe=dataframe, cond_ind_test=cond_ind_test)
-        >>> results = pcmci.run_pcmciplus(tau_min=0, tau_max=2, pc_alpha=0.01)
-        >>> pcmci.print_results(results, alpha_level=0.01)
-            ## Significant links at alpha = 0.01:
-
-            Variable 0 has 1 link(s):
-                (0 -1): pval = 0.00000 | val =  0.676
-
-            Variable 1 has 2 link(s):
-                (1 -1): pval = 0.00000 | val =  0.602
-                (0 -1): pval = 0.00000 | val =  0.599
-
-            Variable 2 has 2 link(s):
-                (1  0): pval = 0.00000 | val =  0.486
-                (2 -1): pval = 0.00000 | val =  0.466
-
-            Variable 3 has 2 link(s):
-                (3 -1): pval = 0.00000 | val =  0.524
-                (2  0): pval = 0.00000 | val = -0.449 
-
-        Parameters
-        ----------
-        selected_links : dict or None
-            Dictionary of form {0: [(3, 0), (0, -1), ...], 1:[], ...}
-            specifying whether only selected links should be tested. If None is
-            passed, all links are tested.
-        tau_min : int, optional (default: 0)
-            Minimum time lag to test.
-        tau_max : int, optional (default: 1)
-            Maximum time lag. Must be larger or equal to tau_min.
-        pc_alpha : float or list of floats, default: 0.01
-            Significance level in algorithm. If a list or None is passed, the
-            pc_alpha level is optimized for every graph across the given
-            pc_alpha values ([0.001, 0.005, 0.01, 0.025, 0.05] for None) using
-            the score computed in cond_ind_test.get_model_selection_criterion().
-        contemp_collider_rule : {'majority', 'conservative', 'none'}
-            Rule for collider phase to use. See the paper for details. Only
-            'majority' and 'conservative' lead to an order-independent
-            algorithm.
-        conflict_resolution : bool, optional (default: True)
-            Whether to mark conflicts in orientation rules. Only for True
-            this leads to an order-independent algorithm.
-        reset_lagged_links : bool, optional (default: False)
-            Restricts the detection of lagged causal links in Step 2 to the
-            significant adjacencies found in the PC1 algorithm in Step 1. For
-            True, *all* lagged links are considered again, which improves
-            detection power for lagged links, but also leads to larger
-            runtimes.
-        max_conds_dim : int, optional (default: None)
-            Maximum number of conditions to test. If None is passed, this number
-            is unrestricted.
-        max_conds_py : int, optional (default: None)
-            Maximum number of lagged conditions of Y to use in MCI tests. If
-            None is passed, this number is unrestricted.
-        max_conds_px : int, optional (default: None)
-            Maximum number of lagged conditions of X to use in MCI tests. If
-            None is passed, this number is unrestricted.
-        max_conds_px_lagged : int, optional (default: None)
-            Maximum number of lagged conditions of X when X is lagged in MCI 
-            tests. If None is passed, this number is equal to max_conds_px.
-        fdr_method : str, optional (default: 'none')
-            Correction method, default is Benjamini-Hochberg False Discovery
-            Rate method.
-
-        Returns
-        -------
-        graph : array of shape [N, N, tau_max+1]
-            Resulting causal graph, see description above for interpretation.
-        val_matrix : array of shape [N, N, tau_max+1]
-            Estimated matrix of test statistic values regarding adjacencies.
-        p_matrix : array of shape [N, N, tau_max+1]
-            Estimated matrix of p-values regarding adjacencies.
-        sepset : dictionary
-            Separating sets. See paper for details.
-        ambiguous_triples : list
-            List of ambiguous triples, only relevant for 'majority' and
-            'conservative' rules, see paper for details.
-        """
-
-        # Check if pc_alpha is chosen to optimze over a list
-        if pc_alpha is None or isinstance(pc_alpha, (list, tuple, np.ndarray)):
-            # Call optimizer wrapper around run_pcmciplus()
-            return self._optimize_pcmciplus_alpha(
-                                    selected_links=selected_links,
-                                    tau_min=tau_min,
-                                    tau_max=tau_max,
-                                    pc_alpha=pc_alpha,
-                                    contemp_collider_rule=contemp_collider_rule,
-                                    conflict_resolution=conflict_resolution,
-                                    reset_lagged_links=reset_lagged_links,
-                                    max_conds_dim=max_conds_dim,
-                                    max_conds_py=max_conds_py,
-                                    max_conds_px=max_conds_px,
-                                    max_conds_px_lagged=max_conds_px_lagged,
-                                    fdr_method=fdr_method)
-
-        # else:
-        #     raise ValueError("pc_alpha=None not supported in PCMCIplus, choose"
-        #                      " 0 < pc_alpha < 1 (e.g., 0.01)")
-
-        # For the lagged PC algorithm only the strongest conditions are tested
-        max_combinations = 1
-
-        # Check the limits on tau
-        self._check_tau_limits(tau_min, tau_max)
-        # Set the selected links
-        _int_sel_links = self._set_sel_links(selected_links, tau_min, tau_max)
-
-        # Step 1: Get a superset of lagged parents from run_pc_stable
-        lagged_parents = self.run_pc_stable(selected_links=selected_links,
-                                            tau_min=tau_min,
-                                            tau_max=tau_max,
-                                            pc_alpha=pc_alpha,
-                                            max_conds_dim=max_conds_dim,
-                                            max_combinations=max_combinations)
-
-        p_matrix = self.p_matrix
-        val_matrix = self.val_matrix
-
-        # Step 2+3+4: PC algorithm with contemp. conditions and MCI tests
-        if self.verbosity > 0:
-            print("\n##\n## Step 2: PC algorithm with contemp. conditions "
-                  "and MCI tests\n##"
-                  "\n\nParameters:")
-            if selected_links is not None:
-                print("\nselected_links = %s" % _int_sel_links)
-            print("\nindependence test = %s" % self.cond_ind_test.measure
-                  + "\ntau_min = %d" % tau_min
-                  + "\ntau_max = %d" % tau_max
-                  + "\npc_alpha = %s" % pc_alpha
-                  + "\ncontemp_collider_rule = %s" % contemp_collider_rule
-                  + "\nconflict_resolution = %s" % conflict_resolution
-                  + "\nreset_lagged_links = %s" % reset_lagged_links
-                  + "\nmax_conds_dim = %s" % max_conds_dim
-                  + "\nmax_conds_py = %s" % max_conds_py
-                  + "\nmax_conds_px = %s" % max_conds_px
-                  + "\nmax_conds_px_lagged = %s" % max_conds_px_lagged
-                  + "\nfdr_method = %s" % fdr_method
-                  )
-
-        # Set the maximum condition dimension for Y and X
-        max_conds_py = self._set_max_condition_dim(max_conds_py,
-                                                   tau_min, tau_max)
-        max_conds_px = self._set_max_condition_dim(max_conds_px,
-                                                   tau_min, tau_max)
-
-        if reset_lagged_links:
-            # Run PCalg on full graph, ignoring that some lagged links
-            # were determined as non-significant in PC1 step
-            links_for_pc = deepcopy(_int_sel_links)
-        else:
-            # Run PCalg only on lagged parents found with PC1 
-            # plus all contemporaneous links
-            links_for_pc = deepcopy(lagged_parents)
-            for j in range(self.N):
-                for link in _int_sel_links[j]:
-                    i, tau = link
-                    if abs(tau) == 0:
-                        links_for_pc[j].append((i, 0))
-
-        results = self.run_pcalg(
-            selected_links=links_for_pc,
-            pc_alpha=pc_alpha,
-            tau_min=tau_min,
-            tau_max=tau_max,
-            max_conds_dim=max_conds_dim,
-            max_combinations=None,
-            lagged_parents=lagged_parents,
-            max_conds_py=max_conds_py,
-            max_conds_px=max_conds_px,
-            max_conds_px_lagged=max_conds_px_lagged,
-            mode='contemp_conds',
-            contemp_collider_rule=contemp_collider_rule,
-            conflict_resolution=conflict_resolution)
-
-        graph = results['graph']
-
-        # Update p_matrix and val_matrix with values from links_for_pc
-        for j in range(self.N):
-            for link in links_for_pc[j]:
-                i, tau = link
-                p_matrix[i, j, abs(tau)] = results['p_matrix'][i, j, abs(tau)]
-                val_matrix[i, j, abs(tau)] = results['val_matrix'][i, j, 
-                                                                   abs(tau)]
-
-        ambiguous = results['ambiguous_triples']
-
-        conf_matrix = None
-        # TODO: implement confidence estimation, but how?
-        # if self.cond_ind_test.confidence is not False:
-        #     conf_matrix = results['conf_matrix']
-
-        # Initialize and fill the q_matrix if there is a fdr_method
-        q_matrix = None
-        if fdr_method != 'none':
-            q_matrix = self.get_corrected_pvalues(p_matrix,
-                                                  fdr_method=fdr_method,
-                                                  exclude_contemporaneous=False)
-        # Store the parents in the pcmci member
-        self.all_parents = lagged_parents
-
-        # Cache the resulting values in the return dictionary
-        return_dict = {'graph': graph,
-                       'val_matrix': val_matrix,
-                       'p_matrix': p_matrix,
-                       'q_matrix': q_matrix,
-                       'ambiguous_triples': ambiguous,
-                       'conf_matrix': conf_matrix}
-        # Print the results
-        if self.verbosity > 0:
-            self.print_results(return_dict, alpha_level=pc_alpha)
-        # Return the dictionary
-        self.results = return_dict
-        return return_dict

-
-
[docs]    def run_pcalg(self, selected_links=None, pc_alpha=0.01, tau_min=0,
-                  tau_max=1, max_conds_dim=None, max_combinations=None,
-                  lagged_parents=None, max_conds_py=None, max_conds_px=None,
-                  max_conds_px_lagged=None,
-                  mode='standard', contemp_collider_rule='majority',
-                  conflict_resolution=True):
-
-        """Runs PC algorithm for time-lagged and contemporaneous causal
-        discovery for time series.
-
-        For ``mode='contemp_conds'`` this implements Steps 2-4 of the
-        PCMCIplus method described in [5]_. For ``mode='standard'`` this
-        implements the standard PC algorithm adapted to time series.
-
-        Parameters
-        ----------
-        selected_links : dict or None
-            Dictionary of form {0: [(3, 0), (0, -1), ...], 1:[], ...}
-            specifying whether only selected links should be tested. If None is
-            passed, all links are tested.
-        lagged_parents : dictionary
-            Dictionary of form {0:[(0, -1), (3, -2), ...], 1:[], ...} containing
-            additional conditions for each CI test. As part of PCMCIplus
-            these are the superset of lagged parents estimated with the PC1
-            algorithm.
-        mode : {'standard', 'contemp_conds'}
-            For ``mode='contemp_conds'`` this implements Steps 2-4 of the
-            PCMCIplus method. For ``mode='standard'`` this implements the
-            standard PC algorithm adapted to time series.
-        tau_min : int, optional (default: 0)
-            Minimum time lag to test.
-        tau_max : int, optional (default: 1)
-            Maximum time lag. Must be larger or equal to tau_min.
-        pc_alpha : float, optional (default: 0.01)
-            Significance level.
-        contemp_collider_rule : {'majority', 'conservative', 'none'}
-            Rule for collider phase to use. See the paper for details. Only
-            'majority' and 'conservative' lead to an order-independent
-            algorithm.
-        conflict_resolution : bool, optional (default: True)
-            Whether to mark conflicts in orientation rules. Only for True
-            this leads to an order-independent algorithm.
-        max_conds_dim : int, optional (default: None)
-            Maximum number of conditions to test. If None is passed, this number
-            is unrestricted.
-        max_combinations : int
-            Maximum number of combinations of conditions of current cardinality
-            to test.
-        max_conds_py : int, optional (default: None)
-            Maximum number of lagged conditions of Y to use in MCI tests. If
-            None is passed, this number is unrestricted.
-        max_conds_px : int, optional (default: None)
-            Maximum number of lagged conditions of X to use in MCI tests. If
-            None is passed, this number is unrestricted.
-        max_conds_px_lagged : int, optional (default: None)
-            Maximum number of lagged conditions of X when X is lagged in MCI 
-            tests. If None is passed, this number is equal to max_conds_px.
-
-        Returns
-        -------
-        graph : array of shape [N, N, tau_max+1]
-            Resulting causal graph, see description above for interpretation.
-        val_matrix : array of shape [N, N, tau_max+1]
-            Estimated matrix of test statistic values regarding adjacencies.
-        p_matrix : array of shape [N, N, tau_max+1]
-            Estimated matrix of p-values regarding adjacencies.
-        sepset : dictionary
-            Separating sets. See paper for details.
-        ambiguous_triples : list
-            List of ambiguous triples, only relevant for 'majority' and
-            'conservative' rules, see paper for details.
-        """
-        # TODO: save_iterations
-
-        # Sanity checks
-        if pc_alpha is None:
-            raise ValueError("pc_alpha=None not supported in PC algorithm, "
-                             "choose 0 < pc_alpha < 1 (e.g., 0.01)")
-
-        if mode not in ['contemp_conds', 'standard']:
-            raise ValueError("mode must be either 'contemp_conds' or "
-                             "'standard'")
-
-        # Check the limits on tau
-        self._check_tau_limits(tau_min, tau_max)
-        # Set the selected links
-        _int_sel_links = self._set_sel_links(selected_links, tau_min, tau_max)
-
-        if max_conds_dim is None:
-            if mode == 'standard':
-                max_conds_dim = self._set_max_condition_dim(max_conds_dim,
-                                                            tau_min, tau_max)
-            elif mode == 'contemp_conds':
-                max_conds_dim = self.N
-
-        if max_combinations is None:
-            max_combinations = np.inf
-
-        # Initialize initial graph from selected_links
-        initial_graph = np.zeros((self.N, self.N, tau_max + 1), dtype='uint8')
-        for j in range(self.N):
-            for link in _int_sel_links[j]:
-                i, tau = link
-                initial_graph[i, j, abs(tau)] = 1
-
-        skeleton_results = self._pcalg_skeleton(
-            initial_graph=initial_graph,
-            lagged_parents=lagged_parents,
-            mode=mode,
-            pc_alpha=pc_alpha,
-            tau_min=tau_min,
-            tau_max=tau_max,
-            max_conds_dim=max_conds_dim,
-            max_combinations=max_combinations,
-            max_conds_py=max_conds_py,
-            max_conds_px=max_conds_px,
-            max_conds_px_lagged=max_conds_px_lagged,
-        )
-
-        skeleton_graph = skeleton_results['graph']
-        sepset = skeleton_results['sepset']
-
-        colliders_step_results = self._pcalg_colliders(
-            graph=skeleton_graph,
-            sepset=sepset,
-            lagged_parents=lagged_parents,
-            mode=mode,
-            pc_alpha=pc_alpha,
-            tau_max=tau_max,
-            max_conds_py=max_conds_py,
-            max_conds_px=max_conds_px,
-            max_conds_px_lagged=max_conds_px_lagged,
-            conflict_resolution=conflict_resolution,
-            contemp_collider_rule=contemp_collider_rule,
-            )
-
-        collider_graph = colliders_step_results['graph']
-        ambiguous_triples = colliders_step_results['ambiguous_triples']
-
-        final_graph = self._pcalg_rules_timeseries(
-            graph=collider_graph,
-            ambiguous_triples=ambiguous_triples,
-            conflict_resolution=conflict_resolution,
-        )
-
-        # Symmetrize p_matrix using maximum p-value
-        # and also symmetrize val_matrix based on same order
-        for i in range(self.N):
-            for j in range(self.N):
-                if (skeleton_results['p_matrix'][i, j, 0]
-                        > skeleton_results['p_matrix'][j, i, 0]
-                        and (i, 0) in _int_sel_links[j]):
-                    skeleton_results['p_matrix'][j, i, 0] = skeleton_results[
-                        'p_matrix'][i, j, 0]
-                    skeleton_results['val_matrix'][j, i, 0] = \
-                        skeleton_results['val_matrix'][i, j, 0]
-
-        # Convert numerical graph matrix to string
-        graph_str = self.convert_to_string_graph(final_graph)
-
-        pc_results = {
-            'graph': graph_str,
-            'p_matrix': skeleton_results['p_matrix'],
-            'val_matrix': skeleton_results['val_matrix'],
-            'sepset': colliders_step_results['sepset'],
-            'ambiguous_triples': colliders_step_results['ambiguous_triples'],
-        }
-
-        if self.verbosity > 1:
-            print("\n-----------------------------")
-            print("PCMCIplus algorithm finished.")
-            print("-----------------------------")
-
-        self.pc_results = pc_results
-        return pc_results

-
-
[docs]    def run_pcalg_non_timeseries_data(self, pc_alpha=0.01,
-                  max_conds_dim=None, max_combinations=None, 
-                  contemp_collider_rule='majority',
-                  conflict_resolution=True):
-
-        """Runs PC algorithm for non-time series data.
-
-        Simply calls run_pcalg with tau_min = tau_max = 0.
-
-        Parameters
-        ----------
-        pc_alpha : float, optional (default: 0.01)
-            Significance level.
-        contemp_collider_rule : {'majority', 'conservative', 'none'}
-            Rule for collider phase to use. See the paper for details. Only
-            'majority' and 'conservative' lead to an order-independent
-            algorithm.
-        conflict_resolution : bool, optional (default: True)
-            Whether to mark conflicts in orientation rules. Only for True
-            this leads to an order-independent algorithm.
-        max_conds_dim : int, optional (default: None)
-            Maximum number of conditions to test. If None is passed, this number
-            is unrestricted.
-        max_combinations : int
-            Maximum number of combinations of conditions of current cardinality
-            to test.
-
-        Returns
-        -------
-        graph : array of shape [N, N, 1]
-            Resulting causal graph, see description above for interpretation.
-        val_matrix : array of shape [N, N, 1]
-            Estimated matrix of test statistic values regarding adjacencies.
-        p_matrix : array of shape [N, N, 1]
-            Estimated matrix of p-values regarding adjacencies.
-        sepset : dictionary
-            Separating sets. See paper for details.
-        ambiguous_triples : list
-            List of ambiguous triples, only relevant for 'majority' and
-            'conservative' rules, see paper for details.
-        """
-
-        results = self.run_pcalg(pc_alpha=pc_alpha, tau_min=0, tau_max=0, 
-                    max_conds_dim=max_conds_dim, max_combinations=max_combinations,
-                  mode='standard', contemp_collider_rule=contemp_collider_rule,
-                  conflict_resolution=conflict_resolution)
-
-        # Remove tau-dimension
-        # results['graph'] = results['graph'].squeeze()
-        # results['val_matrix'] = results['val_matrix'].squeeze()
-        # results['p_matrix'] = results['p_matrix'].squeeze()
-        old_sepsets = results['sepset'].copy()
-        results['sepset'] = {}
-        for old_sepset in old_sepsets:
-           new_sepset = (old_sepset[0][0], old_sepset[1])
-           conds = [cond[0] for cond in old_sepsets[old_sepset]]
-
-           results['sepset'][new_sepset] = conds
-
-        ambiguous_triples = results['ambiguous_triples'].copy()
-        results['ambiguous_triples'] = []
-        for triple in ambiguous_triples:
-           new_triple = (triple[0][0], triple[1], triple[2])
-
-           results['ambiguous_triples'].append(new_triple)
-        
-        self.pc_results = results
-        return results

-
-
-    def _run_pcalg_test(self, i, abstau, j, S, lagged_parents, max_conds_py,
-                        max_conds_px, max_conds_px_lagged, tau_max):
-        """MCI conditional independence tests within PCMCIplus or PC algorithm.
-
-        Parameters
-        ----------
-        i : int
-            Variable index.
-        abstau : int
-            Time lag (absolute value).
-        j : int
-            Variable index.
-        S : list
-            List of contemporaneous conditions.
-        lagged_parents : dictionary of lists
-            Dictionary of lagged parents for each node.
-        max_conds_py : int
-            Max number of lagged parents for node j.
-        max_conds_px : int
-            Max number of lagged parents for lagged node i.
-        max_conds_px_lagged : int
-            Maximum number of lagged conditions of X when X is lagged in MCI 
-            tests. If None is passed, this number is equal to max_conds_px.
-        tau_max : int
-            Maximum time lag.
-
-        Returns
-        -------
-        val : float
-            Test statistic value.
-        pval : float
-            Test statistic p-value.
-        Z : list
-            List of conditions.
-        """
-
-        # Perform independence test adding lagged parents
-        if lagged_parents is not None:
-            conds_y = lagged_parents[j][:max_conds_py]
-            # Get the conditions for node i
-            if abstau == 0:
-                conds_x = lagged_parents[i][:max_conds_px]
-            else:
-                if max_conds_px_lagged is None:
-                    conds_x = lagged_parents[i][:max_conds_px]
-                else:
-                    conds_x = lagged_parents[i][:max_conds_px_lagged]
-
-        else:
-            conds_y = conds_x = []
-        # Shift the conditions for X by tau
-        conds_x_lagged = [(k, -abstau + k_tau) for k, k_tau in conds_x]
-
-        Z = [node for node in S]
-        Z += [node for node in conds_y if
-              node != (i, -abstau) and node not in Z]
-        # Remove overlapping nodes between conds_x_lagged and conds_y
-        Z += [node for node in conds_x_lagged if node not in Z]
-
-        val, pval = self.cond_ind_test.run_test(X=[(i, -abstau)], Y=[(j, 0)],
-                                                Z=Z, tau_max=tau_max,
-                                                # verbosity=self.verbosity
-                                                )
-
-        return val, pval, Z
-
-    def _print_triple_info(self, triple, index, n_triples):
-        """Print info about the current triple being tested.
-
-        Parameters
-        ----------
-        triple : tuple
-            Standard ((i, tau), k, j) tuple of nodes and time delays.
-        index : int
-            Index of triple.
-        n_triples : int
-            Total number of triples.
-        """
-        (i, tau), k, j = triple
-        link_marker = {True:"o-o", False:"-->"}
-
-        print("\n    Triple (%s % d) %s %s o-o %s (%d/%d)" % (
-            self.var_names[i], tau, link_marker[tau==0], self.var_names[k],
-            self.var_names[j], index + 1, n_triples))
-
-
-    def _tests_remaining(self, i, j, abstau, graph, adjt, p):
-        """Helper function returning whether a certain pair still needs to be
-        tested."""
-        return graph[i, j, abstau] != 0 and len(
-            [a for a in adjt[j] if a != (i, -abstau)]) >= p
-
-    def _any_tests_remaining(self, graph, adjt, tau_min, tau_max, p):
-        """Helper function returning whether any pair still needs to be
-        tested."""
-        remaining_pairs = self._remaining_pairs(graph, adjt, tau_min, tau_max,
-                                                p)
-
-        if len(remaining_pairs) > 0:
-            return True
-        else:
-            return False
-
-    def _remaining_pairs(self, graph, adjt, tau_min, tau_max, p):
-        """Helper function returning the remaining pairs that still need to be
-        tested."""
-        N = graph.shape[0]
-        pairs = []
-        for (i, j) in itertools.product(range(N), range(N)):
-            for abstau in range(tau_min, tau_max + 1):
-                if (graph[i, j, abstau] != 0
-                        and len(
-                            [a for a in adjt[j] if a != (i, -abstau)]) >= p):
-                    pairs.append((i, j, abstau))
-
-        return pairs
-
-    def _pcalg_skeleton(self,
-                       initial_graph,
-                       lagged_parents,
-                       mode,
-                       pc_alpha,
-                       tau_min,
-                       tau_max,
-                       max_conds_dim,
-                       max_combinations,
-                       max_conds_py,
-                       max_conds_px,
-                       max_conds_px_lagged,
-                       ):
-        """Implements the skeleton discovery step of the PC algorithm for
-        time series.
-
-        Parameters
-        ----------
-        initial_graph : array of shape (N, N, tau_max+1) or None
-            Initial graph.
-        lagged_parents : dictionary
-            Dictionary of form {0:[(0, -1), (3, -2), ...], 1:[], ...} containing
-            additional conditions for each CI test. As part of PCMCIplus
-            these are the superset of lagged parents estimated with the PC1
-            algorithm.
-        mode : {'standard', 'contemp_conds'}
-            For ``mode='contemp_conds'`` this implements Steps 2-4 of the
-            PCMCIplus method. For ``mode='standard'`` this implements the
-            standard PC algorithm adapted to time series.
-        tau_min : int, optional (default: 0)
-            Minimum time lag to test.
-        tau_max : int, optional (default: 1)
-            Maximum time lag. Must be larger or equal to tau_min.
-        pc_alpha : float, optional (default: 0.01)
-            Significance level.
-        max_conds_dim : int, optional (default: None)
-            Maximum number of conditions to test. If None is passed, this number
-            is unrestricted.
-        max_combinations : int
-            Maximum number of combinations of conditions of current cardinality
-            to test.
-        max_conds_py : int, optional (default: None)
-            Maximum number of lagged conditions of Y to use in MCI tests. If
-            None is passed, this number is unrestricted.
-        max_conds_px : int, optional (default: None)
-            Maximum number of lagged conditions of X to use in MCI tests. If
-            None is passed, this number is unrestricted.
-        max_conds_px_lagged : int, optional (default: None)
-            Maximum number of lagged conditions of X when X is lagged in MCI 
-            tests. If None is passed, this number is equal to max_conds_px.
-
-        Returns
-        -------
-        graph : array of shape [N, N, tau_max+1]
-            Resulting causal graph, see description above for interpretation.
-        val_matrix : array of shape [N, N, tau_max+1]
-            Estimated matrix of test statistic values regarding adjacencies.
-        p_matrix : array of shape [N, N, tau_max+1]
-            Estimated matrix of p-values regarding adjacencies.
-        sepset : dictionary
-            Separating sets. See paper for details.
-        """
-        N = self.N
-
-        # Form complete graph
-        if initial_graph is None:
-            graph = np.ones((N, N, tau_max + 1), dtype='int')
-        else:
-            graph = initial_graph
-
-        # Remove lag-zero self-loops
-        graph[range(N), range(N), 0] = 0
-
-        # Define adjacencies for standard and contemp_conds mode
-        if mode == 'contemp_conds':
-            adjt = self._get_adj_time_series_contemp(graph)
-        elif mode == 'standard':
-            adjt = self._get_adj_time_series(graph)
-
-        val_matrix = np.zeros((N, N, tau_max + 1))
-        val_min = dict()
-        for j in range(self.N):
-            val_min[j] = {(p[0], -p[1]): np.inf
-                          for p in zip(*np.where(graph[:, j, :]))}
-
-        # Initialize p-values. Set to 1 if there's no link in the initial graph
-        pvalues = np.zeros((N, N, tau_max + 1))
-        pvalues[graph == 0] = 1.
-        pval_max = dict()
-        for j in range(self.N):
-            pval_max[j] = {(p[0], -p[1]): 0.
-                           for p in zip(*np.where(graph[:, j, :]))}
-
-        # TODO: Remove sepset alltogether?
-        # Intialize sepsets that store the conditions that make i and j
-        # independent
-        sepset = self._get_sepset(tau_min, tau_max)
-
-        if self.verbosity > 1:
-            print("\n--------------------------")
-            print("Skeleton discovery phase")
-            print("--------------------------")
-
-        # Start with zero cardinality conditions
-        p = 0
-        while (self._any_tests_remaining(graph, adjt, tau_min, tau_max,
-                                         p) and p <= max_conds_dim):
-            if self.verbosity > 1:
-                print(
-                    "\nTesting contemporaneous condition sets of dimension "
-                    "%d: " % p)
-
-            remaining_pairs = self._remaining_pairs(graph, adjt, tau_min,
-                                                    tau_max, p)
-            n_remaining = len(remaining_pairs)
-            for ir, (i, j, abstau) in enumerate(remaining_pairs):
-                # Check if link was not already removed (contemp links)
-                if graph[i, j, abstau]:
-                    if self.verbosity > 1:
-                        self._print_link_info(j=j, index_parent=ir,
-                                              parent=(i, -abstau),
-                                              num_parents=n_remaining)
-
-                    # Generate all subsets of conditions of cardinality p
-                    conditions = list(itertools.combinations(
-                        [(k, tauk) for (k, tauk) in adjt[j]
-                         if not (k == i and tauk == -abstau)], p))
-
-                    n_conditions = len(conditions)
-                    if self.verbosity > 1:
-                        print(
-                            "    Iterate through %d subset(s) of conditions: "
-                            % n_conditions)
-                        if lagged_parents is not None:
-                            self._print_pcmciplus_conditions(lagged_parents, i,
-                                                         j, abstau,
-                                                         max_conds_py,
-                                                         max_conds_px,
-                                                         max_conds_px_lagged)
-                    nonsig = False
-                    # Iterate through condition sets
-                    for q, S in enumerate(conditions):
-                        if q > max_combinations:
-                            break
-
-                        # Run MCI test
-                        val, pval, Z = self._run_pcalg_test(
-                            i, abstau, j, S, lagged_parents, max_conds_py,
-                            max_conds_px, max_conds_px_lagged, tau_max)
-
-                        # Store minimum test statistic value for sorting adjt
-                        # (only internally used)
-                        val_min[j][(i, -abstau)] = min(np.abs(val),
-                                                       val_min[j].get(
-                                                           (i, -abstau)))
-                        # Store maximum p-value (only internally used)
-                        pval_max[j][(i, -abstau)] = max(pval,
-                                                        pval_max[j].get(
-                                                            (i, -abstau)))
-
-                        # Store max. p-value and corresponding value to return
-                        if pval >= pvalues[i, j, abstau]:
-                            pvalues[i, j, abstau] = pval
-                            val_matrix[i, j, abstau] = val
-
-                        if self.verbosity > 1:
-                            self._print_cond_info(Z=S, comb_index=q, pval=pval,
-                                                  val=val)
-
-                        # If conditional independence is found, remove link
-                        # from graph and store sepset
-                        if pval > pc_alpha:
-                            nonsig = True
-                            if abstau == 0:
-                                graph[i, j, 0] = graph[j, i, 0] = 0
-                                sepset[((i, 0), j)] = sepset[
-                                    ((j, 0), i)] = list(S)
-                            else:
-                                graph[i, j, abstau] = 0
-                                sepset[((i, -abstau), j)] = list(S)
-                            break
-
-                    # Print the results if needed
-                    if self.verbosity > 1:
-                        self._print_a_pc_result(nonsig,
-                                                conds_dim=p,
-                                                max_combinations=
-                                                max_combinations)
-                else:
-                    self._print_link_info(j=j, index_parent=ir,
-                                          parent=(i, -abstau),
-                                          num_parents=n_remaining,
-                                          already_removed=True)
-
-            # Increase condition cardinality
-            p += 1
-
-            # Re-compute adj and sort by minimum absolute test statistic value
-            if mode == 'contemp_conds':
-                adjt = self._get_adj_time_series_contemp(graph, sort_by=val_min)
-            elif mode == 'standard':
-                adjt = self._get_adj_time_series(graph, sort_by=val_min)
-
-            if self.verbosity > 1:
-                print("\nUpdated contemp. adjacencies:")
-                self._print_parents(all_parents=adjt, val_min=val_min,
-                                    pval_max=pval_max)
-
-        if self.verbosity > 1:
-            if not (self._any_tests_remaining(graph, adjt, tau_min, tau_max,
-                                              p) and p <= max_conds_dim):
-                print("\nAlgorithm converged at p = %d." % (p - 1))
-            else:
-                print(
-                    "\nAlgorithm not yet converged, but max_conds_dim = %d"
-                    " reached." % max_conds_dim)
-
-        return {'graph': graph,
-                'sepset': sepset,
-                'p_matrix': pvalues,
-                'val_matrix': val_matrix,
-                }
-
-    def _get_adj_time_series(self, graph, include_conflicts=True, sort_by=None):
-        """Helper function that returns dictionary of adjacencies from graph.
-
-        Parameters
-        ----------
-        graph : array of shape [N, N, tau_max+1]
-            Resulting causal graph, see description above for interpretation.
-        include_conflicts : bool, optional (default: True)
-            Whether conflicting links (marked as 2 in graph) should be returned.
-        sort_by : dict or none, optional (default: None)
-            If not None, the adjacencies are sorted by the absolute values of
-            the corresponding entries.
-
-        Returns
-        -------
-        adjt : dictionary
-            Adjacency dictionary.
-        """
-        N, N, tau_max_plusone = graph.shape
-        adjt = {}
-        if include_conflicts:
-            for j in range(N):
-                where = np.where(graph[:, j, :] != 0)
-                adjt[j] = list(zip(*(where[0], -where[1])))
-        else:
-            for j in range(N):
-                where = np.where(graph[:, j, :] == 1)
-                adjt[j] = list(zip(*(where[0], -where[1])))
-
-        if sort_by is not None:
-            for j in range(N):
-                # Get the absolute value for all the test statistics
-                abs_values = {k: np.abs(sort_by[j][k]) for k in list(sort_by[j])
-                              if k in adjt[j]}
-                adjt[j] = sorted(abs_values, key=abs_values.get, reverse=True)
-
-        return adjt
-
-    def _get_adj_time_series_contemp(self, graph, include_conflicts=True,
-                                     sort_by=None):
-        """Helper function that returns dictionary of contemporaneous
-        adjacencies from graph.
-
-        Parameters
-        ----------
-        graph : array of shape [N, N, tau_max+1]
-            Resulting causal graph, see description above for interpretation.
-        include_conflicts : bool, optional (default: True)
-            Whether conflicting links (marked as 2 in graph) should be returned.
-        sort_by : dict or none, optional (default: None)
-            If not None, the adjacencies are sorted by the absolute values of
-            the corresponding entries.
-
-        Returns
-        -------
-        adjt : dictionary
-            Contemporaneous adjacency dictionary.
-        """
-        N, N, tau_max_plusone = graph.shape
-        adjt = self._get_adj_time_series(graph,
-                                         include_conflicts=include_conflicts,
-                                         sort_by=sort_by)
-        for j in range(N):
-            adjt[j] = [a for a in adjt[j] if a[1] == 0]
-            # adjt[j] = list(np.where(graph[:,j,0] != 0)[0])
-
-        return adjt
-
-    def _get_sepset(self, tau_min, tau_max):
-        """Returns initial sepset.
-
-        Parameters
-        ----------
-        tau_min : int, optional (default: 0)
-            Minimum time lag to test.
-        tau_max : int, optional (default: 1)
-            Maximum time lag. Must be larger or equal to tau_min.
-
-        Returns
-        -------
-        sepset : dict
-            Initialized sepset.
-        """
-        sepset = dict([(((i, -tau), j), [])
-                       for tau in range(tau_min, tau_max + 1)
-                       for i in range(self.N)
-                       for j in range(self.N)])
-
-        return sepset
-
-    def _find_unshielded_triples(self, graph):
-        """Find unshielded triples i_tau --(>) k_t -- j_t with i_tau -/- j_t.
-
-        Excludes conflicting links.
-
-        Parameters
-        ----------
-        graph : array of shape [N, N, tau_max+1]
-            Causal graph, see description above for interpretation.
-
-        Returns
-        -------
-        triples : list
-            List of triples.
-        """
-
-        N = graph.shape[0]
-        adjt = self._get_adj_time_series(graph, include_conflicts=False)
-
-        # Find unshielded triples
-        # Find triples i_tau --(>) k_t -- j_t with i_tau -/- j_t
-        triples = []
-        for j in range(N):
-            for (k, tauk) in adjt[j]:
-                if tauk == 0:
-                    for (i, taui) in adjt[k]:
-                        if not (k == j or (
-                                taui == 0 and (i == k or i == j))):
-                            if ((taui == 0 and graph[i, j, 0] == 0 and
-                                 graph[j, i, 0] == 0)
-                                    or taui < 0 and graph[
-                                        i, j, abs(taui)] == 0):
-                                triples.append(((i, taui), k, j))
-
-        return triples
-
-    def _pcalg_colliders(self,
-                        graph,
-                        sepset,
-                        lagged_parents,
-                        mode,
-                        pc_alpha,
-                        tau_max,
-                        max_conds_py,
-                        max_conds_px,
-                        max_conds_px_lagged,
-                        contemp_collider_rule,
-                        conflict_resolution,
-                        ):
-        """Implements the collider orientation step of the PC algorithm for
-        time series.
-
-        Parameters
-        ----------
-        graph : array of shape (N, N, tau_max+1)
-            Current graph.
-        sepset : dictionary
-            Separating sets. See paper for details.
-        lagged_parents : dictionary
-            Dictionary of form {0:[(0, -1), (3, -2), ...], 1:[], ...} containing
-            additional conditions for each CI test. As part of PCMCIplus
-            these are the superset of lagged parents estimated with the PC1
-            algorithm.
-        mode : {'standard', 'contemp_conds'}
-            For ``mode='contemp_conds'`` this implements Steps 2-4 of the
-            PCMCIplus method. For ``mode='standard'`` this implements the
-            standard PC algorithm adapted to time series.
-        pc_alpha : float, optional (default: 0.01)
-            Significance level.
-        tau_max : int, optional (default: 1)
-            Maximum time lag. Must be larger or equal to tau_min.
-        max_conds_py : int, optional (default: None)
-            Maximum number of lagged conditions of Y to use in MCI tests. If
-            None is passed, this number is unrestricted.
-        max_conds_px : int, optional (default: None)
-            Maximum number of lagged conditions of X to use in MCI tests. If
-            None is passed, this number is unrestricted.
-        max_conds_px_lagged : int, optional (default: None)
-            Maximum number of lagged conditions of X when X is lagged in MCI 
-            tests. If None is passed, this number is equal to max_conds_px.
-        contemp_collider_rule : {'majority', 'conservative', 'none'}
-            Rule for collider phase to use. See the paper for details. Only
-            'majority' and 'conservative' lead to an order-independent
-            algorithm.
-        conflict_resolution : bool, optional (default: True)
-            Whether to mark conflicts in orientation rules. Only for True
-            this leads to an order-independent algorithm.
-
-        Returns
-        -------
-        graph : array of shape [N, N, tau_max+1]
-            Resulting causal graph, see description above for interpretation.
-        sepset : dictionary
-            Separating sets. See paper for details.
-        ambiguous_triples : list
-            List of ambiguous triples, only relevant for 'majority' and
-            'conservative' rules, see paper for details.
-        """
-
-        if self.verbosity > 1:
-            print("\n----------------------------")
-            print("Collider orientation phase")
-            print("----------------------------")
-            print("\ncontemp_collider_rule = %s" % contemp_collider_rule)
-            print("conflict_resolution = %s\n" % conflict_resolution)
-
-        # Find unshielded triples
-        triples = self._find_unshielded_triples(graph)
-
-        v_structures = []
-        ambiguous_triples = []
-
-        if contemp_collider_rule is None or contemp_collider_rule == 'none':
-            # Standard collider orientation rule of PC algorithm
-            # If k_t not in sepset(i_tau, j_t), then orient
-            # as i_tau --> k_t <-- j_t
-            for itaukj in triples:
-                (i, tau), k, j = itaukj
-                if (k, 0) not in sepset[((i, tau), j)]:
-                    v_structures.append(itaukj)
-        else:
-            # Apply 'majority' or 'conservative' rule to orient colliders          
-            # Compute all (contemp) subsets of potential parents of i and all 
-            # subsets of potential parents of j that make i and j independent
-            def subsets(s):
-                if len(s) == 0: return []
-                subsets = []
-                for cardinality in range(len(s) + 1):
-                    subsets += list(itertools.combinations(s, cardinality))
-                subsets = [list(sub) for sub in list(set(subsets))]
-                return subsets
-
-            # We only consider contemporaneous adjacencies because only these
-            # can include the (contemp) k. Furthermore, we only need to check
-            # adjacencies of i for tau=0
-            if mode == 'contemp_conds':
-                adjt = self._get_adj_time_series_contemp(graph)
-            elif mode == 'standard':
-                adjt = self._get_adj_time_series(graph)
-
-            n_triples = len(triples)
-            for ir, itaukj in enumerate(triples):
-                (i, tau), k, j = itaukj
-
-                if self.verbosity > 1:
-                    self._print_triple_info(itaukj, ir, n_triples)
-
-                neighbor_subsets_tmp = subsets(
-                    [(l, taul) for (l, taul) in adjt[j]
-                     if not (l == i and tau == taul)])
-                if tau == 0:
-                    # Furthermore, we only need to check contemp. adjacencies
-                    # of i for tau=0
-                    neighbor_subsets_tmp += subsets(
-                        [(l, taul) for (l, taul) in adjt[i]
-                         if not (l == j and taul == 0)])
-
-                # Make unique
-                neighbor_subsets = []
-                for subset in neighbor_subsets_tmp:
-                    if subset not in neighbor_subsets:
-                        neighbor_subsets.append(subset)
-
-                n_neighbors = len(neighbor_subsets)
-
-                if self.verbosity > 1:
-                    print(
-                        "    Iterate through %d condition subset(s) of "
-                        "neighbors: " % n_neighbors)
-                    if lagged_parents is not None:
-                        self._print_pcmciplus_conditions(lagged_parents, i, j,
-                                         abs(tau), max_conds_py, max_conds_px,
-                                         max_conds_px_lagged)
-
-                # Test which neighbor subsets separate i and j
-                neighbor_sepsets = []
-                for iss, S in enumerate(neighbor_subsets):
-                    val, pval, Z = self._run_pcalg_test(
-                        i, abs(tau), j, S, lagged_parents, max_conds_py,
-                        max_conds_px, max_conds_px_lagged, tau_max)
-
-                    if self.verbosity > 1:
-                        self._print_cond_info(Z=S, comb_index=iss, pval=pval,
-                                              val=val)
-
-                    if pval > pc_alpha:
-                        neighbor_sepsets += [S]
-
-                if len(neighbor_sepsets) > 0:
-                    fraction = np.sum(
-                        [(k, 0) in S for S in neighbor_sepsets]) / float(
-                        len(neighbor_sepsets))
-
-                if contemp_collider_rule == 'conservative':
-                    # Triple is labeled as unambiguous if at least one
-                    # separating set is found and either k is in ALL
-                    # (fraction == 1) or NONE (fraction == 0) of them
-                    if len(neighbor_sepsets) == 0:
-                        if self.verbosity > 1:
-                            print(
-                                "    No separating subsets --> ambiguous "
-                                "triple found")
-                        ambiguous_triples.append(itaukj)
-                    else:
-                        if fraction == 0:
-                            # If (k, 0) is in none of the neighbor_sepsets,
-                            # orient as collider
-                            v_structures.append(itaukj)
-                            if self.verbosity > 1:
-                                print(
-                                    "    Fraction of separating subsets "
-                                    "containing (%s 0) is = 0 --> collider "
-                                    "found" % self.var_names[k])
-                            # Also delete (k, 0) from sepset (if present)
-                            if (k, 0) in sepset[((i, tau), j)]:
-                                sepset[((i, tau), j)].remove((k, 0))
-                            if tau == 0:
-                                if (k, 0) in sepset[((j, tau), i)]:
-                                    sepset[((j, tau), i)].remove((k, 0))
-                        elif fraction == 1:
-                            # If (k, 0) is in all of the neighbor_sepsets,
-                            # leave unoriented
-                            if self.verbosity > 1:
-                                print(
-                                    "    Fraction of separating subsets "
-                                    "containing (%s 0) is = 1 --> "
-                                    "non-collider found" % self.var_names[k])
-                            # Also add (k, 0) to sepset (if not present)
-                            if (k, 0) not in sepset[((i, tau), j)]:
-                                sepset[((i, tau), j)].append((k, 0))
-                            if tau == 0:
-                                if (k, 0) not in sepset[((j, tau), i)]:
-                                    sepset[((j, tau), i)].append((k, 0))
-                        else:
-                            if self.verbosity > 1:
-                                print(
-                                    "    Fraction of separating subsets "
-                                    "containing (%s 0) is = between 0 and 1 "
-                                    "--> ambiguous triple found" %
-                                    self.var_names[k])
-                            ambiguous_triples.append(itaukj)
-
-                elif contemp_collider_rule == 'majority':
-
-                    if len(neighbor_sepsets) == 0:
-                        if self.verbosity > 1:
-                            print(
-                                "    No separating subsets --> ambiguous "
-                                "triple found")
-                        ambiguous_triples.append(itaukj)
-                    else:
-                        if fraction == 0.5:
-                            if self.verbosity > 1:
-                                print(
-                                    "    Fraction of separating subsets "
-                                    "containing (%s 0) is = 0.5 --> ambiguous "
-                                    "triple found" % self.var_names[k])
-                            ambiguous_triples.append(itaukj)
-                        elif fraction < 0.5:
-                            v_structures.append(itaukj)
-                            if self.verbosity > 1:
-                                print(
-                                    "    Fraction of separating subsets "
-                                    "containing (%s 0) is < 0.5 "
-                                    "--> collider found" % self.var_names[k])
-                            # Also delete (k, 0) from sepset (if present)
-                            if (k, 0) in sepset[((i, tau), j)]:
-                                sepset[((i, tau), j)].remove((k, 0))
-                            if tau == 0:
-                                if (k, 0) in sepset[((j, tau), i)]:
-                                    sepset[((j, tau), i)].remove((k, 0))
-                        elif fraction > 0.5:
-                            if self.verbosity > 1:
-                                print(
-                                    "    Fraction of separating subsets "
-                                    "containing (%s 0) is > 0.5 "
-                                    "--> non-collider found" %
-                                    self.var_names[k])
-                            # Also add (k, 0) to sepset (if not present)
-                            if (k, 0) not in sepset[((i, tau), j)]:
-                                sepset[((i, tau), j)].append((k, 0))
-                            if tau == 0:
-                                if (k, 0) not in sepset[((j, tau), i)]:
-                                    sepset[((j, tau), i)].append((k, 0))
-
-        if self.verbosity > 1 and len(v_structures) > 0:
-            print("\nOrienting links among colliders:")
-
-        link_marker = {True:"o-o", False:"-->"}
-
-        # Now go through list of v-structures and (optionally) detect conflicts
-        oriented_links = []
-        for itaukj in v_structures:
-            (i, tau), k, j = itaukj
-
-            if self.verbosity > 1:
-                print("\n    Collider (%s % d) %s %s o-o %s:" % (
-                    self.var_names[i], tau, link_marker[
-                        tau==0], self.var_names[k],
-                    self.var_names[j]))
-
-            if (k, j) not in oriented_links and (j, k) not in oriented_links:
-                if self.verbosity > 1:
-                    print("      Orient %s o-o %s as %s --> %s " % (
-                        self.var_names[j], self.var_names[k], self.var_names[j],
-                        self.var_names[k]))
-                graph[k, j, 0] = 0
-                oriented_links.append((j, k))
-            else:
-                if conflict_resolution is False and self.verbosity > 1:
-                    print("      Already oriented")
-
-            if conflict_resolution:
-                if (k, j) in oriented_links:
-                    if self.verbosity > 1:
-                        print(
-                            "        Conflict since %s <-- %s already "
-                            "oriented: Mark link as `2` in graph" % (
-                                self.var_names[j], self.var_names[k]))
-                    graph[j, k, 0] = graph[k, j, 0] = 2
-
-            if tau == 0:
-                if (i, k) not in oriented_links and (
-                        k, i) not in oriented_links:
-                    if self.verbosity > 1:
-                        print("      Orient %s o-o %s as %s --> %s " % (
-                            self.var_names[i], self.var_names[k],
-                            self.var_names[i], self.var_names[k]))
-                    graph[k, i, 0] = 0
-                    oriented_links.append((i, k))
-                else:
-                    if conflict_resolution is False and self.verbosity > 1:
-                        print("      Already oriented")
-
-                if conflict_resolution:
-                    if (k, i) in oriented_links:
-                        if self.verbosity > 1:
-                            print(
-                                "        Conflict since %s <-- %s already "
-                                "oriented: Mark link as `2` in graph" % (
-                                    self.var_names[i], self.var_names[k]))
-                        graph[i, k, 0] = graph[k, i, 0] = 2
-
-        if self.verbosity > 1:
-            adjt = self._get_adj_time_series(graph)
-            print("\nUpdated adjacencies:")
-            self._print_parents(all_parents=adjt, val_min=None, pval_max=None)
-
-        return {'graph': graph,
-                'sepset': sepset,
-                'ambiguous_triples': ambiguous_triples,
-                }
-
-    def _find_triples_rule1(self, graph):
-        """Find triples i_tau --> k_t o-o j_t with i_tau -/- j_t.
-
-        Excludes conflicting links.
-
-        Parameters
-        ----------
-        graph : array of shape [N, N, tau_max+1]
-            Causal graph, see description above for interpretation.
-
-        Returns
-        -------
-        triples : list
-            List of triples.
-        """
-        adjt = self._get_adj_time_series(graph, include_conflicts=False)
-
-        N = graph.shape[0]
-        triples = []
-        for j in range(N):
-            for (k, tauk) in adjt[j]:
-                if tauk == 0 and graph[j, k, 0] == 1:
-                    for (i, taui) in adjt[k]:
-                        if not (k == j or (taui == 0 and (i == k or i == j))):
-                            if ((taui == 0 and graph[i, j, 0] == 0
-                                 and graph[j, i, 0] == 0
-                                 and graph[k, i, 0] == 0)
-                                    or taui < 0 and graph[
-                                        i, j, abs(taui)] == 0):
-                                triples.append(((i, taui), k, j))
-        return triples
-
-    def _find_triples_rule2(self, graph):
-        """Find triples i_t --> k_t --> j_t with i_t -- j_t.
-
-        Excludes conflicting links.
-
-        Parameters
-        ----------
-        graph : array of shape [N, N, tau_max+1]
-            Causal graph, see description above for interpretation.
-
-        Returns
-        -------
-        triples : list
-            List of triples.
-        """
-
-        adjtcont = self._get_adj_time_series_contemp(graph,
-                                                     include_conflicts=False)
-        N = graph.shape[0]
-
-        triples = []
-        for j in range(N):
-            for (k, tauk) in adjtcont[j]:
-                if (j, 0) not in adjtcont[k]:
-                    for (i, taui) in adjtcont[k]:
-                        if (k, 0) not in adjtcont[i]:
-                            if graph[i, j, 0] == 1 and graph[j, i, 0] == 1:
-                                triples.append(((i, 0), k, j))
-        return triples
-
-    def _find_chains_rule3(self, graph):
-        """Find chains i_t o-o k_t --> j_t and i_t o-o l_t --> j_t with
-           i_t o-o j_t and k_t -/- l_t.
-
-        Excludes conflicting links.
-
-        Parameters
-        ----------
-        graph : array of shape [N, N, tau_max+1]
-            Causal graph, see description above for interpretation.
-
-        Returns
-        -------
-        chains : list
-            List of chains.
-        """
-        N = graph.shape[0]
-        adjtcont = self._get_adj_time_series_contemp(graph,
-                                                     include_conflicts=False)
-
-        chains = []
-        for j in range(N):
-            for (i, _) in adjtcont[j]:
-                if graph[j, i, 0] == 1:
-                    for (k, _) in adjtcont[j]:
-                        for (l, _) in adjtcont[j]:
-                            # Nodes should not be identical
-                            if not ((k == l) or (k == i) or (l == i)):
-                                # There should be an arrowhead from k and l to j
-                                if (j, 0) not in adjtcont[k] and (j, 0) not \
-                                        in adjtcont[l]:
-                                    # Check that i is adjacent to k and l
-                                    if (k, 0) in adjtcont[i]\
-                                            and (l, 0) in adjtcont[i]:
-                                        # Check that not both have arrow
-                                        # towards i
-                                        if (i, 0) in adjtcont[k] \
-                                                or (i, 0) in adjtcont[l]:
-                                            # k and l should not be adjacent
-                                            if (graph[k, l, 0] == 0
-                                                    and graph[l, k, 0] == 0):
-                                                chains.append((((i, 0), k, j),
-                                                               ((i, 0), l, j)))
-
-        return chains
-
-    def _pcalg_rules_timeseries(self,
-                                graph,
-                                ambiguous_triples,
-                                conflict_resolution,
-                                ):
-        """Implements the rule orientation step of the PC algorithm for
-        time series.
-
-        Parameters
-        ----------
-        graph : array of shape (N, N, tau_max+1)
-            Current graph.
-        ambiguous_triples : list
-            List of ambiguous triples, only relevant for 'majority' and
-            'conservative' rules, see paper for details.
-        conflict_resolution : bool
-            Whether to mark conflicts in orientation rules. Only for True
-            this leads to an order-independent algorithm.
-
-        Returns
-        -------
-        graph : array of shape [N, N, tau_max+1]
-            Resulting causal graph, see description above for interpretation.
-        """
-        N = graph.shape[0]
-
-        def rule1(graph, oriented_links):
-            """Find (unambiguous) triples i_tau --> k_t o-o j_t with
-               i_tau -/- j_t and orient as i_tau --> k_t --> j_t.
-            """
-            triples = self._find_triples_rule1(graph)
-            triples_left = False
-
-            for itaukj in triples:
-                if itaukj not in ambiguous_triples:
-                    triples_left = True
-                    # Orient as i_tau --> k_t --> j_t
-                    (i, tau), k, j = itaukj
-                    if (j, k) not in oriented_links and (
-                            k, j) not in oriented_links:
-                        if self.verbosity > 1:
-                            print(
-                                "    R1: Found (%s % d) --> %s o-o %s, "
-                                "orient as %s --> %s" % (
-                                    self.var_names[i], tau, self.var_names[k],
-                                    self.var_names[j],
-                                    self.var_names[k], self.var_names[j]))
-                        graph[j, k, 0] = 0
-                        oriented_links.append((k, j))
-
-                    if conflict_resolution:
-                        if (j, k) in oriented_links:
-                            if self.verbosity > 1:
-                                print(
-                                    "        Conflict since %s <-- %s already"
-                                    " oriented: Mark link as `2` in graph" % (
-                                        self.var_names[k], self.var_names[j]))
-                            graph[j, k, 0] = graph[k, j, 0] = 2
-
-            return triples_left, graph, oriented_links
-
-        def rule2(graph, oriented_links):
-            """Find (unambiguous) triples i_t --> k_t --> j_t with i_t o-o j_t
-               and orient as i_t --> j_t.
-            """
-
-            triples = self._find_triples_rule2(graph)
-            triples_left = False
-
-            for itaukj in triples:
-                if itaukj not in ambiguous_triples:
-                    # TODO: CHeck whether this is actually needed
-                    # since ambiguous triples are always unshielded and here
-                    # we look for triples where i and j are connected
-                    triples_left = True
-                    # Orient as i_t --> j_t
-                    (i, tau), k, j = itaukj
-                    if (j, i) not in oriented_links and (
-                            i, j) not in oriented_links:
-                        if self.verbosity > 1:
-                            print(
-                                "    R2: Found %s --> %s --> %s  with  %s "
-                                "o-o %s, orient as %s --> %s" % (
-                                    self.var_names[i], self.var_names[k],
-                                    self.var_names[j],
-                                    self.var_names[i], self.var_names[j],
-                                    self.var_names[i], self.var_names[j]))
-                        graph[j, i, 0] = 0
-                        oriented_links.append((i, j))
-                    if conflict_resolution:
-                        if (j, i) in oriented_links:
-                            if self.verbosity > 1:
-                                print(
-                                    "        Conflict since %s <-- %s already "
-                                    "oriented: Mark link as `2` in graph" % (
-                                        self.var_names[i], self.var_names[j]))
-                            graph[j, i, 0] = graph[i, j, 0] = 2
-
-            return triples_left, graph, oriented_links
-
-        def rule3(graph, oriented_links):
-            """Find (unambiguous) chains i_t o-o k_t --> j_t
-               and i_t o-o l_t --> j_t with i_t o-o j_t
-               and k_t -/- l_t: Orient as i_t --> j_t.
-            """
-            # First find all chains i_t -- k_t --> j_t with i_t -- j_t
-            # and k_t -/- l_t
-            chains = self._find_chains_rule3(graph)
-
-            chains_left = False
-
-            for (itaukj, itaulj) in chains:
-                if (itaukj not in ambiguous_triples and
-                        itaulj not in ambiguous_triples):
-                    # TODO: CHeck whether this is actually needed
-                    # since ambiguous triples are always unshielded and here
-                    # we look for triples where i and j are connected
-                    chains_left = True
-                    # Orient as i_t --> j_t
-                    (i, tau), k, j = itaukj
-                    _       , l, _ = itaulj
-
-                    if (j, i) not in oriented_links and (
-                            i, j) not in oriented_links:
-                        if self.verbosity > 1:
-                            print(
-                                "    R3: Found %s o-o %s --> %s and %s o-o "
-                                "%s --> %s with %s o-o %s and %s -/- %s, "
-                                "orient as %s --> %s" % (
-                                    self.var_names[i], self.var_names[k],
-                                    self.var_names[j], self.var_names[i],
-                                    self.var_names[l], self.var_names[j],
-                                    self.var_names[i], self.var_names[j],
-                                    self.var_names[k], self.var_names[l],
-                                    self.var_names[i], self.var_names[j]))
-                        graph[j, i, 0] = 0
-                        oriented_links.append((i, j))
-                    if conflict_resolution:
-                        if (j, i) in oriented_links:
-                            if self.verbosity > 1:
-                                print(
-                                    "        Conflict since %s <-- %s already "
-                                    "oriented: Mark link as `2` in graph" % (
-                                        self.var_names[i], self.var_names[j]))
-                            graph[j, i, 0] = graph[i, j, 0] = 2
-
-            return chains_left, graph, oriented_links
-
-        if self.verbosity > 1:
-            print("\n")
-            print("----------------------------")
-            print("Rule orientation phase")
-            print("----------------------------")
-
-        oriented_links = []
-        graph_new = np.copy(graph)
-        any1 = any2 = any3 = True
-        while (any1 or any2 or any3):
-            if self.verbosity > 1:
-                print("\nTry rule(s) %s" % (
-                    np.where(np.array([0, any1, any2, any3]))))
-            any1, graph_new, oriented_links = rule1(graph_new, oriented_links)
-            any2, graph_new, oriented_links = rule2(graph_new, oriented_links)
-            any3, graph_new, oriented_links = rule3(graph_new, oriented_links)
-
-        if self.verbosity > 1:
-            adjt = self._get_adj_time_series(graph_new)
-            print("\nUpdated adjacencies:")
-            self._print_parents(all_parents=adjt, val_min=None, pval_max=None)
-
-        return graph_new
-
-    def _get_simplicial_node(self, circle_cpdag, variable_order):
-        """Find simplicial nodes in circle component CPDAG.
-
-        A vertex V is simplicial if all vertices adjacent to V are also adjacent
-        to each other (form a clique).
-
-        Parameters
-        ----------
-        circle_cpdag : array of shape (N, N, tau_max+1)
-            Circle component of PCMCIplus graph.
-        variable_order : list of length N
-            Order of variables in which to search for simplicial nodes.
-
-        Returns
-        -------
-        (j, adj_j) or None
-            First found simplicial node and its adjacencies.
-        """
-
-        for j in variable_order:
-            adj_j = np.where(circle_cpdag[:,j,0] == "o-o")[0].tolist()
-
-            # Make sure the node has any adjacencies
-            all_adjacent = len(adj_j) > 0
-
-            # If it has just one adjacency, it's also simplicial
-            if len(adj_j) == 1:
-                return (j, adj_j)  
-            else:
-                for (var1, var2) in itertools.combinations(adj_j, 2):
-                    if circle_cpdag[var1, var2, 0] == "": 
-                        all_adjacent = False
-                        break
-
-                if all_adjacent:
-                    return (j, adj_j)
-
-        return None
-
-    def _get_dag_from_cpdag(self, cpdag_graph, variable_order):
-        """Yields one member of the Markov equivalence class of a CPDAG.
-
-        Removes conflicting edges.
-
-        Used in PCMCI to run model selection on the output of PCMCIplus in order
-        to, e.g., optimize pc_alpha.
-
-        Based on Zhang 2008, Theorem 2 (simplified for CPDAGs): Let H be the
-        graph resulting from the following procedure applied to a CPDAG:
- 
-        Consider the circle component of the CPDAG (sub graph consisting of all
-        (o-o edges, i.e., only for contemporaneous links), CPDAG^C and turn into
-        a DAG with no unshielded colliders. Then (H is a member of the Markov
-        equivalence class of the CPDAG.
-
-        We use the approach mentioned in Colombo and Maathuis (2015) Lemma 7.6:
-        First note that CPDAG^C is chordal, that is, any cycle of length four or
-        more has a chord, which is an edge joining two vertices that are not
-        adjacent in the cycle; see the proof of Lemma 4.1 of Zhang (2008b). Any
-        chordal graph with more than one vertex has two simplicial vertices,
-        that is, vertices V such that all vertices adjacent to V are also
-        adjacent to each other. We choose such a vertex V1 and orient any edges
-        incident to V1 into V1. Since V1 is simplicial, this does not create
-        unshielded colliders. We then remove V1 and these edges from the graph.
-        The resulting graph is again chordal and therefore again has at least
-        two simplicial vertices. Choose such a vertex V2 , and orient any edges
-        incident to V2 into V2. We continue this procedure until all edges are
-        oriented. The resulting ordering is called a perfect elimination scheme
-        for CPDAG^C. Then the combined graph with the directed edges already
-        contained in the CPDAG is returned.
-
-        Parameters
-        ----------
-        cpdag_graph : array of shape (N, N, tau_max+1)
-            Result of PCMCIplus, a CPDAG.
-        variable_order : list of length N
-            Order of variables in which to search for simplicial nodes.
-
-        Returns
-        -------
-        dag : array of shape (N, N, tau_max+1)
-            One member of the Markov equivalence class of the CPDAG.
-        """
-
-        # TODO: Check whether CPDAG is chordal
-
-        # Initialize resulting MAG
-        dag = np.copy(cpdag_graph)
-
-        # Turn circle component CPDAG^C into a DAG with no unshielded colliders.
-        circle_cpdag = np.copy(cpdag_graph)
-        # All lagged links are directed by time, remove them here
-        circle_cpdag[:,:,1:] = ""
-        # Also remove conflicting links
-        circle_cpdag[circle_cpdag=="x-x"] = ""
-        # Find undirected links, remove directed links
-        for i, j, tau in zip(*np.where(circle_cpdag != "")):
-            if circle_cpdag[i,j,0] == "-->":
-                circle_cpdag[i,j,0] = ""
-
-        # Iterate through simplicial nodes
-        simplicial_node = self._get_simplicial_node(circle_cpdag,
-                                                    variable_order)
-        while simplicial_node is not None:
-
-            # Choose such a vertex V1 and orient any edges incident to V1 into
-            # V1 in the MAG And remove V1 and these edges from the circle
-            # component PAG
-            (j, adj_j) = simplicial_node
-            for var in adj_j:
-                dag[var, j, 0] = "-->"
-                dag[j, var, 0] = "<--"
-                circle_cpdag[var, j, 0] = circle_cpdag[j, var, 0] = "" 
-
-            # Iterate
-            simplicial_node = self._get_simplicial_node(circle_cpdag,
-                                                    variable_order)
-
-        return dag
-
-    def _optimize_pcmciplus_alpha(self,
-                      selected_links,
-                      tau_min,
-                      tau_max,
-                      pc_alpha,
-                      contemp_collider_rule,
-                      conflict_resolution,
-                      reset_lagged_links,
-                      max_conds_dim,
-                      max_conds_py,
-                      max_conds_px,
-                      max_conds_px_lagged,
-                      fdr_method,
-                      ):
-        """Optimizes pc_alpha in PCMCIplus.
-
-        If a list or None is passed for ``pc_alpha``, the significance level is
-        optimized for every graph across the given ``pc_alpha`` values using the
-        score computed in ``cond_ind_test.get_model_selection_criterion()``
-
-        Parameters
-        ----------
-        See those for run_pcmciplus()
-
-        Returns
-        -------
-        Results for run_pcmciplus() for the optimal pc_alpha.
-        """
-
-        if pc_alpha is None:
-            pc_alpha_list = [0.001, 0.005, 0.01, 0.025, 0.05]
-        else:
-            pc_alpha_list = pc_alpha
-
-        if self.verbosity > 0:
-            print("\n##\n## Optimizing pc_alpha over " + 
-                  "pc_alpha_list = %s" % str(pc_alpha_list) +
-                  "\n##")
-
-        results = {}
-        score = np.zeros_like(pc_alpha_list)
-        for iscore, pc_alpha_here in enumerate(pc_alpha_list):
-            # Print statement about the pc_alpha being tested
-            if self.verbosity > 0:
-                print("\n## pc_alpha = %s (%d/%d):" % (pc_alpha_here,
-                                                      iscore + 1,
-                                                      score.shape[0]))
-            # Get the results for this alpha value
-            results[pc_alpha_here] = \
-                self.run_pcmciplus(selected_links=selected_links,
-                                    tau_min=tau_min,
-                                    tau_max=tau_max,
-                                    pc_alpha=pc_alpha_here,
-                                    contemp_collider_rule=contemp_collider_rule,
-                                    conflict_resolution=conflict_resolution,
-                                    reset_lagged_links=reset_lagged_links,
-                                    max_conds_dim=max_conds_dim,
-                                    max_conds_py=max_conds_py,
-                                    max_conds_px=max_conds_px,
-                                    max_conds_px_lagged=max_conds_px_lagged,
-                                    fdr_method=fdr_method)
-
-            # Get one member of the Markov equivalence class of the result
-            # of PCMCIplus, which is a CPDAG
-
-            # First create order that is based on some feature of the variables
-            # to avoid order-dependence of DAG, i.e., it should not matter
-            # in which order the variables appear in dataframe
-            # Here we use the sum of absolute val_matrix values incident at j
-            val_matrix = results[pc_alpha_here]['val_matrix']
-            variable_order = np.argsort(
-                                np.abs(val_matrix).sum(axis=(0,2)))[::-1]
-
-            dag = self._get_dag_from_cpdag(
-                            cpdag_graph=results[pc_alpha_here]['graph'],
-                            variable_order=variable_order)
-            
-            # = self.return_significant_links(
-            #         pq_matrix=results[pc_alpha_here]['p_matrix'],
-            #         val_matrix=results[pc_alpha_here]['val_matrix'], 
-            #         alpha_level=pc_alpha_here,
-            #         include_lagzero_links=True)['link_dict']
-
-            # Compute the best average score when the model selection
-            # is applied to all N variables
-            for j in range(self.N):
-                parents = []
-                for i, tau in zip(*np.where(dag[:,j,:] == "-->")):
-                    parents.append((i, -tau))
-                score[iscore] += \
-                    self.cond_ind_test.get_model_selection_criterion(
-                        j, parents, tau_max)
-            score[iscore] /= float(self.N)
-
-        # Record the optimal alpha value
-        optimal_alpha = pc_alpha_list[score.argmin()]
-
-        if self.verbosity > 0:
-            print("\n##\n## Returning results for optimal " +
-                  "pc_alpha = %s" % optimal_alpha + 
-                  "\n##"+
-                  "\n\n## Scores for individual pc_alpha values:\n")
-            for iscore, pc_alpha in enumerate(pc_alpha_list):
-                print("   pc_alpha = %7s yields score = %.5f" % (pc_alpha, 
-                                                                score[iscore]))
-
-        optimal_results = results[optimal_alpha]
-        optimal_results['optimal_alpha'] = optimal_alpha
-        return optimal_results
-
-
[docs]    def convert_to_string_graph(self, graph_bool):
-        """Converts the 0,1-based graph returned by PCMCI to a string array
-        with links '-->'.
-
-        Parameters
-        ----------
-        graph_bool : array
-            0,1-based graph array output by PCMCI.
-
-        Returns
-        -------
-        graph : array
-            graph as string array with links '-->'.
-        """
-
-        graph = np.zeros(graph_bool.shape, dtype='<U3')
-        graph[:] = ""
-        # Lagged links
-        graph[:,:,1:][graph_bool[:,:,1:]==1] = "-->"
-        # Unoriented contemporaneous links
-        graph[:,:,0][np.logical_and(graph_bool[:,:,0]==1, 
-                                    graph_bool[:,:,0].T==1)] = "o-o"
-        # Conflicting contemporaneous links
-        graph[:,:,0][np.logical_and(graph_bool[:,:,0]==2, 
-                                    graph_bool[:,:,0].T==2)] = "x-x"
-        # Directed contemporaneous links
-        for (i,j) in zip(*np.where(
-            np.logical_and(graph_bool[:,:,0]==1, graph_bool[:,:,0].T==0))):
-            graph[i,j,0] = "-->"
-            graph[j,i,0] = "<--"
-
-        return graph

-
-
-if __name__ == '__main__':
-    from tigramite.independence_tests import ParCorr, CMIknn
-    import tigramite.data_processing as pp
-    import tigramite.plotting as tp
-
-    np.random.seed(43)
-
-    # Example process to play around with
-    # Each key refers to a variable and the incoming links are supplied
-    # as a list of format [((var, -lag), coeff, function), ...]
-    def lin_f(x): return x
-    def nonlin_f(x): return (x + 5. * x ** 2 * np.exp(-x ** 2 / 20.))
-
-    links = {0: [((0, -1), 0.9, lin_f)],
-             1: [((1, -1), 0.8, lin_f), ((0, -1), 0.8, lin_f)],
-             2: [((2, -1), 0.7, lin_f), ((1, 0), 0.6, lin_f)],
-             3: [((3, -1), 0.7, lin_f), ((2, 0), -0.5, lin_f)],
-             }
-
-    data, nonstat = pp.structural_causal_process(links,
-                        T=1000, seed=7)
-
-    # Data must be array of shape (time, variables)
-    print(data.shape)
-    dataframe = pp.DataFrame(data)
-    cond_ind_test = ParCorr()
-    pcmci = PCMCI(dataframe=dataframe, cond_ind_test=cond_ind_test)
-    results = pcmci.run_pcmciplus(tau_min=0, tau_max=2, pc_alpha=0.01)
-    pcmci.print_results(results, alpha_level=0.01)
-
-
-
-
- -
-
-
-
-
- - - - \ No newline at end of file diff --git a/docs/_build/html/_modules/tigramite/plotting.html b/docs/_build/html/_modules/tigramite/plotting.html deleted file mode 100644 index 598b6778..00000000 --- a/docs/_build/html/_modules/tigramite/plotting.html +++ /dev/null @@ -1,3230 +0,0 @@ - - - - - - - tigramite.plotting — Tigramite 4.2 documentation - - - - - - - - - - - - - -
-
-
-
- -

Source code for tigramite.plotting

-"""Tigramite plotting package."""
-
-# Author: Jakob Runge <jakobrunge@posteo.de>
-#
-# License: GNU General Public License v3.0
-
-import numpy as np
-import matplotlib
-from matplotlib.colors import ListedColormap
-import matplotlib.transforms as transforms
-from matplotlib import pyplot, ticker
-from matplotlib.ticker import FormatStrFormatter
-import matplotlib.patches as mpatches
-from matplotlib.collections import PatchCollection
-
-import sys
-from operator import sub
-import networkx as nx
-import tigramite.data_processing as pp
-from copy import deepcopy
-import matplotlib.path as mpath
-import matplotlib.patheffects as PathEffects
-
-# TODO: Add proper docstrings to internal functions...
-
-
-def _par_corr_trafo(cmi):
-    """Transformation of CMI to partial correlation scale."""
-
-    # Set negative values to small positive number
-    # (zero would be interpreted as non-significant in some functions)
-    if np.ndim(cmi) == 0:
-        if cmi < 0.0:
-            cmi = 1e-8
-    else:
-        cmi[cmi < 0.0] = 1e-8
-
-    return np.sqrt(1.0 - np.exp(-2.0 * cmi))
-
-
-def _par_corr_to_cmi(par_corr):
-    """Transformation of partial correlation to CMI scale."""
-
-    return -0.5 * np.log(1.0 - par_corr ** 2)
-
-
-def _myround(x, base=5, round_mode="updown"):
-    """Rounds x to a float with precision base."""
-
-    if round_mode == "updown":
-        return base * round(float(x) / base)
-    elif round_mode == "down":
-        return base * np.floor(float(x) / base)
-    elif round_mode == "up":
-        return base * np.ceil(float(x) / base)
-
-    return base * round(float(x) / base)
-
-
-def _make_nice_axes(ax, where=None, skip=2, color=None):
-    """Makes nice axes."""
-
-    if where is None:
-        where = ["left", "bottom"]
-    if color is None:
-        color = {"left": "black", "right": "black", "bottom": "black", "top": "black"}
-
-    if type(skip) == int:
-        skip_x = skip_y = skip
-    else:
-        skip_x = skip[0]
-        skip_y = skip[1]
-
-    for loc, spine in ax.spines.items():
-        if loc in where:
-            spine.set_position(("outward", 5))  # outward by 10 points
-            spine.set_color(color[loc])
-            if loc == "left" or loc == "right":
-                pyplot.setp(ax.get_yticklines(), color=color[loc])
-                pyplot.setp(ax.get_yticklabels(), color=color[loc])
-            if loc == "top" or loc == "bottom":
-                pyplot.setp(ax.get_xticklines(), color=color[loc])
-        elif loc in [
-            item for item in ["left", "bottom", "right", "top"] if item not in where
-        ]:
-            spine.set_color("none")  # don't draw spine
-
-        else:
-            raise ValueError("unknown spine location: %s" % loc)
-
-    # ax.xaxis.get_major_formatter().set_useOffset(False)
-
-    # turn off ticks where there is no spine
-    if "top" in where and "bottom" not in where:
-        ax.xaxis.set_ticks_position("top")
-        ax.set_xticks(ax.get_xticks()[::skip_x])
-    elif "bottom" in where:
-        ax.xaxis.set_ticks_position("bottom")
-        ax.set_xticks(ax.get_xticks()[::skip_x])
-    else:
-        ax.xaxis.set_ticks_position("none")
-        ax.xaxis.set_ticklabels([])
-    if "right" in where and "left" not in where:
-        ax.yaxis.set_ticks_position("right")
-        ax.set_yticks(ax.get_yticks()[::skip_y])
-    elif "left" in where:
-        ax.yaxis.set_ticks_position("left")
-        ax.set_yticks(ax.get_yticks()[::skip_y])
-    else:
-        ax.yaxis.set_ticks_position("none")
-        ax.yaxis.set_ticklabels([])
-
-    ax.patch.set_alpha(0.0)
-
-
-def _get_absmax(val_matrix):
-    """Get value at absolute maximum in lag function array.
-    For an (N, N, tau)-array this comutes the lag of the absolute maximum
-    along the tau-axis and stores the (positive or negative) value in
-    the (N,N)-array absmax."""
-
-    absmax_indices = np.abs(val_matrix).argmax(axis=2)
-    i, j = np.indices(val_matrix.shape[:2])
-
-    return val_matrix[i, j, absmax_indices]
-
-
-def _add_timeseries(
-    fig,
-    axes,
-    i,
-    time,
-    dataseries,
-    label,
-    use_mask=False,
-    mask=None,
-    missing_flag=None,
-    grey_masked_samples=False,
-    data_linewidth=1.0,
-    skip_ticks_data_x=1,
-    skip_ticks_data_y=1,
-    unit=None,
-    last=False,
-    time_label="",
-    label_fontsize=10,
-    color="black",
-    grey_alpha=1.0,
-):
-    """Adds a time series plot to an axis.
-    Plot of dataseries is added to axis. Allows for proper visualization of
-    masked data.
-
-    Parameters
-    ----------
-    fig : figure instance
-        Figure instance.
-    axes : axis instance
-        Either gridded axis object or single axis instance.
-    i : int
-        Index of axis in gridded axis object.
-    time : array
-        Timelabel array.
-    dataseries : array-like
-        One-dimensional data series array of variable.
-    missing_flag : number, optional (default: None)
-        Flag for missing values in dataframe. Dismisses all time slices of
-        samples where missing values occur in any variable and also flags
-        samples for all lags up to 2*tau_max. This avoids biases, see section on
-        masking in Supplement of [1]_.
-    label : str
-        Variable label.
-    use_mask : bool, optional (default: False)
-        Whether to use masked data.
-    mask : array-like, optional (default: None)
-        Data mask where True labels masked samples.
-    grey_masked_samples : bool, optional (default: False)
-        Whether to mark masked samples by grey fills ('fill') or grey data
-        ('data').
-    data_linewidth : float, optional (default: 1.)
-        Linewidth.
-    skip_ticks_data_x : int, optional (default: 1)
-        Skip every other tickmark.
-    skip_ticks_data_y : int, optional (default: 1)
-        Skip every other tickmark.
-    unit : str, optional (default: None)
-        Units of variable.
-    last : bool, optional (default: False)
-        Specifiy whether this is the last panel where also the bottom axis is
-        plotted.
-    time_label : str, optional (default: '')
-        Label of time axis.
-    label_fontsize : int, optional (default: 10)
-        Fontsize.
-    color : str, optional (default: black)
-        Line color.
-    grey_alpha : float, optional (default: 1.)
-        Opacity of line.
-    """
-
-    # axes[i].xaxis.get_major_formatter().set_useOffset(False)
-    try:
-        ax = axes[i]
-    except:
-        ax = axes
-
-    if missing_flag is not None:
-        dataseries_nomissing = np.ma.masked_where(
-            dataseries == missing_flag, dataseries
-        )
-    else:
-        dataseries_nomissing = np.ma.masked_where(
-            np.zeros(dataseries.shape), dataseries
-        )
-
-    if use_mask:
-
-        maskdata = np.ma.masked_where(mask, dataseries_nomissing)
-
-        if grey_masked_samples == "fill":
-            ax.fill_between(
-                time,
-                maskdata.min(),
-                maskdata.max(),
-                where=mask,
-                color="grey",
-                interpolate=True,
-                linewidth=0.0,
-                alpha=grey_alpha,
-            )
-        elif grey_masked_samples == "data":
-            ax.plot(
-                time,
-                dataseries_nomissing,
-                color="grey",
-                marker=".",
-                markersize=data_linewidth,
-                linewidth=data_linewidth,
-                clip_on=False,
-                alpha=grey_alpha,
-            )
-
-        ax.plot(
-            time,
-            maskdata,
-            color=color,
-            linewidth=data_linewidth,
-            marker=".",
-            markersize=data_linewidth,
-            clip_on=False,
-        )
-    else:
-        ax.plot(
-            time,
-            dataseries_nomissing,
-            color=color,
-            linewidth=data_linewidth,
-            clip_on=False,
-        )
-
-    if last:
-        _make_nice_axes(
-            ax, where=["left", "bottom"], skip=(skip_ticks_data_x, skip_ticks_data_y)
-        )
-        ax.set_xlabel(r"%s" % time_label, fontsize=label_fontsize)
-    else:
-        _make_nice_axes(ax, where=["left"], skip=(skip_ticks_data_x, skip_ticks_data_y))
-    # ax.get_xaxis().get_major_formatter().set_useOffset(False)
-
-    ax.xaxis.set_major_formatter(FormatStrFormatter("%.0f"))
-    ax.label_outer()
-
-    ax.set_xlim(time[0], time[-1])
-
-    trans = transforms.blended_transform_factory(fig.transFigure, ax.transAxes)
-    if unit:
-        ax.set_ylabel(r"%s [%s]" % (label, unit), fontsize=label_fontsize)
-    else:
-        ax.set_ylabel(r"%s" % (label), fontsize=label_fontsize)
-
-        # ax.text(.02, .5, r'%s [%s]' % (label, unit), fontsize=label_fontsize,
-        #         horizontalalignment='left', verticalalignment='center',
-        #         rotation=90, transform=trans)
-    # else:
-    #     ax.text(.02, .5, r'%s' % (label), fontsize=label_fontsize,
-    #             horizontalalignment='left', verticalalignment='center',
-    #             rotation=90, transform=trans)
-    pyplot.tight_layout()
-
-
-
[docs]def plot_timeseries(
-    dataframe=None,
-    save_name=None,
-    fig_axes=None,
-    figsize=None,
-    var_units=None,
-    time_label="time",
-    use_mask=False,
-    grey_masked_samples=False,
-    data_linewidth=1.0,
-    skip_ticks_data_x=1,
-    skip_ticks_data_y=2,
-    label_fontsize=12,
-):
-    """Create and save figure of stacked panels with time series.
-
-    Parameters
-    ----------
-    dataframe : data object, optional
-        This is the Tigramite dataframe object. It has the attributes
-        dataframe.values yielding a np array of shape (observations T,
-        variables N) and optionally a mask of the same shape.
-    save_name : str, optional (default: None)
-        Name of figure file to save figure. If None, figure is shown in window.
-    fig_axes : subplots instance, optional (default: None)
-        Figure and axes instance. If None they are created as
-        fig, axes = pyplot.subplots(N,...)
-    figsize : tuple of floats, optional (default: None)
-        Figure size if new figure is created. If None, default pyplot figsize
-        is used.
-    var_units : list of str, optional (default: None)
-        Units of variables.
-    time_label : str, optional (default: '')
-        Label of time axis.
-    use_mask : bool, optional (default: False)
-        Whether to use masked data.
-    grey_masked_samples : bool, optional (default: False)
-        Whether to mark masked samples by grey fills ('fill') or grey data
-        ('data').
-    data_linewidth : float, optional (default: 1.)
-        Linewidth.
-    skip_ticks_data_x : int, optional (default: 1)
-        Skip every other tickmark.
-    skip_ticks_data_y : int, optional (default: 2)
-        Skip every other tickmark.
-    label_fontsize : int, optional (default: 10)
-        Fontsize of variable labels.
-    """
-
-    # Read in all attributes from dataframe
-    data = dataframe.values
-    mask = dataframe.mask
-    var_names = dataframe.var_names
-    missing_flag = dataframe.missing_flag
-    datatime = dataframe.datatime
-
-    T, N = data.shape
-
-    if var_units is None:
-        var_units = ["" for i in range(N)]
-
-    if fig_axes is None:
-        fig, axes = pyplot.subplots(N, sharex=True, figsize=figsize)
-    else:
-        fig, axes = fig_axes
-
-    for i in range(N):
-        if mask is None:
-            mask_i = None
-        else:
-            mask_i = mask[:, i]
-        _add_timeseries(
-            fig=fig,
-            axes=axes,
-            i=i,
-            time=datatime,
-            dataseries=data[:, i],
-            label=var_names[i],
-            use_mask=use_mask,
-            mask=mask_i,
-            missing_flag=missing_flag,
-            grey_masked_samples=grey_masked_samples,
-            data_linewidth=data_linewidth,
-            skip_ticks_data_x=skip_ticks_data_x,
-            skip_ticks_data_y=skip_ticks_data_y,
-            unit=var_units[i],
-            last=(i == N - 1),
-            time_label=time_label,
-            label_fontsize=label_fontsize,
-        )
-
-    fig.subplots_adjust(bottom=0.15, top=0.9, left=0.15, right=0.95, hspace=0.3)
-    pyplot.tight_layout()
-
-    if save_name is not None:
-        fig.savefig(save_name)
-    else:
-        return fig, axes

-
-
-
[docs]def plot_lagfuncs(val_matrix, name=None, setup_args={}, add_lagfunc_args={}):
-    """Wrapper helper function to plot lag functions.
-    Sets up the matrix object and plots the lagfunction, see parameters in
-    setup_matrix and add_lagfuncs.
-
-    Parameters
-    ----------
-    val_matrix : array_like
-        Matrix of shape (N, N, tau_max+1) containing test statistic values.
-    name : str, optional (default: None)
-        File name. If None, figure is shown in window.
-    setup_args : dict
-        Arguments for setting up the lag function matrix, see doc of
-        setup_matrix.
-    add_lagfunc_args : dict
-        Arguments for adding a lag function matrix, see doc of add_lagfuncs.
-
-    Returns
-    -------
-    matrix : object
-        Further lag functions can be overlaid using the
-        matrix.add_lagfuncs(val_matrix) function.
-    """
-
-    N, N, tau_max_plusone = val_matrix.shape
-    tau_max = tau_max_plusone - 1
-
-    matrix = setup_matrix(N=N, tau_max=tau_max, **setup_args)
-    matrix.add_lagfuncs(val_matrix=val_matrix, **add_lagfunc_args)
-
-    if name is not None:
-        matrix.savefig(name=name)
-
-    return matrix

-
-
-
[docs]class setup_matrix:
-    """Create matrix of lag function panels.
-    Class to setup figure object. The function add_lagfuncs(...) allows to plot
-    the val_matrix of shape (N, N, tau_max+1). Multiple lagfunctions can be
-    overlaid for comparison.
-
-    Parameters
-    ----------
-    N : int
-        Number of variables
-    tau_max : int
-        Maximum time lag.
-    var_names : list, optional (default: None)
-        List of variable names. If None, range(N) is used.
-    figsize : tuple of floats, optional (default: None)
-        Figure size if new figure is created. If None, default pyplot figsize
-        is used.
-    minimum : int, optional (default: -1)
-        Lower y-axis limit.
-    maximum : int, optional (default: 1)
-        Upper y-axis limit.
-    label_space_left : float, optional (default: 0.1)
-        Fraction of horizontal figure space to allocate left of plot for labels.
-    label_space_top : float, optional (default: 0.05)
-        Fraction of vertical figure space to allocate top of plot for labels.
-    legend_width : float, optional (default: 0.15)
-        Fraction of horizontal figure space to allocate right of plot for
-        legend.
-    x_base : float, optional (default: 1.)
-        x-tick intervals to show.
-    y_base : float, optional (default: .4)
-        y-tick intervals to show.
-    plot_gridlines : bool, optional (default: False)
-        Whether to show a grid.
-    lag_units : str, optional (default: '')
-    lag_array : array, optional (default: None)
-        Optional specification of lags overwriting np.arange(0, tau_max+1)
-    label_fontsize : int, optional (default: 10)
-        Fontsize of variable labels.
-    """
-
-    def __init__(
-        self,
-        N,
-        tau_max,
-        var_names=None,
-        figsize=None,
-        minimum=-1,
-        maximum=1,
-        label_space_left=0.1,
-        label_space_top=0.05,
-        legend_width=0.15,
-        legend_fontsize=10,
-        x_base=1.0,
-        y_base=0.5,
-        plot_gridlines=False,
-        lag_units="",
-        lag_array=None,
-        label_fontsize=10,
-    ):
-
-        self.tau_max = tau_max
-
-        self.labels = []
-        self.lag_units = lag_units
-        # if lag_array is None:
-        #     self.lag_array = np.arange(0, self.tau_max + 1)
-        # else:
-        self.lag_array = lag_array
-        if x_base is None:
-            self.x_base = 1
-        else:
-            self.x_base = x_base
-
-        self.legend_width = legend_width
-        self.legend_fontsize = legend_fontsize
-
-        self.label_space_left = label_space_left
-        self.label_space_top = label_space_top
-        self.label_fontsize = label_fontsize
-
-        self.fig = pyplot.figure(figsize=figsize)
-
-        self.axes_dict = {}
-
-        if var_names is None:
-            var_names = range(N)
-
-        plot_index = 1
-        for i in range(N):
-            for j in range(N):
-                self.axes_dict[(i, j)] = self.fig.add_subplot(N, N, plot_index)
-                # Plot process labels
-                if j == 0:
-                    trans = transforms.blended_transform_factory(
-                        self.fig.transFigure, self.axes_dict[(i, j)].transAxes
-                    )
-                    self.axes_dict[(i, j)].text(
-                        0.01,
-                        0.5,
-                        "%s" % str(var_names[i]),
-                        fontsize=label_fontsize,
-                        horizontalalignment="left",
-                        verticalalignment="center",
-                        transform=trans,
-                    )
-                if i == 0:
-                    trans = transforms.blended_transform_factory(
-                        self.axes_dict[(i, j)].transAxes, self.fig.transFigure
-                    )
-                    self.axes_dict[(i, j)].text(
-                        0.5,
-                        0.99,
-                        r"${\to}$ " + "%s" % str(var_names[j]),
-                        fontsize=label_fontsize,
-                        horizontalalignment="center",
-                        verticalalignment="top",
-                        transform=trans,
-                    )
-
-                # Make nice axis
-                _make_nice_axes(
-                    self.axes_dict[(i, j)], where=["left", "bottom"], skip=(1, 1)
-                )
-                if x_base is not None:
-                    self.axes_dict[(i, j)].xaxis.set_major_locator(
-                        ticker.FixedLocator(np.arange(0, self.tau_max + 1, x_base))
-                    )
-                    if x_base / 2.0 % 1 == 0:
-                        self.axes_dict[(i, j)].xaxis.set_minor_locator(
-                            ticker.FixedLocator(
-                                np.arange(0, self.tau_max + 1, x_base / 2.0)
-                            )
-                        )
-                if y_base is not None:
-                    self.axes_dict[(i, j)].yaxis.set_major_locator(
-                        ticker.FixedLocator(
-                            np.arange(
-                                _myround(minimum, y_base, "down"),
-                                _myround(maximum, y_base, "up") + y_base,
-                                y_base,
-                            )
-                        )
-                    )
-                    self.axes_dict[(i, j)].yaxis.set_minor_locator(
-                        ticker.FixedLocator(
-                            np.arange(
-                                _myround(minimum, y_base, "down"),
-                                _myround(maximum, y_base, "up") + y_base,
-                                y_base / 2.0,
-                            )
-                        )
-                    )
-
-                    self.axes_dict[(i, j)].set_ylim(
-                        _myround(minimum, y_base, "down"),
-                        _myround(maximum, y_base, "up"),
-                    )
-                if j != 0:
-                    self.axes_dict[(i, j)].get_yaxis().set_ticklabels([])
-                self.axes_dict[(i, j)].set_xlim(0, self.tau_max)
-                if plot_gridlines:
-                    self.axes_dict[(i, j)].grid(
-                        True,
-                        which="major",
-                        color="black",
-                        linestyle="dotted",
-                        dashes=(1, 1),
-                        linewidth=0.05,
-                        zorder=-5,
-                    )
-
-                plot_index += 1
-
-
[docs]    def add_lagfuncs(
-        self,
-        val_matrix,
-        sig_thres=None,
-        conf_matrix=None,
-        color="black",
-        label=None,
-        two_sided_thres=True,
-        marker=".",
-        markersize=5,
-        alpha=1.0,
-    ):
-        """Add lag function plot from val_matrix array.
-
-        Parameters
-        ----------
-        val_matrix : array_like
-            Matrix of shape (N, N, tau_max+1) containing test statistic values.
-        sig_thres : array-like, optional (default: None)
-            Matrix of significance thresholds. Must be of same shape as
-            val_matrix.
-        conf_matrix : array-like, optional (default: None)
-            Matrix of shape (, N, tau_max+1, 2) containing confidence bounds.
-        color : str, optional (default: 'black')
-            Line color.
-        label : str
-            Test statistic label.
-        two_sided_thres : bool, optional (default: True)
-            Whether to draw sig_thres for pos. and neg. values.
-        marker : matplotlib marker symbol, optional (default: '.')
-            Marker.
-        markersize : int, optional (default: 5)
-            Marker size.
-        alpha : float, optional (default: 1.)
-            Opacity.
-        """
-
-        if label is not None:
-            self.labels.append((label, color, marker, markersize, alpha))
-
-        for ij in list(self.axes_dict):
-            i = ij[0]
-            j = ij[1]
-            maskedres = np.copy(val_matrix[i, j, int(i == j) :])
-            self.axes_dict[(i, j)].plot(
-                range(int(i == j), self.tau_max + 1),
-                maskedres,
-                linestyle="",
-                color=color,
-                marker=marker,
-                markersize=markersize,
-                alpha=alpha,
-                clip_on=False,
-            )
-            if conf_matrix is not None:
-                maskedconfres = np.copy(conf_matrix[i, j, int(i == j) :])
-                self.axes_dict[(i, j)].plot(
-                    range(int(i == j), self.tau_max + 1),
-                    maskedconfres[:, 0],
-                    linestyle="",
-                    color=color,
-                    marker="_",
-                    markersize=markersize - 2,
-                    alpha=alpha,
-                    clip_on=False,
-                )
-                self.axes_dict[(i, j)].plot(
-                    range(int(i == j), self.tau_max + 1),
-                    maskedconfres[:, 1],
-                    linestyle="",
-                    color=color,
-                    marker="_",
-                    markersize=markersize - 2,
-                    alpha=alpha,
-                    clip_on=False,
-                )
-
-            self.axes_dict[(i, j)].plot(
-                range(int(i == j), self.tau_max + 1),
-                np.zeros(self.tau_max + 1 - int(i == j)),
-                color="black",
-                linestyle="dotted",
-                linewidth=0.1,
-            )
-
-            if sig_thres is not None:
-                maskedsigres = sig_thres[i, j, int(i == j) :]
-
-                self.axes_dict[(i, j)].plot(
-                    range(int(i == j), self.tau_max + 1),
-                    maskedsigres,
-                    color=color,
-                    linestyle="solid",
-                    linewidth=0.1,
-                    alpha=alpha,
-                )
-                if two_sided_thres:
-                    self.axes_dict[(i, j)].plot(
-                        range(int(i == j), self.tau_max + 1),
-                        -sig_thres[i, j, int(i == j) :],
-                        color=color,
-                        linestyle="solid",
-                        linewidth=0.1,
-                        alpha=alpha,
-                    )

-        # pyplot.tight_layout()
-
-
[docs]    def savefig(self, name=None):
-        """Save matrix figure.
-
-        Parameters
-        ----------
-        name : str, optional (default: None)
-            File name. If None, figure is shown in window.
-        """
-
-        # Trick to plot legend
-        if len(self.labels) > 0:
-            axlegend = self.fig.add_subplot(111, frameon=False)
-            axlegend.spines["left"].set_color("none")
-            axlegend.spines["right"].set_color("none")
-            axlegend.spines["bottom"].set_color("none")
-            axlegend.spines["top"].set_color("none")
-            axlegend.set_xticks([])
-            axlegend.set_yticks([])
-
-            # self.labels.append((label, color, marker, markersize, alpha))
-            for item in self.labels:
-                label = item[0]
-                color = item[1]
-                marker = item[2]
-                markersize = item[3]
-                alpha = item[4]
-
-                axlegend.plot(
-                    [],
-                    [],
-                    linestyle="",
-                    color=color,
-                    marker=marker,
-                    markersize=markersize,
-                    label=label,
-                    alpha=alpha,
-                )
-            axlegend.legend(
-                loc="upper left",
-                ncol=1,
-                bbox_to_anchor=(1.05, 0.0, 0.1, 1.0),
-                borderaxespad=0,
-                fontsize=self.legend_fontsize,
-            ).draw_frame(False)
-
-            self.fig.subplots_adjust(
-                left=self.label_space_left,
-                right=1.0 - self.legend_width,
-                top=1.0 - self.label_space_top,
-                hspace=0.35,
-                wspace=0.35,
-            )
-            pyplot.figtext(
-                0.5,
-                0.01,
-                r"lag $\tau$ [%s]" % self.lag_units,
-                horizontalalignment="center",
-                fontsize=self.label_fontsize,
-            )
-        else:
-            self.fig.subplots_adjust(
-                left=self.label_space_left,
-                right=0.95,
-                top=1.0 - self.label_space_top,
-                hspace=0.35,
-                wspace=0.35,
-            )
-            pyplot.figtext(
-                0.55,
-                0.01,
-                r"lag $\tau$ [%s]" % self.lag_units,
-                horizontalalignment="center",
-                fontsize=self.label_fontsize,
-            )
-
-        if self.lag_array is not None:
-            assert self.lag_array.shape == np.arange(self.tau_max + 1).shape
-            for ij in list(self.axes_dict):
-                i = ij[0]
-                j = ij[1]
-                self.axes_dict[(i, j)].set_xticklabels(self.lag_array[:: self.x_base])
-
-        if name is not None:
-            self.fig.savefig(name)
-        else:
-            pyplot.show()

-
-
-def _draw_network_with_curved_edges(
-    fig,
-    ax,
-    G,
-    pos,
-    node_rings,
-    node_labels,
-    node_label_size,
-    node_alpha=1.0,
-    standard_size=100,
-    node_aspect=None,
-    standard_cmap="OrRd",
-    standard_color="lightgrey",
-    log_sizes=False,
-    cmap_links="YlOrRd",
-    cmap_links_edges="YlOrRd",
-    links_vmin=0.0,
-    links_vmax=1.0,
-    links_edges_vmin=0.0,
-    links_edges_vmax=1.0,
-    links_ticks=0.2,
-    links_edges_ticks=0.2,
-    link_label_fontsize=8,
-    arrowstyle="->, head_width=0.4, head_length=1",
-    arrowhead_size=3.0,
-    curved_radius=0.2,
-    label_fontsize=4,
-    label_fraction=0.5,
-    link_colorbar_label="link",
-    # link_edge_colorbar_label='link_edge',
-    inner_edge_curved=False,
-    inner_edge_style="solid",
-    network_lower_bound=0.2,
-    show_colorbar=True,
-):
-    """Function to draw a network from networkx graph instance.
-    Various attributes are used to specify the graph's properties.
-    This function is just a beta-template for now that can be further
-    customized.
-    """
-
-    from matplotlib.patches import FancyArrowPatch, Circle, Ellipse
-
-    ax.spines["left"].set_color("none")
-    ax.spines["right"].set_color("none")
-    ax.spines["bottom"].set_color("none")
-    ax.spines["top"].set_color("none")
-    ax.set_xticks([])
-    ax.set_yticks([])
-
-    N = len(G)
-
-    # This fixes a positioning bug in matplotlib.
-    ax.scatter(0, 0, zorder=-10, alpha=0)
-
-    def draw_edge(
-        ax,
-        u,
-        v,
-        d,
-        seen,
-        arrowstyle="->, head_width=0.4, head_length=1",
-        outer_edge=True,
-    ):
-
-        # avoiding attribute error raised by changes in networkx
-        if hasattr(G, "node"):
-            # works with networkx 1.10
-            n1 = G.node[u]["patch"]
-            n2 = G.node[v]["patch"]
-        else:
-            # works with networkx 2.4
-            n1 = G.nodes[u]["patch"]
-            n2 = G.nodes[v]["patch"]
-
-        if outer_edge:
-            rad = -1.0 * curved_radius
-            if cmap_links is not None:
-                facecolor = data_to_rgb_links.to_rgba(d["outer_edge_color"])
-            else:
-                if d["outer_edge_color"] is not None:
-                    facecolor = d["outer_edge_color"]
-                else:
-                    facecolor = standard_color
-
-            width = d["outer_edge_width"]
-            alpha = d["outer_edge_alpha"]
-            if (u, v) in seen:
-                rad = seen.get((u, v))
-                rad = (rad + np.sign(rad) * 0.1) * -1.0
-            arrowstyle = arrowstyle
-            # link_edge = d['outer_edge_edge']
-            linestyle = d.get("outer_edge_style")
-
-            if d.get("outer_edge_attribute", None) == "spurious":
-                facecolor = "grey"
-
-            if d.get("outer_edge_type") in ["<-o", "<--", "<-x"]:
-                n1, n2 = n2, n1
-
-            if d.get("outer_edge_type") in [
-                "o-o",
-                "o--",
-                "--o",
-                "---",
-                "x-x",
-                "x--",
-                "--x",
-                "o-x",
-                "x-o",
-            ]:
-                arrowstyle = "-"
-                # linewidth = width*factor
-            elif d.get("outer_edge_type") == "<->":
-                arrowstyle = "<->, head_width=0.4, head_length=1"
-                # linewidth = width*factor
-            elif d.get("outer_edge_type") in ["o->", "-->", "<-o", "<--", "<-x", "x->"]:
-                arrowstyle = "->, head_width=0.4, head_length=1"
-
-        else:
-            rad = -1.0 * inner_edge_curved * curved_radius
-            if cmap_links is not None:
-                facecolor = data_to_rgb_links.to_rgba(d["inner_edge_color"])
-            else:
-                if d["inner_edge_color"] is not None:
-                    facecolor = d["inner_edge_color"]
-                else:
-                    facecolor = standard_color
-
-            width = d["inner_edge_width"]
-            alpha = d["inner_edge_alpha"]
-
-            if d.get("inner_edge_attribute", None) == "spurious":
-                facecolor = "grey"
-            if d.get("inner_edge_type") in ["<-o", "<--", "<-x"]:
-                n1, n2 = n2, n1
-
-            if d.get("inner_edge_type") in [
-                "o-o",
-                "o--",
-                "--o",
-                "---",
-                "x-x",
-                "x--",
-                "--x",
-                "o-x",
-                "x-o",
-            ]:
-                arrowstyle = "-"
-            elif d.get("inner_edge_type") == "<->":
-                arrowstyle = "<->, head_width=0.4, head_length=1"
-            elif d.get("inner_edge_type") in ["o->", "-->", "<-o", "<--", "<-x", "x->"]:
-                arrowstyle = "->, head_width=0.4, head_length=1"
-
-            linestyle = d.get("inner_edge_style")
-
-        coor1 = n1.center
-        coor2 = n2.center
-
-        marker_size = width ** 2
-        figuresize = fig.get_size_inches()
-
-        e_p = FancyArrowPatch(
-            coor1,
-            coor2,
-            arrowstyle=arrowstyle,
-            connectionstyle=f"arc3,rad={rad}",
-            mutation_scale=width,
-            lw=width / 2,
-            alpha=alpha,
-            linestyle=linestyle,
-            color=facecolor,
-            clip_on=False,
-            patchA=n1,
-            patchB=n2,
-            shrinkA=0,
-            shrinkB=0,
-            zorder=-1,
-        )
-
-        ax.add_artist(e_p)
-        path = e_p.get_path()
-        vertices = path.vertices.copy()
-        m, n = vertices.shape
-
-        start = vertices[0]
-        end = vertices[-1]
-
-        # This must be added to avoid rescaling of the plot, when no 'o'
-        # or 'x' is added to the graph.
-        ax.scatter(*start, zorder=-10, alpha=0)
-
-        if outer_edge:
-            if d.get("outer_edge_type") in ["o->", "o--"]:
-                circle_marker_start = ax.scatter(
-                    *start,
-                    marker="o",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_start)
-            elif d.get("outer_edge_type") == "<-o":
-                circle_marker_end = ax.scatter(
-                    *start,
-                    marker="o",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_end)
-            elif d.get("outer_edge_type") == "--o":
-                circle_marker_end = ax.scatter(
-                    *end,
-                    marker="o",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_end)
-            elif d.get("outer_edge_type") in ["x--", "x->"]:
-                circle_marker_start = ax.scatter(
-                    *start,
-                    marker="X",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_start)
-            elif d.get("outer_edge_type") == "<-x":
-                circle_marker_end = ax.scatter(
-                    *start,
-                    marker="X",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_end)
-            elif d.get("outer_edge_type") == "--x":
-                circle_marker_end = ax.scatter(
-                    *end,
-                    marker="X",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_end)
-            elif d.get("outer_edge_type") == "o-o":
-                circle_marker_start = ax.scatter(
-                    *start,
-                    marker="o",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_start)
-                circle_marker_end = ax.scatter(
-                    *end,
-                    marker="o",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_end)
-            elif d.get("outer_edge_type") == "x-x":
-                circle_marker_start = ax.scatter(
-                    *start,
-                    marker="X",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_start)
-                circle_marker_end = ax.scatter(
-                    *end,
-                    marker="X",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_end)
-            elif d.get("outer_edge_type") == "o-x":
-                circle_marker_start = ax.scatter(
-                    *start,
-                    marker="o",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_start)
-                circle_marker_end = ax.scatter(
-                    *end,
-                    marker="X",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_end)
-            elif d.get("outer_edge_type") == "x-o":
-                circle_marker_start = ax.scatter(
-                    *start,
-                    marker="X",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_start)
-                circle_marker_end = ax.scatter(
-                    *end,
-                    marker="o",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_end)
-
-        else:
-            if d.get("inner_edge_type") in ["o->", "o--"]:
-                circle_marker_start = ax.scatter(
-                    *start,
-                    marker="o",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_start)
-            elif d.get("outer_edge_type") == "<-o":
-                circle_marker_end = ax.scatter(
-                    *start,
-                    marker="o",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_end)
-            elif d.get("outer_edge_type") == "--o":
-                circle_marker_end = ax.scatter(
-                    *end,
-                    marker="o",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_end)
-            elif d.get("inner_edge_type") in ["x--", "x->"]:
-                circle_marker_start = ax.scatter(
-                    *start,
-                    marker="X",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_start)
-            elif d.get("outer_edge_type") == "<-x":
-                circle_marker_end = ax.scatter(
-                    *start,
-                    marker="X",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_end)
-            elif d.get("outer_edge_type") == "--x":
-                circle_marker_end = ax.scatter(
-                    *end,
-                    marker="X",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_end)
-            elif d.get("inner_edge_type") == "o-o":
-                circle_marker_start = ax.scatter(
-                    *start,
-                    marker="o",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_start)
-                circle_marker_end = ax.scatter(
-                    *end,
-                    marker="o",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_end)
-            elif d.get("inner_edge_type") == "x-x":
-                circle_marker_start = ax.scatter(
-                    *start,
-                    marker="X",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_start)
-                circle_marker_end = ax.scatter(
-                    *end,
-                    marker="X",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_end)
-            elif d.get("inner_edge_type") == "o-x":
-                circle_marker_start = ax.scatter(
-                    *start,
-                    marker="o",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_start)
-                circle_marker_end = ax.scatter(
-                    *end,
-                    marker="X",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_end)
-            elif d.get("inner_edge_type") == "x-o":
-                circle_marker_start = ax.scatter(
-                    *start,
-                    marker="X",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_start)
-                circle_marker_end = ax.scatter(
-                    *end,
-                    marker="o",
-                    s=marker_size,
-                    facecolor="w",
-                    edgecolor=facecolor,
-                    zorder=1,
-                )
-                ax.add_collection(circle_marker_end)
-
-        if d["label"] is not None and outer_edge:
-            # Attach labels of lags
-            trans = None  # patch.get_transform()
-            path = e_p.get_path()
-            verts = path.to_polygons(trans)[0]
-            if len(verts) > 2:
-                label_vert = verts[1, :]
-                l = d["label"]
-                string = str(l)
-                txt = ax.text(
-                    label_vert[0],
-                    label_vert[1],
-                    string,
-                    fontsize=link_label_fontsize,
-                    verticalalignment="center",
-                    horizontalalignment="center",
-                    color="w",
-                    zorder=1,
-                )
-                txt.set_path_effects(
-                    [PathEffects.withStroke(linewidth=2, foreground="k")]
-                )
-
-        return rad
-
-    # Collect all edge weights to get color scale
-    all_links_weights = []
-    all_links_edge_weights = []
-    for (u, v, d) in G.edges(data=True):
-        if u != v:
-            if d["outer_edge"] and d["outer_edge_color"] is not None:
-                all_links_weights.append(d["outer_edge_color"])
-            if d["inner_edge"] and d["inner_edge_color"] is not None:
-                all_links_weights.append(d["inner_edge_color"])
-
-    if cmap_links is not None and len(all_links_weights) > 0:
-        if links_vmin is None:
-            links_vmin = np.array(all_links_weights).min()
-        if links_vmax is None:
-            links_vmax = np.array(all_links_weights).max()
-        data_to_rgb_links = pyplot.cm.ScalarMappable(
-            norm=None, cmap=pyplot.get_cmap(cmap_links)
-        )
-        data_to_rgb_links.set_array(np.array(all_links_weights))
-        data_to_rgb_links.set_clim(vmin=links_vmin, vmax=links_vmax)
-        # Create colorbars for links
-
-        # setup colorbar axes.
-        if show_colorbar:
-            cax_e = pyplot.axes(
-                [
-                    0.55,
-                    ax.figbox.bounds[1] + 0.02,
-                    0.4,
-                    0.025 + (len(all_links_edge_weights) == 0) * 0.035,
-                ],
-                frameon=False,
-            )
-
-            cb_e = pyplot.colorbar(
-                data_to_rgb_links, cax=cax_e, orientation="horizontal"
-            )
-            # try:
-            cb_e.set_ticks(
-                np.arange(
-                    _myround(links_vmin, links_ticks, "down"),
-                    _myround(links_vmax, links_ticks, "up") + links_ticks,
-                    links_ticks,
-                )
-            )
-            # except:
-            #     print('no ticks given')
-
-            cb_e.outline.remove()
-            cax_e.set_xlabel(
-                link_colorbar_label, labelpad=1, fontsize=label_fontsize, zorder=-10
-            )
-
-    ##
-    # Draw nodes
-    ##
-    node_sizes = np.zeros((len(node_rings), N))
-    for ring in list(node_rings):  # iterate through to get all node sizes
-        if node_rings[ring]["sizes"] is not None:
-            node_sizes[ring] = node_rings[ring]["sizes"]
-
-        else:
-            node_sizes[ring] = standard_size
-    max_sizes = node_sizes.max(axis=1)
-    total_max_size = node_sizes.sum(axis=0).max()
-    node_sizes /= total_max_size
-    node_sizes *= standard_size
-
-    def get_aspect(ax):
-        # Total figure size
-        figW, figH = ax.get_figure().get_size_inches()
-        # print(figW, figH)
-        # Axis size on figure
-        _, _, w, h = ax.get_position().bounds
-        # Ratio of display units
-        # print(w, h)
-        disp_ratio = (figH * h) / (figW * w)
-        # Ratio of data units
-        # Negative over negative because of the order of subtraction
-        data_ratio = sub(*ax.get_ylim()) / sub(*ax.get_xlim())
-        # print(data_ratio, disp_ratio)
-        return disp_ratio / data_ratio
-
-    if node_aspect is None:
-        node_aspect = get_aspect(ax)
-
-    # start drawing the outer ring first...
-    for ring in list(node_rings)[::-1]:
-        #        print ring
-        # dictionary of rings: {0:{'sizes':(N,)-array, 'color_array':(N,)-array
-        # or None, 'cmap':string, 'vmin':float or None, 'vmax':float or None}}
-        if node_rings[ring]["color_array"] is not None:
-            color_data = node_rings[ring]["color_array"]
-            if node_rings[ring]["vmin"] is not None:
-                vmin = node_rings[ring]["vmin"]
-            else:
-                vmin = node_rings[ring]["color_array"].min()
-            if node_rings[ring]["vmax"] is not None:
-                vmax = node_rings[ring]["vmax"]
-            else:
-                vmax = node_rings[ring]["color_array"].max()
-            if node_rings[ring]["cmap"] is not None:
-                cmap = node_rings[ring]["cmap"]
-            else:
-                cmap = standard_cmap
-            data_to_rgb = pyplot.cm.ScalarMappable(
-                norm=None, cmap=pyplot.get_cmap(cmap)
-            )
-            data_to_rgb.set_array(color_data)
-            data_to_rgb.set_clim(vmin=vmin, vmax=vmax)
-            colors = [data_to_rgb.to_rgba(color_data[n]) for n in G]
-
-            if node_rings[ring]["colorbar"]:
-                # Create colorbars for nodes
-                # cax_n = pyplot.axes([.8 + ring*0.11,
-                # ax.figbox.bounds[1]+0.05, 0.025, 0.35], frameon=False) #
-                # setup colorbar axes.
-                # setup colorbar axes.
-                cax_n = pyplot.axes(
-                    [
-                        0.05,
-                        ax.figbox.bounds[1] + 0.02 + ring * 0.11,
-                        0.4,
-                        0.025 + (len(node_rings) == 1) * 0.035,
-                    ],
-                    frameon=False,
-                )
-                cb_n = pyplot.colorbar(data_to_rgb, cax=cax_n, orientation="horizontal")
-                # try:
-                cb_n.set_ticks(
-                    np.arange(
-                        _myround(vmin, node_rings[ring]["ticks"], "down"),
-                        _myround(vmax, node_rings[ring]["ticks"], "up")
-                        + node_rings[ring]["ticks"],
-                        node_rings[ring]["ticks"],
-                    )
-                )
-                # except:
-                #     print ('no ticks given')
-                cb_n.outline.remove()
-                # cb_n.set_ticks()
-                cax_n.set_xlabel(
-                    node_rings[ring]["label"], labelpad=1, fontsize=label_fontsize
-                )
-        else:
-            colors = None
-            vmin = None
-            vmax = None
-
-        for n in G:
-            if type(node_alpha) == dict:
-                alpha = node_alpha[n]
-            else:
-                alpha = 1.0
-
-            if colors is None:
-                c = Ellipse(
-                    pos[n],
-                    width=node_sizes[: ring + 1].sum(axis=0)[n] * node_aspect,
-                    height=node_sizes[: ring + 1].sum(axis=0)[n],
-                    clip_on=False,
-                    facecolor=standard_color,
-                    edgecolor=standard_color,
-                    zorder=-ring - 1,
-                )
-
-            else:
-                c = Ellipse(
-                    pos[n],
-                    width=node_sizes[: ring + 1].sum(axis=0)[n] * node_aspect,
-                    height=node_sizes[: ring + 1].sum(axis=0)[n],
-                    clip_on=False,
-                    facecolor=colors[n],
-                    edgecolor=colors[n],
-                    zorder=-ring - 1,
-                )
-
-            ax.add_patch(c)
-
-            # avoiding attribute error raised by changes in networkx
-            if hasattr(G, "node"):
-                # works with networkx 1.10
-                G.node[n]["patch"] = c
-            else:
-                # works with networkx 2.4
-                G.nodes[n]["patch"] = c
-
-            if ring == 0:
-                ax.text(
-                    pos[n][0],
-                    pos[n][1],
-                    node_labels[n],
-                    fontsize=node_label_size,
-                    horizontalalignment="center",
-                    verticalalignment="center",
-                    alpha=1.0,
-                )
-
-    # Draw edges
-    seen = {}
-    for (u, v, d) in G.edges(data=True):
-        if d.get("no_links"):
-            d["inner_edge_alpha"] = 1e-8
-            d["outer_edge_alpha"] = 1e-8
-        if u != v:
-            if d["outer_edge"]:
-                seen[(u, v)] = draw_edge(ax, u, v, d, seen, arrowstyle, outer_edge=True)
-            if d["inner_edge"]:
-                seen[(u, v)] = draw_edge(ax, u, v, d, seen, outer_edge=False)
-
-    pyplot.subplots_adjust(bottom=network_lower_bound)
-
-
-
[docs]def plot_graph(
-    link_matrix=None,
-    val_matrix=None,
-    sig_thres=None,
-    var_names=None,
-    fig_ax=None,
-    figsize=None,
-    save_name=None,
-    link_colorbar_label="MCI",
-    node_colorbar_label="auto-MCI",
-    link_width=None,
-    link_attribute=None,
-    node_pos=None,
-    arrow_linewidth=10.0,
-    vmin_edges=-1,
-    vmax_edges=1.0,
-    edge_ticks=0.4,
-    cmap_edges="RdBu_r",
-    vmin_nodes=0,
-    vmax_nodes=1.0,
-    node_ticks=0.4,
-    cmap_nodes="OrRd",
-    node_size=0.3,
-    node_aspect=None,
-    arrowhead_size=20,
-    curved_radius=0.2,
-    label_fontsize=10,
-    alpha=1.0,
-    node_label_size=10,
-    link_label_fontsize=10,
-    lag_array=None,
-    network_lower_bound=0.2,
-    show_colorbar=True,
-    inner_edge_style="dashed",
-):
-    """Creates a network plot.
-    This is still in beta. The network is defined either from True values in
-    link_matrix, or from thresholding the val_matrix with sig_thres.  Nodes
-    denote variables, straight links contemporaneous dependencies and curved
-    arrows lagged dependencies. The node color denotes the maximal absolute
-    auto-dependency and the link color the value at the lag with maximal
-    absolute cross-dependency. The link label lists the lags with significant
-    dependency in order of absolute magnitude. The network can also be plotted
-    over a map drawn before on the same axis. Then the node positions can be
-    supplied in appropriate axis coordinates via node_pos.
-
-    Parameters
-    ----------
-    link_matrix : bool array-like, optional (default: None)
-        Matrix of significant links. Must be of same shape as val_matrix. Either
-        sig_thres or link_matrix has to be provided.
-    val_matrix : array_like
-        Matrix of shape (N, N, tau_max+1) containing test statistic values.
-    sig_thres : array-like, optional (default: None)
-        Matrix of significance thresholds. Must be of same shape as  val_matrix.
-        Either sig_thres or link_matrix has to be provided.
-    var_names : list, optional (default: None)
-        List of variable names. If None, range(N) is used.
-    fig_ax : tuple of figure and axis object, optional (default: None)
-        Figure and axes instance. If None they are created.
-    figsize : tuple
-        Size of figure.
-    save_name : str, optional (default: None)
-        Name of figure file to save figure. If None, figure is shown in window.
-    link_colorbar_label : str, optional (default: 'MCI')
-        Test statistic label.
-    node_colorbar_label : str, optional (default: 'auto-MCI')
-        Test statistic label for auto-dependencies.
-    link_width : array-like, optional (default: None)
-        Array of val_matrix.shape specifying relative link width with maximum
-        given by arrow_linewidth. If None, all links have same width.
-    link_attribute : array-like, optional (default: None)
-        String array of val_matrix.shape specifying link attributes.
-    node_pos : dictionary, optional (default: None)
-        Dictionary of node positions in axis coordinates of form
-        node_pos = {'x':array of shape (N,), 'y':array of shape(N)}. These
-        coordinates could have been transformed before for basemap plots.
-    arrow_linewidth : float, optional (default: 30)
-        Linewidth.
-    vmin_edges : float, optional (default: -1)
-        Link colorbar scale lower bound.
-    vmax_edges : float, optional (default: 1)
-        Link colorbar scale upper bound.
-    edge_ticks : float, optional (default: 0.4)
-        Link tick mark interval.
-    cmap_edges : str, optional (default: 'RdBu_r')
-        Colormap for links.
-    vmin_nodes : float, optional (default: 0)
-        Node colorbar scale lower bound.
-    vmax_nodes : float, optional (default: 1)
-        Node colorbar scale upper bound.
-    node_ticks : float, optional (default: 0.4)
-        Node tick mark interval.
-    cmap_nodes : str, optional (default: 'OrRd')
-        Colormap for links.
-    node_size : int, optional (default: 0.3)
-        Node size.
-    node_aspect : float, optional (default: None)
-        Ratio between the heigth and width of the varible nodes.
-    arrowhead_size : int, optional (default: 20)
-        Size of link arrow head. Passed on to FancyArrowPatch object.
-    curved_radius, float, optional (default: 0.2)
-        Curvature of links. Passed on to FancyArrowPatch object.
-    label_fontsize : int, optional (default: 10)
-        Fontsize of colorbar labels.
-    alpha : float, optional (default: 1.)
-        Opacity.
-    node_label_size : int, optional (default: 10)
-        Fontsize of node labels.
-    link_label_fontsize : int, optional (default: 6)
-        Fontsize of link labels.
-    lag_array : array, optional (default: None)
-        Optional specification of lags overwriting np.arange(0, tau_max+1)
-    network_lower_bound : float, optional (default: 0.2)
-        Fraction of vertical space below graph plot.
-    show_colorbar : bool
-        Whether to show colorbars for links and nodes.
-    """
-
-    if fig_ax is None:
-        fig = pyplot.figure(figsize=figsize)
-        ax = fig.add_subplot(111, frame_on=False)
-    else:
-        fig, ax = fig_ax
-
-    (link_matrix, val_matrix, link_width, link_attribute) = _check_matrices(
-        link_matrix, val_matrix, link_width, link_attribute, sig_thres
-    )
-
-    N, N, dummy = val_matrix.shape
-    tau_max = dummy - 1
-
-    if np.count_nonzero(link_matrix != "") == np.count_nonzero(
-        np.diagonal(link_matrix) != ""
-    ):
-        diagonal = True
-    else:
-        diagonal = False
-
-    if np.count_nonzero(link_matrix == "") == link_matrix.size or diagonal:
-        link_matrix[0, 1, 0] = "---"
-        no_links = True
-    else:
-        no_links = False
-
-    if var_names is None:
-        var_names = range(N)
-
-    # Define graph links by absolute maximum (positive or negative like for
-    # partial correlation)
-    # val_matrix[np.abs(val_matrix) < sig_thres] = 0.
-
-    # Only draw link in one direction among contemp
-    # Remove lower triangle
-    link_matrix_upper = np.copy(link_matrix)
-    link_matrix_upper[:, :, 0] = np.triu(link_matrix_upper[:, :, 0])
-
-    # net = _get_absmax(link_matrix != "")
-    net = np.any(link_matrix_upper != "", axis=2)
-    G = nx.DiGraph(net)
-
-    # This handels Graphs with no links.
-    # nx.draw(G, alpha=0, zorder=-10)
-
-    node_color = np.zeros(N)
-    # list of all strengths for color map
-    all_strengths = []
-    # Add attributes, contemporaneous and lagged links are handled separately
-    for (u, v, dic) in G.edges(data=True):
-        dic["no_links"] = no_links
-        # average lagfunc for link u --> v ANDOR u -- v
-        if tau_max > 0:
-            # argmax of absolute maximum
-            argmax = np.abs(val_matrix[u, v][1:]).argmax() + 1
-        else:
-            argmax = 0
-
-        if u != v:
-            # For contemp links masking or finite samples can lead to different
-            # values for u--v and v--u
-            # Here we use the  maximum for the width and weight (=color)
-            # of the link
-            # Draw link if u--v OR v--u at lag 0 is nonzero
-            # dic['inner_edge'] = ((np.abs(val_matrix[u, v][0]) >=
-            #                       sig_thres[u, v][0]) or
-            #                      (np.abs(val_matrix[v, u][0]) >=
-            #                       sig_thres[v, u][0]))
-            dic["inner_edge"] = link_matrix_upper[u, v, 0]
-            dic["inner_edge_type"] = link_matrix_upper[u, v, 0]
-            dic["inner_edge_alpha"] = alpha
-            dic["inner_edge_color"] = val_matrix[u, v, 0]
-            # # value at argmax of average
-            # if np.abs(val_matrix[u, v][0] - val_matrix[v, u][0]) > .0001:
-            #     print("Contemporaneous I(%d; %d)=%.3f != I(%d; %d)=%.3f" % (
-            #           u, v, val_matrix[u, v][0], v, u, val_matrix[v, u][0]) +
-            #           " due to conditions, finite sample effects or "
-            #           "masking, here edge color = "
-            #           "larger (absolute) value.")
-            # dic['inner_edge_color'] = _get_absmax(
-            #     np.array([[[val_matrix[u, v][0],
-            #                    val_matrix[v, u][0]]]])).squeeze()
-
-            if link_width is None:
-                dic["inner_edge_width"] = arrow_linewidth
-            else:
-                dic["inner_edge_width"] = (
-                    link_width[u, v, 0] / link_width.max() * arrow_linewidth
-                )
-
-            if link_attribute is None:
-                dic["inner_edge_attribute"] = None
-            else:
-                dic["inner_edge_attribute"] = link_attribute[u, v, 0]
-
-            #     # fraction of nonzero values
-            dic["inner_edge_style"] = "solid"
-            # else:
-            # dic['inner_edge_style'] = link_style[
-            #         u, v, 0]
-
-            all_strengths.append(dic["inner_edge_color"])
-
-            if tau_max > 0:
-                # True if ensemble mean at lags > 0 is nonzero
-                # dic['outer_edge'] = np.any(
-                #     np.abs(val_matrix[u, v][1:]) >= sig_thres[u, v][1:])
-                dic["outer_edge"] = np.any(link_matrix_upper[u, v, 1:] != "")
-            else:
-                dic["outer_edge"] = False
-
-            dic["outer_edge_type"] = link_matrix_upper[u, v, argmax]
-
-            dic["outer_edge_alpha"] = alpha
-            if link_width is None:
-                # fraction of nonzero values
-                dic["outer_edge_width"] = arrow_linewidth
-            else:
-                dic["outer_edge_width"] = (
-                    link_width[u, v, argmax] / link_width.max() * arrow_linewidth
-                )
-
-            if link_attribute is None:
-                # fraction of nonzero values
-                dic["outer_edge_attribute"] = None
-            else:
-                dic["outer_edge_attribute"] = link_attribute[u, v, argmax]
-
-            # value at argmax of average
-            dic["outer_edge_color"] = val_matrix[u, v][argmax]
-            all_strengths.append(dic["outer_edge_color"])
-
-            # Sorted list of significant lags (only if robust wrt
-            # d['min_ensemble_frac'])
-            if tau_max > 0:
-                lags = np.abs(val_matrix[u, v][1:]).argsort()[::-1] + 1
-                sig_lags = (np.where(link_matrix_upper[u, v, 1:] != "")[0] + 1).tolist()
-            else:
-                lags, sig_lags = [], []
-            if lag_array is not None:
-                dic["label"] = str([lag_array[l] for l in lags if l in sig_lags])[1:-1]
-            else:
-                dic["label"] = str([l for l in lags if l in sig_lags])[1:-1]
-        else:
-            # Node color is max of average autodependency
-            node_color[u] = val_matrix[u, v][argmax]
-            dic["inner_edge_attribute"] = None
-            dic["outer_edge_attribute"] = None
-
-        # dic['outer_edge_edge'] = False
-        # dic['outer_edge_edgecolor'] = None
-        # dic['inner_edge_edge'] = False
-        # dic['inner_edge_edgecolor'] = None
-
-    # If no links are present, set value to zero
-    if len(all_strengths) == 0:
-        all_strengths = [0.0]
-
-    if node_pos is None:
-        pos = nx.circular_layout(deepcopy(G))
-    else:
-        pos = {}
-        for i in range(N):
-            pos[i] = (node_pos["x"][i], node_pos["y"][i])
-
-    if cmap_nodes is None:
-        node_color = None
-
-    node_rings = {
-        0: {
-            "sizes": None,
-            "color_array": node_color,
-            "cmap": cmap_nodes,
-            "vmin": vmin_nodes,
-            "vmax": vmax_nodes,
-            "ticks": node_ticks,
-            "label": node_colorbar_label,
-            "colorbar": show_colorbar,
-        }
-    }
-
-    _draw_network_with_curved_edges(
-        fig=fig,
-        ax=ax,
-        G=deepcopy(G),
-        pos=pos,
-        # dictionary of rings: {0:{'sizes':(N,)-array, 'color_array':(N,)-array
-        # or None, 'cmap':string,
-        node_rings=node_rings,
-        # 'vmin':float or None, 'vmax':float or None, 'label':string or None}}
-        node_labels=var_names,
-        node_label_size=node_label_size,
-        node_alpha=alpha,
-        standard_size=node_size,
-        node_aspect=node_aspect,
-        standard_cmap="OrRd",
-        standard_color="orange",
-        log_sizes=False,
-        cmap_links=cmap_edges,
-        links_vmin=vmin_edges,
-        links_vmax=vmax_edges,
-        links_ticks=edge_ticks,
-        # cmap_links_edges='YlOrRd', links_edges_vmin=-1., links_edges_vmax=1.,
-        # links_edges_ticks=.2, link_edge_colorbar_label='link_edge',
-        arrowstyle="simple",
-        arrowhead_size=arrowhead_size,
-        curved_radius=curved_radius,
-        label_fontsize=label_fontsize,
-        link_label_fontsize=link_label_fontsize,
-        link_colorbar_label=link_colorbar_label,
-        network_lower_bound=network_lower_bound,
-        show_colorbar=show_colorbar,
-        # label_fraction=label_fraction,
-    )
-
-    if save_name is not None:
-        pyplot.savefig(save_name, dpi=300)
-    else:
-        return fig, ax

-
-
-def _reverse_patt(patt):
-    """Inverts a link pattern"""
-
-    if patt == "":
-        return ""
-
-    left_mark, middle_mark, right_mark = patt[0], patt[1], patt[2]
-    if left_mark == "<":
-        new_right_mark = ">"
-    else:
-        new_right_mark = left_mark
-    if right_mark == ">":
-        new_left_mark = "<"
-    else:
-        new_left_mark = right_mark
-
-    return new_left_mark + middle_mark + new_right_mark
-
-    # if patt in ['---', 'o--', '--o', 'o-o', '']:
-    #     return patt[::-1]
-    # elif patt == '<->':
-    #     return '<->'
-    # elif patt == 'o->':
-    #     return '<-o'
-    # elif patt == '<-o':
-    #     return 'o->'
-    # elif patt == '-->':
-    #     return '<--'
-    # elif patt == '<--':
-    #     return '-->'
-
-
-def _check_matrices(link_matrix, val_matrix, link_width, link_attribute, sig_thres):
-    if link_matrix is None and (val_matrix is None or sig_thres is None):
-        raise ValueError(
-            "Need to specify either val_matrix together with sig_thres, or link_matrix"
-        )
-
-    if link_matrix is not None:
-        pass
-    elif link_matrix is None and sig_thres is not None and val_matrix is not None:
-        link_matrix = np.abs(val_matrix) >= sig_thres
-    else:
-        raise ValueError(
-            "Need to specify either val_matrix together with sig_thres, or link_matrix"
-        )
-
-    if link_matrix.dtype != "<U3":
-        # Transform to new link_matrix data type U3
-        old_matrix = np.copy(link_matrix)
-        link_matrix = np.zeros(old_matrix.shape, dtype="<U3")
-        link_matrix[:] = ""
-        for i, j, tau in zip(*np.where(old_matrix)):
-            if tau == 0:
-                if old_matrix[j, i, 0] == 0:
-                    link_matrix[i, j, 0] = "-->"
-                    link_matrix[j, i, 0] = "<--"
-                else:
-                    link_matrix[i, j, 0] = "o-o"
-                    link_matrix[j, i, 0] = "o-o"
-            else:
-                link_matrix[i, j, tau] = "-->"
-    else:
-        # print(link_matrix[:,:,0])
-        # Assert that link_matrix has valid and consistent lag-zero entries
-        for i, j, tau in zip(*np.where(link_matrix)):
-            if tau == 0:
-                if link_matrix[i, j, 0] != _reverse_patt(link_matrix[j, i, 0]):
-                    raise ValueError(
-                        "link_matrix needs to have consistent lag-zero patterns (eg"
-                        " link_matrix[i,j,0]='-->' requires link_matrix[j,i,0]='<--')"
-                    )
-                if (
-                    val_matrix is not None
-                    and val_matrix[i, j, 0] != val_matrix[j, i, 0]
-                ):
-                    raise ValueError("val_matrix needs to be symmetric for lag-zero")
-                if (
-                    link_width is not None
-                    and link_width[i, j, 0] != link_width[j, i, 0]
-                ):
-                    raise ValueError("link_width needs to be symmetric for lag-zero")
-                if (
-                    link_attribute is not None
-                    and link_attribute[i, j, 0] != link_attribute[j, i, 0]
-                ):
-                    raise ValueError(
-                        "link_attribute needs to be symmetric for lag-zero"
-                    )
-
-            if link_matrix[i, j, tau] not in [
-                "---",
-                "o--",
-                "--o",
-                "o-o",
-                "o->",
-                "<-o",
-                "-->",
-                "<--",
-                "<->",
-                "x-o",
-                "o-x",
-                "x--",
-                "--x",
-                "x->",
-                "<-x",
-                "x-x",
-            ]:
-                raise ValueError("Invalid link_matrix entry.")
-
-    if val_matrix is None:
-        val_matrix = (link_matrix != "").astype("int")
-
-    if link_width is not None and not np.all(link_width >= 0.0):
-        raise ValueError("link_width must be non-negative")
-
-    return link_matrix, val_matrix, link_width, link_attribute
-
-
-
[docs]def plot_time_series_graph(
-    link_matrix=None,
-    val_matrix=None,
-    sig_thres=None,
-    var_names=None,
-    fig_ax=None,
-    figsize=None,
-    link_colorbar_label="MCI",
-    save_name=None,
-    link_width=None,
-    link_attribute=None,
-    arrow_linewidth=8,
-    vmin_edges=-1,
-    vmax_edges=1.0,
-    edge_ticks=0.4,
-    cmap_edges="RdBu_r",
-    order=None,
-    node_size=0.1,
-    node_aspect=None,
-    arrowhead_size=20,
-    curved_radius=0.2,
-    label_fontsize=12,
-    alpha=1.0,
-    node_label_size=12,
-    label_space_left=0.1,
-    label_space_top=0.0,
-    network_lower_bound=0.2,
-    inner_edge_style="dashed",
-):
-    """Creates a time series graph.
-    This is still in beta. The time series graph's links are colored by
-    val_matrix.
-
-    Parameters
-    ----------
-    link_matrix : bool array-like, optional (default: None)
-        Matrix of significant links. Must be of same shape as val_matrix. Either
-        sig_thres or link_matrix has to be provided.
-    val_matrix : array_like
-        Matrix of shape (N, N, tau_max+1) containing test statistic values.
-    sig_thres : array-like, optional (default: None)
-        Matrix of significance thresholds. Must be of same shape as  val_matrix.
-        Either sig_thres or link_matrix has to be provided.
-    var_names : list, optional (default: None)
-        List of variable names. If None, range(N) is used.
-    fig_ax : tuple of figure and axis object, optional (default: None)
-        Figure and axes instance. If None they are created.
-    figsize : tuple
-        Size of figure.
-    save_name : str, optional (default: None)
-        Name of figure file to save figure. If None, figure is shown in window.
-    link_colorbar_label : str, optional (default: 'MCI')
-        Test statistic label.
-    link_width : array-like, optional (default: None)
-        Array of val_matrix.shape specifying relative link width with maximum
-        given by arrow_linewidth. If None, all links have same width.
-    order : list, optional (default: None)
-        order of variables from top to bottom.
-    arrow_linewidth : float, optional (default: 30)
-        Linewidth.
-    vmin_edges : float, optional (default: -1)
-        Link colorbar scale lower bound.
-    vmax_edges : float, optional (default: 1)
-        Link colorbar scale upper bound.
-    edge_ticks : float, optional (default: 0.4)
-        Link tick mark interval.
-    cmap_edges : str, optional (default: 'RdBu_r')
-        Colormap for links.
-    node_size : int, optional (default: 0.1)
-        Node size.
-    node_aspect : float, optional (default: None)
-        Ratio between the heigth and width of the varible nodes.
-    arrowhead_size : int, optional (default: 20)
-        Size of link arrow head. Passed on to FancyArrowPatch object.
-    curved_radius, float, optional (default: 0.2)
-        Curvature of links. Passed on to FancyArrowPatch object.
-    label_fontsize : int, optional (default: 10)
-        Fontsize of colorbar labels.
-    alpha : float, optional (default: 1.)
-        Opacity.
-    node_label_size : int, optional (default: 10)
-        Fontsize of node labels.
-    link_label_fontsize : int, optional (default: 6)
-        Fontsize of link labels.
-    label_space_left : float, optional (default: 0.1)
-        Fraction of horizontal figure space to allocate left of plot for labels.
-    label_space_top : float, optional (default: 0.)
-        Fraction of vertical figure space to allocate top of plot for labels.
-    network_lower_bound : float, optional (default: 0.2)
-        Fraction of vertical space below graph plot.
-    inner_edge_style : string, optional (default: 'dashed')
-        Style of inner_edge contemporaneous links.
-    """
-
-    if fig_ax is None:
-        fig = pyplot.figure(figsize=figsize)
-        ax = fig.add_subplot(111, frame_on=False)
-    else:
-        fig, ax = fig_ax
-
-    (link_matrix, val_matrix, link_width, link_attribute) = _check_matrices(
-        link_matrix, val_matrix, link_width, link_attribute, sig_thres
-    )
-
-    N, N, dummy = link_matrix.shape
-    tau_max = dummy - 1
-    max_lag = tau_max + 1
-
-    if np.count_nonzero(link_matrix == "") == link_matrix.size:
-        link_matrix[0, 1, 0] = "---"
-        no_links = True
-    else:
-        no_links = False
-
-    if var_names is None:
-        var_names = range(N)
-
-    if order is None:
-        order = range(N)
-
-    if set(order) != set(range(N)):
-        raise ValueError("order must be a permutation of range(N)")
-
-    def translate(row, lag):
-        return row * max_lag + lag
-
-    # Define graph links by absolute maximum (positive or negative like for
-    # partial correlation)
-    tsg = np.zeros((N * max_lag, N * max_lag))
-    tsg_val = np.zeros((N * max_lag, N * max_lag))
-    tsg_width = np.zeros((N * max_lag, N * max_lag))
-    tsg_style = np.zeros((N * max_lag, N * max_lag), dtype=link_matrix.dtype)
-    if link_attribute is not None:
-        tsg_attr = np.zeros((N * max_lag, N * max_lag), dtype=link_attribute.dtype)
-
-    # Only draw link in one direction among contemp
-    # Remove lower triangle
-    link_matrix_tsg = np.copy(link_matrix)
-    link_matrix_tsg[:, :, 0] = np.triu(link_matrix[:, :, 0])
-
-    for i, j, tau in np.column_stack(np.where(link_matrix_tsg)):
-        for t in range(max_lag):
-            if (
-                0 <= translate(i, t - tau)
-                and translate(i, t - tau) % max_lag <= translate(j, t) % max_lag
-            ):
-
-                tsg[
-                    translate(i, t - tau), translate(j, t)
-                ] = 1.0  # val_matrix[i, j, tau]
-                tsg_val[translate(i, t - tau), translate(j, t)] = val_matrix[i, j, tau]
-                tsg_style[translate(i, t - tau), translate(j, t)] = link_matrix[
-                    i, j, tau
-                ]
-                if link_width is not None:
-                    tsg_width[translate(i, t - tau), translate(j, t)] = (
-                        link_width[i, j, tau] / link_width.max() * arrow_linewidth
-                    )
-                if link_attribute is not None:
-                    tsg_attr[translate(i, t - tau), translate(j, t)] = link_attribute[
-                        i, j, tau
-                    ]
-
-    G = nx.DiGraph(tsg)
-
-    # node_color = np.zeros(N)
-    # list of all strengths for color map
-    all_strengths = []
-    # Add attributes, contemporaneous and lagged links are handled separately
-    for (u, v, dic) in G.edges(data=True):
-        dic["no_links"] = no_links
-        if u != v:
-            dic["inner_edge"] = False
-            dic["outer_edge"] = True
-
-            dic["outer_edge_type"] = tsg_style[u, v]
-
-            dic["outer_edge_alpha"] = alpha
-
-            if link_width is None:
-                # fraction of nonzero values
-                dic["outer_edge_width"] = dic["inner_edge_width"] = arrow_linewidth
-            else:
-                dic["outer_edge_width"] = dic["inner_edge_width"] = tsg_width[u, v]
-
-            if link_attribute is None:
-                dic["outer_edge_attribute"] = None
-            else:
-                dic["outer_edge_attribute"] = tsg_attr[u, v]
-
-            # value at argmax of average
-            dic["outer_edge_color"] = tsg_val[u, v]
-
-            all_strengths.append(dic["outer_edge_color"])
-            dic["label"] = None
-
-    # If no links are present, set value to zero
-    if len(all_strengths) == 0:
-        all_strengths = [0.0]
-
-    posarray = np.zeros((N * max_lag, 2))
-    for i in range(N * max_lag):
-        posarray[i] = np.array([(i % max_lag), (1.0 - i // max_lag)])
-
-    pos_tmp = {}
-    for i in range(N * max_lag):
-        # for n in range(N):
-        #     for tau in range(max_lag):
-        #         i = n*N + tau
-        pos_tmp[i] = np.array(
-            [
-                ((i % max_lag) - posarray.min(axis=0)[0])
-                / (posarray.max(axis=0)[0] - posarray.min(axis=0)[0]),
-                ((1.0 - i // max_lag) - posarray.min(axis=0)[1])
-                / (posarray.max(axis=0)[1] - posarray.min(axis=0)[1]),
-            ]
-        )
-        pos_tmp[i][np.isnan(pos_tmp[i])] = 0.0
-
-    pos = {}
-    for n in range(N):
-        for tau in range(max_lag):
-            pos[n * max_lag + tau] = pos_tmp[order[n] * max_lag + tau]
-
-    node_rings = {
-        0: {"sizes": None, "color_array": None, "label": "", "colorbar": False,}
-    }
-
-    node_labels = ["" for i in range(N * max_lag)]
-
-    _draw_network_with_curved_edges(
-        fig=fig,
-        ax=ax,
-        G=deepcopy(G),
-        pos=pos,
-        node_rings=node_rings,
-        node_labels=node_labels,
-        node_label_size=node_label_size,
-        node_alpha=alpha,
-        standard_size=node_size,
-        node_aspect=node_aspect,
-        standard_cmap="OrRd",
-        standard_color="lightgrey",
-        log_sizes=False,
-        cmap_links=cmap_edges,
-        links_vmin=vmin_edges,
-        links_vmax=vmax_edges,
-        links_ticks=edge_ticks,
-        arrowstyle="simple",
-        arrowhead_size=arrowhead_size,
-        curved_radius=curved_radius,
-        label_fontsize=label_fontsize,
-        label_fraction=0.5,
-        link_colorbar_label=link_colorbar_label,
-        inner_edge_curved=True,
-        network_lower_bound=network_lower_bound,
-        inner_edge_style=inner_edge_style,
-    )
-
-    for i in range(N):
-        trans = transforms.blended_transform_factory(fig.transFigure, ax.transData)
-        ax.text(
-            label_space_left,
-            pos[order[i] * max_lag][1],
-            f"{var_names[order[i]]}",
-            fontsize=label_fontsize,
-            horizontalalignment="left",
-            verticalalignment="center",
-            transform=trans,
-        )
-
-    for tau in np.arange(max_lag - 1, -1, -1):
-        trans = transforms.blended_transform_factory(ax.transData, fig.transFigure)
-        if tau == max_lag - 1:
-            ax.text(
-                pos[tau][0],
-                1.0 - label_space_top,
-                r"$t$",
-                fontsize=int(label_fontsize * 0.8),
-                horizontalalignment="center",
-                verticalalignment="top",
-                transform=trans,
-            )
-        else:
-            ax.text(
-                pos[tau][0],
-                1.0 - label_space_top,
-                r"$t-%s$" % str(max_lag - tau - 1),
-                fontsize=int(label_fontsize * 0.8),
-                horizontalalignment="center",
-                verticalalignment="top",
-                transform=trans,
-            )
-
-    if save_name is not None:
-        pyplot.savefig(save_name, dpi=300)
-    else:
-        return fig, ax

-
-
-
[docs]def plot_mediation_time_series_graph(
-    path_node_array,
-    tsg_path_val_matrix,
-    var_names=None,
-    fig_ax=None,
-    figsize=None,
-    link_colorbar_label="link coeff. (edge color)",
-    node_colorbar_label="MCE (node color)",
-    save_name=None,
-    link_width=None,
-    arrow_linewidth=8,
-    vmin_edges=-1,
-    vmax_edges=1.0,
-    edge_ticks=0.4,
-    cmap_edges="RdBu_r",
-    order=None,
-    vmin_nodes=-1.0,
-    vmax_nodes=1.0,
-    node_ticks=0.4,
-    cmap_nodes="RdBu_r",
-    node_size=0.1,
-    node_aspect=None,
-    arrowhead_size=20,
-    curved_radius=0.2,
-    label_fontsize=12,
-    alpha=1.0,
-    node_label_size=12,
-    label_space_left=0.1,
-    label_space_top=0.0,
-    network_lower_bound=0.2,
-):
-    """Creates a mediation time series graph plot.
-    This is still in beta. The time series graph's links are colored by
-    val_matrix.
-
-    Parameters
-    ----------
-    tsg_path_val_matrix : array_like
-        Matrix of shape (N*tau_max, N*tau_max) containing link weight values.
-    path_node_array: array_like
-        Array of shape (N,) containing node values.
-    var_names : list, optional (default: None)
-        List of variable names. If None, range(N) is used.
-    fig_ax : tuple of figure and axis object, optional (default: None)
-        Figure and axes instance. If None they are created.
-    figsize : tuple
-        Size of figure.
-    save_name : str, optional (default: None)
-        Name of figure file to save figure. If None, figure is shown in window.
-    link_colorbar_label : str, optional (default: 'link coeff. (edge color)')
-        Link colorbar label.
-    node_colorbar_label : str, optional (default: 'MCE (node color)')
-        Node colorbar label.
-    link_width : array-like, optional (default: None)
-        Array of val_matrix.shape specifying relative link width with maximum
-        given by arrow_linewidth. If None, all links have same width.
-    order : list, optional (default: None)
-        order of variables from top to bottom.
-    arrow_linewidth : float, optional (default: 30)
-        Linewidth.
-    vmin_edges : float, optional (default: -1)
-        Link colorbar scale lower bound.
-    vmax_edges : float, optional (default: 1)
-        Link colorbar scale upper bound.
-    edge_ticks : float, optional (default: 0.4)
-        Link tick mark interval.
-    cmap_edges : str, optional (default: 'RdBu_r')
-        Colormap for links.
-    vmin_nodes : float, optional (default: 0)
-        Node colorbar scale lower bound.
-    vmax_nodes : float, optional (default: 1)
-        Node colorbar scale upper bound.
-    node_ticks : float, optional (default: 0.4)
-        Node tick mark interval.
-    cmap_nodes : str, optional (default: 'OrRd')
-        Colormap for links.
-    node_size : int, optional (default: 0.1)
-        Node size.
-    node_aspect : float, optional (default: None)
-        Ratio between the heigth and width of the varible nodes.
-    arrowhead_size : int, optional (default: 20)
-        Size of link arrow head. Passed on to FancyArrowPatch object.
-    curved_radius, float, optional (default: 0.2)
-        Curvature of links. Passed on to FancyArrowPatch object.
-    label_fontsize : int, optional (default: 10)
-        Fontsize of colorbar labels.
-    alpha : float, optional (default: 1.)
-        Opacity.
-    node_label_size : int, optional (default: 10)
-        Fontsize of node labels.
-    link_label_fontsize : int, optional (default: 6)
-        Fontsize of link labels.
-    label_space_left : float, optional (default: 0.1)
-        Fraction of horizontal figure space to allocate left of plot for labels.
-    label_space_top : float, optional (default: 0.)
-        Fraction of vertical figure space to allocate top of plot for labels.
-    network_lower_bound : float, optional (default: 0.2)
-        Fraction of vertical space below graph plot.
-    """
-    N = len(path_node_array)
-    Nmaxlag = tsg_path_val_matrix.shape[0]
-    max_lag = Nmaxlag // N
-
-    if var_names is None:
-        var_names = range(N)
-
-    if fig_ax is None:
-        fig = pyplot.figure(figsize=figsize)
-        ax = fig.add_subplot(111, frame_on=False)
-    else:
-        fig, ax = fig_ax
-
-    if link_width is not None and not np.all(link_width >= 0.0):
-        raise ValueError("link_width must be non-negative")
-
-    if order is None:
-        order = range(N)
-
-    if set(order) != set(range(N)):
-        raise ValueError("order must be a permutation of range(N)")
-
-    def translate(row, lag):
-        return row * max_lag + lag
-
-    if np.count_nonzero(tsg_path_val_matrix) == np.count_nonzero(
-        np.diagonal(tsg_path_val_matrix)
-    ):
-        diagonal = True
-    else:
-        diagonal = False
-
-    if np.count_nonzero(tsg_path_val_matrix) == tsg_path_val_matrix.size or diagonal:
-        tsg_path_val_matrix[0, 1] = 1
-        no_links = True
-    else:
-        no_links = False
-
-    # Define graph links by absolute maximum (positive or negative like for
-    # partial correlation)
-    tsg = tsg_path_val_matrix
-    tsg_attr = np.zeros((N * max_lag, N * max_lag))
-
-    G = nx.DiGraph(tsg)
-
-    # node_color = np.zeros(N)
-    # list of all strengths for color map
-    all_strengths = []
-    # Add attributes, contemporaneous and lagged links are handled separately
-    for (u, v, dic) in G.edges(data=True):
-        dic["no_links"] = no_links
-        dic["outer_edge_attribute"] = None
-
-        if u != v:
-
-            if u % max_lag == v % max_lag:
-                dic["inner_edge"] = True
-                dic["outer_edge"] = False
-            else:
-                dic["inner_edge"] = False
-                dic["outer_edge"] = True
-
-            dic["inner_edge_alpha"] = alpha
-            dic["inner_edge_color"] = _get_absmax(
-                np.array([[[tsg[u, v], tsg[v, u]]]])
-            ).squeeze()
-            dic["inner_edge_width"] = arrow_linewidth
-            all_strengths.append(dic["inner_edge_color"])
-
-            dic["outer_edge_alpha"] = alpha
-
-            dic["outer_edge_width"] = arrow_linewidth
-
-            # value at argmax of average
-            dic["outer_edge_color"] = tsg[u, v]
-            all_strengths.append(dic["outer_edge_color"])
-            dic["label"] = None
-
-        # dic['outer_edge_edge'] = False
-        # dic['outer_edge_edgecolor'] = None
-        # dic['inner_edge_edge'] = False
-        # dic['inner_edge_edgecolor'] = None
-
-    # If no links are present, set value to zero
-    if len(all_strengths) == 0:
-        all_strengths = [0.0]
-
-    posarray = np.zeros((N * max_lag, 2))
-    for i in range(N * max_lag):
-        posarray[i] = np.array([(i % max_lag), (1.0 - i // max_lag)])
-
-    pos_tmp = {}
-    for i in range(N * max_lag):
-        # for n in range(N):
-        #     for tau in range(max_lag):
-        #         i = n*N + tau
-        pos_tmp[i] = np.array(
-            [
-                ((i % max_lag) - posarray.min(axis=0)[0])
-                / (posarray.max(axis=0)[0] - posarray.min(axis=0)[0]),
-                ((1.0 - i // max_lag) - posarray.min(axis=0)[1])
-                / (posarray.max(axis=0)[1] - posarray.min(axis=0)[1]),
-            ]
-        )
-        pos_tmp[i][np.isnan(pos_tmp[i])] = 0.0
-
-    pos = {}
-    for n in range(N):
-        for tau in range(max_lag):
-            pos[n * max_lag + tau] = pos_tmp[order[n] * max_lag + tau]
-
-    node_color = np.zeros(N * max_lag)
-    for inet, n in enumerate(range(0, N * max_lag, max_lag)):
-        node_color[n : n + max_lag] = path_node_array[inet]
-
-    # node_rings = {0: {'sizes': None, 'color_array': color_array,
-    #                   'label': '', 'colorbar': False,
-    #                   }
-    #               }
-
-    node_rings = {
-        0: {
-            "sizes": None,
-            "color_array": node_color,
-            "cmap": cmap_nodes,
-            "vmin": vmin_nodes,
-            "vmax": vmax_nodes,
-            "ticks": node_ticks,
-            "label": node_colorbar_label,
-            "colorbar": True,
-        }
-    }
-
-    # ] for v in range(max_lag)]
-    node_labels = ["" for i in range(N * max_lag)]
-
-    _draw_network_with_curved_edges(
-        fig=fig,
-        ax=ax,
-        G=deepcopy(G),
-        pos=pos,
-        # dictionary of rings: {0:{'sizes':(N,)-array, 'color_array':(N,)-array
-        # or None, 'cmap':string,
-        node_rings=node_rings,
-        # 'vmin':float or None, 'vmax':float or None, 'label':string or None}}
-        node_labels=node_labels,
-        node_label_size=node_label_size,
-        node_alpha=alpha,
-        standard_size=node_size,
-        node_aspect=node_aspect,
-        standard_cmap="OrRd",
-        standard_color="grey",
-        log_sizes=False,
-        cmap_links=cmap_edges,
-        links_vmin=vmin_edges,
-        links_vmax=vmax_edges,
-        links_ticks=edge_ticks,
-        # cmap_links_edges='YlOrRd', links_edges_vmin=-1., links_edges_vmax=1.,
-        # links_edges_ticks=.2, link_edge_colorbar_label='link_edge',
-        arrowhead_size=arrowhead_size,
-        curved_radius=curved_radius,
-        label_fontsize=label_fontsize,
-        label_fraction=0.5,
-        link_colorbar_label=link_colorbar_label,
-        inner_edge_curved=True,
-        network_lower_bound=network_lower_bound
-        # inner_edge_style=inner_edge_style
-    )
-
-    for i in range(N):
-        trans = transforms.blended_transform_factory(fig.transFigure, ax.transData)
-        ax.text(
-            label_space_left,
-            pos[order[i] * max_lag][1],
-            "%s" % str(var_names[order[i]]),
-            fontsize=label_fontsize,
-            horizontalalignment="left",
-            verticalalignment="center",
-            transform=trans,
-        )
-
-    for tau in np.arange(max_lag - 1, -1, -1):
-        trans = transforms.blended_transform_factory(ax.transData, fig.transFigure)
-        if tau == max_lag - 1:
-            ax.text(
-                pos[tau][0],
-                1.0 - label_space_top,
-                r"$t$",
-                fontsize=label_fontsize,
-                horizontalalignment="center",
-                verticalalignment="top",
-                transform=trans,
-            )
-        else:
-            ax.text(
-                pos[tau][0],
-                1.0 - label_space_top,
-                r"$t-%s$" % str(max_lag - tau - 1),
-                fontsize=label_fontsize,
-                horizontalalignment="center",
-                verticalalignment="top",
-                transform=trans,
-            )
-
-    # fig.subplots_adjust(left=0.1, right=.98, bottom=.25, top=.9)
-    # savestring = os.path.expanduser(save_name)
-    if save_name is not None:
-        pyplot.savefig(save_name)
-    else:
-        pyplot.show()

-
-
-
[docs]def plot_mediation_graph(
-    path_val_matrix,
-    path_node_array=None,
-    var_names=None,
-    fig_ax=None,
-    figsize=None,
-    save_name=None,
-    link_colorbar_label="link coeff. (edge color)",
-    node_colorbar_label="MCE (node color)",
-    link_width=None,
-    node_pos=None,
-    arrow_linewidth=10.0,
-    vmin_edges=-1,
-    vmax_edges=1.0,
-    edge_ticks=0.4,
-    cmap_edges="RdBu_r",
-    vmin_nodes=-1.0,
-    vmax_nodes=1.0,
-    node_ticks=0.4,
-    cmap_nodes="RdBu_r",
-    node_size=0.3,
-    node_aspect=None,
-    arrowhead_size=20,
-    curved_radius=0.2,
-    label_fontsize=10,
-    lag_array=None,
-    alpha=1.0,
-    node_label_size=10,
-    link_label_fontsize=10,
-    network_lower_bound=0.2,
-):
-    """Creates a network plot visualizing the pathways of a mediation analysis.
-    This is still in beta. The network is defined from non-zero entries in
-    ``path_val_matrix``.  Nodes denote variables, straight links contemporaneous
-    dependencies and curved arrows lagged dependencies. The node color denotes
-    the mediated causal effect (MCE) and the link color the value at the lag
-    with maximal link coefficient. The link label lists the lags with
-    significant dependency in order of absolute magnitude. The network can also
-    be plotted over a map drawn before on the same axis. Then the node positions
-    can be supplied in appropriate axis coordinates via node_pos.
-
-    Parameters
-    ----------
-    path_val_matrix : array_like
-        Matrix of shape (N, N, tau_max+1) containing link weight values.
-    path_node_array: array_like
-        Array of shape (N,) containing node values.
-    var_names : list, optional (default: None)
-        List of variable names. If None, range(N) is used.
-    fig_ax : tuple of figure and axis object, optional (default: None)
-        Figure and axes instance. If None they are created.
-    figsize : tuple
-        Size of figure.
-    save_name : str, optional (default: None)
-        Name of figure file to save figure. If None, figure is shown in window.
-    link_colorbar_label : str, optional (default: 'link coeff. (edge color)')
-        Link colorbar label.
-    node_colorbar_label : str, optional (default: 'MCE (node color)')
-        Node colorbar label.
-    link_width : array-like, optional (default: None)
-        Array of val_matrix.shape specifying relative link width with maximum
-        given by arrow_linewidth. If None, all links have same width.
-    node_pos : dictionary, optional (default: None)
-        Dictionary of node positions in axis coordinates of form
-        node_pos = {'x':array of shape (N,), 'y':array of shape(N)}. These
-        coordinates could have been transformed before for basemap plots.
-    arrow_linewidth : float, optional (default: 30)
-        Linewidth.
-    vmin_edges : float, optional (default: -1)
-        Link colorbar scale lower bound.
-    vmax_edges : float, optional (default: 1)
-        Link colorbar scale upper bound.
-    edge_ticks : float, optional (default: 0.4)
-        Link tick mark interval.
-    cmap_edges : str, optional (default: 'RdBu_r')
-        Colormap for links.
-    vmin_nodes : float, optional (default: 0)
-        Node colorbar scale lower bound.
-    vmax_nodes : float, optional (default: 1)
-        Node colorbar scale upper bound.
-    node_ticks : float, optional (default: 0.4)
-        Node tick mark interval.
-    cmap_nodes : str, optional (default: 'OrRd')
-        Colormap for links.
-    node_size : int, optional (default: 0.3)
-        Node size.
-    node_aspect : float, optional (default: None)
-        Ratio between the heigth and width of the varible nodes.
-    arrowhead_size : int, optional (default: 20)
-        Size of link arrow head. Passed on to FancyArrowPatch object.
-    curved_radius, float, optional (default: 0.2)
-        Curvature of links. Passed on to FancyArrowPatch object.
-    label_fontsize : int, optional (default: 10)
-        Fontsize of colorbar labels.
-    alpha : float, optional (default: 1.)
-        Opacity.
-    node_label_size : int, optional (default: 10)
-        Fontsize of node labels.
-    link_label_fontsize : int, optional (default: 6)
-        Fontsize of link labels.
-    network_lower_bound : float, optional (default: 0.2)
-        Fraction of vertical space below graph plot.
-    lag_array : array, optional (default: None)
-        Optional specification of lags overwriting np.arange(0, tau_max+1)
-    """
-    val_matrix = path_val_matrix
-
-    if fig_ax is None:
-        fig = pyplot.figure(figsize=figsize)
-        ax = fig.add_subplot(111, frame_on=False)
-    else:
-        fig, ax = fig_ax
-
-    if link_width is not None and not np.all(link_width >= 0.0):
-        raise ValueError("link_width must be non-negative")
-
-    N, N, dummy = val_matrix.shape
-    tau_max = dummy - 1
-
-    if np.count_nonzero(val_matrix) == np.count_nonzero(np.diagonal(val_matrix)):
-        diagonal = True
-    else:
-        diagonal = False
-
-    if np.count_nonzero(val_matrix) == val_matrix.size or diagonal:
-        val_matrix[0, 1, 0] = 1
-        no_links = True
-    else:
-        no_links = False
-
-    if var_names is None:
-        var_names = range(N)
-
-    # Define graph links by absolute maximum (positive or negative like for
-    # partial correlation)
-    # val_matrix[np.abs(val_matrix) < sig_thres] = 0.
-    link_matrix = val_matrix != 0.0
-    net = _get_absmax(val_matrix)
-    G = nx.DiGraph(net)
-
-    node_color = np.zeros(N)
-    # list of all strengths for color map
-    all_strengths = []
-    # Add attributes, contemporaneous and lagged links are handled separately
-    for (u, v, dic) in G.edges(data=True):
-        dic["outer_edge_attribute"] = None
-        dic["no_links"] = no_links
-        # average lagfunc for link u --> v ANDOR u -- v
-        if tau_max > 0:
-            # argmax of absolute maximum
-            argmax = np.abs(val_matrix[u, v][1:]).argmax() + 1
-        else:
-            argmax = 0
-        if u != v:
-            # For contemp links masking or finite samples can lead to different
-            # values for u--v and v--u
-            # Here we use the  maximum for the width and weight (=color)
-            # of the link
-            # Draw link if u--v OR v--u at lag 0 is nonzero
-            # dic['inner_edge'] = ((np.abs(val_matrix[u, v][0]) >=
-            #                       sig_thres[u, v][0]) or
-            #                      (np.abs(val_matrix[v, u][0]) >=
-            #                       sig_thres[v, u][0]))
-            dic["inner_edge"] = link_matrix[u, v, 0] or link_matrix[v, u, 0]
-            dic["inner_edge_alpha"] = alpha
-            # value at argmax of average
-            if np.abs(val_matrix[u, v][0] - val_matrix[v, u][0]) > 0.0001:
-                print(
-                    "Contemporaneous I(%d; %d)=%.3f != I(%d; %d)=%.3f"
-                    % (u, v, val_matrix[u, v][0], v, u, val_matrix[v, u][0])
-                    + " due to conditions, finite sample effects or "
-                    "masking, here edge color = "
-                    "larger (absolute) value."
-                )
-            dic["inner_edge_color"] = _get_absmax(
-                np.array([[[val_matrix[u, v][0], val_matrix[v, u][0]]]])
-            ).squeeze()
-            if link_width is None:
-                dic["inner_edge_width"] = arrow_linewidth
-            else:
-                dic["inner_edge_width"] = (
-                    link_width[u, v, 0] / link_width.max() * arrow_linewidth
-                )
-
-            all_strengths.append(dic["inner_edge_color"])
-
-            if tau_max > 0:
-                # True if ensemble mean at lags > 0 is nonzero
-                # dic['outer_edge'] = np.any(
-                #     np.abs(val_matrix[u, v][1:]) >= sig_thres[u, v][1:])
-                dic["outer_edge"] = np.any(link_matrix[u, v, 1:])
-            else:
-                dic["outer_edge"] = False
-            dic["outer_edge_alpha"] = alpha
-            if link_width is None:
-                # fraction of nonzero values
-                dic["outer_edge_width"] = arrow_linewidth
-            else:
-                dic["outer_edge_width"] = (
-                    link_width[u, v, argmax] / link_width.max() * arrow_linewidth
-                )
-
-            # value at argmax of average
-            dic["outer_edge_color"] = val_matrix[u, v][argmax]
-            all_strengths.append(dic["outer_edge_color"])
-
-            # Sorted list of significant lags (only if robust wrt
-            # d['min_ensemble_frac'])
-            if tau_max > 0:
-                lags = np.abs(val_matrix[u, v][1:]).argsort()[::-1] + 1
-                sig_lags = (np.where(link_matrix[u, v, 1:])[0] + 1).tolist()
-            else:
-                lags, sig_lags = [], []
-            if lag_array is not None:
-                dic["label"] = str([lag_array[l] for l in lags if l in sig_lags])[1:-1]
-            else:
-                dic["label"] = str([l for l in lags if l in sig_lags])[1:-1]
-        else:
-            # Node color is max of average autodependency
-            node_color[u] = val_matrix[u, v][argmax]
-
-        # dic['outer_edge_edge'] = False
-        # dic['outer_edge_edgecolor'] = None
-        # dic['inner_edge_edge'] = False
-        # dic['inner_edge_edgecolor'] = None
-
-    node_color = path_node_array
-    # print node_color
-    # If no links are present, set value to zero
-    if len(all_strengths) == 0:
-        all_strengths = [0.0]
-
-    if node_pos is None:
-        pos = nx.circular_layout(deepcopy(G))
-    #            pos = nx.spring_layout(deepcopy(G))
-    else:
-        pos = {}
-        for i in range(N):
-            pos[i] = (node_pos["x"][i], node_pos["y"][i])
-
-    node_rings = {
-        0: {
-            "sizes": None,
-            "color_array": node_color,
-            "cmap": cmap_nodes,
-            "vmin": vmin_nodes,
-            "vmax": vmax_nodes,
-            "ticks": node_ticks,
-            "label": node_colorbar_label,
-            "colorbar": True,
-        }
-    }
-
-    _draw_network_with_curved_edges(
-        fig=fig,
-        ax=ax,
-        G=deepcopy(G),
-        pos=pos,
-        # dictionary of rings: {0:{'sizes':(N,)-array, 'color_array':(N,)-array
-        # or None, 'cmap':string,
-        node_rings=node_rings,
-        # 'vmin':float or None, 'vmax':float or None, 'label':string or None}}
-        node_labels=var_names,
-        node_label_size=node_label_size,
-        node_alpha=alpha,
-        standard_size=node_size,
-        node_aspect=node_aspect,
-        standard_cmap="OrRd",
-        standard_color="orange",
-        log_sizes=False,
-        cmap_links=cmap_edges,
-        links_vmin=vmin_edges,
-        links_vmax=vmax_edges,
-        links_ticks=edge_ticks,
-        # cmap_links_edges='YlOrRd', links_edges_vmin=-1., links_edges_vmax=1.,
-        # links_edges_ticks=.2, link_edge_colorbar_label='link_edge',
-        arrowhead_size=arrowhead_size,
-        curved_radius=curved_radius,
-        label_fontsize=label_fontsize,
-        link_label_fontsize=link_label_fontsize,
-        link_colorbar_label=link_colorbar_label,
-        network_lower_bound=network_lower_bound,
-        # label_fraction=label_fraction,
-        # inner_edge_style=inner_edge_style
-    )
-
-    # fig.subplots_adjust(left=0.1, right=.9, bottom=.25, top=.95)
-    # savestring = os.path.expanduser(save_name)
-    if save_name is not None:
-        pyplot.savefig(save_name)
-    else:
-        pyplot.show()

-
-
-#
-#  Functions to plot time series graphs from links including ancestors
-#
-
[docs]def plot_tsg(links, X, Y, Z=None, anc_x=None, anc_y=None, anc_xy=None):
-    """Plots TSG that is input in format (N*max_lag, N*max_lag).
-    Compared to the tigramite plotting function here links
-    X^i_{t-tau} --> X^j_t can be missing for different t'. Helpful to
-    visualize the conditioned TSG.
-    """
-
-    def varlag2node(var, lag):
-        """Translate from (var, lag) notation to node in TSG.
-        lag must be <= 0.
-        """
-        return var * max_lag + lag
-
-    def node2varlag(node):
-        """Translate from node in TSG to (var, -tau) notation.
-        Here tau is <= 0.
-        """
-        var = node // max_lag
-        tau = node % (max_lag) - (max_lag - 1)
-        return var, tau
-
-    def _links_to_tsg(link_coeffs, max_lag=None):
-        """Transform link_coeffs to time series graph.
-        TSG is of shape (N*max_lag, N*max_lag).
-        """
-        N = len(link_coeffs)
-
-        # Get maximum lag
-        min_lag_links, max_lag_links = pp._get_minmax_lag(link_coeffs)
-
-        # max_lag of TSG is max lag in links + 1 for the zero lag.
-        if max_lag is None:
-            max_lag = max_lag_links + 1
-
-        tsg = np.zeros((N * max_lag, N * max_lag))
-
-        for j in range(N):
-            for link_props in link_coeffs[j]:
-                i, lag = link_props[0]
-                tau = abs(lag)
-                coeff = link_props[1]
-                # func = link_props[2]
-                if coeff != 0.0:
-                    for t in range(max_lag):
-                        if (
-                            0 <= varlag2node(i, t - tau)
-                            and varlag2node(i, t - tau) % max_lag
-                            <= varlag2node(j, t) % max_lag
-                        ):
-                            tsg[varlag2node(i, t - tau), varlag2node(j, t)] = 1.0
-
-        return tsg
-
-    color_list = ["lightgrey", "grey", "black", "red", "blue", "orange"]
-    listcmap = ListedColormap(color_list)
-
-    N = len(links)
-
-    min_lag_links, max_lag_links = pp._get_minmax_lag(links)
-    max_lag = max_lag_links
-
-    for anc in X + Y:
-        max_lag = max(max_lag, abs(anc[1]))
-    for anc in Y:
-        max_lag = max(max_lag, abs(anc[1]))
-    if Z is not None:
-        for anc in Z:
-            max_lag = max(max_lag, abs(anc[1]))
-
-    if anc_x is not None:
-        for anc in anc_x:
-            max_lag = max(max_lag, abs(anc[1]))
-    if anc_y is not None:
-        for anc in anc_y:
-            max_lag = max(max_lag, abs(anc[1]))
-    if anc_xy is not None:
-        for anc in anc_xy:
-            max_lag = max(max_lag, abs(anc[1]))
-
-    max_lag = max_lag + 1
-
-    tsg = _links_to_tsg(links, max_lag=max_lag)
-
-    G = nx.DiGraph(tsg)
-
-    figsize = (3, 3)
-    link_colorbar_label = "MCI"
-    arrow_linewidth = 20.0
-    vmin_edges = -1
-    vmax_edges = 1.0
-    edge_ticks = 0.4
-    cmap_edges = "RdBu_r"
-    order = None
-    node_size = 10
-    arrowhead_size = 20
-    curved_radius = 0.2
-    label_fontsize = 10
-    alpha = 1.0
-    node_label_size = 10
-    label_space_left = 0.1
-    label_space_top = 0.0
-    network_lower_bound = 0.2
-    inner_edge_style = "dashed"
-
-    node_color = np.ones(N * max_lag)  # , dtype = 'object')
-    node_color[:] = 0
-
-    if anc_x is not None:
-        for n in [varlag2node(itau[0], max_lag - 1 + itau[1]) for itau in anc_x]:
-            node_color[n] = 3
-    if anc_y is not None:
-        for n in [varlag2node(itau[0], max_lag - 1 + itau[1]) for itau in anc_y]:
-            node_color[n] = 4
-    if anc_xy is not None:
-        for n in [varlag2node(itau[0], max_lag - 1 + itau[1]) for itau in anc_xy]:
-            node_color[n] = 5
-
-    for x in X:
-        node_color[varlag2node(x[0], max_lag - 1 + x[1])] = 2
-    for y in Y:
-        node_color[varlag2node(y[0], max_lag - 1 + y[1])] = 2
-    if Z is not None:
-        for z in Z:
-            node_color[varlag2node(z[0], max_lag - 1 + z[1])] = 1
-
-    fig = pyplot.figure(figsize=figsize)
-    ax = fig.add_subplot(111, frame_on=False)
-    var_names = range(N)
-    order = range(N)
-
-    # list of all strengths for color map
-    all_strengths = []
-    # Add attributes, contemporaneous and lagged links are handled separately
-    for (u, v, dic) in G.edges(data=True):
-        if u != v:
-            if tsg[u, v] and tsg[v, u]:
-                dic["inner_edge"] = True
-                dic["outer_edge"] = False
-            else:
-                dic["inner_edge"] = False
-                dic["outer_edge"] = True
-
-            dic["inner_edge_alpha"] = alpha
-            dic["inner_edge_color"] = tsg[u, v]
-
-            dic["inner_edge_width"] = arrow_linewidth
-            dic["inner_edge_attribute"] = dic["outer_edge_attribute"] = None
-
-            all_strengths.append(dic["inner_edge_color"])
-            dic["outer_edge_alpha"] = alpha
-            dic["outer_edge_width"] = dic["inner_edge_width"] = arrow_linewidth
-
-            # value at argmax of average
-            dic["outer_edge_color"] = tsg[u, v]
-
-            all_strengths.append(dic["outer_edge_color"])
-            dic["label"] = None
-
-    # If no links are present, set value to zero
-    if len(all_strengths) == 0:
-        all_strengths = [0.0]
-
-    posarray = np.zeros((N * max_lag, 2))
-    for i in range(N * max_lag):
-        posarray[i] = np.array([(i % max_lag), (1.0 - i // max_lag)])
-
-    pos_tmp = {}
-    for i in range(N * max_lag):
-        pos_tmp[i] = np.array(
-            [
-                ((i % max_lag) - posarray.min(axis=0)[0])
-                / (posarray.max(axis=0)[0] - posarray.min(axis=0)[0]),
-                ((1.0 - i // max_lag) - posarray.min(axis=0)[1])
-                / (posarray.max(axis=0)[1] - posarray.min(axis=0)[1]),
-            ]
-        )
-        pos_tmp[i][np.isnan(pos_tmp[i])] = 0.0
-
-    pos = {}
-    for n in range(N):
-        for tau in range(max_lag):
-            pos[n * max_lag + tau] = pos_tmp[order[n] * max_lag + tau]
-
-    node_rings = {
-        0: {
-            "sizes": None,
-            "color_array": node_color,
-            "label": "",
-            "colorbar": False,
-            "cmap": listcmap,
-            "vmin": 0,
-            "vmax": len(color_list),
-        }
-    }
-
-    node_labels = ["" for i in range(N * max_lag)]
-
-    _draw_network_with_curved_edges(
-        fig=fig,
-        ax=ax,
-        G=deepcopy(G),
-        pos=pos,
-        # dictionary of rings: {0:{'sizes':(N,)-array, 'color_array':(N,)-array
-        # or None, 'cmap':string,
-        node_rings=node_rings,
-        # 'vmin':float or None, 'vmax':float or None, 'label':string or None}}
-        node_labels=node_labels,
-        node_label_size=ode_label_size,
-        node_alpha=alpha,
-        standard_size=node_size,
-        node_aspect=node_aspect,
-        standard_cmap="OrRd",
-        standard_color="lightgrey",
-        log_sizes=False,
-        cmap_links=cmap_edges,
-        links_vmin=vmin_edges,
-        links_vmax=vmax_edges,
-        links_ticks=edge_ticks,
-        arrowstyle="simple",
-        arrowhead_size=arrowhead_size,
-        curved_radius=curved_radius,
-        label_fontsize=label_fontsize,
-        label_fraction=0.5,
-        link_colorbar_label=link_colorbar_label,
-        inner_edge_curved=True,
-        network_lower_bound=network_lower_bound,
-        inner_edge_style=inner_edge_style,
-        show_colorbar=False,
-    )
-
-    for i in range(N):
-        trans = transforms.blended_transform_factory(fig.transFigure, ax.transData)
-        ax.text(
-            label_space_left,
-            pos[order[i] * max_lag][1],
-            "%s" % str(var_names[order[i]]),
-            fontsize=label_fontsize,
-            horizontalalignment="left",
-            verticalalignment="center",
-            transform=trans,
-        )
-
-    for tau in np.arange(max_lag - 1, -1, -1):
-        trans = transforms.blended_transform_factory(ax.transData, fig.transFigure)
-        if tau == max_lag - 1:
-            ax.text(
-                pos[tau][0],
-                1.0 - label_space_top,
-                r"$t$",
-                fontsize=int(label_fontsize * 0.7),
-                horizontalalignment="center",
-                verticalalignment="top",
-                transform=trans,
-            )
-        else:
-            ax.text(
-                pos[tau][0],
-                1.0 - label_space_top,
-                r"$t-%s$" % str(max_lag - tau - 1),
-                fontsize=int(label_fontsize * 0.7),
-                horizontalalignment="center",
-                verticalalignment="top",
-                transform=trans,
-            )
-
-    return fig, ax

-
-
-if __name__ == "__main__":
-
-    val_matrix = np.zeros((4, 4, 3))
-
-    # Complete test case
-    link_matrix = np.zeros(val_matrix.shape)
-
-    link_matrix[0, 1, 0] = 0
-    link_matrix[1, 0, 0] = 1
-
-    nolinks = np.zeros(link_matrix.shape)
-    # nolinks[range(4), range(4), 1] = 1
-
-    plot_time_series_graph(link_matrix=nolinks)
-    plot_graph(link_matrix=nolinks, save_name=None)
-
-    pyplot.show()
-
-
- -
-
-
-
-
- - - - \ No newline at end of file diff --git a/docs/_build/html/_sources/index.rst.txt b/docs/_build/html/_sources/index.rst.txt deleted file mode 100644 index be82a31d..00000000 --- a/docs/_build/html/_sources/index.rst.txt +++ /dev/null @@ -1,141 +0,0 @@ -.. Tigramite documentation master file, created by - sphinx-quickstart on Thu May 11 18:32:05 2017. - You can adapt this file completely to your liking, but it should at least - contain the root `toctree` directive. - -TIGRAMITE -========= - -`Github repo `_ - -Tigramite is a causal time series analysis python package. It allows to -efficiently reconstruct causal graphs from high-dimensional time series -datasets and model the obtained causal dependencies for causal mediation and -prediction analyses. 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: - - -0. J. Runge et al. (2019): Inferring causation from time series in Earth -system sciences. Nature Communications, 10(1):2553. -https://www.nature.com/articles/s41467-019-10105-3 - -1. J. Runge, P. Nowack, M. Kretschmer, S. Flaxman, D. Sejdinovic (2019): -Detecting and quantifying causal associations in large nonlinear time series -datasets. Sci. Adv. 5, eaau4996. -https://advances.sciencemag.org/content/5/11/eaau4996 - -2. 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 - -3. 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 - -4. 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 - -5. 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 - -6. 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 - - -.. toctree:: - :maxdepth: 2 - :caption: Contents: - -.. autosummary:: - - tigramite.pcmci.PCMCI - tigramite.independence_tests.CondIndTest - tigramite.independence_tests.ParCorr - tigramite.independence_tests.GPDC - tigramite.independence_tests.CMIknn - tigramite.independence_tests.CMIsymb - tigramite.independence_tests.OracleCI - tigramite.data_processing - tigramite.models.Models - tigramite.models.LinearMediation - tigramite.models.Prediction - tigramite.plotting - - -:mod:`tigramite.pcmci`: PCMCI -=========================================== - -.. autoclass:: tigramite.pcmci.PCMCI - :members: - -:mod:`tigramite.independence_tests`: Conditional independence tests -================================================================================= - -Base class: - -.. autoclass:: tigramite.independence_tests.CondIndTest - :members: - -Test statistics: - -.. autoclass:: tigramite.independence_tests.ParCorr - :members: - -.. autoclass:: tigramite.independence_tests.GPDC - :members: - -.. autoclass:: tigramite.independence_tests.CMIknn - :members: - -.. autoclass:: tigramite.independence_tests.CMIsymb - :members: - -.. autoclass:: tigramite.independence_tests.OracleCI - :members: - - -:mod:`tigramite.data_processing`: Data processing functions -=========================================================== - -.. automodule:: tigramite.data_processing - :members: - -:mod:`tigramite.models`: Time series modeling, mediation, and prediction -======================================================================== - -Base class: - -.. autoclass:: tigramite.models.Models - :members: - -Derived classes: - -.. autoclass:: tigramite.models.LinearMediation - :members: - -.. autoclass:: tigramite.models.Prediction - :members: - -:mod:`tigramite.plotting`: Plotting functions -============================================= - -.. automodule:: tigramite.plotting - :members: - -Indices and tables -================== - -* :ref:`genindex` -* :ref:`modindex` -* :ref:`search` diff --git a/docs/_build/html/_static/ajax-loader.gif b/docs/_build/html/_static/ajax-loader.gif deleted file mode 100644 index 61faf8cab23993bd3e1560bff0668bd628642330..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 673 zcmZ?wbhEHb6krfw_{6~Q|Nno%(3)e{?)x>&1u}A`t?OF7Z|1gRivOgXi&7IyQd1Pl zGfOfQ60;I3a`F>X^fL3(@);C=vM_KlFfb_o=k{|A33hf2a5d61U}gjg=>Rd%XaNQW zW@Cw{|b%Y*pl8F?4B9 zlo4Fz*0kZGJabY|>}Okf0}CCg{u4`zEPY^pV?j2@h+|igy0+Kz6p;@SpM4s6)XEMg z#3Y4GX>Hjlml5ftdH$4x0JGdn8~MX(U~_^d!Hi)=HU{V%g+mi8#UGbE-*ao8f#h+S z2a0-5+vc7MU$e-NhmBjLIC1v|)9+Im8x1yacJ7{^tLX(ZhYi^rpmXm0`@ku9b53aN zEXH@Y3JaztblgpxbJt{AtE1ad1Ca>{v$rwwvK(>{m~Gf_=-Ro7Fk{#;i~+{{>QtvI yb2P8Zac~?~=sRA>$6{!(^3;ZP0TPFR(G_-UDU(8Jl0?(IXu$~#4A!880|o%~Al1tN diff --git a/docs/_build/html/_static/alabaster.css b/docs/_build/html/_static/alabaster.css deleted file mode 100644 index bc420a48..00000000 --- a/docs/_build/html/_static/alabaster.css +++ /dev/null @@ -1,593 +0,0 @@ - - - - - - - - - - - - - - - - - -@import url("basic.css"); - -/* -- page layout ----------------------------------------------------------- */ - -body { - font-family: 'goudy old style', 'minion pro', 'bell mt', Georgia, 'Hiragino Mincho Pro', serif; - font-size: 17px; - background-color: white; - color: #000; - margin: 0; - padding: 0; -} - -div.document { - width: 940px; - margin: 30px auto 0 auto; -} - -div.documentwrapper { - float: left; - width: 100%; -} - -div.bodywrapper { - margin: 0 0 0 220px; -} - -div.sphinxsidebar { - width: 220px; -} - -hr { - border: 1px solid #B1B4B6; -} - -div.body { - background-color: #ffffff; - color: #3E4349; - padding: 0 30px 0 30px; -} - -div.body > .section { - text-align: left; -} - -div.footer { - width: 940px; - margin: 20px auto 30px auto; - font-size: 14px; - color: #888; - text-align: right; -} - -div.footer a { - color: #888; -} - - -div.relations { - display: none; -} - - -div.sphinxsidebar a { - color: #444; - text-decoration: none; - border-bottom: 1px dotted #999; -} - -div.sphinxsidebar a:hover { - border-bottom: 1px solid #999; -} - -div.sphinxsidebar { - font-size: 14px; - line-height: 1.5; -} - -div.sphinxsidebarwrapper { - padding: 18px 10px; -} - -div.sphinxsidebarwrapper p.logo { - padding: 0; - margin: -10px 0 0 0px; - text-align: center; -} - -div.sphinxsidebarwrapper h1.logo { - margin-top: -10px; - text-align: center; - margin-bottom: 5px; - text-align: left; -} - -div.sphinxsidebarwrapper h1.logo-name { - margin-top: 0px; -} - -div.sphinxsidebarwrapper p.blurb { - margin-top: 0; - font-style: normal; -} - -div.sphinxsidebar h3, -div.sphinxsidebar h4 { - font-family: 'Garamond', 'Georgia', serif; - color: #444; - font-size: 24px; - font-weight: normal; - margin: 0 0 5px 0; - padding: 0; -} - -div.sphinxsidebar h4 { - font-size: 20px; -} - -div.sphinxsidebar h3 a { - color: #444; -} - -div.sphinxsidebar p.logo a, -div.sphinxsidebar h3 a, -div.sphinxsidebar p.logo a:hover, -div.sphinxsidebar h3 a:hover { - border: none; -} - -div.sphinxsidebar p { - color: #555; - margin: 10px 0; -} - -div.sphinxsidebar ul { - margin: 10px 0; - padding: 0; - color: #000; -} - -div.sphinxsidebar ul li.toctree-l1 > a { - font-size: 120%; -} - -div.sphinxsidebar ul li.toctree-l2 > a { - font-size: 110%; -} - -div.sphinxsidebar input { - border: 1px solid #CCC; - font-family: 'goudy old style', 'minion pro', 'bell mt', Georgia, 'Hiragino Mincho Pro', serif; - font-size: 1em; -} - -div.sphinxsidebar hr { - border: none; - height: 1px; - color: #AAA; - background: #AAA; - - text-align: left; - margin-left: 0; - width: 50%; -} - -/* -- body styles ----------------------------------------------------------- */ - -a { - color: #004B6B; - text-decoration: underline; -} - -a:hover { - color: #6D4100; - text-decoration: underline; -} - -div.body h1, -div.body h2, -div.body h3, -div.body h4, -div.body h5, -div.body h6 { - font-family: 'Garamond', 'Georgia', serif; - font-weight: normal; - margin: 30px 0px 10px 0px; - padding: 0; -} - -div.body h1 { margin-top: 0; padding-top: 0; font-size: 240%; } -div.body h2 { font-size: 180%; } -div.body h3 { font-size: 150%; } -div.body h4 { font-size: 130%; } -div.body h5 { font-size: 100%; } -div.body h6 { font-size: 100%; } - -a.headerlink { - color: #DDD; - padding: 0 4px; - text-decoration: none; -} - -a.headerlink:hover { - color: #444; - background: #EAEAEA; -} - -div.body p, div.body dd, div.body li { - line-height: 1.4em; -} - -div.admonition { - margin: 20px 0px; - padding: 10px 30px; - background-color: #FCC; - border: 1px solid #FAA; -} - -div.admonition tt.xref, div.admonition a tt { - border-bottom: 1px solid #fafafa; -} - -dd div.admonition { - margin-left: -60px; - padding-left: 60px; -} - -div.admonition p.admonition-title { - font-family: 'Garamond', 'Georgia', serif; - font-weight: normal; - font-size: 24px; - margin: 0 0 10px 0; - padding: 0; - line-height: 1; -} - -div.admonition p.last { - margin-bottom: 0; -} - -div.highlight { - background-color: white; -} - -dt:target, .highlight { - background: #FAF3E8; -} - -div.note { - background-color: #EEE; - border: 1px solid #CCC; -} - -div.seealso { - background-color: #EEE; - border: 1px solid #CCC; -} - -div.topic { - background-color: #eee; -} - -p.admonition-title { - display: inline; -} - -p.admonition-title:after { - content: ":"; -} - -pre, tt, code { - font-family: 'Consolas', 'Menlo', 'Deja Vu Sans Mono', 'Bitstream Vera Sans Mono', monospace; - font-size: 0.9em; -} - -.hll { - background-color: #FFC; - margin: 0 -12px; - padding: 0 12px; - display: block; -} - -img.screenshot { -} - -tt.descname, tt.descclassname, code.descname, code.descclassname { - font-size: 0.95em; -} - -tt.descname, code.descname { - padding-right: 0.08em; -} - -img.screenshot { - -moz-box-shadow: 2px 2px 4px #eee; - -webkit-box-shadow: 2px 2px 4px #eee; - box-shadow: 2px 2px 4px #eee; -} - -table.docutils { - border: 1px solid #888; - -moz-box-shadow: 2px 2px 4px #eee; - -webkit-box-shadow: 2px 2px 4px #eee; - box-shadow: 2px 2px 4px #eee; -} - -table.docutils td, table.docutils th { - border: 1px solid #888; - padding: 0.25em 0.7em; -} - -table.field-list, table.footnote { - border: none; - -moz-box-shadow: none; - -webkit-box-shadow: none; - box-shadow: none; -} - -table.footnote { - margin: 15px 0; - width: 100%; - border: 1px solid #EEE; - background: #FDFDFD; - font-size: 0.9em; -} - -table.footnote + table.footnote { - margin-top: -15px; - border-top: none; -} - -table.field-list th { - padding: 0 0.8em 0 0; -} - -table.field-list td { - padding: 0; -} - -table.field-list p { - margin-bottom: 0.8em; -} - -table.footnote td.label { - width: 0px; - padding: 0.3em 0 0.3em 0.5em; -} - -table.footnote td { - padding: 0.3em 0.5em; -} - -dl { - margin: 0; - padding: 0; -} - -dl dd { - margin-left: 30px; -} - -blockquote { - margin: 0 0 0 30px; - padding: 0; -} - -ul, ol { - margin: 10px 0 10px 30px; - padding: 0; -} - -pre { - background: #EEE; - padding: 7px 30px; - margin: 15px 0px; - line-height: 1.3em; -} - -dl pre, blockquote pre, li pre { - margin-left: 0; - padding-left: 30px; -} - -dl dl pre { - margin-left: -90px; - padding-left: 90px; -} - -tt, code { - background-color: #ecf0f3; - color: #222; - /* padding: 1px 2px; */ -} - -tt.xref, code.xref, a tt { - background-color: #FBFBFB; - border-bottom: 1px solid white; -} - -a.reference { - text-decoration: none; - border-bottom: 1px dotted #004B6B; -} - -a.reference:hover { - border-bottom: 1px solid #6D4100; -} - -a.footnote-reference { - text-decoration: none; - font-size: 0.7em; - vertical-align: top; - border-bottom: 1px dotted #004B6B; -} - -a.footnote-reference:hover { - border-bottom: 1px solid #6D4100; -} - -a:hover tt, a:hover code { - background: #EEE; -} - - -@media screen and (max-width: 870px) { - - div.sphinxsidebar { - display: none; - } - - div.document { - width: 100%; - - } - - div.documentwrapper { - margin-left: 0; - margin-top: 0; - margin-right: 0; - margin-bottom: 0; - } - - div.bodywrapper { - margin-top: 0; - margin-right: 0; - margin-bottom: 0; - margin-left: 0; - } - - ul { - margin-left: 0; - } - - .document { - width: auto; - } - - .footer { - width: auto; - } - - .bodywrapper { - margin: 0; - } - - .footer { - width: auto; - } - - .github { - display: none; - } - - - -} - - - -@media screen and (max-width: 875px) { - - body { - margin: 0; - padding: 20px 30px; - } - - div.documentwrapper { - float: none; - background: white; - } - - div.sphinxsidebar { - display: block; - float: none; - width: 102.5%; - margin: 50px -30px -20px -30px; - padding: 10px 20px; - background: #333; - color: #FFF; - } - - div.sphinxsidebar h3, div.sphinxsidebar h4, div.sphinxsidebar p, - div.sphinxsidebar h3 a { - color: white; - } - - div.sphinxsidebar a { - color: #AAA; - } - - div.sphinxsidebar p.logo { - display: none; - } - - div.document { - width: 100%; - margin: 0; - } - - div.footer { - display: none; - } - - div.bodywrapper { - margin: 0; - } - - div.body { - min-height: 0; - padding: 0; - } - - .rtd_doc_footer { - display: none; - } - - .document { - width: auto; - } - - .footer { - width: auto; - } - - .footer { - width: auto; - } - - .github { - display: none; - } -} - - -/* misc. */ - -.revsys-inline { - display: none!important; -} - -/* Make nested-list/multi-paragraph items look better in Releases changelog - * pages. Without this, docutils' magical list fuckery causes inconsistent - * formatting between different release sub-lists. - */ -div#changelog > div.section > ul > li > p:only-child { - margin-bottom: 0; -} - -/* Hide fugly table cell borders in ..bibliography:: directive output */ -table.docutils.citation, table.docutils.citation td, table.docutils.citation th { - border: none; - /* Below needed in some edge cases; if not applied, bottom shadows appear */ - -moz-box-shadow: none; - -webkit-box-shadow: none; - box-shadow: none; -} \ No newline at end of file diff --git a/docs/_build/html/_static/basic.css b/docs/_build/html/_static/basic.css deleted file mode 100644 index dc88b5a2..00000000 --- a/docs/_build/html/_static/basic.css +++ /dev/null @@ -1,632 +0,0 @@ -/* - * basic.css - * ~~~~~~~~~ - * - * Sphinx stylesheet -- basic theme. - * - * :copyright: Copyright 2007-2017 by the Sphinx team, see AUTHORS. - * :license: BSD, see LICENSE for details. - * - */ - -/* -- main layout ----------------------------------------------------------- */ - -div.clearer { - clear: both; -} - -/* -- relbar ---------------------------------------------------------------- */ - -div.related { - width: 100%; - font-size: 90%; -} - -div.related h3 { - display: none; -} - -div.related ul { - margin: 0; - padding: 0 0 0 10px; - list-style: none; -} - -div.related li { - display: inline; -} - -div.related li.right { - float: right; - margin-right: 5px; -} - -/* -- sidebar --------------------------------------------------------------- */ - -div.sphinxsidebarwrapper { - padding: 10px 5px 0 10px; -} - -div.sphinxsidebar { - float: left; - width: 230px; - margin-left: -100%; - font-size: 90%; - word-wrap: break-word; - overflow-wrap : break-word; -} - -div.sphinxsidebar ul { - list-style: none; -} - -div.sphinxsidebar ul ul, -div.sphinxsidebar ul.want-points { - margin-left: 20px; - list-style: square; -} - -div.sphinxsidebar ul ul { - margin-top: 0; - margin-bottom: 0; -} - -div.sphinxsidebar form { - margin-top: 10px; -} - -div.sphinxsidebar input { - border: 1px solid #98dbcc; - font-family: sans-serif; - font-size: 1em; -} - -div.sphinxsidebar #searchbox input[type="text"] { - width: 170px; -} - -img { - border: 0; - max-width: 100%; -} - -/* -- search page ----------------------------------------------------------- */ - -ul.search { - margin: 10px 0 0 20px; - padding: 0; -} - -ul.search li { - padding: 5px 0 5px 20px; - background-image: url(file.png); - background-repeat: no-repeat; - background-position: 0 7px; -} - -ul.search li a { - font-weight: bold; -} - -ul.search li div.context { - color: #888; - margin: 2px 0 0 30px; - text-align: left; -} - -ul.keywordmatches li.goodmatch a { - font-weight: bold; -} - -/* -- index page ------------------------------------------------------------ */ - -table.contentstable { - width: 90%; - margin-left: auto; - margin-right: auto; -} - -table.contentstable p.biglink { - line-height: 150%; -} - -a.biglink { - font-size: 1.3em; -} - -span.linkdescr { - font-style: italic; - padding-top: 5px; - font-size: 90%; -} - -/* -- general index --------------------------------------------------------- */ - -table.indextable { - width: 100%; -} - -table.indextable td { - text-align: left; - vertical-align: top; -} - -table.indextable ul { - margin-top: 0; - margin-bottom: 0; - list-style-type: none; -} - -table.indextable > tbody > tr > td > ul { - padding-left: 0em; -} - -table.indextable tr.pcap { - height: 10px; -} - -table.indextable tr.cap { - margin-top: 10px; - background-color: #f2f2f2; -} - -img.toggler { - margin-right: 3px; - margin-top: 3px; - cursor: pointer; -} - -div.modindex-jumpbox { - border-top: 1px solid #ddd; - border-bottom: 1px solid #ddd; - margin: 1em 0 1em 0; - padding: 0.4em; -} - -div.genindex-jumpbox { - border-top: 1px solid #ddd; - border-bottom: 1px solid #ddd; - margin: 1em 0 1em 0; - padding: 0.4em; -} - -/* -- domain module index --------------------------------------------------- */ - -table.modindextable td { - padding: 2px; - border-collapse: collapse; -} - -/* -- general body styles --------------------------------------------------- */ - -div.body p, div.body dd, div.body li, div.body blockquote { - -moz-hyphens: auto; - -ms-hyphens: auto; - -webkit-hyphens: auto; - hyphens: auto; -} - -a.headerlink { - visibility: hidden; -} - -h1:hover > a.headerlink, -h2:hover > a.headerlink, -h3:hover > a.headerlink, -h4:hover > a.headerlink, -h5:hover > a.headerlink, -h6:hover > a.headerlink, -dt:hover > a.headerlink, -caption:hover > a.headerlink, -p.caption:hover > a.headerlink, -div.code-block-caption:hover > a.headerlink { - visibility: visible; -} - -div.body p.caption { - text-align: inherit; -} - -div.body td { - text-align: left; -} - -.first { - margin-top: 0 !important; -} - -p.rubric { - margin-top: 30px; - font-weight: bold; -} - -img.align-left, .figure.align-left, object.align-left { - clear: left; - float: left; - margin-right: 1em; -} - -img.align-right, .figure.align-right, object.align-right { - clear: right; - float: right; - margin-left: 1em; -} - -img.align-center, .figure.align-center, object.align-center { - display: block; - margin-left: auto; - margin-right: auto; -} - -.align-left { - text-align: left; -} - -.align-center { - text-align: center; -} - -.align-right { - text-align: right; -} - -/* -- sidebars -------------------------------------------------------------- */ - -div.sidebar { - margin: 0 0 0.5em 1em; - border: 1px solid #ddb; - padding: 7px 7px 0 7px; - background-color: #ffe; - width: 40%; - float: right; -} - -p.sidebar-title { - font-weight: bold; -} - -/* -- topics ---------------------------------------------------------------- */ - -div.topic { - border: 1px solid #ccc; - padding: 7px 7px 0 7px; - margin: 10px 0 10px 0; -} - -p.topic-title { - font-size: 1.1em; - font-weight: bold; - margin-top: 10px; -} - -/* -- admonitions ----------------------------------------------------------- */ - -div.admonition { - margin-top: 10px; - margin-bottom: 10px; - padding: 7px; -} - -div.admonition dt { - font-weight: bold; -} - -div.admonition dl { - margin-bottom: 0; -} - -p.admonition-title { - margin: 0px 10px 5px 0px; - font-weight: bold; -} - -div.body p.centered { - text-align: center; - margin-top: 25px; -} - -/* -- tables ---------------------------------------------------------------- */ - -table.docutils { - border: 0; - border-collapse: collapse; -} - -table caption span.caption-number { - font-style: italic; -} - -table caption span.caption-text { -} - -table.docutils td, table.docutils th { - padding: 1px 8px 1px 5px; - border-top: 0; - border-left: 0; - border-right: 0; - border-bottom: 1px solid #aaa; -} - -table.footnote td, table.footnote th { - border: 0 !important; -} - -th { - text-align: left; - padding-right: 5px; -} - -table.citation { - border-left: solid 1px gray; - margin-left: 1px; -} - -table.citation td { - border-bottom: none; -} - -/* -- figures --------------------------------------------------------------- */ - -div.figure { - margin: 0.5em; - padding: 0.5em; -} - -div.figure p.caption { - padding: 0.3em; -} - -div.figure p.caption span.caption-number { - font-style: italic; -} - -div.figure p.caption span.caption-text { -} - -/* -- field list styles ----------------------------------------------------- */ - -table.field-list td, table.field-list th { - border: 0 !important; -} - -.field-list ul { - margin: 0; - padding-left: 1em; -} - -.field-list p { - margin: 0; -} - -/* -- other body styles ----------------------------------------------------- */ - -ol.arabic { - list-style: decimal; -} - -ol.loweralpha { - list-style: lower-alpha; -} - -ol.upperalpha { - list-style: upper-alpha; -} - -ol.lowerroman { - list-style: lower-roman; -} - -ol.upperroman { - list-style: upper-roman; -} - -dl { - margin-bottom: 15px; -} - -dd p { - margin-top: 0px; -} - -dd ul, dd table { - margin-bottom: 10px; -} - -dd { - margin-top: 3px; - margin-bottom: 10px; - margin-left: 30px; -} - -dt:target, .highlighted { - background-color: #fbe54e; -} - -dl.glossary dt { - font-weight: bold; - font-size: 1.1em; -} - -.optional { - font-size: 1.3em; -} - -.sig-paren { - font-size: larger; -} - -.versionmodified { - font-style: italic; -} - -.system-message { - background-color: #fda; - padding: 5px; - border: 3px solid red; -} - -.footnote:target { - background-color: #ffa; -} - -.line-block { - display: block; - margin-top: 1em; - margin-bottom: 1em; -} - -.line-block .line-block { - margin-top: 0; - margin-bottom: 0; - margin-left: 1.5em; -} - -.guilabel, .menuselection { - font-family: sans-serif; -} - -.accelerator { - text-decoration: underline; -} - -.classifier { - font-style: oblique; -} - -abbr, acronym { - border-bottom: dotted 1px; - cursor: help; -} - -/* -- code displays --------------------------------------------------------- */ - -pre { - overflow: auto; - overflow-y: hidden; /* fixes display issues on Chrome browsers */ -} - -span.pre { - -moz-hyphens: none; - -ms-hyphens: none; - -webkit-hyphens: none; - hyphens: none; -} - -td.linenos pre { - padding: 5px 0px; - border: 0; - background-color: transparent; - color: #aaa; -} - -table.highlighttable { - margin-left: 0.5em; -} - -table.highlighttable td { - padding: 0 0.5em 0 0.5em; -} - -div.code-block-caption { - padding: 2px 5px; - font-size: small; -} - -div.code-block-caption code { - background-color: transparent; -} - -div.code-block-caption + div > div.highlight > pre { - margin-top: 0; -} - -div.code-block-caption span.caption-number { - padding: 0.1em 0.3em; - font-style: italic; -} - -div.code-block-caption span.caption-text { -} - -div.literal-block-wrapper { - padding: 1em 1em 0; -} - -div.literal-block-wrapper div.highlight { - margin: 0; -} - -code.descname { - background-color: transparent; - font-weight: bold; - font-size: 1.2em; -} - -code.descclassname { - background-color: transparent; -} - -code.xref, a code { - background-color: transparent; - font-weight: bold; -} - -h1 code, h2 code, h3 code, h4 code, h5 code, h6 code { - background-color: transparent; -} - -.viewcode-link { - float: right; -} - -.viewcode-back { - float: right; - font-family: sans-serif; -} - -div.viewcode-block:target { - margin: -1px -10px; - padding: 0 10px; -} - -/* -- math display ---------------------------------------------------------- */ - -img.math { - vertical-align: middle; -} - -div.body div.math p { - text-align: center; -} - -span.eqno { - float: right; -} - -span.eqno a.headerlink { - position: relative; - left: 0px; - z-index: 1; -} - -div.math:hover a.headerlink { - visibility: visible; -} - -/* -- printout stylesheet --------------------------------------------------- */ - -@media print { - div.document, - div.documentwrapper, - div.bodywrapper { - margin: 0 !important; - width: 100%; - } - - div.sphinxsidebar, - div.related, - div.footer, - #top-link { - display: none; - } -} \ No newline at end of file diff --git a/docs/_build/html/_static/comment-bright.png b/docs/_build/html/_static/comment-bright.png deleted file mode 100644 index 15e27edb12ac25701ac0ac21b97b52bb4e45415e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 756 zcmVgfIX78 z$8Pzv({A~p%??+>KickCb#0FM1rYN=mBmQ&Nwp<#JXUhU;{|)}%&s>suq6lXw*~s{ zvHx}3C%<;wE5CH!BR{p5@ml9ws}y)=QN-kL2?#`S5d*6j zk`h<}j1>tD$b?4D^N9w}-k)bxXxFg>+#kme^xx#qg6FI-%iv2U{0h(Y)cs%5a|m%Pn_K3X_bDJ>EH#(Fb73Z zfUt2Q3B>N+ot3qb*DqbTZpFIn4a!#_R-}{?-~Hs=xSS6p&$sZ-k1zDdtqU`Y@`#qL z&zv-~)Q#JCU(dI)Hf;$CEnK=6CK50}q7~wdbI->?E07bJ0R;!GSQTs5Am`#;*WHjvHRvY?&$Lm-vq1a_BzocI^ULXV!lbMd%|^B#fY;XX)n<&R^L z=84u1e_3ziq;Hz-*k5~zwY3*oDKt0;bM@M@@89;@m*4RFgvvM_4;5LB!@OB@^WbVT zjl{t;a8_>od-~P4 m{5|DvB&z#xT;*OnJqG}gk~_7HcNkCr0000W zanA~u9RIXo;n7c96&U)YLgs-FGlx~*_c{Jgvesu1E5(8YEf&5wF=YFPcRe@1=MJmi zag(L*xc2r0(slpcN!vC5CUju;vHJkHc*&70_n2OZsK%O~A=!+YIw z7zLLl7~Z+~RgWOQ=MI6$#0pvpu$Q43 zP@36QAmu6!_9NPM?o<1_!+stoVRRZbW9#SPe!n;#A_6m8f}|xN1;H{`0RoXQ2LM47 zt(g;iZ6|pCb@h2xk&(}S3=EVBUO0e90m2Lp5CB<(SPIaB;n4))3JB87Or#XPOPcum z?<^(g+m9}VNn4Y&B`g8h{t_$+RB1%HKRY6fjtd-<7&EsU;vs0GM(Lmbhi%Gwcfs0FTF}T zL{_M6Go&E0Eg8FuB*(Yn+Z*RVTBE@10eIOb3El^MhO`GabDll(V0&FlJi2k^;q8af zkENdk2}x2)_KVp`5OAwXZM;dG0?M-S)xE1IKDi6BY@5%Or?#aZ9$gcX)dPZ&wA1a< z$rFXHPn|TBf`e?>Are8sKtKrKcjF$i^lp!zkL?C|y^vlHr1HXeVJd;1I~g&Ob-q)& z(fn7s-KI}G{wnKzg_U5G(V%bX6uk zIa+<@>rdmZYd!9Y=C0cuchrbIjuRB_Wq{-RXlic?flu1*_ux}x%(HDH&nT`k^xCeC ziHi1!ChH*sQ6|UqJpTTzX$aw8e(UfcS^f;6yBWd+(1-70zU(rtxtqR%j z-lsH|CKQJXqD{+F7V0OTv8@{~(wp(`oIP^ZykMWgR>&|RsklFMCnOo&Bd{le} zV5F6424Qzl;o2G%oVvmHgRDP9!=rK8fy^!yV8y*4p=??uIRrrr0?>O!(z*g5AvL2!4z0{sq%vhG*Po}`a<6%kTK5TNhtC8}rXNu&h^QH4A&Sk~Autm*s~45(H7+0bi^MraaRVzr05hQ3iK?j` zR#U@^i0WhkIHTg29u~|ypU?sXCQEQgXfObPW;+0YAF;|5XyaMAEM0sQ@4-xCZe=0e z7r$ofiAxn@O5#RodD8rh5D@nKQ;?lcf@tg4o+Wp44aMl~c47azN_(im0N)7OqdPBC zGw;353_o$DqGRDhuhU$Eaj!@m000000NkvXXu0mjfjZ7Z_ diff --git a/docs/_build/html/_static/contents.png b/docs/_build/html/_static/contents.png deleted file mode 100644 index 6c59aa1f9c8c3b754b258b8ab4f6b95971c99109..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 107 zcmeAS@N?(olHy`uVBq!ia0vp^j6kfx!2~2XTwzxLQbwLGjv*C{Q@c%>8XN?UO#1VG zcLb|!+10i0Jzf{Gv>fyFaQYL)bKk!I{mJd!3^2Uu$-u=wds-dX_E&EV= 0 && !jQuery(node.parentNode).hasClass(className)) { - var span = document.createElement("span"); - span.className = className; - span.appendChild(document.createTextNode(val.substr(pos, text.length))); - node.parentNode.insertBefore(span, node.parentNode.insertBefore( - document.createTextNode(val.substr(pos + text.length)), - node.nextSibling)); - node.nodeValue = val.substr(0, pos); - } - } - else if (!jQuery(node).is("button, select, textarea")) { - jQuery.each(node.childNodes, function() { - highlight(this); - }); - } - } - return this.each(function() { - highlight(this); - }); -}; - -/* - * backward compatibility for jQuery.browser - * This will be supported until firefox bug is fixed. - */ -if (!jQuery.browser) { - jQuery.uaMatch = function(ua) { - ua = ua.toLowerCase(); - - var match = /(chrome)[ \/]([\w.]+)/.exec(ua) || - /(webkit)[ \/]([\w.]+)/.exec(ua) || - /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) || - /(msie) ([\w.]+)/.exec(ua) || - ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) || - []; - - return { - browser: match[ 1 ] || "", - version: match[ 2 ] || "0" - }; - }; - jQuery.browser = {}; - jQuery.browser[jQuery.uaMatch(navigator.userAgent).browser] = true; -} - -/** - * Small JavaScript module for the documentation. - */ -var Documentation = { - - init : function() { - this.fixFirefoxAnchorBug(); - this.highlightSearchWords(); - this.initIndexTable(); - - }, - - /** - * i18n support - */ - TRANSLATIONS : {}, - PLURAL_EXPR : function(n) { return n == 1 ? 0 : 1; }, - LOCALE : 'unknown', - - // gettext and ngettext don't access this so that the functions - // can safely bound to a different name (_ = Documentation.gettext) - gettext : function(string) { - var translated = Documentation.TRANSLATIONS[string]; - if (typeof translated == 'undefined') - return string; - return (typeof translated == 'string') ? translated : translated[0]; - }, - - ngettext : function(singular, plural, n) { - var translated = Documentation.TRANSLATIONS[singular]; - if (typeof translated == 'undefined') - return (n == 1) ? singular : plural; - return translated[Documentation.PLURALEXPR(n)]; - }, - - addTranslations : function(catalog) { - for (var key in catalog.messages) - this.TRANSLATIONS[key] = catalog.messages[key]; - this.PLURAL_EXPR = new Function('n', 'return +(' + catalog.plural_expr + ')'); - this.LOCALE = catalog.locale; - }, - - /** - * add context elements like header anchor links - */ - addContextElements : function() { - $('div[id] > :header:first').each(function() { - $('\u00B6'). - attr('href', '#' + this.id). - attr('title', _('Permalink to this headline')). - appendTo(this); - }); - $('dt[id]').each(function() { - $('\u00B6'). - attr('href', '#' + this.id). - attr('title', _('Permalink to this definition')). - appendTo(this); - }); - }, - - /** - * workaround a firefox stupidity - * see: https://bugzilla.mozilla.org/show_bug.cgi?id=645075 - */ - fixFirefoxAnchorBug : function() { - if (document.location.hash) - window.setTimeout(function() { - document.location.href += ''; - }, 10); - }, - - /** - * highlight the search words provided in the url in the text - */ - highlightSearchWords : function() { - var params = $.getQueryParameters(); - var terms = (params.highlight) ? params.highlight[0].split(/\s+/) : []; - if (terms.length) { - var body = $('div.body'); - if (!body.length) { - body = $('body'); - } - window.setTimeout(function() { - $.each(terms, function() { - body.highlightText(this.toLowerCase(), 'highlighted'); - }); - }, 10); - $('

' + _('Hide Search Matches') + '

') - .appendTo($('#searchbox')); - } - }, - - /** - * init the domain index toggle buttons - */ - initIndexTable : function() { - var togglers = $('img.toggler').click(function() { - var src = $(this).attr('src'); - var idnum = $(this).attr('id').substr(7); - $('tr.cg-' + idnum).toggle(); - if (src.substr(-9) == 'minus.png') - $(this).attr('src', src.substr(0, src.length-9) + 'plus.png'); - else - $(this).attr('src', src.substr(0, src.length-8) + 'minus.png'); - }).css('display', ''); - if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) { - togglers.click(); - } - }, - - /** - * helper function to hide the search marks again - */ - hideSearchWords : function() { - $('#searchbox .highlight-link').fadeOut(300); - $('span.highlighted').removeClass('highlighted'); - }, - - /** - * make the url absolute - */ - makeURL : function(relativeURL) { - return DOCUMENTATION_OPTIONS.URL_ROOT + '/' + relativeURL; - }, - - /** - * get the current relative url - */ - getCurrentURL : function() { - var path = document.location.pathname; - var parts = path.split(/\//); - $.each(DOCUMENTATION_OPTIONS.URL_ROOT.split(/\//), function() { - if (this == '..') - parts.pop(); - }); - var url = parts.join('/'); - return path.substring(url.lastIndexOf('/') + 1, path.length - 1); - }, - - initOnKeyListeners: function() { - $(document).keyup(function(event) { - var activeElementType = document.activeElement.tagName; - // don't navigate when in search box or textarea - if (activeElementType !== 'TEXTAREA' && activeElementType !== 'INPUT' && activeElementType !== 'SELECT') { - switch (event.keyCode) { - case 37: // left - var prevHref = $('link[rel="prev"]').prop('href'); - if (prevHref) { - window.location.href = prevHref; - return false; - } - case 39: // right - var nextHref = $('link[rel="next"]').prop('href'); - if (nextHref) { - window.location.href = nextHref; - return false; - } - } - } - }); - } -}; - -// quick alias for translations -_ = Documentation.gettext; - -$(document).ready(function() { - Documentation.init(); -}); \ No newline at end of file diff --git a/docs/_build/html/_static/documentation_options.js b/docs/_build/html/_static/documentation_options.js deleted file mode 100644 index 8a5f4b08..00000000 --- a/docs/_build/html/_static/documentation_options.js +++ /dev/null @@ -1,9 +0,0 @@ -var DOCUMENTATION_OPTIONS = { - URL_ROOT: '', - VERSION: '4.0', - LANGUAGE: 'None', - COLLAPSE_INDEX: false, - FILE_SUFFIX: '.html', - HAS_SOURCE: true, - SOURCELINK_SUFFIX: '.txt' -}; \ No newline at end of file diff --git a/docs/_build/html/_static/down-pressed.png b/docs/_build/html/_static/down-pressed.png deleted file mode 100644 index 5756c8cad8854722893dc70b9eb4bb0400343a39..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 222 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`OFdm2Ln;`PZ^+1>KjR?B@S0W7 z%OS_REiHONoJ6{+Ks@6k3590|7k9F+ddB6!zw3#&!aw#S`x}3V3&=A(a#84O-&F7T z^k3tZB;&iR9siw0|F|E|DAL<8r-F4!1H-;1{e*~yAKZN5f0|Ei6yUmR#Is)EM(Po_ zi`qJR6|P<~+)N+kSDgL7AjdIC_!O7Q?eGb+L+qOjm{~LLinM4NHn7U%HcK%uoMYO5 VJ~8zD2B3o(JYD@<);T3K0RV0%P>BEl diff --git a/docs/_build/html/_static/down.png b/docs/_build/html/_static/down.png deleted file mode 100644 index 1b3bdad2ceffae91cee61b32f3295f9bbe646e48..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 202 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!60wlNoGJgf6CVIL!hEy=F?b*7pIY7kW{q%Rg zx!yQ<9v8bmJwa`TQk7YSw}WVQ()mRdQ;TC;* diff --git a/docs/_build/html/_static/file.png b/docs/_build/html/_static/file.png deleted file mode 100644 index a858a410e4faa62ce324d814e4b816fff83a6fb3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 286 zcmV+(0pb3MP)s`hMrGg#P~ix$^RISR_I47Y|r1 z_CyJOe}D1){SET-^Amu_i71Lt6eYfZjRyw@I6OQAIXXHDfiX^GbOlHe=Ae4>0m)d(f|Me07*qoM6N<$f}vM^LjV8( diff --git a/docs/_build/html/_static/jquery-3.1.0.js b/docs/_build/html/_static/jquery-3.1.0.js deleted file mode 100644 index f2fc2747..00000000 --- a/docs/_build/html/_static/jquery-3.1.0.js +++ /dev/null @@ -1,10074 +0,0 @@ -/*eslint-disable no-unused-vars*/ -/*! - * jQuery JavaScript Library v3.1.0 - * https://jquery.com/ - * - * Includes Sizzle.js - * https://sizzlejs.com/ - * - * Copyright jQuery Foundation and other contributors - * Released under the MIT license - * https://jquery.org/license - * - * Date: 2016-07-07T21:44Z - */ -( function( global, factory ) { - - "use strict"; - - if ( typeof module === "object" && typeof module.exports === "object" ) { - - // For CommonJS and CommonJS-like environments where a proper `window` - // is present, execute the factory and get jQuery. - // For environments that do not have a `window` with a `document` - // (such as Node.js), expose a factory as module.exports. - // This accentuates the need for the creation of a real `window`. - // e.g. var jQuery = require("jquery")(window); - // See ticket #14549 for more info. - module.exports = global.document ? - factory( global, true ) : - function( w ) { - if ( !w.document ) { - throw new Error( "jQuery requires a window with a document" ); - } - return factory( w ); - }; - } else { - factory( global ); - } - -// Pass this if window is not defined yet -} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) { - -// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1 -// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode -// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common -// enough that all such attempts are guarded in a try block. -"use strict"; - -var arr = []; - -var document = window.document; - -var getProto = Object.getPrototypeOf; - -var slice = arr.slice; - -var concat = arr.concat; - -var push = arr.push; - -var indexOf = arr.indexOf; - -var class2type = {}; - -var toString = class2type.toString; - -var hasOwn = class2type.hasOwnProperty; - -var fnToString = hasOwn.toString; - -var ObjectFunctionString = fnToString.call( Object ); - -var support = {}; - - - - function DOMEval( code, doc ) { - doc = doc || document; - - var script = doc.createElement( "script" ); - - script.text = code; - doc.head.appendChild( script ).parentNode.removeChild( script ); - } -/* global Symbol */ -// Defining this global in .eslintrc would create a danger of using the global -// unguarded in another place, it seems safer to define global only for this module - - - -var - version = "3.1.0", - - // Define a local copy of jQuery - jQuery = function( selector, context ) { - - // The jQuery object is actually just the init constructor 'enhanced' - // Need init if jQuery is called (just allow error to be thrown if not included) - return new jQuery.fn.init( selector, context ); - }, - - // Support: Android <=4.0 only - // Make sure we trim BOM and NBSP - rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, - - // Matches dashed string for camelizing - rmsPrefix = /^-ms-/, - rdashAlpha = /-([a-z])/g, - - // Used by jQuery.camelCase as callback to replace() - fcamelCase = function( all, letter ) { - return letter.toUpperCase(); - }; - -jQuery.fn = jQuery.prototype = { - - // The current version of jQuery being used - jquery: version, - - constructor: jQuery, - - // The default length of a jQuery object is 0 - length: 0, - - toArray: function() { - return slice.call( this ); - }, - - // Get the Nth element in the matched element set OR - // Get the whole matched element set as a clean array - get: function( num ) { - return num != null ? - - // Return just the one element from the set - ( num < 0 ? this[ num + this.length ] : this[ num ] ) : - - // Return all the elements in a clean array - slice.call( this ); - }, - - // Take an array of elements and push it onto the stack - // (returning the new matched element set) - pushStack: function( elems ) { - - // Build a new jQuery matched element set - var ret = jQuery.merge( this.constructor(), elems ); - - // Add the old object onto the stack (as a reference) - ret.prevObject = this; - - // Return the newly-formed element set - return ret; - }, - - // Execute a callback for every element in the matched set. - each: function( callback ) { - return jQuery.each( this, callback ); - }, - - map: function( callback ) { - return this.pushStack( jQuery.map( this, function( elem, i ) { - return callback.call( elem, i, elem ); - } ) ); - }, - - slice: function() { - return this.pushStack( slice.apply( this, arguments ) ); - }, - - first: function() { - return this.eq( 0 ); - }, - - last: function() { - return this.eq( -1 ); - }, - - eq: function( i ) { - var len = this.length, - j = +i + ( i < 0 ? len : 0 ); - return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] ); - }, - - end: function() { - return this.prevObject || this.constructor(); - }, - - // For internal use only. - // Behaves like an Array's method, not like a jQuery method. - push: push, - sort: arr.sort, - splice: arr.splice -}; - -jQuery.extend = jQuery.fn.extend = function() { - var options, name, src, copy, copyIsArray, clone, - target = arguments[ 0 ] || {}, - i = 1, - length = arguments.length, - deep = false; - - // Handle a deep copy situation - if ( typeof target === "boolean" ) { - deep = target; - - // Skip the boolean and the target - target = arguments[ i ] || {}; - i++; - } - - // Handle case when target is a string or something (possible in deep copy) - if ( typeof target !== "object" && !jQuery.isFunction( target ) ) { - target = {}; - } - - // Extend jQuery itself if only one argument is passed - if ( i === length ) { - target = this; - i--; - } - - for ( ; i < length; i++ ) { - - // Only deal with non-null/undefined values - if ( ( options = arguments[ i ] ) != null ) { - - // Extend the base object - for ( name in options ) { - src = target[ name ]; - copy = options[ name ]; - - // Prevent never-ending loop - if ( target === copy ) { - continue; - } - - // Recurse if we're merging plain objects or arrays - if ( deep && copy && ( jQuery.isPlainObject( copy ) || - ( copyIsArray = jQuery.isArray( copy ) ) ) ) { - - if ( copyIsArray ) { - copyIsArray = false; - clone = src && jQuery.isArray( src ) ? src : []; - - } else { - clone = src && jQuery.isPlainObject( src ) ? src : {}; - } - - // Never move original objects, clone them - target[ name ] = jQuery.extend( deep, clone, copy ); - - // Don't bring in undefined values - } else if ( copy !== undefined ) { - target[ name ] = copy; - } - } - } - } - - // Return the modified object - return target; -}; - -jQuery.extend( { - - // Unique for each copy of jQuery on the page - expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ), - - // Assume jQuery is ready without the ready module - isReady: true, - - error: function( msg ) { - throw new Error( msg ); - }, - - noop: function() {}, - - isFunction: function( obj ) { - return jQuery.type( obj ) === "function"; - }, - - isArray: Array.isArray, - - isWindow: function( obj ) { - return obj != null && obj === obj.window; - }, - - isNumeric: function( obj ) { - - // As of jQuery 3.0, isNumeric is limited to - // strings and numbers (primitives or objects) - // that can be coerced to finite numbers (gh-2662) - var type = jQuery.type( obj ); - return ( type === "number" || type === "string" ) && - - // parseFloat NaNs numeric-cast false positives ("") - // ...but misinterprets leading-number strings, particularly hex literals ("0x...") - // subtraction forces infinities to NaN - !isNaN( obj - parseFloat( obj ) ); - }, - - isPlainObject: function( obj ) { - var proto, Ctor; - - // Detect obvious negatives - // Use toString instead of jQuery.type to catch host objects - if ( !obj || toString.call( obj ) !== "[object Object]" ) { - return false; - } - - proto = getProto( obj ); - - // Objects with no prototype (e.g., `Object.create( null )`) are plain - if ( !proto ) { - return true; - } - - // Objects with prototype are plain iff they were constructed by a global Object function - Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor; - return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString; - }, - - isEmptyObject: function( obj ) { - - /* eslint-disable no-unused-vars */ - // See https://github.com/eslint/eslint/issues/6125 - var name; - - for ( name in obj ) { - return false; - } - return true; - }, - - type: function( obj ) { - if ( obj == null ) { - return obj + ""; - } - - // Support: Android <=2.3 only (functionish RegExp) - return typeof obj === "object" || typeof obj === "function" ? - class2type[ toString.call( obj ) ] || "object" : - typeof obj; - }, - - // Evaluates a script in a global context - globalEval: function( code ) { - DOMEval( code ); - }, - - // Convert dashed to camelCase; used by the css and data modules - // Support: IE <=9 - 11, Edge 12 - 13 - // Microsoft forgot to hump their vendor prefix (#9572) - camelCase: function( string ) { - return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase ); - }, - - nodeName: function( elem, name ) { - return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase(); - }, - - each: function( obj, callback ) { - var length, i = 0; - - if ( isArrayLike( obj ) ) { - length = obj.length; - for ( ; i < length; i++ ) { - if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { - break; - } - } - } else { - for ( i in obj ) { - if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { - break; - } - } - } - - return obj; - }, - - // Support: Android <=4.0 only - trim: function( text ) { - return text == null ? - "" : - ( text + "" ).replace( rtrim, "" ); - }, - - // results is for internal usage only - makeArray: function( arr, results ) { - var ret = results || []; - - if ( arr != null ) { - if ( isArrayLike( Object( arr ) ) ) { - jQuery.merge( ret, - typeof arr === "string" ? - [ arr ] : arr - ); - } else { - push.call( ret, arr ); - } - } - - return ret; - }, - - inArray: function( elem, arr, i ) { - return arr == null ? -1 : indexOf.call( arr, elem, i ); - }, - - // Support: Android <=4.0 only, PhantomJS 1 only - // push.apply(_, arraylike) throws on ancient WebKit - merge: function( first, second ) { - var len = +second.length, - j = 0, - i = first.length; - - for ( ; j < len; j++ ) { - first[ i++ ] = second[ j ]; - } - - first.length = i; - - return first; - }, - - grep: function( elems, callback, invert ) { - var callbackInverse, - matches = [], - i = 0, - length = elems.length, - callbackExpect = !invert; - - // Go through the array, only saving the items - // that pass the validator function - for ( ; i < length; i++ ) { - callbackInverse = !callback( elems[ i ], i ); - if ( callbackInverse !== callbackExpect ) { - matches.push( elems[ i ] ); - } - } - - return matches; - }, - - // arg is for internal usage only - map: function( elems, callback, arg ) { - var length, value, - i = 0, - ret = []; - - // Go through the array, translating each of the items to their new values - if ( isArrayLike( elems ) ) { - length = elems.length; - for ( ; i < length; i++ ) { - value = callback( elems[ i ], i, arg ); - - if ( value != null ) { - ret.push( value ); - } - } - - // Go through every key on the object, - } else { - for ( i in elems ) { - value = callback( elems[ i ], i, arg ); - - if ( value != null ) { - ret.push( value ); - } - } - } - - // Flatten any nested arrays - return concat.apply( [], ret ); - }, - - // A global GUID counter for objects - guid: 1, - - // Bind a function to a context, optionally partially applying any - // arguments. - proxy: function( fn, context ) { - var tmp, args, proxy; - - if ( typeof context === "string" ) { - tmp = fn[ context ]; - context = fn; - fn = tmp; - } - - // Quick check to determine if target is callable, in the spec - // this throws a TypeError, but we will just return undefined. - if ( !jQuery.isFunction( fn ) ) { - return undefined; - } - - // Simulated bind - args = slice.call( arguments, 2 ); - proxy = function() { - return fn.apply( context || this, args.concat( slice.call( arguments ) ) ); - }; - - // Set the guid of unique handler to the same of original handler, so it can be removed - proxy.guid = fn.guid = fn.guid || jQuery.guid++; - - return proxy; - }, - - now: Date.now, - - // jQuery.support is not used in Core but other projects attach their - // properties to it so it needs to exist. - support: support -} ); - -if ( typeof Symbol === "function" ) { - jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ]; -} - -// Populate the class2type map -jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ), -function( i, name ) { - class2type[ "[object " + name + "]" ] = name.toLowerCase(); -} ); - -function isArrayLike( obj ) { - - // Support: real iOS 8.2 only (not reproducible in simulator) - // `in` check used to prevent JIT error (gh-2145) - // hasOwn isn't used here due to false negatives - // regarding Nodelist length in IE - var length = !!obj && "length" in obj && obj.length, - type = jQuery.type( obj ); - - if ( type === "function" || jQuery.isWindow( obj ) ) { - return false; - } - - return type === "array" || length === 0 || - typeof length === "number" && length > 0 && ( length - 1 ) in obj; -} -var Sizzle = -/*! - * Sizzle CSS Selector Engine v2.3.0 - * https://sizzlejs.com/ - * - * Copyright jQuery Foundation and other contributors - * Released under the MIT license - * http://jquery.org/license - * - * Date: 2016-01-04 - */ -(function( window ) { - -var i, - support, - Expr, - getText, - isXML, - tokenize, - compile, - select, - outermostContext, - sortInput, - hasDuplicate, - - // Local document vars - setDocument, - document, - docElem, - documentIsHTML, - rbuggyQSA, - rbuggyMatches, - matches, - contains, - - // Instance-specific data - expando = "sizzle" + 1 * new Date(), - preferredDoc = window.document, - dirruns = 0, - done = 0, - classCache = createCache(), - tokenCache = createCache(), - compilerCache = createCache(), - sortOrder = function( a, b ) { - if ( a === b ) { - hasDuplicate = true; - } - return 0; - }, - - // Instance methods - hasOwn = ({}).hasOwnProperty, - arr = [], - pop = arr.pop, - push_native = arr.push, - push = arr.push, - slice = arr.slice, - // Use a stripped-down indexOf as it's faster than native - // https://jsperf.com/thor-indexof-vs-for/5 - indexOf = function( list, elem ) { - var i = 0, - len = list.length; - for ( ; i < len; i++ ) { - if ( list[i] === elem ) { - return i; - } - } - return -1; - }, - - booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped", - - // Regular expressions - - // http://www.w3.org/TR/css3-selectors/#whitespace - whitespace = "[\\x20\\t\\r\\n\\f]", - - // http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier - identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+", - - // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors - attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + - // Operator (capture 2) - "*([*^$|!~]?=)" + whitespace + - // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]" - "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace + - "*\\]", - - pseudos = ":(" + identifier + ")(?:\\((" + - // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments: - // 1. quoted (capture 3; capture 4 or capture 5) - "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" + - // 2. simple (capture 6) - "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" + - // 3. anything else (capture 2) - ".*" + - ")\\)|)", - - // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter - rwhitespace = new RegExp( whitespace + "+", "g" ), - rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ), - - rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), - rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ), - - rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ), - - rpseudo = new RegExp( pseudos ), - ridentifier = new RegExp( "^" + identifier + "$" ), - - matchExpr = { - "ID": new RegExp( "^#(" + identifier + ")" ), - "CLASS": new RegExp( "^\\.(" + identifier + ")" ), - "TAG": new RegExp( "^(" + identifier + "|[*])" ), - "ATTR": new RegExp( "^" + attributes ), - "PSEUDO": new RegExp( "^" + pseudos ), - "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + - "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + - "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), - "bool": new RegExp( "^(?:" + booleans + ")$", "i" ), - // For use in libraries implementing .is() - // We use this for POS matching in `select` - "needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + - whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" ) - }, - - rinputs = /^(?:input|select|textarea|button)$/i, - rheader = /^h\d$/i, - - rnative = /^[^{]+\{\s*\[native \w/, - - // Easily-parseable/retrievable ID or TAG or CLASS selectors - rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, - - rsibling = /[+~]/, - - // CSS escapes - // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters - runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ), - funescape = function( _, escaped, escapedWhitespace ) { - var high = "0x" + escaped - 0x10000; - // NaN means non-codepoint - // Support: Firefox<24 - // Workaround erroneous numeric interpretation of +"0x" - return high !== high || escapedWhitespace ? - escaped : - high < 0 ? - // BMP codepoint - String.fromCharCode( high + 0x10000 ) : - // Supplemental Plane codepoint (surrogate pair) - String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 ); - }, - - // CSS string/identifier serialization - // https://drafts.csswg.org/cssom/#common-serializing-idioms - rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g, - fcssescape = function( ch, asCodePoint ) { - if ( asCodePoint ) { - - // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER - if ( ch === "\0" ) { - return "\uFFFD"; - } - - // Control characters and (dependent upon position) numbers get escaped as code points - return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " "; - } - - // Other potentially-special ASCII characters get backslash-escaped - return "\\" + ch; - }, - - // Used for iframes - // See setDocument() - // Removing the function wrapper causes a "Permission Denied" - // error in IE - unloadHandler = function() { - setDocument(); - }, - - disabledAncestor = addCombinator( - function( elem ) { - return elem.disabled === true; - }, - { dir: "parentNode", next: "legend" } - ); - -// Optimize for push.apply( _, NodeList ) -try { - push.apply( - (arr = slice.call( preferredDoc.childNodes )), - preferredDoc.childNodes - ); - // Support: Android<4.0 - // Detect silently failing push.apply - arr[ preferredDoc.childNodes.length ].nodeType; -} catch ( e ) { - push = { apply: arr.length ? - - // Leverage slice if possible - function( target, els ) { - push_native.apply( target, slice.call(els) ); - } : - - // Support: IE<9 - // Otherwise append directly - function( target, els ) { - var j = target.length, - i = 0; - // Can't trust NodeList.length - while ( (target[j++] = els[i++]) ) {} - target.length = j - 1; - } - }; -} - -function Sizzle( selector, context, results, seed ) { - var m, i, elem, nid, match, groups, newSelector, - newContext = context && context.ownerDocument, - - // nodeType defaults to 9, since context defaults to document - nodeType = context ? context.nodeType : 9; - - results = results || []; - - // Return early from calls with invalid selector or context - if ( typeof selector !== "string" || !selector || - nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) { - - return results; - } - - // Try to shortcut find operations (as opposed to filters) in HTML documents - if ( !seed ) { - - if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) { - setDocument( context ); - } - context = context || document; - - if ( documentIsHTML ) { - - // If the selector is sufficiently simple, try using a "get*By*" DOM method - // (excepting DocumentFragment context, where the methods don't exist) - if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) { - - // ID selector - if ( (m = match[1]) ) { - - // Document context - if ( nodeType === 9 ) { - if ( (elem = context.getElementById( m )) ) { - - // Support: IE, Opera, Webkit - // TODO: identify versions - // getElementById can match elements by name instead of ID - if ( elem.id === m ) { - results.push( elem ); - return results; - } - } else { - return results; - } - - // Element context - } else { - - // Support: IE, Opera, Webkit - // TODO: identify versions - // getElementById can match elements by name instead of ID - if ( newContext && (elem = newContext.getElementById( m )) && - contains( context, elem ) && - elem.id === m ) { - - results.push( elem ); - return results; - } - } - - // Type selector - } else if ( match[2] ) { - push.apply( results, context.getElementsByTagName( selector ) ); - return results; - - // Class selector - } else if ( (m = match[3]) && support.getElementsByClassName && - context.getElementsByClassName ) { - - push.apply( results, context.getElementsByClassName( m ) ); - return results; - } - } - - // Take advantage of querySelectorAll - if ( support.qsa && - !compilerCache[ selector + " " ] && - (!rbuggyQSA || !rbuggyQSA.test( selector )) ) { - - if ( nodeType !== 1 ) { - newContext = context; - newSelector = selector; - - // qSA looks outside Element context, which is not what we want - // Thanks to Andrew Dupont for this workaround technique - // Support: IE <=8 - // Exclude object elements - } else if ( context.nodeName.toLowerCase() !== "object" ) { - - // Capture the context ID, setting it first if necessary - if ( (nid = context.getAttribute( "id" )) ) { - nid = nid.replace( rcssescape, fcssescape ); - } else { - context.setAttribute( "id", (nid = expando) ); - } - - // Prefix every selector in the list - groups = tokenize( selector ); - i = groups.length; - while ( i-- ) { - groups[i] = "#" + nid + " " + toSelector( groups[i] ); - } - newSelector = groups.join( "," ); - - // Expand context for sibling selectors - newContext = rsibling.test( selector ) && testContext( context.parentNode ) || - context; - } - - if ( newSelector ) { - try { - push.apply( results, - newContext.querySelectorAll( newSelector ) - ); - return results; - } catch ( qsaError ) { - } finally { - if ( nid === expando ) { - context.removeAttribute( "id" ); - } - } - } - } - } - } - - // All others - return select( selector.replace( rtrim, "$1" ), context, results, seed ); -} - -/** - * Create key-value caches of limited size - * @returns {function(string, object)} Returns the Object data after storing it on itself with - * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) - * deleting the oldest entry - */ -function createCache() { - var keys = []; - - function cache( key, value ) { - // Use (key + " ") to avoid collision with native prototype properties (see Issue #157) - if ( keys.push( key + " " ) > Expr.cacheLength ) { - // Only keep the most recent entries - delete cache[ keys.shift() ]; - } - return (cache[ key + " " ] = value); - } - return cache; -} - -/** - * Mark a function for special use by Sizzle - * @param {Function} fn The function to mark - */ -function markFunction( fn ) { - fn[ expando ] = true; - return fn; -} - -/** - * Support testing using an element - * @param {Function} fn Passed the created element and returns a boolean result - */ -function assert( fn ) { - var el = document.createElement("fieldset"); - - try { - return !!fn( el ); - } catch (e) { - return false; - } finally { - // Remove from its parent by default - if ( el.parentNode ) { - el.parentNode.removeChild( el ); - } - // release memory in IE - el = null; - } -} - -/** - * Adds the same handler for all of the specified attrs - * @param {String} attrs Pipe-separated list of attributes - * @param {Function} handler The method that will be applied - */ -function addHandle( attrs, handler ) { - var arr = attrs.split("|"), - i = arr.length; - - while ( i-- ) { - Expr.attrHandle[ arr[i] ] = handler; - } -} - -/** - * Checks document order of two siblings - * @param {Element} a - * @param {Element} b - * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b - */ -function siblingCheck( a, b ) { - var cur = b && a, - diff = cur && a.nodeType === 1 && b.nodeType === 1 && - a.sourceIndex - b.sourceIndex; - - // Use IE sourceIndex if available on both nodes - if ( diff ) { - return diff; - } - - // Check if b follows a - if ( cur ) { - while ( (cur = cur.nextSibling) ) { - if ( cur === b ) { - return -1; - } - } - } - - return a ? 1 : -1; -} - -/** - * Returns a function to use in pseudos for input types - * @param {String} type - */ -function createInputPseudo( type ) { - return function( elem ) { - var name = elem.nodeName.toLowerCase(); - return name === "input" && elem.type === type; - }; -} - -/** - * Returns a function to use in pseudos for buttons - * @param {String} type - */ -function createButtonPseudo( type ) { - return function( elem ) { - var name = elem.nodeName.toLowerCase(); - return (name === "input" || name === "button") && elem.type === type; - }; -} - -/** - * Returns a function to use in pseudos for :enabled/:disabled - * @param {Boolean} disabled true for :disabled; false for :enabled - */ -function createDisabledPseudo( disabled ) { - // Known :disabled false positives: - // IE: *[disabled]:not(button, input, select, textarea, optgroup, option, menuitem, fieldset) - // not IE: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable - return function( elem ) { - - // Check form elements and option elements for explicit disabling - return "label" in elem && elem.disabled === disabled || - "form" in elem && elem.disabled === disabled || - - // Check non-disabled form elements for fieldset[disabled] ancestors - "form" in elem && elem.disabled === false && ( - // Support: IE6-11+ - // Ancestry is covered for us - elem.isDisabled === disabled || - - // Otherwise, assume any non-

QT;$k$g)&UkFP!fN>2BBvW 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 z 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