From 68e825ffc4357964e42503ddf57b57b17b5d0478 Mon Sep 17 00:00:00 2001 From: Xiao Zhou <1298856981@qq.com> Date: Tue, 16 Jul 2024 07:04:42 +0000 Subject: [PATCH] chore: Remove unnecessary files and configurations, update README --- .devcontainer/devcontainer.json | 22 - .github/dependabot.yml | 12 - .vscode/launch.json | 16 - README.md | 104 +- layers.py | 31 - mobo_aligner.py | 418 - monotonic_align/__init__.py | 21 - .../core.cpython-39-x86_64-linux-gnu.so | Bin 202728 -> 0 bytes .../core.cpython-311-darwin.so | Bin 176376 -> 0 bytes .../build/temp.linux-x86_64-cpython-39/core.o | Bin 272016 -> 0 bytes .../temp.macosx-11.1-arm64-cpython-311/core.o | Bin 203456 -> 0 bytes monotonic_align/core.c | 29848 ---------------- monotonic_align/core.pyx | 45 - .../core.cpython-311-darwin.so | Bin 176376 -> 0 bytes .../core.cpython-39-x86_64-linux-gnu.so | Bin 202728 -> 0 bytes monotonic_align/setup.py | 11 - robo_utils/__init__.py | 34 - .../core.cpython-39-x86_64-linux-gnu.so | Bin 207016 -> 0 bytes .../build/temp.linux-x86_64-cpython-39/core.o | Bin 274960 -> 0 bytes robo_utils/core.c | 28346 --------------- robo_utils/core.pyx | 116 - .../core.cpython-39-x86_64-linux-gnu.so | Bin 207016 -> 0 bytes robo_utils/setup.py | 11 - romo_aligner.py | 399 - rough_aligner.py | 71 - tensor_utils.py | 537 - test_robo_utils.py | 49 - 27 files changed, 46 insertions(+), 60045 deletions(-) delete mode 100644 .devcontainer/devcontainer.json delete mode 100644 .github/dependabot.yml delete mode 100644 .vscode/launch.json delete mode 100644 layers.py delete mode 100644 mobo_aligner.py delete mode 100644 monotonic_align/__init__.py delete mode 100755 monotonic_align/build/lib.linux-x86_64-cpython-39/monotonic_align/core.cpython-39-x86_64-linux-gnu.so delete mode 100755 monotonic_align/build/lib.macosx-11.1-arm64-cpython-311/monotonic_align/core.cpython-311-darwin.so delete mode 100644 monotonic_align/build/temp.linux-x86_64-cpython-39/core.o delete mode 100644 monotonic_align/build/temp.macosx-11.1-arm64-cpython-311/core.o delete mode 100644 monotonic_align/core.c delete mode 100644 monotonic_align/core.pyx delete mode 100755 monotonic_align/monotonic_align/core.cpython-311-darwin.so delete mode 100755 monotonic_align/monotonic_align/core.cpython-39-x86_64-linux-gnu.so delete mode 100644 monotonic_align/setup.py delete mode 100644 robo_utils/__init__.py delete mode 100755 robo_utils/build/lib.linux-x86_64-cpython-39/robo_utils/core.cpython-39-x86_64-linux-gnu.so delete mode 100644 robo_utils/build/temp.linux-x86_64-cpython-39/core.o delete mode 100644 robo_utils/core.c delete mode 100644 robo_utils/core.pyx delete mode 100755 robo_utils/robo_utils/core.cpython-39-x86_64-linux-gnu.so delete mode 100644 robo_utils/setup.py delete mode 100644 romo_aligner.py delete mode 100644 rough_aligner.py delete mode 100644 tensor_utils.py delete mode 100644 test_robo_utils.py diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json deleted file mode 100644 index 8e8d65b..0000000 --- a/.devcontainer/devcontainer.json +++ /dev/null @@ -1,22 +0,0 @@ -// For format details, see https://aka.ms/devcontainer.json. For config options, see the -// README at: https://github.com/devcontainers/templates/tree/main/src/python -{ - "name": "ESPNET", - // Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile - "image": "espnet/espnet:cpu-latest" - - // Features to add to the dev container. More info: https://containers.dev/features. - // "features": {}, - - // Use 'forwardPorts' to make a list of ports inside the container available locally. - // "forwardPorts": [], - - // Use 'postCreateCommand' to run commands after the container is created. - // "postCreateCommand": "pip3 install --user -r requirements.txt", - - // Configure tool-specific properties. - // "customizations": {}, - - // Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root. - // "remoteUser": "root" -} diff --git a/.github/dependabot.yml b/.github/dependabot.yml deleted file mode 100644 index f33a02c..0000000 --- a/.github/dependabot.yml +++ /dev/null @@ -1,12 +0,0 @@ -# To get started with Dependabot version updates, you'll need to specify which -# package ecosystems to update and where the package manifests are located. -# Please see the documentation for more information: -# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates -# https://containers.dev/guide/dependabot - -version: 2 -updates: - - package-ecosystem: "devcontainers" - directory: "/" - schedule: - interval: weekly diff --git a/.vscode/launch.json b/.vscode/launch.json deleted file mode 100644 index 51f24ce..0000000 --- a/.vscode/launch.json +++ /dev/null @@ -1,16 +0,0 @@ -{ - // 使用 IntelliSense 了解相关属性。 - // 悬停以查看现有属性的描述。 - // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387 - "version": "0.2.0", - "configurations": [ - { - "name": "Python: 当前文件", - "type": "python", - "request": "launch", - "program": "${workspaceFolder}/romo_aligner.py", - "console": "integratedTerminal", - "justMyCode": true - } - ] -} \ No newline at end of file diff --git a/README.md b/README.md index d8e78f3..b33cc1a 100644 --- a/README.md +++ b/README.md @@ -1,67 +1,55 @@ -# RoMoAligner: Robust and Monotonic Alignment for Non-Autoregressive TTS +# Text-to-Speech Alignment Project -RoMoAligner is a novel alignment model designed for non-autoregressive Text-to-Speech (TTS) synthesis. It combines a rough aligner and a fine-grained monotonic boundary aligner (MoBoAligner) to achieve fast and accurate alignment between text and speech. +## Project Overview +This project explores and implements various text-to-speech (TTS) alignment techniques, aiming to improve the quality and efficiency of TTS systems. Our work spans multiple approaches, each addressing different aspects of the alignment challenge. -## Features +## Project Structure +This repository is organized into three main branches, each representing a distinct approach to TTS alignment: -- Two-stage alignment: RoMoAligner first uses a rough aligner to estimate the coarse boundaries of each text token, then applies MoBoAligner to refine the alignment within the selected boundaries. -- Monotonic alignment: MoBoAligner ensures the monotonicity and continuity of the alignment, which is crucial for TTS. -- Robust and efficient: By selecting the most relevant mel frames for each text token, RoMoAligner reduces the computational complexity and improves the robustness of the alignment. -- Easy integration: RoMoAligner can be easily integrated into any non-autoregressive TTS system to provide accurate duration information. +1. [`MoBoAligner`](https://github.com/xiaozhah/Aligner/tree/MoBoAligner) + - **Status**: Completed, for reference only + - **Description**: Unofficial implementation of the "MoBoAligner: a Neural Alignment Model for Non-autoregressive TTS with Monotonic Boundary Search" paper + - **Purpose**: Learning and baseline comparison + - **Limitation**: Not suitable for large-scale applications due to maximum duration constraints -## Installation +2. [`RoMoAligner`](https://github.com/xiaozhah/Aligner/tree/RoMoAligner) + - **Status**: Development halted, for reference only + - **Description**: Experimental improvement attempt combining Rough Alignment with MoBoAligner + - **Purpose**: Explore self-supervised learning techniques in TTS alignment + - **Limitation**: Performance improvements were limited and did not meet expectations -1. Clone the repository: - ``` - git clone https://github.com/yourusername/RoMoAligner.git - cd RoMoAligner - ``` +3. [`OTA`](https://github.com/xiaozhah/Aligner/tree/OTA) 👈 **Current Focus** + - **Status**: In active planning and early development + - **Description**: Adaptation of the "One TTS Alignment To Rule Them All" (OTA) method for implicit pause modeling + - **Goal**: Develop a solution for handling implicit pauses without relying on explicit silence tokens + - **Progress**: Conceptual development and planning phase -2. Install the required dependencies: - ``` - pip install -r requirements.txt - ``` +## Current Focus +Our primary focus is on the `OTA` branch, where we're exploring ways to adapt the OTA method for improved alignment, especially in handling implicit pauses in speech. -3. Compile the Cython extension: - ``` - python setup.py build_ext --inplace - ``` - -## Usage - -```python -from romo_aligner import RoMoAligner - -aligner = RoMoAligner( - text_channels, mel_channels, attention_dim, attention_head, dropout, noise_scale -) - -soft_alignment, hard_alignment, expanded_text_embeddings, dur_by_rough, dur_by_mobo = aligner( - text_embeddings, - mel_embeddings, - text_mask, - mel_mask, - direction=["forward", "backward"], -) -``` - -## Model Architecture - -RoMoAligner consists of two main components: - -1. **RoughAligner**: A cross-modal attention-based module that estimates the coarse boundaries of each text token in the mel spectrogram. -2. **MoBoAligner (unofficial)**: A fine-grained monotonic boundary aligner that refines the alignment within the selected boundaries. - -The rough aligner first provides an initial estimation of the text token durations, which are then used to select the most relevant mel frames for each token. MoBoAligner then performs a more precise alignment within these selected frames, ensuring the monotonicity and continuity of the alignment. +## How to Use This Repository +1. Check out each branch for specific implementation details and progress. +2. Refer to individual branch READMEs for setup and usage instructions. +3. For the latest developments, focus on the `OTA` branch. ## Contributing - -We welcome contributions to RoMoAligner! If you have any bug reports, feature requests, or suggestions, please open an issue on the [GitHub repository](https://github.com/yourusername/RoMoAligner/issues). If you'd like to contribute code, please fork the repository and submit a pull request. - -## License - -RoMoAligner is released under the [MIT License](LICENSE). - -## Acknowledgements - -We would like to thank the open-source community for their valuable contributions and feedback. Special thanks to the developers of [ESPnet](https://github.com/espnet/espnet) and [PyTorch](https://pytorch.org/) for their excellent libraries. +We welcome contributions to any of our branches. If you're interested in contributing: +1. Check the issues in the relevant branch for tasks you can help with. +2. Fork the repository and create a pull request with your improvements. +3. For major changes, please open an issue first to discuss what you would like to change. + +## Roadmap +- [x] Implement MoBoAligner (unofficial implementation) +- [x] Develop and test RoMoAligner +- [ ] Adapt and implement OTA for implicit pause modeling +- [ ] Conduct comparative studies across all methods +- [ ] Refine and optimize the most promising approach + +## Acknowledgments +- Original [MoBoAligner paper](https://www.isca-speech.org/archive/interspeech_2020/li20h_interspeech.html) +- [OTA paper](https://arxiv.org/pdf/2108.10447) + +We appreciate the support and interest from the TTS and speech processing community in advancing this research. + +--- +*Last updated: [Current Date]* \ No newline at end of file diff --git a/layers.py b/layers.py deleted file mode 100644 index 1cee07c..0000000 --- a/layers.py +++ /dev/null @@ -1,31 +0,0 @@ -import torch -from torch import nn - - -class LinearNorm(nn.Module): - def __init__( - self, - in_dim, - out_dim, - bias=True, - w_init_gain="linear", - weight_norm=False, - init_weight_norm=1.0, - ): - super(LinearNorm, self).__init__() - if weight_norm: - self.linear_layer = nn.utils.parametrizations.weight_norm( - nn.Linear(in_dim, out_dim, bias=bias) - ) - self.linear_layer.weight_g = nn.Parameter( - torch.FloatTensor(1).fill_(init_weight_norm) - ) - else: - self.linear_layer = nn.Linear(in_dim, out_dim, bias=bias) - - nn.init.xavier_uniform_( - self.linear_layer.weight, gain=nn.init.calculate_gain(w_init_gain) - ) - - def forward(self, x): - return self.linear_layer(x) diff --git a/mobo_aligner.py b/mobo_aligner.py deleted file mode 100644 index 408c70d..0000000 --- a/mobo_aligner.py +++ /dev/null @@ -1,418 +0,0 @@ -import math -from typing import List, Optional, Tuple - -import numpy as np -import torch -import torch.nn as nn -import torch.nn.functional as F - -import monotonic_align -from layers import LinearNorm -from tensor_utils import * - - -class MoBoAligner(nn.Module): - def __init__( - self, text_channels, mel_channels, attention_dim, noise_scale=2.0, max_dur=10 - ): - super(MoBoAligner, self).__init__() - self.mel_layer = LinearNorm( - mel_channels, attention_dim, bias=True, w_init_gain="tanh" - ) - self.text_layer = LinearNorm( - text_channels, attention_dim, bias=False, w_init_gain="tanh" - ) - self.v = LinearNorm( - attention_dim, - 1, - bias=True, - w_init_gain="relu", # because the SoftPlus is a smooth approximation to the ReLU function - weight_norm=True, - init_weight_norm=math.sqrt(1 / attention_dim), - ) - - self.noise_scale = noise_scale - self.max_dur = max_dur # max duration of a text token - - def check_parameter_validity(self, text_mask, mel_mask, direction): - """ - Check if the parameters are valid for the alignment. - """ - I = text_mask.sum(1) - J = mel_mask.sum(1) - if not ( - len(direction) >= 1 - and set(direction).issubset(set(["forward", "backward"])) - ): - raise ValueError( - f"Direction must be a subset of 'forward' or 'backward', {direction} is not allowed." - ) - if not torch.all(I <= J): - raise ValueError( - f"The length of text hiddens is greater than the length of mel hiddens, which is not allowed." - ) - if not torch.all(I * self.max_dur >= J): - raise ValueError( - f"The length of mel hiddens is greater than or equal to the {self.max_dur} times of the length of text hiddens, which is not allowed. Try to increase the max_dur or use RoMoAligner." - ) - - def compute_energy(self, text_hiddens, mel_hiddens, alignment_mask): - """ - Compute the energy matrix between text hiddens and mel hiddens, which must be contain positional information. - - Args: - text_hiddens (torch.FloatTensor): The text hiddens of shape (B, I, D_text). - mel_hiddens (torch.FloatTensor): The mel hiddens of shape (B, J, D_mel). - alignment_mask (torch.BoolTensor): The alignment mask of shape (B, I, J). - - Returns: - energy (torch.FloatTensor): The energy matrix of shape (B, I, J) which applied Gaussian noise. - """ - processed_mel = self.mel_layer(mel_hiddens.unsqueeze(1)) # (B, 1, J, D_att) - processed_text = self.text_layer(text_hiddens.unsqueeze(2)) # (B, I, 1, D_att) - energy = self.v(torch.tanh(processed_mel + processed_text)) # (B, I, J, 1) - - energy = energy.squeeze(-1) # (B, I, J) - - noise = torch.randn_like(energy) * self.noise_scale - # energy = F.sigmoid(energy + noise).log() - energy = -F.softplus(-energy - noise) # log(sigmoid(x)) = -softplus(-x) - energy.masked_fill_(~alignment_mask, LOG_EPS) - - return energy - - def compute_reversed_energy_and_masks(self, energy, text_mask, mel_mask): - """ - Compute the backward energy matrix and the corresponding text and mel masks. - - Args: - energy (torch.FloatTensor): The energy matrix of shape (B, I, J). - text_mask (torch.BoolTensor): The text mask of shape (B, I). - mel_mask (torch.BoolTensor): The mel hidden mask of shape (B, J). - - Returns: - energy_backward (torch.FloatTensor): The backward energy matrix of shape (B, I-1, J-1). - text_mask_backward (torch.BoolTensor): The backward text mask of shape (B, I-1). - mel_mask_backward (torch.BoolTensor): The backward mel hidden mask of shape (B, J-1). - """ - shifts_text_dim = compute_max_length_diff(text_mask) - shifts_mel_dim = compute_max_length_diff(mel_mask) - - energy_backward = shift_tensor( - energy.flip(1, 2).unsqueeze(-1), - shifts_text_dim=-shifts_text_dim, - shifts_mel_dim=-shifts_mel_dim, - ).squeeze(-1) - - energy_backward = energy_backward[:, 1:, 1:] - text_mask_backward = text_mask[:, 1:] - mel_mask_backward = mel_mask[:, 1:] - alignment_mask_backward = compute_alignment_mask( - text_mask_backward, mel_mask_backward - ) # (B, I-1, J-1) - return ( - energy_backward, - text_mask_backward, - mel_mask_backward, - alignment_mask_backward, - ) - - def compute_cond_prob(self, energy, text_mask, mel_mask, max_dur): - """ - Compute the log conditional probability of the alignment in the specified direction. - - Args: - energy (torch.FloatTensor): The energy matrix of shape (B, I, J) for forward, or (B, I-1, J-1) for backward. - text_mask (torch.BoolTensor): The text mask of shape (B, I) for forward, or (B, I-1) for backward. - mel_mask (torch.BoolTensor): The mel hidden mask of shape (B, J) for forward, or (B, J-1) for backward. - max_dur (int): The maximum duration of a text token. - - Returns: - log_cond_prob (torch.FloatTensor): The log conditional probability tensor of shape (B, I, D, K) for forward, or (B, I-1, D+1, K-1) for backward. - log_cond_prob_geq (torch.FloatTensor): The log cumulative conditional probability tensor of shape (B, I, D, K) for forward, or (B, I-1, D+1, K-1) for backward. - """ - B, I = text_mask.shape - _, K = mel_mask.shape # K = J, j index from 1 to J, k index from 0 to J-1 - - energy_4D = BIJ_to_BIDK(energy, max_dur, padding_direction="right") - valid_mask = gen_left_right_mask(B, I, max_dur, K, text_mask, mel_mask) - energy_4D.masked_fill_(~valid_mask, LOG_EPS) - - log_cond_prob = energy_4D - torch.logsumexp( - energy_4D, dim=2, keepdim=True - ) # on the D dimension - log_cond_prob.masked_fill_(~valid_mask, LOG_EPS) - - log_cond_prob_geq = torch.logcumsumexp(log_cond_prob.flip(2), dim=2).flip(2) - log_cond_prob_geq.masked_fill_(~valid_mask, LOG_EPS) - - return log_cond_prob, log_cond_prob_geq - - def compute_boundary_prob(self, log_cond_prob, text_mask, mel_mask): - """ - Compute boundary prob recursively in the log domain. - - Args: - log_cond_prob (torch.FloatTensor): The log conditional probability tensor for forward of shape (B, I, D, K) for forward, or (B, I-1, D+1, K-1) for backward. - text_mask (torch.BoolTensor): The text mask of shape (B, I) for forward, or (B, I-1) for backward. - mel_mask (torch.BoolTensor): The mel hidden mask of shape (B, J) for forward, or (B, J-1) for backward. - - Returns: - log_boundary_prob (torch.FloatTensor): The forward tensor of shape (B, I+1, J+1) for forward, or (B, I, J) for backward. - """ - B, I = text_mask.shape - _, J = mel_mask.shape - - log_boundary_prob = torch.full( - (B, I + 1, J + 1), LOG_EPS, device=log_cond_prob.device, dtype=torch.float - ) - log_boundary_prob[:, 0, 0] = 0 # Initialize forward[0, 0] = 0 - for i in range(1, I + 1): - log_boundary_prob[:, i, i:] = diag_logsumexp( - log_boundary_prob[:, i - 1, :-1].unsqueeze(1) - + log_cond_prob[:, i - 1], # (B, D, J) - from_ind=i - 1, - ) # sum at the D dimension - - return log_boundary_prob - - def compute_interval_prob( - self, boundary_prob, log_cond_prob_geq_or_gt, text_mask, alignment_mask - ): - """ - Compute the log interval probability, which is the log of the probability P(B_{i-1} < j <= B_i), the sum of P(B_{i-1} < j <= B_i) over i is 1. - - Args: - boundary_prob (torch.FloatTensor): The forward or backward tensor of shape (B, I, J) for forward, or (B, I-1, J-1) for backward. - log_cond_prob_geq_or_gt (torch.FloatTensor): The log cumulative conditional probability tensor of shape (B, I, D, K) for forward, or (B, I-1, D, J-1) for backward. - text_mask (torch.BoolTensor): The text mask of shape (B, I) for forward, or (B, I-1) for backward. - alignment_mask (torch.BoolTensor): The alignment mask of shape (B, I, J) for forward, or (B, I-1, J-1) for backward. - - Returns: - log_interval_prob (torch.FloatTensor): The log interval probability tensor of shape (B, I, J) for forward, or (B, I-1, J-1) for backward. - """ - D = log_cond_prob_geq_or_gt.shape[2] - prob_trans = BIJ_to_BIDK( - boundary_prob, D=D, padding_direction="left" - ) # -> (B, I, D, K) for forward , or (B, I-1, D-1, K-1) for backward - log_cond_prob_geq_or_gt_trans = BIDK_transform( - log_cond_prob_geq_or_gt - ) # -> (B, I, D, K) for forward, or (B, I-1, D-1, K-1) for backward - - log_interval_prob = torch.logsumexp( - prob_trans[:, :-1] + log_cond_prob_geq_or_gt_trans[:, :-1], dim=2 - ) # (B, I-1, J) for forward, or (B, I-2, J-1) for backward - - log_interval_prob = force_assign_last_text_prob( - log_interval_prob, boundary_prob, text_mask, alignment_mask - ) # (B, I, J) for forward, or (B, I-1, J-1) for backward - - return log_interval_prob - - def combine_alignments(self, log_interval_forward, log_interval_backward): - """ - Combine the log probabilities from forward and backward boundary calculations. - - Args: - log_interval_forward (torch.FloatTensor): The log probabilities from the forward boundary calculation of shape (B, I, J). - log_interval_backward (torch.FloatTensor): The log probabilities from the backward boundary calculation of shape (B, I, J). - - Returns: - log_interval_prob (torch.FloatTensor): The combined log probabilities of shape (B, I, J). - """ - log_interval_prob = torch.logaddexp( - log_interval_forward - LOG_2, log_interval_backward - LOG_2 - ) - return log_interval_prob - - @torch.no_grad() - def compute_hard_alignment(self, log_probs, alignment_mask): - """ - Compute the Viterbi path for the maximum alignment probabilities. - - This function uses `monotonic_align.maximum_path` to find the path with the maximum probabilities, - subject to the constraints of the alignment mask. - - Args: - log_probs (torch.FloatTensor): The log probabilities tensor of shape (B, I, J). - alignment_mask (torch.BoolTensor): The alignment mask of shape (B, I, J). - - Returns: - hard_alignment (torch.FloatTensor): The tensor representing the hard alignment path of shape (B, I, J). - """ - hard_alignment = monotonic_align.maximum_path(log_probs, alignment_mask) - return hard_alignment - - def forward( - self, - text_hiddens: torch.FloatTensor, - mel_hiddens: torch.FloatTensor, - text_mask: torch.BoolTensor, - mel_mask: torch.BoolTensor, - direction: List[str], - return_hard_alignment: bool = False, - ) -> Tuple[torch.FloatTensor, Optional[torch.FloatTensor]]: - """ - Compute the soft alignment and the expanded text hiddens. - - Args: - text_hiddens (torch.FloatTensor): The text hiddens of shape (B, I, D_text). - mel_hiddens (torch.FloatTensor): The mel hiddens of shape (B, J, D_mel). - text_mask (torch.BoolTensor): The text mask of shape (B, I). - mel_mask (torch.BoolTensor): The mel hidden mask of shape (B, J). - direction (List[str]): The direction of the alignment, a subset of ["forward", "backward"]. - return_hard_alignment (bool): Whether to return the hard alignment which obtained by Viterbi decoding. - - Returns: - soft_alignment (torch.FloatTensor): The soft alignment tensor of shape (B, I, J) in the log domain. - hard_alignment (torch.FloatTensor): The hard alignment tensor of shape (B, I, J). - """ - # Check length of text < length of mel and direction is either "forward" or "backward" - self.check_parameter_validity(text_mask, mel_mask, direction) - - alignment_mask = compute_alignment_mask(text_mask, mel_mask) - - # Compute the energy matrix and apply noise - energy = self.compute_energy(text_hiddens, mel_hiddens, alignment_mask) - - if "forward" in direction: - # 1. Compute the log conditional probability P(B_i=j | B_{i-1}=k), P(B_i >= j | B_{i-1}=k) for forward - log_cond_prob_forward, log_cond_prob_geq_forward = self.compute_cond_prob( - energy, text_mask, mel_mask, self.max_dur - ) - - # 2. Compute forward recursively in the log domain - log_boundary_prob_forward = self.compute_boundary_prob( - log_cond_prob_forward, text_mask, mel_mask - ) - log_boundary_prob_forward = BIJ_to_BIK(log_boundary_prob_forward) - - # 3. Compute the forward P(B_{i-1} < j <= B_i) - log_interval_forward = self.compute_interval_prob( - log_boundary_prob_forward, - log_cond_prob_geq_forward, - text_mask, - alignment_mask, - ) - - if "backward" in direction: - # 1.1 Compute the energy matrix for backward direction - ( - energy_backward, - text_mask_backward, - mel_mask_backward, - alignment_mask_backward, - ) = self.compute_reversed_energy_and_masks(energy, text_mask, mel_mask) - - # 1.2 Compute the log conditional probability P(B_i=j | B_{i+1}=k), P(B_i < j | B_{i+1}=k) for backward - log_cond_prob_backward, log_cond_prob_geq_backward = self.compute_cond_prob( - energy_backward, - text_mask_backward, - mel_mask_backward, - self.max_dur - + 1, # instead of self.max_dur, because considering the geq to gt in the next step - ) - log_cond_prob_gt_backward = convert_geq_to_gt(log_cond_prob_geq_backward) - - # 2. Compute backward recursively in the log domain - log_boundary_prob_backward = self.compute_boundary_prob( - log_cond_prob_backward, text_mask_backward, mel_mask_backward - ) - log_boundary_prob_backward = BIJ_to_BIK(log_boundary_prob_backward) - - # 3.1 Compute the backward P(B_{i-1} < j <= B_i) - log_interval_backward = self.compute_interval_prob( - log_boundary_prob_backward, - log_cond_prob_gt_backward, - text_mask_backward, - alignment_mask_backward, - ) - - # 3.2 reverse the text and mel direction of log_interval_backward, and pad head and tail one-hot vector on mel dimension - log_interval_backward = pad_and_reverse_alignment( - log_interval_backward, text_mask_backward, mel_mask_backward - ) - - # Combine the forward and backward soft alignment - if direction == ["forward"]: - log_soft_alignment = log_interval_forward - elif direction == ["backward"]: - log_soft_alignment = log_interval_backward - else: - log_soft_alignment = self.combine_alignments( - log_interval_forward, log_interval_backward - ) - - soft_alignment = torch.exp(log_soft_alignment) * alignment_mask - - hard_alignment = None - if return_hard_alignment: - hard_alignment = self.compute_hard_alignment( - log_soft_alignment, alignment_mask - ) - - return soft_alignment, hard_alignment - - -if __name__ == "__main__": - torch.autograd.set_detect_anomaly(True) - - # Set a random seed to ensure reproducibility of the results - torch.manual_seed(1234) - - I = 10 - J = 91 - device = "cpu" - - if device == "cuda": - torch.cuda.reset_max_memory_allocated() # 重置显存使用情况 - - # Initialize the text and mel hidden tensors - text_hiddens = torch.randn( - 2, I, 10, requires_grad=True, device=device - ) # Batch size: 2, Text tokens: I, hidden dimension: 10 - mel_hiddens = torch.randn( - 2, J, 10, requires_grad=True, device=device - ) # Batch size: 2, Mel frames: J, hidden dimension: 10 - # Initialize the text and mel masks - text_mask = torch.tensor( - [[1] * I, [1] * 10 + [0] * (I - 10)], dtype=torch.bool, device=device - ) # Batch size: 2, Text tokens: I - mel_mask = torch.tensor( - [[1] * J, [1] * 70 + [0] * (J - 70)], dtype=torch.bool, device=device - ) # Batch size: 2, Mel frames: J - - # Initialize the MoBoAligner model - aligner = MoBoAligner(text_hiddens.size(-1), mel_hiddens.size(-1), 128).to(device) - - soft_alignment, hard_alignment = aligner( - text_hiddens, - mel_hiddens, - text_mask, - mel_mask, - direction=["forward", "backward"], - return_hard_alignment=True, - ) - - # Print the shape of the soft and hard alignment and the expanded text hiddens - print("Soft alignment:") - print(soft_alignment.shape) - print("Hard alignment:") - print(hard_alignment.shape) - print("Expanded text hiddens:") - print(soft_alignment.mean()) - - if device == "cuda": - # Print the memory usage - print( - f"Memory allocated: {torch.cuda.max_memory_allocated() / (1024 ** 2):.2f} MB" - ) - - # Backward pass test - with torch.autograd.detect_anomaly(): - soft_alignment.mean().backward() - - print("Gradient for text_hiddens:") - print(text_hiddens.grad.mean()) - print("Gradient for mel_hiddens:") - print(mel_hiddens.grad.mean()) diff --git a/monotonic_align/__init__.py b/monotonic_align/__init__.py deleted file mode 100644 index 642fdb2..0000000 --- a/monotonic_align/__init__.py +++ /dev/null @@ -1,21 +0,0 @@ -import numpy as np -import torch -from .monotonic_align.core import maximum_path_c - - -def maximum_path(value, mask): - """ Cython optimised version. - value: [b, t_x, t_y] - mask: [b, t_x, t_y] - """ - value = value * mask - device = value.device - dtype = value.dtype - value = value.data.cpu().numpy().astype(np.float32) - path = np.zeros_like(value).astype(np.int32) - mask = mask.data.cpu().numpy() - - t_x_max = mask.sum(1)[:, 0].astype(np.int32) - t_y_max = mask.sum(2)[:, 0].astype(np.int32) - maximum_path_c(path, value, t_x_max, t_y_max) - return torch.from_numpy(path).to(device=device, dtype=dtype) diff --git a/monotonic_align/build/lib.linux-x86_64-cpython-39/monotonic_align/core.cpython-39-x86_64-linux-gnu.so b/monotonic_align/build/lib.linux-x86_64-cpython-39/monotonic_align/core.cpython-39-x86_64-linux-gnu.so deleted file mode 100755 index 30b056a77fb4f3accd14fa78358617d689a38623..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 202728 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 diff --git a/monotonic_align/build/lib.macosx-11.1-arm64-cpython-311/monotonic_align/core.cpython-311-darwin.so b/monotonic_align/build/lib.macosx-11.1-arm64-cpython-311/monotonic_align/core.cpython-311-darwin.so deleted file mode 100755 index 8b217b2d58db08c7fee3c9ceacac493402a7b430..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 176376 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 W@VDO>|9Da5N3Y&{@e7Y$X8b>%LM1c+ diff --git a/monotonic_align/build/temp.linux-x86_64-cpython-39/core.o b/monotonic_align/build/temp.linux-x86_64-cpython-39/core.o deleted file mode 100644 index 757ab86a436c31981b085a5b454c9070dc2a324d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 272016 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 H5x4(;eoOaB diff --git a/monotonic_align/build/temp.macosx-11.1-arm64-cpython-311/core.o b/monotonic_align/build/temp.macosx-11.1-arm64-cpython-311/core.o deleted file mode 100644 index a1e425bde3f044f61f551ae6cfc7f82d98984d4d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 203456 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 diff --git a/monotonic_align/core.c b/monotonic_align/core.c deleted file mode 100644 index fcabef5..0000000 --- a/monotonic_align/core.c +++ /dev/null @@ -1,29848 +0,0 @@ -/* Generated by Cython 3.0.10 */ - -/* BEGIN: Cython Metadata -{ - "distutils": { - "depends": [], - "name": "monotonic_align.core", - "sources": [ - "core.pyx" - ] - }, - "module_name": "monotonic_align.core" -} -END: Cython Metadata */ - -#ifndef PY_SSIZE_T_CLEAN -#define PY_SSIZE_T_CLEAN -#endif /* PY_SSIZE_T_CLEAN */ -#if defined(CYTHON_LIMITED_API) && 0 - #ifndef Py_LIMITED_API - #if CYTHON_LIMITED_API+0 > 0x03030000 - #define Py_LIMITED_API CYTHON_LIMITED_API - #else - #define Py_LIMITED_API 0x03030000 - #endif - #endif -#endif - -#include "Python.h" -#ifndef Py_PYTHON_H - #error Python headers needed to compile C extensions, please install development version of Python. -#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) - #error Cython requires Python 2.7+ or Python 3.3+. -#else -#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API -#define __PYX_EXTRA_ABI_MODULE_NAME "limited" -#else -#define __PYX_EXTRA_ABI_MODULE_NAME "" -#endif -#define CYTHON_ABI "3_0_10" __PYX_EXTRA_ABI_MODULE_NAME -#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI -#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." -#define CYTHON_HEX_VERSION 0x03000AF0 -#define CYTHON_FUTURE_DIVISION 1 -#include -#ifndef offsetof - #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) -#endif -#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) - #ifndef __stdcall - #define __stdcall - #endif - #ifndef __cdecl - #define __cdecl - #endif - #ifndef __fastcall - #define __fastcall - #endif -#endif -#ifndef DL_IMPORT - #define DL_IMPORT(t) t -#endif -#ifndef DL_EXPORT - #define DL_EXPORT(t) t -#endif -#define __PYX_COMMA , -#ifndef HAVE_LONG_LONG - #define HAVE_LONG_LONG -#endif -#ifndef PY_LONG_LONG - #define PY_LONG_LONG LONG_LONG -#endif -#ifndef Py_HUGE_VAL - #define Py_HUGE_VAL HUGE_VAL -#endif -#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX -#if defined(GRAALVM_PYTHON) - /* For very preliminary testing purposes. Most variables are set the same as PyPy. - The existence of this section does not imply that anything works or is even tested */ - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 1 - #define CYTHON_COMPILING_IN_NOGIL 0 - #undef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 0 - #undef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 0 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #if PY_VERSION_HEX < 0x03050000 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #undef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 0 - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #undef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 1 - #undef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 0 - #undef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 0 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL 0 - #undef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) - #endif - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #undef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 0 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 - #endif - #undef CYTHON_USE_FREELISTS - #define CYTHON_USE_FREELISTS 0 -#elif defined(PYPY_VERSION) - #define CYTHON_COMPILING_IN_PYPY 1 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 0 - #undef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 0 - #ifndef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 0 - #endif - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #if PY_VERSION_HEX < 0x03050000 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #undef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 0 - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #undef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 1 - #undef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 0 - #undef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 0 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL 0 - #undef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) - #endif - #if PY_VERSION_HEX < 0x03090000 - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #endif - #undef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 0 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 - #endif - #undef CYTHON_USE_FREELISTS - #define CYTHON_USE_FREELISTS 0 -#elif defined(CYTHON_LIMITED_API) - #ifdef Py_LIMITED_API - #undef __PYX_LIMITED_VERSION_HEX - #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API - #endif - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 1 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 0 - #undef CYTHON_CLINE_IN_TRACEBACK - #define CYTHON_CLINE_IN_TRACEBACK 0 - #undef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 0 - #undef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 1 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #undef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #endif - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #ifndef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 0 - #endif - #undef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 0 - #undef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 0 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL 0 - #undef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS 1 - #endif - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #undef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 1 - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #endif - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 - #endif - #undef CYTHON_USE_FREELISTS - #define CYTHON_USE_FREELISTS 0 -#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 1 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 - #endif - #ifndef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 0 - #endif - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #ifndef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #ifndef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #endif - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 - #endif - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #ifndef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 0 - #endif - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL 0 - #ifndef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL 1 - #endif - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS 1 - #endif - #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #endif - #ifndef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 0 - #endif - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 1 - #endif - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 - #endif - #ifndef CYTHON_USE_FREELISTS - #define CYTHON_USE_FREELISTS 0 - #endif -#else - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 1 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 0 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 - #endif - #ifndef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 0 - #endif - #ifndef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 1 - #endif - #if PY_MAJOR_VERSION < 3 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #ifndef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 1 - #endif - #ifndef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 1 - #endif - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 - #endif - #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #elif !defined(CYTHON_USE_UNICODE_WRITER) - #define CYTHON_USE_UNICODE_WRITER 1 - #endif - #ifndef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 0 - #endif - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif - #ifndef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 1 - #endif - #ifndef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) - #endif - #ifndef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) - #endif - #ifndef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 1 - #endif - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS 1 - #endif - #if PY_VERSION_HEX < 0x03050000 - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #endif - #ifndef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 0 - #endif - #if PY_VERSION_HEX < 0x030400a1 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #elif !defined(CYTHON_USE_TP_FINALIZE) - #define CYTHON_USE_TP_FINALIZE 1 - #endif - #if PY_VERSION_HEX < 0x030600B1 - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #elif !defined(CYTHON_USE_DICT_VERSIONS) - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5) - #endif - #if PY_VERSION_HEX < 0x030700A3 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #elif !defined(CYTHON_USE_EXC_INFO_STACK) - #define CYTHON_USE_EXC_INFO_STACK 1 - #endif - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 - #endif - #ifndef CYTHON_USE_FREELISTS - #define CYTHON_USE_FREELISTS 1 - #endif -#endif -#if !defined(CYTHON_FAST_PYCCALL) -#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) -#endif -#if !defined(CYTHON_VECTORCALL) -#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) -#endif -#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) -#if CYTHON_USE_PYLONG_INTERNALS - #if PY_MAJOR_VERSION < 3 - #include "longintrepr.h" - #endif - #undef SHIFT - #undef BASE - #undef MASK - #ifdef SIZEOF_VOID_P - enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; - #endif -#endif -#ifndef __has_attribute - #define __has_attribute(x) 0 -#endif -#ifndef __has_cpp_attribute - #define __has_cpp_attribute(x) 0 -#endif -#ifndef CYTHON_RESTRICT - #if defined(__GNUC__) - #define CYTHON_RESTRICT __restrict__ - #elif defined(_MSC_VER) && _MSC_VER >= 1400 - #define CYTHON_RESTRICT __restrict - #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - #define CYTHON_RESTRICT restrict - #else - #define CYTHON_RESTRICT - #endif -#endif -#ifndef CYTHON_UNUSED - #if defined(__cplusplus) - /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 - * but leads to warnings with -pedantic, since it is a C++17 feature */ - #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) - #if __has_cpp_attribute(maybe_unused) - #define CYTHON_UNUSED [[maybe_unused]] - #endif - #endif - #endif -#endif -#ifndef CYTHON_UNUSED -# if defined(__GNUC__) -# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) -# define CYTHON_UNUSED __attribute__ ((__unused__)) -# else -# define CYTHON_UNUSED -# endif -# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) -# define CYTHON_UNUSED __attribute__ ((__unused__)) -# else -# define CYTHON_UNUSED -# endif -#endif -#ifndef CYTHON_UNUSED_VAR -# if defined(__cplusplus) - template void CYTHON_UNUSED_VAR( const T& ) { } -# else -# define CYTHON_UNUSED_VAR(x) (void)(x) -# endif -#endif -#ifndef CYTHON_MAYBE_UNUSED_VAR - #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) -#endif -#ifndef CYTHON_NCP_UNUSED -# if CYTHON_COMPILING_IN_CPYTHON -# define CYTHON_NCP_UNUSED -# else -# define CYTHON_NCP_UNUSED CYTHON_UNUSED -# endif -#endif -#ifndef CYTHON_USE_CPP_STD_MOVE - #if defined(__cplusplus) && (\ - __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) - #define CYTHON_USE_CPP_STD_MOVE 1 - #else - #define CYTHON_USE_CPP_STD_MOVE 0 - #endif -#endif -#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) -#ifdef _MSC_VER - #ifndef _MSC_STDINT_H_ - #if _MSC_VER < 1300 - typedef unsigned char uint8_t; - typedef unsigned short uint16_t; - typedef unsigned int uint32_t; - #else - typedef unsigned __int8 uint8_t; - typedef unsigned __int16 uint16_t; - typedef unsigned __int32 uint32_t; - #endif - #endif - #if _MSC_VER < 1300 - #ifdef _WIN64 - typedef unsigned long long __pyx_uintptr_t; - #else - typedef unsigned int __pyx_uintptr_t; - #endif - #else - #ifdef _WIN64 - typedef unsigned __int64 __pyx_uintptr_t; - #else - typedef unsigned __int32 __pyx_uintptr_t; - #endif - #endif -#else - #include - typedef uintptr_t __pyx_uintptr_t; -#endif -#ifndef CYTHON_FALLTHROUGH - #if defined(__cplusplus) - /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 - * but leads to warnings with -pedantic, since it is a C++17 feature */ - #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) - #if __has_cpp_attribute(fallthrough) - #define CYTHON_FALLTHROUGH [[fallthrough]] - #endif - #endif - #ifndef CYTHON_FALLTHROUGH - #if __has_cpp_attribute(clang::fallthrough) - #define CYTHON_FALLTHROUGH [[clang::fallthrough]] - #elif __has_cpp_attribute(gnu::fallthrough) - #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] - #endif - #endif - #endif - #ifndef CYTHON_FALLTHROUGH - #if __has_attribute(fallthrough) - #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) - #else - #define CYTHON_FALLTHROUGH - #endif - #endif - #if defined(__clang__) && defined(__apple_build_version__) - #if __apple_build_version__ < 7000000 - #undef CYTHON_FALLTHROUGH - #define CYTHON_FALLTHROUGH - #endif - #endif -#endif -#ifdef __cplusplus - template - struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; - #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) -#else - #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) -#endif -#if CYTHON_COMPILING_IN_PYPY == 1 - #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) -#else - #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) -#endif -#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) - -#ifndef CYTHON_INLINE - #if defined(__clang__) - #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) - #elif defined(__GNUC__) - #define CYTHON_INLINE __inline__ - #elif defined(_MSC_VER) - #define CYTHON_INLINE __inline - #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - #define CYTHON_INLINE inline - #else - #define CYTHON_INLINE - #endif -#endif - -#define __PYX_BUILD_PY_SSIZE_T "n" -#define CYTHON_FORMAT_SSIZE_T "z" -#if PY_MAJOR_VERSION < 3 - #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" - #define __Pyx_DefaultClassType PyClass_Type - #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) -#else - #define __Pyx_BUILTIN_MODULE_NAME "builtins" - #define __Pyx_DefaultClassType PyType_Type -#if CYTHON_COMPILING_IN_LIMITED_API - static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, - PyObject *code, PyObject *c, PyObject* n, PyObject *v, - PyObject *fv, PyObject *cell, PyObject* fn, - PyObject *name, int fline, PyObject *lnos) { - PyObject *exception_table = NULL; - PyObject *types_module=NULL, *code_type=NULL, *result=NULL; - #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 - PyObject *version_info; - PyObject *py_minor_version = NULL; - #endif - long minor_version = 0; - PyObject *type, *value, *traceback; - PyErr_Fetch(&type, &value, &traceback); - #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000 - minor_version = 11; - #else - if (!(version_info = PySys_GetObject("version_info"))) goto end; - if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; - minor_version = PyLong_AsLong(py_minor_version); - Py_DECREF(py_minor_version); - if (minor_version == -1 && PyErr_Occurred()) goto end; - #endif - if (!(types_module = PyImport_ImportModule("types"))) goto end; - if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; - if (minor_version <= 7) { - (void)p; - result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code, - c, n, v, fn, name, fline, lnos, fv, cell); - } else if (minor_version <= 10) { - result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, - c, n, v, fn, name, fline, lnos, fv, cell); - } else { - if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; - result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, - c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); - } - end: - Py_XDECREF(code_type); - Py_XDECREF(exception_table); - Py_XDECREF(types_module); - if (type) { - PyErr_Restore(type, value, traceback); - } - return result; - } - #ifndef CO_OPTIMIZED - #define CO_OPTIMIZED 0x0001 - #endif - #ifndef CO_NEWLOCALS - #define CO_NEWLOCALS 0x0002 - #endif - #ifndef CO_VARARGS - #define CO_VARARGS 0x0004 - #endif - #ifndef CO_VARKEYWORDS - #define CO_VARKEYWORDS 0x0008 - #endif - #ifndef CO_ASYNC_GENERATOR - #define CO_ASYNC_GENERATOR 0x0200 - #endif - #ifndef CO_GENERATOR - #define CO_GENERATOR 0x0020 - #endif - #ifndef CO_COROUTINE - #define CO_COROUTINE 0x0080 - #endif -#elif PY_VERSION_HEX >= 0x030B0000 - static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, - PyObject *code, PyObject *c, PyObject* n, PyObject *v, - PyObject *fv, PyObject *cell, PyObject* fn, - PyObject *name, int fline, PyObject *lnos) { - PyCodeObject *result; - PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); - if (!empty_bytes) return NULL; - result = - #if PY_VERSION_HEX >= 0x030C0000 - PyUnstable_Code_NewWithPosOnlyArgs - #else - PyCode_NewWithPosOnlyArgs - #endif - (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes); - Py_DECREF(empty_bytes); - return result; - } -#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY - #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) -#else - #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) -#endif -#endif -#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) - #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) -#else - #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) -#endif -#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) - #define __Pyx_Py_Is(x, y) Py_Is(x, y) -#else - #define __Pyx_Py_Is(x, y) ((x) == (y)) -#endif -#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) - #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) -#else - #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) -#endif -#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) - #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) -#else - #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) -#endif -#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) - #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) -#else - #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) -#endif -#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) -#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY - #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) -#else - #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) -#endif -#ifndef CO_COROUTINE - #define CO_COROUTINE 0x80 -#endif -#ifndef CO_ASYNC_GENERATOR - #define CO_ASYNC_GENERATOR 0x200 -#endif -#ifndef Py_TPFLAGS_CHECKTYPES - #define Py_TPFLAGS_CHECKTYPES 0 -#endif -#ifndef Py_TPFLAGS_HAVE_INDEX - #define Py_TPFLAGS_HAVE_INDEX 0 -#endif -#ifndef Py_TPFLAGS_HAVE_NEWBUFFER - #define Py_TPFLAGS_HAVE_NEWBUFFER 0 -#endif -#ifndef Py_TPFLAGS_HAVE_FINALIZE - #define Py_TPFLAGS_HAVE_FINALIZE 0 -#endif -#ifndef Py_TPFLAGS_SEQUENCE - #define Py_TPFLAGS_SEQUENCE 0 -#endif -#ifndef Py_TPFLAGS_MAPPING - #define Py_TPFLAGS_MAPPING 0 -#endif -#ifndef METH_STACKLESS - #define METH_STACKLESS 0 -#endif -#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) - #ifndef METH_FASTCALL - #define METH_FASTCALL 0x80 - #endif - typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); - typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, - Py_ssize_t nargs, PyObject *kwnames); -#else - #if PY_VERSION_HEX >= 0x030d00A4 - # define __Pyx_PyCFunctionFast PyCFunctionFast - # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords - #else - # define __Pyx_PyCFunctionFast _PyCFunctionFast - # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords - #endif -#endif -#if CYTHON_METH_FASTCALL - #define __Pyx_METH_FASTCALL METH_FASTCALL - #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast - #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords -#else - #define __Pyx_METH_FASTCALL METH_VARARGS - #define __Pyx_PyCFunction_FastCall PyCFunction - #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords -#endif -#if CYTHON_VECTORCALL - #define __pyx_vectorcallfunc vectorcallfunc - #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET - #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) -#elif CYTHON_BACKPORT_VECTORCALL - typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, - size_t nargsf, PyObject *kwnames); - #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) - #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) -#else - #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 - #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) -#endif -#if PY_MAJOR_VERSION >= 0x030900B1 -#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) -#else -#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) -#endif -#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) -#elif !CYTHON_COMPILING_IN_LIMITED_API -#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) -#endif -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) -static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { - return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; -} -#endif -static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { -#if CYTHON_COMPILING_IN_LIMITED_API - return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; -#else - return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; -#endif -} -#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) -#if __PYX_LIMITED_VERSION_HEX < 0x030900B1 - #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) - typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); -#else - #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) - #define __Pyx_PyCMethod PyCMethod -#endif -#ifndef METH_METHOD - #define METH_METHOD 0x200 -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) - #define PyObject_Malloc(s) PyMem_Malloc(s) - #define PyObject_Free(p) PyMem_Free(p) - #define PyObject_Realloc(p) PyMem_Realloc(p) -#endif -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) - #define __Pyx_PyFrame_SetLineNumber(frame, lineno) -#else - #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) - #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) -#endif -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_PyThreadState_Current PyThreadState_Get() -#elif !CYTHON_FAST_THREAD_STATE - #define __Pyx_PyThreadState_Current PyThreadState_GET() -#elif PY_VERSION_HEX >= 0x030d00A1 - #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() -#elif PY_VERSION_HEX >= 0x03060000 - #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() -#elif PY_VERSION_HEX >= 0x03000000 - #define __Pyx_PyThreadState_Current PyThreadState_GET() -#else - #define __Pyx_PyThreadState_Current _PyThreadState_Current -#endif -#if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) -{ - void *result; - result = PyModule_GetState(op); - if (!result) - Py_FatalError("Couldn't find the module state"); - return result; -} -#endif -#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) -#else - #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) -#endif -#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) -#include "pythread.h" -#define Py_tss_NEEDS_INIT 0 -typedef int Py_tss_t; -static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { - *key = PyThread_create_key(); - return 0; -} -static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { - Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); - *key = Py_tss_NEEDS_INIT; - return key; -} -static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { - PyObject_Free(key); -} -static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { - return *key != Py_tss_NEEDS_INIT; -} -static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { - PyThread_delete_key(*key); - *key = Py_tss_NEEDS_INIT; -} -static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { - return PyThread_set_key_value(*key, value); -} -static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { - return PyThread_get_key_value(*key); -} -#endif -#if PY_MAJOR_VERSION < 3 - #if CYTHON_COMPILING_IN_PYPY - #if PYPY_VERSION_NUM < 0x07030600 - #if defined(__cplusplus) && __cplusplus >= 201402L - [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] - #elif defined(__GNUC__) || defined(__clang__) - __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) - #elif defined(_MSC_VER) - __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) - #endif - static CYTHON_INLINE int PyGILState_Check(void) { - return 0; - } - #else // PYPY_VERSION_NUM < 0x07030600 - #endif // PYPY_VERSION_NUM < 0x07030600 - #else - static CYTHON_INLINE int PyGILState_Check(void) { - PyThreadState * tstate = _PyThreadState_Current; - return tstate && (tstate == PyGILState_GetThisThreadState()); - } - #endif -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) -#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) -#else -#define __Pyx_PyDict_NewPresized(n) PyDict_New() -#endif -#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION - #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) - #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) -#else - #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) - #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS -#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) -static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { - PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); - if (res == NULL) PyErr_Clear(); - return res; -} -#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000) -#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError -#define __Pyx_PyDict_GetItemStr PyDict_GetItem -#else -static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { -#if CYTHON_COMPILING_IN_PYPY - return PyDict_GetItem(dict, name); -#else - PyDictEntry *ep; - PyDictObject *mp = (PyDictObject*) dict; - long hash = ((PyStringObject *) name)->ob_shash; - assert(hash != -1); - ep = (mp->ma_lookup)(mp, name, hash); - if (ep == NULL) { - return NULL; - } - return ep->me_value; -#endif -} -#define __Pyx_PyDict_GetItemStr PyDict_GetItem -#endif -#if CYTHON_USE_TYPE_SLOTS - #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) - #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) - #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) -#else - #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) - #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) - #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next -#endif -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) -#else - #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) -#endif -#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 -#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ - PyTypeObject *type = Py_TYPE((PyObject*)obj);\ - assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ - PyObject_GC_Del(obj);\ - Py_DECREF(type);\ -} -#else -#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) -#endif -#if CYTHON_COMPILING_IN_LIMITED_API - #define CYTHON_PEP393_ENABLED 1 - #define __Pyx_PyUnicode_READY(op) (0) - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) - #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) - #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) - #define __Pyx_PyUnicode_DATA(u) ((void*)u) - #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) -#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) - #define CYTHON_PEP393_ENABLED 1 - #if PY_VERSION_HEX >= 0x030C0000 - #define __Pyx_PyUnicode_READY(op) (0) - #else - #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ - 0 : _PyUnicode_Ready((PyObject *)(op))) - #endif - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) - #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) - #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u)) - #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, (Py_UCS4) ch) - #if PY_VERSION_HEX >= 0x030C0000 - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) - #else - #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) - #else - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) - #endif - #endif -#else - #define CYTHON_PEP393_ENABLED 0 - #define PyUnicode_1BYTE_KIND 1 - #define PyUnicode_2BYTE_KIND 2 - #define PyUnicode_4BYTE_KIND 4 - #define __Pyx_PyUnicode_READY(op) (0) - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) - #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) - #define __Pyx_PyUnicode_KIND(u) ((int)sizeof(Py_UNICODE)) - #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) - #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) -#endif -#if CYTHON_COMPILING_IN_PYPY - #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) - #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) -#else - #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) - #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ - PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) -#endif -#if CYTHON_COMPILING_IN_PYPY - #if !defined(PyUnicode_DecodeUnicodeEscape) - #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) - #endif - #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) - #undef PyUnicode_Contains - #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) - #endif - #if !defined(PyByteArray_Check) - #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) - #endif - #if !defined(PyObject_Format) - #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) - #endif -#endif -#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) -#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) -#else - #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) -#endif -#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) - #define PyObject_ASCII(o) PyObject_Repr(o) -#endif -#if PY_MAJOR_VERSION >= 3 - #define PyBaseString_Type PyUnicode_Type - #define PyStringObject PyUnicodeObject - #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) -#else - #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) - #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) -#endif -#if CYTHON_COMPILING_IN_CPYTHON - #define __Pyx_PySequence_ListKeepNew(obj)\ - (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) -#else - #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) -#endif -#ifndef PySet_CheckExact - #define PySet_CheckExact(obj) __Pyx_IS_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_ITEM(o, i) PySequence_ITEM(o, i) - #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) - #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) - #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) - #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) - #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) - #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) - #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) - #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) -#else - #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) - #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) - #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) - #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) - #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) - #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) - #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) - #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) - #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) -#endif -#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 - #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) -#else - static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { - PyObject *module = PyImport_AddModule(name); - Py_XINCREF(module); - return module; - } -#endif -#if PY_MAJOR_VERSION >= 3 - #define PyIntObject PyLongObject - #define PyInt_Type PyLong_Type - #define PyInt_Check(op) PyLong_Check(op) - #define PyInt_CheckExact(op) PyLong_CheckExact(op) - #define __Pyx_Py3Int_Check(op) PyLong_Check(op) - #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) - #define PyInt_FromString PyLong_FromString - #define PyInt_FromUnicode PyLong_FromUnicode - #define PyInt_FromLong PyLong_FromLong - #define PyInt_FromSize_t PyLong_FromSize_t - #define PyInt_FromSsize_t PyLong_FromSsize_t - #define PyInt_AsLong PyLong_AsLong - #define PyInt_AS_LONG PyLong_AS_LONG - #define PyInt_AsSsize_t PyLong_AsSsize_t - #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask - #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask - #define PyNumber_Int PyNumber_Long -#else - #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) - #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) -#endif -#if PY_MAJOR_VERSION >= 3 - #define PyBoolObject PyLongObject -#endif -#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY - #ifndef PyUnicode_InternFromString - #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) - #endif -#endif -#if PY_VERSION_HEX < 0x030200A4 - typedef long Py_hash_t; - #define __Pyx_PyInt_FromHash_t PyInt_FromLong - #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t -#else - #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t - #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t -#endif -#if CYTHON_USE_ASYNC_SLOTS - #if PY_VERSION_HEX >= 0x030500B1 - #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods - #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) - #else - #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) - #endif -#else - #define __Pyx_PyType_AsAsync(obj) NULL -#endif -#ifndef __Pyx_PyAsyncMethodsStruct - typedef struct { - unaryfunc am_await; - unaryfunc am_aiter; - unaryfunc am_anext; - } __Pyx_PyAsyncMethodsStruct; -#endif - -#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) - #if !defined(_USE_MATH_DEFINES) - #define _USE_MATH_DEFINES - #endif -#endif -#include -#ifdef NAN -#define __PYX_NAN() ((float) NAN) -#else -static CYTHON_INLINE float __PYX_NAN() { - float value; - memset(&value, 0xFF, sizeof(value)); - return value; -} -#endif -#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) -#define __Pyx_truncl trunc -#else -#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; } - -#ifdef CYTHON_EXTERN_C - #undef __PYX_EXTERN_C - #define __PYX_EXTERN_C CYTHON_EXTERN_C -#elif defined(__PYX_EXTERN_C) - #ifdef _MSC_VER - #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") - #else - #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. - #endif -#else - #ifdef __cplusplus - #define __PYX_EXTERN_C extern "C" - #else - #define __PYX_EXTERN_C extern - #endif -#endif - -#define __PYX_HAVE__monotonic_align__core -#define __PYX_HAVE_API__monotonic_align__core -/* Early includes */ -#include -#include - - /* Using NumPy API declarations from "numpy/__init__.cython-30.pxd" */ - -#include "numpy/arrayobject.h" -#include "numpy/ndarrayobject.h" -#include "numpy/ndarraytypes.h" -#include "numpy/arrayscalars.h" -#include "numpy/ufuncobject.h" -#include "pythread.h" -#include -#ifdef _OPENMP -#include -#endif /* _OPENMP */ - -#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) -#define CYTHON_WITHOUT_ASSERTIONS -#endif - -typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; - const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; - -#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 -#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 -#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) -#define __PYX_DEFAULT_STRING_ENCODING "" -#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString -#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize -#define __Pyx_uchar_cast(c) ((unsigned char)c) -#define __Pyx_long_cast(x) ((long)x) -#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ - (sizeof(type) < sizeof(Py_ssize_t)) ||\ - (sizeof(type) > sizeof(Py_ssize_t) &&\ - likely(v < (type)PY_SSIZE_T_MAX ||\ - v == (type)PY_SSIZE_T_MAX) &&\ - (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ - v == (type)PY_SSIZE_T_MIN))) ||\ - (sizeof(type) == sizeof(Py_ssize_t) &&\ - (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ - v == (type)PY_SSIZE_T_MAX))) ) -static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { - return (size_t) i < (size_t) limit; -} -#if defined (__cplusplus) && __cplusplus >= 201103L - #include - #define __Pyx_sst_abs(value) std::abs(value) -#elif SIZEOF_INT >= SIZEOF_SIZE_T - #define __Pyx_sst_abs(value) abs(value) -#elif SIZEOF_LONG >= SIZEOF_SIZE_T - #define __Pyx_sst_abs(value) labs(value) -#elif defined (_MSC_VER) - #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) -#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - #define __Pyx_sst_abs(value) llabs(value) -#elif defined (__GNUC__) - #define __Pyx_sst_abs(value) __builtin_llabs(value) -#else - #define __Pyx_sst_abs(value) ((value<0) ? -value : value) -#endif -static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); -static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); -static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); -static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); -#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) -#define __Pyx_PyBytes_FromString PyBytes_FromString -#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); -#if PY_MAJOR_VERSION < 3 - #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString - #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize -#else - #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString - #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize -#endif -#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) -#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) -#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) -#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) -#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) -#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) -#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode -#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) -#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) -static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); -static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); -static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); -static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); -#define __Pyx_PySequence_Tuple(obj)\ - (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) -static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); -static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); -static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); -#if CYTHON_ASSUME_SAFE_MACROS -#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) -#else -#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) -#endif -#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) -#if PY_MAJOR_VERSION >= 3 -#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) -#else -#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) -#endif -#if CYTHON_USE_PYLONG_INTERNALS - #if PY_VERSION_HEX >= 0x030C00A7 - #ifndef _PyLong_SIGN_MASK - #define _PyLong_SIGN_MASK 3 - #endif - #ifndef _PyLong_NON_SIZE_BITS - #define _PyLong_NON_SIZE_BITS 3 - #endif - #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) - #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) - #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) - #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) - #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) - #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) - #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) - #define __Pyx_PyLong_SignedDigitCount(x)\ - ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) - #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) - #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) - #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) - #else - #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) - #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) - #endif - typedef Py_ssize_t __Pyx_compact_pylong; - typedef size_t __Pyx_compact_upylong; - #else - #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) - #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) - #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) - #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) - #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) - #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) - #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) - #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) - #define __Pyx_PyLong_CompactValue(x)\ - ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) - typedef sdigit __Pyx_compact_pylong; - typedef digit __Pyx_compact_upylong; - #endif - #if PY_VERSION_HEX >= 0x030C00A5 - #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) - #else - #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) - #endif -#endif -#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII -#include -static int __Pyx_sys_getdefaultencoding_not_ascii; -static int __Pyx_init_sys_getdefaultencoding_params(void) { - PyObject* sys; - PyObject* default_encoding = NULL; - PyObject* ascii_chars_u = NULL; - PyObject* ascii_chars_b = NULL; - const char* default_encoding_c; - sys = PyImport_ImportModule("sys"); - if (!sys) goto bad; - default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); - Py_DECREF(sys); - if (!default_encoding) goto bad; - default_encoding_c = PyBytes_AsString(default_encoding); - if (!default_encoding_c) goto bad; - if (strcmp(default_encoding_c, "ascii") == 0) { - __Pyx_sys_getdefaultencoding_not_ascii = 0; - } else { - char ascii_chars[128]; - int c; - for (c = 0; c < 128; c++) { - ascii_chars[c] = (char) c; - } - __Pyx_sys_getdefaultencoding_not_ascii = 1; - ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); - if (!ascii_chars_u) goto bad; - ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); - if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { - PyErr_Format( - PyExc_ValueError, - "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", - default_encoding_c); - goto bad; - } - Py_DECREF(ascii_chars_u); - Py_DECREF(ascii_chars_b); - } - Py_DECREF(default_encoding); - return 0; -bad: - Py_XDECREF(default_encoding); - Py_XDECREF(ascii_chars_u); - Py_XDECREF(ascii_chars_b); - return -1; -} -#endif -#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 -#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) -#else -#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) -#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT -#include -static char* __PYX_DEFAULT_STRING_ENCODING; -static int __Pyx_init_sys_getdefaultencoding_params(void) { - PyObject* sys; - PyObject* default_encoding = NULL; - char* default_encoding_c; - sys = PyImport_ImportModule("sys"); - if (!sys) goto bad; - default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); - Py_DECREF(sys); - if (!default_encoding) goto bad; - default_encoding_c = PyBytes_AsString(default_encoding); - if (!default_encoding_c) goto bad; - __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); - if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; - strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); - Py_DECREF(default_encoding); - return 0; -bad: - Py_XDECREF(default_encoding); - return -1; -} -#endif -#endif - - -/* Test for GCC > 2.95 */ -#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) - #define likely(x) __builtin_expect(!!(x), 1) - #define unlikely(x) __builtin_expect(!!(x), 0) -#else /* !__GNUC__ or GCC < 2.95 */ - #define likely(x) (x) - #define unlikely(x) (x) -#endif /* __GNUC__ */ -static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } - -#if !CYTHON_USE_MODULE_STATE -static PyObject *__pyx_m = NULL; -#endif -static int __pyx_lineno; -static int __pyx_clineno = 0; -static const char * __pyx_cfilenm = __FILE__; -static const char *__pyx_filename; - -/* Header.proto */ -#if !defined(CYTHON_CCOMPLEX) - #if defined(__cplusplus) - #define CYTHON_CCOMPLEX 1 - #elif (defined(_Complex_I) && !defined(_MSC_VER)) || ((defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) && !defined(__STDC_NO_COMPLEX__) && !defined(_MSC_VER)) - #define CYTHON_CCOMPLEX 1 - #else - #define CYTHON_CCOMPLEX 0 - #endif -#endif -#if CYTHON_CCOMPLEX - #ifdef __cplusplus - #include - #else - #include - #endif -#endif -#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) - #undef _Complex_I - #define _Complex_I 1.0fj -#endif - -/* #### Code section: filename_table ### */ - -static const char *__pyx_f[] = { - "core.pyx", - "", - "__init__.cython-30.pxd", - "type.pxd", -}; -/* #### Code section: utility_code_proto_before_types ### */ -/* 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 */ -struct __Pyx_StructField_; -#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) -typedef struct { - const char* name; - struct __Pyx_StructField_* fields; - size_t size; - size_t arraysize[8]; - int ndim; - char typegroup; - char is_unsigned; - int flags; -} __Pyx_TypeInfo; -typedef struct __Pyx_StructField_ { - __Pyx_TypeInfo* type; - const char* name; - size_t offset; -} __Pyx_StructField; -typedef struct { - __Pyx_StructField* field; - size_t parent_offset; -} __Pyx_BufFmt_StackElem; -typedef struct { - __Pyx_StructField root; - __Pyx_BufFmt_StackElem* head; - size_t fmt_offset; - size_t new_count, enc_count; - size_t struct_alignment; - int is_complex; - char enc_type; - char new_packmode; - char enc_packmode; - char is_valid_array; -} __Pyx_BufFmt_Context; - -/* Atomics.proto */ -#include -#ifndef CYTHON_ATOMICS - #define CYTHON_ATOMICS 1 -#endif -#define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS -#define __pyx_atomic_int_type int -#define __pyx_nonatomic_int_type int -#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ - (__STDC_VERSION__ >= 201112L) &&\ - !defined(__STDC_NO_ATOMICS__)) - #include -#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ - (__cplusplus >= 201103L) ||\ - (defined(_MSC_VER) && _MSC_VER >= 1700))) - #include -#endif -#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ - (__STDC_VERSION__ >= 201112L) &&\ - !defined(__STDC_NO_ATOMICS__) &&\ - ATOMIC_INT_LOCK_FREE == 2) - #undef __pyx_atomic_int_type - #define __pyx_atomic_int_type atomic_int - #define __pyx_atomic_incr_aligned(value) atomic_fetch_add_explicit(value, 1, memory_order_relaxed) - #define __pyx_atomic_decr_aligned(value) atomic_fetch_sub_explicit(value, 1, memory_order_acq_rel) - #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) - #pragma message ("Using standard C atomics") - #elif defined(__PYX_DEBUG_ATOMICS) - #warning "Using standard C atomics" - #endif -#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ - (__cplusplus >= 201103L) ||\ -\ - (defined(_MSC_VER) && _MSC_VER >= 1700)) &&\ - ATOMIC_INT_LOCK_FREE == 2) - #undef __pyx_atomic_int_type - #define __pyx_atomic_int_type std::atomic_int - #define __pyx_atomic_incr_aligned(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_relaxed) - #define __pyx_atomic_decr_aligned(value) std::atomic_fetch_sub_explicit(value, 1, std::memory_order_acq_rel) - #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) - #pragma message ("Using standard C++ atomics") - #elif defined(__PYX_DEBUG_ATOMICS) - #warning "Using standard C++ atomics" - #endif -#elif CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\ - (__GNUC_MINOR__ > 1 ||\ - (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2)))) - #define __pyx_atomic_incr_aligned(value) __sync_fetch_and_add(value, 1) - #define __pyx_atomic_decr_aligned(value) __sync_fetch_and_sub(value, 1) - #ifdef __PYX_DEBUG_ATOMICS - #warning "Using GNU atomics" - #endif -#elif CYTHON_ATOMICS && defined(_MSC_VER) - #include - #undef __pyx_atomic_int_type - #define __pyx_atomic_int_type long - #undef __pyx_nonatomic_int_type - #define __pyx_nonatomic_int_type long - #pragma intrinsic (_InterlockedExchangeAdd) - #define __pyx_atomic_incr_aligned(value) _InterlockedExchangeAdd(value, 1) - #define __pyx_atomic_decr_aligned(value) _InterlockedExchangeAdd(value, -1) - #ifdef __PYX_DEBUG_ATOMICS - #pragma message ("Using MSVC atomics") - #endif -#else - #undef CYTHON_ATOMICS - #define CYTHON_ATOMICS 0 - #ifdef __PYX_DEBUG_ATOMICS - #warning "Not using atomics" - #endif -#endif -#if CYTHON_ATOMICS - #define __pyx_add_acquisition_count(memview)\ - __pyx_atomic_incr_aligned(__pyx_get_slice_count_pointer(memview)) - #define __pyx_sub_acquisition_count(memview)\ - __pyx_atomic_decr_aligned(__pyx_get_slice_count_pointer(memview)) -#else - #define __pyx_add_acquisition_count(memview)\ - __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) - #define __pyx_sub_acquisition_count(memview)\ - __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) -#endif - -/* MemviewSliceStruct.proto */ -struct __pyx_memoryview_obj; -typedef struct { - struct __pyx_memoryview_obj *memview; - char *data; - Py_ssize_t shape[8]; - Py_ssize_t strides[8]; - Py_ssize_t suboffsets[8]; -} __Pyx_memviewslice; -#define __Pyx_MemoryView_Len(m) (m.shape[0]) - -/* #### Code section: numeric_typedefs ### */ - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":731 - * # in Cython to enable them only on the right systems. - * - * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< - * ctypedef npy_int16 int16_t - * ctypedef npy_int32 int32_t - */ -typedef npy_int8 __pyx_t_5numpy_int8_t; - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":732 - * - * ctypedef npy_int8 int8_t - * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< - * ctypedef npy_int32 int32_t - * ctypedef npy_int64 int64_t - */ -typedef npy_int16 __pyx_t_5numpy_int16_t; - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":733 - * ctypedef npy_int8 int8_t - * ctypedef npy_int16 int16_t - * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< - * ctypedef npy_int64 int64_t - * #ctypedef npy_int96 int96_t - */ -typedef npy_int32 __pyx_t_5numpy_int32_t; - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":734 - * ctypedef npy_int16 int16_t - * ctypedef npy_int32 int32_t - * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< - * #ctypedef npy_int96 int96_t - * #ctypedef npy_int128 int128_t - */ -typedef npy_int64 __pyx_t_5numpy_int64_t; - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":738 - * #ctypedef npy_int128 int128_t - * - * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< - * ctypedef npy_uint16 uint16_t - * ctypedef npy_uint32 uint32_t - */ -typedef npy_uint8 __pyx_t_5numpy_uint8_t; - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":739 - * - * ctypedef npy_uint8 uint8_t - * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< - * ctypedef npy_uint32 uint32_t - * ctypedef npy_uint64 uint64_t - */ -typedef npy_uint16 __pyx_t_5numpy_uint16_t; - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":740 - * ctypedef npy_uint8 uint8_t - * ctypedef npy_uint16 uint16_t - * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< - * ctypedef npy_uint64 uint64_t - * #ctypedef npy_uint96 uint96_t - */ -typedef npy_uint32 __pyx_t_5numpy_uint32_t; - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":741 - * ctypedef npy_uint16 uint16_t - * ctypedef npy_uint32 uint32_t - * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< - * #ctypedef npy_uint96 uint96_t - * #ctypedef npy_uint128 uint128_t - */ -typedef npy_uint64 __pyx_t_5numpy_uint64_t; - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":745 - * #ctypedef npy_uint128 uint128_t - * - * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< - * ctypedef npy_float64 float64_t - * #ctypedef npy_float80 float80_t - */ -typedef npy_float32 __pyx_t_5numpy_float32_t; - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":746 - * - * ctypedef npy_float32 float32_t - * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< - * #ctypedef npy_float80 float80_t - * #ctypedef npy_float128 float128_t - */ -typedef npy_float64 __pyx_t_5numpy_float64_t; - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":755 - * # The int types are mapped a bit surprising -- - * # numpy.int corresponds to 'l' and numpy.long to 'q' - * ctypedef npy_long int_t # <<<<<<<<<<<<<< - * ctypedef npy_longlong long_t - * ctypedef npy_longlong longlong_t - */ -typedef npy_long __pyx_t_5numpy_int_t; - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":756 - * # numpy.int corresponds to 'l' and numpy.long to 'q' - * ctypedef npy_long int_t - * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< - * ctypedef npy_longlong longlong_t - * - */ -typedef npy_longlong __pyx_t_5numpy_long_t; - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":757 - * ctypedef npy_long int_t - * ctypedef npy_longlong long_t - * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< - * - * ctypedef npy_ulong uint_t - */ -typedef npy_longlong __pyx_t_5numpy_longlong_t; - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":759 - * ctypedef npy_longlong longlong_t - * - * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< - * ctypedef npy_ulonglong ulong_t - * ctypedef npy_ulonglong ulonglong_t - */ -typedef npy_ulong __pyx_t_5numpy_uint_t; - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":760 - * - * ctypedef npy_ulong uint_t - * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< - * ctypedef npy_ulonglong ulonglong_t - * - */ -typedef npy_ulonglong __pyx_t_5numpy_ulong_t; - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":761 - * ctypedef npy_ulong uint_t - * ctypedef npy_ulonglong ulong_t - * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< - * - * ctypedef npy_intp intp_t - */ -typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":763 - * ctypedef npy_ulonglong ulonglong_t - * - * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< - * ctypedef npy_uintp uintp_t - * - */ -typedef npy_intp __pyx_t_5numpy_intp_t; - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":764 - * - * ctypedef npy_intp intp_t - * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< - * - * ctypedef npy_double float_t - */ -typedef npy_uintp __pyx_t_5numpy_uintp_t; - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":766 - * ctypedef npy_uintp uintp_t - * - * ctypedef npy_double float_t # <<<<<<<<<<<<<< - * ctypedef npy_double double_t - * ctypedef npy_longdouble longdouble_t - */ -typedef npy_double __pyx_t_5numpy_float_t; - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":767 - * - * ctypedef npy_double float_t - * ctypedef npy_double double_t # <<<<<<<<<<<<<< - * ctypedef npy_longdouble longdouble_t - * - */ -typedef npy_double __pyx_t_5numpy_double_t; - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":768 - * ctypedef npy_double float_t - * ctypedef npy_double double_t - * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< - * - * ctypedef npy_cfloat cfloat_t - */ -typedef npy_longdouble __pyx_t_5numpy_longdouble_t; -/* #### Code section: complex_type_declarations ### */ -/* Declarations.proto */ -#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) - #ifdef __cplusplus - typedef ::std::complex< float > __pyx_t_float_complex; - #else - typedef float _Complex __pyx_t_float_complex; - #endif -#else - typedef struct { float real, imag; } __pyx_t_float_complex; -#endif -static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); - -/* Declarations.proto */ -#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) - #ifdef __cplusplus - typedef ::std::complex< double > __pyx_t_double_complex; - #else - typedef double _Complex __pyx_t_double_complex; - #endif -#else - typedef struct { double real, imag; } __pyx_t_double_complex; -#endif -static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); - -/* #### Code section: type_declarations ### */ - -/*--- Type declarations ---*/ -struct __pyx_array_obj; -struct __pyx_MemviewEnum_obj; -struct __pyx_memoryview_obj; -struct __pyx_memoryviewslice_obj; - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":770 - * ctypedef npy_longdouble longdouble_t - * - * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< - * ctypedef npy_cdouble cdouble_t - * ctypedef npy_clongdouble clongdouble_t - */ -typedef npy_cfloat __pyx_t_5numpy_cfloat_t; - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":771 - * - * ctypedef npy_cfloat cfloat_t - * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< - * ctypedef npy_clongdouble clongdouble_t - * - */ -typedef npy_cdouble __pyx_t_5numpy_cdouble_t; - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":772 - * ctypedef npy_cfloat cfloat_t - * ctypedef npy_cdouble cdouble_t - * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< - * - * ctypedef npy_cdouble complex_t - */ -typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":774 - * ctypedef npy_clongdouble clongdouble_t - * - * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< - * - * cdef inline object PyArray_MultiIterNew1(a): - */ -typedef npy_cdouble __pyx_t_5numpy_complex_t; -struct __pyx_opt_args_15monotonic_align_4core_maximum_path_c; - -/* "monotonic_align/core.pyx":40 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * cpdef void maximum_path_c(int[:,:,::1] paths, float[:,:,::1] values, int[::1] t_xs, int[::1] t_ys, float max_neg_val=-1e9) nogil: # <<<<<<<<<<<<<< - * cdef int b = values.shape[0] - * - */ -struct __pyx_opt_args_15monotonic_align_4core_maximum_path_c { - int __pyx_n; - float max_neg_val; -}; - -/* "View.MemoryView":114 - * @cython.collection_type("sequence") - * @cname("__pyx_array") - * cdef class array: # <<<<<<<<<<<<<< - * - * cdef: - */ -struct __pyx_array_obj { - PyObject_HEAD - struct __pyx_vtabstruct_array *__pyx_vtab; - char *data; - Py_ssize_t len; - char *format; - int ndim; - Py_ssize_t *_shape; - Py_ssize_t *_strides; - Py_ssize_t itemsize; - PyObject *mode; - PyObject *_format; - void (*callback_free_data)(void *); - int free_data; - int dtype_is_object; -}; - - -/* "View.MemoryView":302 - * - * @cname('__pyx_MemviewEnum') - * cdef class Enum(object): # <<<<<<<<<<<<<< - * cdef object name - * def __init__(self, name): - */ -struct __pyx_MemviewEnum_obj { - PyObject_HEAD - PyObject *name; -}; - - -/* "View.MemoryView":337 - * - * @cname('__pyx_memoryview') - * cdef class memoryview: # <<<<<<<<<<<<<< - * - * cdef object obj - */ -struct __pyx_memoryview_obj { - PyObject_HEAD - struct __pyx_vtabstruct_memoryview *__pyx_vtab; - PyObject *obj; - PyObject *_size; - PyObject *_array_interface; - PyThread_type_lock lock; - __pyx_atomic_int_type acquisition_count; - Py_buffer view; - int flags; - int dtype_is_object; - __Pyx_TypeInfo *typeinfo; -}; - - -/* "View.MemoryView":952 - * @cython.collection_type("sequence") - * @cname('__pyx_memoryviewslice') - * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< - * "Internal class for passing memoryview slices to Python" - * - */ -struct __pyx_memoryviewslice_obj { - struct __pyx_memoryview_obj __pyx_base; - __Pyx_memviewslice from_slice; - PyObject *from_object; - PyObject *(*to_object_func)(char *); - int (*to_dtype_func)(char *, PyObject *); -}; - - - -/* "View.MemoryView":114 - * @cython.collection_type("sequence") - * @cname("__pyx_array") - * cdef class array: # <<<<<<<<<<<<<< - * - * cdef: - */ - -struct __pyx_vtabstruct_array { - PyObject *(*get_memview)(struct __pyx_array_obj *); -}; -static struct __pyx_vtabstruct_array *__pyx_vtabptr_array; - - -/* "View.MemoryView":337 - * - * @cname('__pyx_memoryview') - * cdef class memoryview: # <<<<<<<<<<<<<< - * - * cdef object obj - */ - -struct __pyx_vtabstruct_memoryview { - char *(*get_item_pointer)(struct __pyx_memoryview_obj *, PyObject *); - PyObject *(*is_slice)(struct __pyx_memoryview_obj *, PyObject *); - PyObject *(*setitem_slice_assignment)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); - PyObject *(*setitem_slice_assign_scalar)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *); - PyObject *(*setitem_indexed)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); - PyObject *(*convert_item_to_object)(struct __pyx_memoryview_obj *, char *); - PyObject *(*assign_item_from_object)(struct __pyx_memoryview_obj *, char *, PyObject *); - PyObject *(*_get_base)(struct __pyx_memoryview_obj *); -}; -static struct __pyx_vtabstruct_memoryview *__pyx_vtabptr_memoryview; - - -/* "View.MemoryView":952 - * @cython.collection_type("sequence") - * @cname('__pyx_memoryviewslice') - * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< - * "Internal class for passing memoryview slices to Python" - * - */ - -struct __pyx_vtabstruct__memoryviewslice { - struct __pyx_vtabstruct_memoryview __pyx_base; -}; -static struct __pyx_vtabstruct__memoryviewslice *__pyx_vtabptr__memoryviewslice; -/* #### Code section: utility_code_proto ### */ - -/* --- Runtime support code (head) --- */ -/* Refnanny.proto */ -#ifndef CYTHON_REFNANNY - #define CYTHON_REFNANNY 0 -#endif -#if CYTHON_REFNANNY - typedef struct { - void (*INCREF)(void*, PyObject*, Py_ssize_t); - void (*DECREF)(void*, PyObject*, Py_ssize_t); - void (*GOTREF)(void*, PyObject*, Py_ssize_t); - void (*GIVEREF)(void*, PyObject*, Py_ssize_t); - void* (*SetupContext)(const char*, Py_ssize_t, const char*); - void (*FinishContext)(void**); - } __Pyx_RefNannyAPIStruct; - static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; - static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); - #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; -#ifdef WITH_THREAD - #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - if (acquire_gil) {\ - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ - PyGILState_Release(__pyx_gilstate_save);\ - } else {\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ - } - #define __Pyx_RefNannyFinishContextNogil() {\ - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __Pyx_RefNannyFinishContext();\ - PyGILState_Release(__pyx_gilstate_save);\ - } -#else - #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) - #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() -#endif - #define __Pyx_RefNannyFinishContextNogil() {\ - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __Pyx_RefNannyFinishContext();\ - PyGILState_Release(__pyx_gilstate_save);\ - } - #define __Pyx_RefNannyFinishContext()\ - __Pyx_RefNanny->FinishContext(&__pyx_refnanny) - #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) - #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) - #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) - #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) - #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0) - #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) - #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) - #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) -#else - #define __Pyx_RefNannyDeclarations - #define __Pyx_RefNannySetupContext(name, acquire_gil) - #define __Pyx_RefNannyFinishContextNogil() - #define __Pyx_RefNannyFinishContext() - #define __Pyx_INCREF(r) Py_INCREF(r) - #define __Pyx_DECREF(r) Py_DECREF(r) - #define __Pyx_GOTREF(r) - #define __Pyx_GIVEREF(r) - #define __Pyx_XINCREF(r) Py_XINCREF(r) - #define __Pyx_XDECREF(r) Py_XDECREF(r) - #define __Pyx_XGOTREF(r) - #define __Pyx_XGIVEREF(r) -#endif -#define __Pyx_Py_XDECREF_SET(r, v) do {\ - PyObject *tmp = (PyObject *) r;\ - r = v; Py_XDECREF(tmp);\ - } while (0) -#define __Pyx_XDECREF_SET(r, v) do {\ - PyObject *tmp = (PyObject *) r;\ - r = v; __Pyx_XDECREF(tmp);\ - } while (0) -#define __Pyx_DECREF_SET(r, v) do {\ - PyObject *tmp = (PyObject *) r;\ - r = v; __Pyx_DECREF(tmp);\ - } while (0) -#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) -#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) - -/* PyErrExceptionMatches.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) -static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); -#else -#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) -#endif - -/* PyThreadStateGet.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; -#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; -#if PY_VERSION_HEX >= 0x030C00A6 -#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) -#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) -#else -#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) -#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) -#endif -#else -#define __Pyx_PyThreadState_declare -#define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) -#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() -#endif - -/* PyErrFetchRestore.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) -#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 -#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) -#else -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#endif -#else -#define __Pyx_PyErr_Clear() PyErr_Clear() -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) -#endif - -/* PyObjectGetAttrStr.proto */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) -#endif - -/* PyObjectGetAttrStrNoError.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); - -/* GetBuiltinName.proto */ -static PyObject *__Pyx_GetBuiltinName(PyObject *name); - -/* TupleAndListFromArray.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); -static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); -#endif - -/* IncludeStringH.proto */ -#include - -/* BytesEquals.proto */ -static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); - -/* UnicodeEquals.proto */ -static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); - -/* fastcall.proto */ -#if CYTHON_AVOID_BORROWED_REFS - #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i) -#elif CYTHON_ASSUME_SAFE_MACROS - #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) -#else - #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) -#endif -#if CYTHON_AVOID_BORROWED_REFS - #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) - #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) -#else - #define __Pyx_Arg_NewRef_VARARGS(arg) arg - #define __Pyx_Arg_XDECREF_VARARGS(arg) -#endif -#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) -#define __Pyx_KwValues_VARARGS(args, nargs) NULL -#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) -#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) -#if CYTHON_METH_FASTCALL - #define __Pyx_Arg_FASTCALL(args, i) args[i] - #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds) - #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) - static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 - CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); - #else - #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) - #endif - #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs - to have the same reference counting */ - #define __Pyx_Arg_XDECREF_FASTCALL(arg) -#else - #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS - #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS - #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS - #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS - #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS - #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) - #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) -#endif -#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS -#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) -#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) -#else -#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) -#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) -#endif - -/* RaiseArgTupleInvalid.proto */ -static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, - Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); - -/* RaiseDoubleKeywords.proto */ -static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); - -/* ParseKeywords.proto */ -static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, - PyObject **argnames[], - PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, - const char* function_name); - -/* ArgTypeTest.proto */ -#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ - ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\ - __Pyx__ArgTypeTest(obj, type, name, exact)) -static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); - -/* RaiseException.proto */ -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); - -/* PyFunctionFastCall.proto */ -#if CYTHON_FAST_PYCALL -#if !CYTHON_VECTORCALL -#define __Pyx_PyFunction_FastCall(func, args, nargs)\ - __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) -static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); -#endif -#define __Pyx_BUILD_ASSERT_EXPR(cond)\ - (sizeof(char [1 - 2*!(cond)]) - 1) -#ifndef Py_MEMBER_SIZE -#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) -#endif -#if !CYTHON_VECTORCALL -#if PY_VERSION_HEX >= 0x03080000 - #include "frameobject.h" -#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API - #ifndef Py_BUILD_CORE - #define Py_BUILD_CORE 1 - #endif - #include "internal/pycore_frame.h" -#endif - #define __Pxy_PyFrame_Initialize_Offsets() - #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) -#else - static size_t __pyx_pyframe_localsplus_offset = 0; - #include "frameobject.h" - #define __Pxy_PyFrame_Initialize_Offsets()\ - ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ - (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) - #define __Pyx_PyFrame_GetLocalsplus(frame)\ - (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) -#endif -#endif -#endif - -/* PyObjectCall.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); -#else -#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) -#endif - -/* PyObjectCallMethO.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); -#endif - -/* PyObjectFastCall.proto */ -#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) -static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs); - -/* RaiseUnexpectedTypeError.proto */ -static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj); - -/* GCCDiagnostics.proto */ -#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) -#define __Pyx_HAS_GCC_DIAGNOSTIC -#endif - -/* BuildPyUnicode.proto */ -static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, char* chars, int clength, - int prepend_sign, char padding_char); - -/* CIntToPyUnicode.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char); - -/* CIntToPyUnicode.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char); - -/* JoinPyUnicode.proto */ -static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, - Py_UCS4 max_char); - -/* StrEquals.proto */ -#if PY_MAJOR_VERSION >= 3 -#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals -#else -#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals -#endif - -/* PyObjectFormatSimple.proto */ -#if CYTHON_COMPILING_IN_PYPY - #define __Pyx_PyObject_FormatSimple(s, f) (\ - likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ - PyObject_Format(s, f)) -#elif PY_MAJOR_VERSION < 3 - #define __Pyx_PyObject_FormatSimple(s, f) (\ - likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ - likely(PyString_CheckExact(s)) ? PyUnicode_FromEncodedObject(s, NULL, "strict") :\ - PyObject_Format(s, f)) -#elif CYTHON_USE_TYPE_SLOTS - #define __Pyx_PyObject_FormatSimple(s, f) (\ - likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ - likely(PyLong_CheckExact(s)) ? PyLong_Type.tp_repr(s) :\ - likely(PyFloat_CheckExact(s)) ? PyFloat_Type.tp_repr(s) :\ - PyObject_Format(s, f)) -#else - #define __Pyx_PyObject_FormatSimple(s, f) (\ - likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ - PyObject_Format(s, f)) -#endif - -CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ -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); - -/* PyObjectCallOneArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); - -/* ObjectGetItem.proto */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key); -#else -#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) -#endif - -/* KeywordStringCheck.proto */ -static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed); - -/* DivInt[Py_ssize_t].proto */ -static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t, Py_ssize_t); - -/* UnaryNegOverflows.proto */ -#define __Pyx_UNARY_NEG_WOULD_OVERFLOW(x)\ - (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x))) - -/* GetAttr3.proto */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); - -/* PyDictVersioning.proto */ -#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS -#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) -#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) -#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ - (version_var) = __PYX_GET_DICT_VERSION(dict);\ - (cache_var) = (value); -#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ - static PY_UINT64_T __pyx_dict_version = 0;\ - static PyObject *__pyx_dict_cached_value = NULL;\ - if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ - (VAR) = __pyx_dict_cached_value;\ - } else {\ - (VAR) = __pyx_dict_cached_value = (LOOKUP);\ - __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ - }\ -} -static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); -static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); -static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); -#else -#define __PYX_GET_DICT_VERSION(dict) (0) -#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) -#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); -#endif - -/* GetModuleGlobalName.proto */ -#if CYTHON_USE_DICT_VERSIONS -#define __Pyx_GetModuleGlobalName(var, name) do {\ - static PY_UINT64_T __pyx_dict_version = 0;\ - static PyObject *__pyx_dict_cached_value = NULL;\ - (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ - (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ - __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} while(0) -#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ - PY_UINT64_T __pyx_dict_version;\ - PyObject *__pyx_dict_cached_value;\ - (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} while(0) -static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); -#else -#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) -#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) -static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); -#endif - -/* AssertionsEnabled.proto */ -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) - #define __Pyx_init_assertions_enabled() (0) - #define __pyx_assertions_enabled() (1) -#elif CYTHON_COMPILING_IN_LIMITED_API || (CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030C0000) - static int __pyx_assertions_enabled_flag; - #define __pyx_assertions_enabled() (__pyx_assertions_enabled_flag) - static int __Pyx_init_assertions_enabled(void) { - PyObject *builtins, *debug, *debug_str; - int flag; - builtins = PyEval_GetBuiltins(); - if (!builtins) goto bad; - debug_str = PyUnicode_FromStringAndSize("__debug__", 9); - if (!debug_str) goto bad; - debug = PyObject_GetItem(builtins, debug_str); - Py_DECREF(debug_str); - if (!debug) goto bad; - flag = PyObject_IsTrue(debug); - Py_DECREF(debug); - if (flag == -1) goto bad; - __pyx_assertions_enabled_flag = flag; - return 0; - bad: - __pyx_assertions_enabled_flag = 1; - return -1; - } -#else - #define __Pyx_init_assertions_enabled() (0) - #define __pyx_assertions_enabled() (!Py_OptimizeFlag) -#endif - -/* RaiseTooManyValuesToUnpack.proto */ -static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); - -/* RaiseNeedMoreValuesToUnpack.proto */ -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 && CYTHON_FAST_THREAD_STATE -static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); -#endif - -/* SaveResetException.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); -#else -#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) -#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) -#endif - -/* GetException.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) -static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#else -static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); -#endif - -/* SwapException.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#else -static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); -#endif - -/* Import.proto */ -static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); - -/* ImportDottedModule.proto */ -static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple); -#if PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple); -#endif - -/* FastTypeChecks.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) -#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) -static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); -static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b); -static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); -static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); -#else -#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) -#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) -#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) -#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) -#endif -#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) -#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) - -CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ -/* ListCompAppend.proto */ -#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS -static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { - PyListObject* L = (PyListObject*) list; - Py_ssize_t len = Py_SIZE(list); - if (likely(L->allocated > len)) { - Py_INCREF(x); - #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 - L->ob_item[len] = x; - #else - PyList_SET_ITEM(list, len, x); - #endif - __Pyx_SET_SIZE(list, len + 1); - return 0; - } - return PyList_Append(list, x); -} -#else -#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) -#endif - -/* PySequenceMultiply.proto */ -#define __Pyx_PySequence_Multiply_Left(mul, seq) __Pyx_PySequence_Multiply(seq, mul) -static CYTHON_INLINE PyObject* __Pyx_PySequence_Multiply(PyObject *seq, Py_ssize_t mul); - -/* SetItemInt.proto */ -#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\ - (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\ - __Pyx_SetItemInt_Generic(o, to_py_func(i), v))) -static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); -static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, - int is_list, int wraparound, int boundscheck); - -/* RaiseUnboundLocalError.proto */ -static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); - -/* DivInt[long].proto */ -static CYTHON_INLINE long __Pyx_div_long(long, long); - -/* PySequenceContains.proto */ -static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { - int result = PySequence_Contains(seq, item); - return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); -} - -/* ImportFrom.proto */ -static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); - -/* HasAttr.proto */ -#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 -#define __Pyx_HasAttr(o, n) PyObject_HasAttrWithError(o, n) -#else -static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); -#endif - -/* ErrOccurredWithGIL.proto */ -static CYTHON_INLINE int __Pyx_ErrOccurredWithGIL(void); - -/* PyObject_GenericGetAttrNoDict.proto */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr -#endif - -/* PyObject_GenericGetAttr.proto */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr -#endif - -/* IncludeStructmemberH.proto */ -#include - -/* FixUpExtensionType.proto */ -#if CYTHON_USE_TYPE_SPECS -static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); -#endif - -/* PyObjectCallNoArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); - -/* PyObjectGetMethod.proto */ -static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); - -/* PyObjectCallMethod0.proto */ -static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); - -/* ValidateBasesTuple.proto */ -#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS -static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); -#endif - -/* PyType_Ready.proto */ -CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); - -/* SetVTable.proto */ -static int __Pyx_SetVtable(PyTypeObject* typeptr , void* vtable); - -/* GetVTable.proto */ -static void* __Pyx_GetVtable(PyTypeObject *type); - -/* MergeVTables.proto */ -#if !CYTHON_COMPILING_IN_LIMITED_API -static int __Pyx_MergeVtables(PyTypeObject *type); -#endif - -/* SetupReduce.proto */ -#if !CYTHON_COMPILING_IN_LIMITED_API -static int __Pyx_setup_reduce(PyObject* type_obj); -#endif - -/* TypeImport.proto */ -#ifndef __PYX_HAVE_RT_ImportType_proto_3_0_10 -#define __PYX_HAVE_RT_ImportType_proto_3_0_10 -#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L -#include -#endif -#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L -#define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) alignof(s) -#else -#define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) sizeof(void*) -#endif -enum __Pyx_ImportType_CheckSize_3_0_10 { - __Pyx_ImportType_CheckSize_Error_3_0_10 = 0, - __Pyx_ImportType_CheckSize_Warn_3_0_10 = 1, - __Pyx_ImportType_CheckSize_Ignore_3_0_10 = 2 -}; -static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size); -#endif - -/* FetchSharedCythonModule.proto */ -static PyObject *__Pyx_FetchSharedCythonABIModule(void); - -/* FetchCommonType.proto */ -#if !CYTHON_USE_TYPE_SPECS -static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); -#else -static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); -#endif - -/* PyMethodNew.proto */ -#if CYTHON_COMPILING_IN_LIMITED_API -static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { - PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; - CYTHON_UNUSED_VAR(typ); - if (!self) - return __Pyx_NewRef(func); - typesModule = PyImport_ImportModule("types"); - if (!typesModule) return NULL; - methodType = PyObject_GetAttrString(typesModule, "MethodType"); - Py_DECREF(typesModule); - if (!methodType) return NULL; - result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL); - Py_DECREF(methodType); - return result; -} -#elif PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { - CYTHON_UNUSED_VAR(typ); - if (!self) - return __Pyx_NewRef(func); - return PyMethod_New(func, self); -} -#else - #define __Pyx_PyMethod_New PyMethod_New -#endif - -/* PyVectorcallFastCallDict.proto */ -#if CYTHON_METH_FASTCALL -static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); -#endif - -/* CythonFunctionShared.proto */ -#define __Pyx_CyFunction_USED -#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 -#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 -#define __Pyx_CYFUNCTION_CCLASS 0x04 -#define __Pyx_CYFUNCTION_COROUTINE 0x08 -#define __Pyx_CyFunction_GetClosure(f)\ - (((__pyx_CyFunctionObject *) (f))->func_closure) -#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_CyFunction_GetClassObj(f)\ - (((__pyx_CyFunctionObject *) (f))->func_classobj) -#else - #define __Pyx_CyFunction_GetClassObj(f)\ - ((PyObject*) ((PyCMethodObject *) (f))->mm_class) -#endif -#define __Pyx_CyFunction_SetClassObj(f, classobj)\ - __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (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 { -#if CYTHON_COMPILING_IN_LIMITED_API - PyObject_HEAD - PyObject *func; -#elif PY_VERSION_HEX < 0x030900B1 - PyCFunctionObject func; -#else - PyCMethodObject func; -#endif -#if CYTHON_BACKPORT_VECTORCALL - __pyx_vectorcallfunc func_vectorcall; -#endif -#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API - 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; -#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API - PyObject *func_classobj; -#endif - void *defaults; - int defaults_pyobjects; - size_t defaults_size; - int flags; - PyObject *defaults_tuple; - PyObject *defaults_kwdict; - PyObject *(*defaults_getter)(PyObject *); - PyObject *func_annotations; - PyObject *func_is_coroutine; -} __pyx_CyFunctionObject; -#undef __Pyx_CyOrPyCFunction_Check -#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_CyFunctionType) -#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) -#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) -static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); -#undef __Pyx_IsSameCFunction -#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) -static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, - int flags, PyObject* qualname, - PyObject *closure, - PyObject *module, PyObject *globals, - PyObject* code); -static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); -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(PyObject *module); -#if CYTHON_METH_FASTCALL -static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); -static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); -static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); -static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); -#if CYTHON_BACKPORT_VECTORCALL -#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) -#else -#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) -#endif -#endif - -/* CythonFunction.proto */ -static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, - int flags, PyObject* qualname, - PyObject *closure, - PyObject *module, PyObject *globals, - PyObject* code); - -/* CLineInTraceback.proto */ -#ifdef CYTHON_CLINE_IN_TRACEBACK -#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) -#else -static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); -#endif - -/* CodeObjectCache.proto */ -#if !CYTHON_COMPILING_IN_LIMITED_API -typedef struct { - PyCodeObject* code_object; - int code_line; -} __Pyx_CodeObjectCacheEntry; -struct __Pyx_CodeObjectCache { - int count; - int max_count; - __Pyx_CodeObjectCacheEntry* entries; -}; -static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; -static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); -static PyCodeObject *__pyx_find_code_object(int code_line); -static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); -#endif - -/* AddTraceback.proto */ -static void __Pyx_AddTraceback(const char *funcname, int c_line, - int py_line, const char *filename); - -#if PY_MAJOR_VERSION < 3 - static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); - static void __Pyx_ReleaseBuffer(Py_buffer *view); -#else - #define __Pyx_GetBuffer PyObject_GetBuffer - #define __Pyx_ReleaseBuffer PyBuffer_Release -#endif - - -/* BufferStructDeclare.proto */ -typedef struct { - Py_ssize_t shape, strides, suboffsets; -} __Pyx_Buf_DimInfo; -typedef struct { - size_t refcount; - Py_buffer pybuffer; -} __Pyx_Buffer; -typedef struct { - __Pyx_Buffer *rcbuffer; - char *data; - __Pyx_Buf_DimInfo diminfo[8]; -} __Pyx_LocalBuf_ND; - -/* MemviewSliceIsContig.proto */ -static int __pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim); - -/* OverlappingSlices.proto */ -static int __pyx_slices_overlap(__Pyx_memviewslice *slice1, - __Pyx_memviewslice *slice2, - int ndim, size_t itemsize); - -/* 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); - -/* MemviewSliceValidateAndInit.proto */ -static int __Pyx_ValidateAndInit_memviewslice( - int *axes_specs, - int c_or_f_flag, - int buf_flags, - int ndim, - __Pyx_TypeInfo *dtype, - __Pyx_BufFmt_StackElem stack[], - __Pyx_memviewslice *memviewslice, - PyObject *original_obj); - -/* ObjectToMemviewSlice.proto */ -static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_int(PyObject *, int writable_flag); - -/* ObjectToMemviewSlice.proto */ -static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_float(PyObject *, int writable_flag); - -/* ObjectToMemviewSlice.proto */ -static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_int(PyObject *, int writable_flag); - -/* RealImag.proto */ -#if CYTHON_CCOMPLEX - #ifdef __cplusplus - #define __Pyx_CREAL(z) ((z).real()) - #define __Pyx_CIMAG(z) ((z).imag()) - #else - #define __Pyx_CREAL(z) (__real__(z)) - #define __Pyx_CIMAG(z) (__imag__(z)) - #endif -#else - #define __Pyx_CREAL(z) ((z).real) - #define __Pyx_CIMAG(z) ((z).imag) -#endif -#if defined(__cplusplus) && CYTHON_CCOMPLEX\ - && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103) - #define __Pyx_SET_CREAL(z,x) ((z).real(x)) - #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) -#else - #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) - #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) -#endif - -/* Arithmetic.proto */ -#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) - #define __Pyx_c_eq_float(a, b) ((a)==(b)) - #define __Pyx_c_sum_float(a, b) ((a)+(b)) - #define __Pyx_c_diff_float(a, b) ((a)-(b)) - #define __Pyx_c_prod_float(a, b) ((a)*(b)) - #define __Pyx_c_quot_float(a, b) ((a)/(b)) - #define __Pyx_c_neg_float(a) (-(a)) - #ifdef __cplusplus - #define __Pyx_c_is_zero_float(z) ((z)==(float)0) - #define __Pyx_c_conj_float(z) (::std::conj(z)) - #if 1 - #define __Pyx_c_abs_float(z) (::std::abs(z)) - #define __Pyx_c_pow_float(a, b) (::std::pow(a, b)) - #endif - #else - #define __Pyx_c_is_zero_float(z) ((z)==0) - #define __Pyx_c_conj_float(z) (conjf(z)) - #if 1 - #define __Pyx_c_abs_float(z) (cabsf(z)) - #define __Pyx_c_pow_float(a, b) (cpowf(a, b)) - #endif - #endif -#else - static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex); - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex); - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex); - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex); - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex); - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex); - static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex); - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex); - #if 1 - static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex); - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex); - #endif -#endif - -/* Arithmetic.proto */ -#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) - #define __Pyx_c_eq_double(a, b) ((a)==(b)) - #define __Pyx_c_sum_double(a, b) ((a)+(b)) - #define __Pyx_c_diff_double(a, b) ((a)-(b)) - #define __Pyx_c_prod_double(a, b) ((a)*(b)) - #define __Pyx_c_quot_double(a, b) ((a)/(b)) - #define __Pyx_c_neg_double(a) (-(a)) - #ifdef __cplusplus - #define __Pyx_c_is_zero_double(z) ((z)==(double)0) - #define __Pyx_c_conj_double(z) (::std::conj(z)) - #if 1 - #define __Pyx_c_abs_double(z) (::std::abs(z)) - #define __Pyx_c_pow_double(a, b) (::std::pow(a, b)) - #endif - #else - #define __Pyx_c_is_zero_double(z) ((z)==0) - #define __Pyx_c_conj_double(z) (conj(z)) - #if 1 - #define __Pyx_c_abs_double(z) (cabs(z)) - #define __Pyx_c_pow_double(a, b) (cpow(a, b)) - #endif - #endif -#else - static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex); - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex); - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex); - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex); - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex); - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex); - static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex); - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex); - #if 1 - static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex); - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex); - #endif -#endif - -/* MemviewSliceCopyTemplate.proto */ -static __Pyx_memviewslice -__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, - const char *mode, int ndim, - size_t sizeof_dtype, int contig_flag, - int dtype_is_object); - -/* MemviewSliceInit.proto */ -#define __Pyx_BUF_MAX_NDIMS %(BUF_MAX_NDIMS)d -#define __Pyx_MEMVIEW_DIRECT 1 -#define __Pyx_MEMVIEW_PTR 2 -#define __Pyx_MEMVIEW_FULL 4 -#define __Pyx_MEMVIEW_CONTIG 8 -#define __Pyx_MEMVIEW_STRIDED 16 -#define __Pyx_MEMVIEW_FOLLOW 32 -#define __Pyx_IS_C_CONTIG 1 -#define __Pyx_IS_F_CONTIG 2 -static int __Pyx_init_memviewslice( - struct __pyx_memoryview_obj *memview, - int ndim, - __Pyx_memviewslice *memviewslice, - int memview_is_new_reference); -static CYTHON_INLINE int __pyx_add_acquisition_count_locked( - __pyx_atomic_int_type *acquisition_count, PyThread_type_lock lock); -static CYTHON_INLINE int __pyx_sub_acquisition_count_locked( - __pyx_atomic_int_type *acquisition_count, PyThread_type_lock lock); -#define __pyx_get_slice_count_pointer(memview) (&memview->acquisition_count) -#define __PYX_INC_MEMVIEW(slice, have_gil) __Pyx_INC_MEMVIEW(slice, have_gil, __LINE__) -#define __PYX_XCLEAR_MEMVIEW(slice, have_gil) __Pyx_XCLEAR_MEMVIEW(slice, have_gil, __LINE__) -static CYTHON_INLINE void __Pyx_INC_MEMVIEW(__Pyx_memviewslice *, int, int); -static CYTHON_INLINE void __Pyx_XCLEAR_MEMVIEW(__Pyx_memviewslice *, int, int); - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); - -/* CIntFromPy.proto */ -static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); - -/* CIntFromPy.proto */ -static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); - -/* CIntFromPy.proto */ -static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *); - -/* FormatTypeName.proto */ -#if CYTHON_COMPILING_IN_LIMITED_API -typedef PyObject *__Pyx_TypeName; -#define __Pyx_FMT_TYPENAME "%U" -static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); -#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) -#else -typedef const char *__Pyx_TypeName; -#define __Pyx_FMT_TYPENAME "%.200s" -#define __Pyx_PyType_GetName(tp) ((tp)->tp_name) -#define __Pyx_DECREF_TypeName(obj) -#endif - -/* CheckBinaryVersion.proto */ -static unsigned long __Pyx_get_runtime_version(void); -static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); - -/* InitStrings.proto */ -static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); - -/* #### Code section: module_declarations ### */ -static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self); /* proto*/ -static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto*/ -static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj); /* proto*/ -static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src); /* proto*/ -static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value); /* proto*/ -static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto*/ -static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/ -static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/ -static PyObject *__pyx_memoryview__get_base(struct __pyx_memoryview_obj *__pyx_v_self); /* proto*/ -static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/ -static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/ -static PyObject *__pyx_memoryviewslice__get_base(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto*/ -static CYTHON_INLINE PyObject *__pyx_f_5numpy_7ndarray_4base_base(PyArrayObject *__pyx_v_self); /* proto*/ -static CYTHON_INLINE PyArray_Descr *__pyx_f_5numpy_7ndarray_5descr_descr(PyArrayObject *__pyx_v_self); /* proto*/ -static CYTHON_INLINE int __pyx_f_5numpy_7ndarray_4ndim_ndim(PyArrayObject *__pyx_v_self); /* proto*/ -static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_5shape_shape(PyArrayObject *__pyx_v_self); /* proto*/ -static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_7strides_strides(PyArrayObject *__pyx_v_self); /* proto*/ -static CYTHON_INLINE npy_intp __pyx_f_5numpy_7ndarray_4size_size(PyArrayObject *__pyx_v_self); /* proto*/ -static CYTHON_INLINE char *__pyx_f_5numpy_7ndarray_4data_data(PyArrayObject *__pyx_v_self); /* proto*/ - -/* Module declarations from "libc.string" */ - -/* Module declarations from "libc.stdio" */ - -/* Module declarations from "__builtin__" */ - -/* Module declarations from "cpython.type" */ - -/* Module declarations from "cpython" */ - -/* Module declarations from "cpython.object" */ - -/* Module declarations from "cpython.ref" */ - -/* Module declarations from "numpy" */ - -/* Module declarations from "numpy" */ - -/* Module declarations from "cython.view" */ - -/* Module declarations from "cython.dataclasses" */ - -/* Module declarations from "cython" */ - -/* Module declarations from "monotonic_align.core" */ -static PyObject *__pyx_collections_abc_Sequence = 0; -static PyObject *generic = 0; -static PyObject *strided = 0; -static PyObject *indirect = 0; -static PyObject *contiguous = 0; -static PyObject *indirect_contiguous = 0; -static int __pyx_memoryview_thread_locks_used; -static PyThread_type_lock __pyx_memoryview_thread_locks[8]; -static void __pyx_f_15monotonic_align_4core_maximum_path_each(__Pyx_memviewslice, __Pyx_memviewslice, int, int, float); /*proto*/ -static void __pyx_f_15monotonic_align_4core_maximum_path_c(__Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, int __pyx_skip_dispatch, struct __pyx_opt_args_15monotonic_align_4core_maximum_path_c *__pyx_optional_args); /*proto*/ -static int __pyx_array_allocate_buffer(struct __pyx_array_obj *); /*proto*/ -static struct __pyx_array_obj *__pyx_array_new(PyObject *, Py_ssize_t, char *, char *, char *); /*proto*/ -static PyObject *__pyx_memoryview_new(PyObject *, int, int, __Pyx_TypeInfo *); /*proto*/ -static CYTHON_INLINE int __pyx_memoryview_check(PyObject *); /*proto*/ -static PyObject *_unellipsify(PyObject *, int); /*proto*/ -static int assert_direct_dimensions(Py_ssize_t *, int); /*proto*/ -static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *, PyObject *); /*proto*/ -static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int, int); /*proto*/ -static char *__pyx_pybuffer_index(Py_buffer *, char *, Py_ssize_t, Py_ssize_t); /*proto*/ -static int __pyx_memslice_transpose(__Pyx_memviewslice *); /*proto*/ -static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice, int, PyObject *(*)(char *), int (*)(char *, PyObject *), int); /*proto*/ -static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ -static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ -static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *); /*proto*/ -static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ -static Py_ssize_t abs_py_ssize_t(Py_ssize_t); /*proto*/ -static char __pyx_get_best_slice_order(__Pyx_memviewslice *, int); /*proto*/ -static void _copy_strided_to_strided(char *, Py_ssize_t *, char *, Py_ssize_t *, Py_ssize_t *, Py_ssize_t *, int, size_t); /*proto*/ -static void copy_strided_to_strided(__Pyx_memviewslice *, __Pyx_memviewslice *, int, size_t); /*proto*/ -static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *, int); /*proto*/ -static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *, Py_ssize_t *, Py_ssize_t, int, char); /*proto*/ -static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *, __Pyx_memviewslice *, char, int); /*proto*/ -static int __pyx_memoryview_err_extents(int, Py_ssize_t, Py_ssize_t); /*proto*/ -static int __pyx_memoryview_err_dim(PyObject *, PyObject *, int); /*proto*/ -static int __pyx_memoryview_err(PyObject *, PyObject *); /*proto*/ -static int __pyx_memoryview_err_no_memory(void); /*proto*/ -static int __pyx_memoryview_copy_contents(__Pyx_memviewslice, __Pyx_memviewslice, int, int, int); /*proto*/ -static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *, int, int); /*proto*/ -static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *, int, int, int); /*proto*/ -static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/ -static void __pyx_memoryview_refcount_objects_in_slice(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/ -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*/ -/* #### Code section: typeinfo ### */ -static __Pyx_TypeInfo __Pyx_TypeInfo_int = { "int", NULL, sizeof(int), { 0 }, 0, __PYX_IS_UNSIGNED(int) ? 'U' : 'I', __PYX_IS_UNSIGNED(int), 0 }; -static __Pyx_TypeInfo __Pyx_TypeInfo_float = { "float", NULL, sizeof(float), { 0 }, 0, 'R', 0, 0 }; -/* #### Code section: before_global_var ### */ -#define __Pyx_MODULE_NAME "monotonic_align.core" -extern int __pyx_module_is_main_monotonic_align__core; -int __pyx_module_is_main_monotonic_align__core = 0; - -/* Implementation of "monotonic_align.core" */ -/* #### Code section: global_var ### */ -static PyObject *__pyx_builtin_range; -static PyObject *__pyx_builtin___import__; -static PyObject *__pyx_builtin_ValueError; -static PyObject *__pyx_builtin_MemoryError; -static PyObject *__pyx_builtin_enumerate; -static PyObject *__pyx_builtin_TypeError; -static PyObject *__pyx_builtin_AssertionError; -static PyObject *__pyx_builtin_Ellipsis; -static PyObject *__pyx_builtin_id; -static PyObject *__pyx_builtin_IndexError; -static PyObject *__pyx_builtin_ImportError; -/* #### Code section: string_decls ### */ -static const char __pyx_k_[] = ": "; -static const char __pyx_k_O[] = "O"; -static const char __pyx_k_c[] = "c"; -static const char __pyx_k__2[] = "."; -static const char __pyx_k__3[] = "*"; -static const char __pyx_k__6[] = "'"; -static const char __pyx_k__7[] = ")"; -static const char __pyx_k_gc[] = "gc"; -static const char __pyx_k_id[] = "id"; -static const char __pyx_k_np[] = "np"; -static const char __pyx_k__25[] = "?"; -static const char __pyx_k_abc[] = "abc"; -static const char __pyx_k_and[] = " and "; -static const char __pyx_k_got[] = " (got "; -static const char __pyx_k_new[] = "__new__"; -static const char __pyx_k_obj[] = "obj"; -static const char __pyx_k_sys[] = "sys"; -static const char __pyx_k_base[] = "base"; -static const char __pyx_k_dict[] = "__dict__"; -static const char __pyx_k_main[] = "__main__"; -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_size[] = "size"; -static const char __pyx_k_spec[] = "__spec__"; -static const char __pyx_k_step[] = "step"; -static const char __pyx_k_stop[] = "stop"; -static const char __pyx_k_t_xs[] = "t_xs"; -static const char __pyx_k_t_ys[] = "t_ys"; -static const char __pyx_k_test[] = "__test__"; -static const char __pyx_k_ASCII[] = "ASCII"; -static const char __pyx_k_class[] = "__class__"; -static const char __pyx_k_count[] = "count"; -static const char __pyx_k_error[] = "error"; -static const char __pyx_k_flags[] = "flags"; -static const char __pyx_k_index[] = "index"; -static const char __pyx_k_numpy[] = "numpy"; -static const char __pyx_k_paths[] = "paths"; -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_enable[] = "enable"; -static const char __pyx_k_encode[] = "encode"; -static const char __pyx_k_format[] = "format"; -static const char __pyx_k_import[] = "__import__"; -static const char __pyx_k_name_2[] = "__name__"; -static const char __pyx_k_pickle[] = "pickle"; -static const char __pyx_k_reduce[] = "__reduce__"; -static const char __pyx_k_struct[] = "struct"; -static const char __pyx_k_unpack[] = "unpack"; -static const char __pyx_k_update[] = "update"; -static const char __pyx_k_values[] = "values"; -static const char __pyx_k_disable[] = "disable"; -static const char __pyx_k_fortran[] = "fortran"; -static const char __pyx_k_memview[] = "memview"; -static const char __pyx_k_Ellipsis[] = "Ellipsis"; -static const char __pyx_k_Sequence[] = "Sequence"; -static const char __pyx_k_core_pyx[] = "core.pyx"; -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_register[] = "register"; -static const char __pyx_k_setstate[] = "__setstate__"; -static const char __pyx_k_TypeError[] = "TypeError"; -static const char __pyx_k_enumerate[] = "enumerate"; -static const char __pyx_k_isenabled[] = "isenabled"; -static const char __pyx_k_pyx_state[] = "__pyx_state"; -static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; -static const char __pyx_k_IndexError[] = "IndexError"; -static const char __pyx_k_ValueError[] = "ValueError"; -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_collections[] = "collections"; -static const char __pyx_k_max_neg_val[] = "max_neg_val"; -static const char __pyx_k_initializing[] = "_initializing"; -static const char __pyx_k_is_coroutine[] = "_is_coroutine"; -static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; -static const char __pyx_k_stringsource[] = ""; -static const char __pyx_k_version_info[] = "version_info"; -static const char __pyx_k_class_getitem[] = "__class_getitem__"; -static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; -static const char __pyx_k_AssertionError[] = "AssertionError"; -static const char __pyx_k_maximum_path_c[] = "maximum_path_c"; -static const char __pyx_k_View_MemoryView[] = "View.MemoryView"; -static const char __pyx_k_allocate_buffer[] = "allocate_buffer"; -static const char __pyx_k_collections_abc[] = "collections.abc"; -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__"; -static const char __pyx_k_pyx_unpickle_Enum[] = "__pyx_unpickle_Enum"; -static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines"; -static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; -static const char __pyx_k_strided_and_direct[] = ""; -static const char __pyx_k_monotonic_align_core[] = "monotonic_align.core"; -static const char __pyx_k_strided_and_indirect[] = ""; -static const char __pyx_k_Invalid_shape_in_axis[] = "Invalid shape in axis "; -static const char __pyx_k_contiguous_and_direct[] = ""; -static const char __pyx_k_Cannot_index_with_type[] = "Cannot index with type '"; -static const char __pyx_k_MemoryView_of_r_object[] = ""; -static const char __pyx_k_MemoryView_of_r_at_0x_x[] = ""; -static const char __pyx_k_contiguous_and_indirect[] = ""; -static const char __pyx_k_Dimension_d_is_not_direct[] = "Dimension %d is not direct"; -static const char __pyx_k_Index_out_of_bounds_axis_d[] = "Index out of bounds (axis %d)"; -static const char __pyx_k_Step_may_not_be_zero_axis_d[] = "Step may not be zero (axis %d)"; -static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cython.array"; -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_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import"; -static const char __pyx_k_All_dimensions_preceding_dimensi[] = "All dimensions preceding dimension %d must be indexed and not sliced"; -static const char __pyx_k_Buffer_view_does_not_expose_stri[] = "Buffer view does not expose strides"; -static const char __pyx_k_Can_only_create_a_buffer_that_is[] = "Can only create a buffer that is contiguous in memory."; -static const char __pyx_k_Cannot_assign_to_read_only_memor[] = "Cannot assign to read-only memoryview"; -static const char __pyx_k_Cannot_create_writable_memory_vi[] = "Cannot create writable memory view from read-only memoryview"; -static const char __pyx_k_Cannot_transpose_memoryview_with[] = "Cannot transpose memoryview with indirect dimensions"; -static const char __pyx_k_Empty_shape_tuple_for_cython_arr[] = "Empty shape tuple for cython.array"; -static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))"; -static const char __pyx_k_Indirect_dimensions_not_supporte[] = "Indirect dimensions not supported"; -static const char __pyx_k_Invalid_mode_expected_c_or_fortr[] = "Invalid mode, expected 'c' or 'fortran', got "; -static const char __pyx_k_Out_of_bounds_on_buffer_access_a[] = "Out of bounds on buffer access (axis "; -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 "; -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."; -/* #### Code section: decls ### */ -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 */ -static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self); /* proto */ -static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr); /* proto */ -static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item); /* proto */ -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); /* proto */ -static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self); /* proto */ -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); /* proto */ -static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ -static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ -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); /* proto */ -static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto */ -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); /* proto */ -static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ -static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ -static PyObject *__pyx_pf_15monotonic_align_4core_maximum_path_c(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_paths, __Pyx_memviewslice __pyx_v_values, __Pyx_memviewslice __pyx_v_t_xs, __Pyx_memviewslice __pyx_v_t_ys, float __pyx_v_max_neg_val); /* proto */ -static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -/* #### Code section: late_includes ### */ -/* #### Code section: module_state ### */ -typedef struct { - PyObject *__pyx_d; - PyObject *__pyx_b; - PyObject *__pyx_cython_runtime; - PyObject *__pyx_empty_tuple; - PyObject *__pyx_empty_bytes; - PyObject *__pyx_empty_unicode; - #ifdef __Pyx_CyFunction_USED - PyTypeObject *__pyx_CyFunctionType; - #endif - #ifdef __Pyx_FusedFunction_USED - PyTypeObject *__pyx_FusedFunctionType; - #endif - #ifdef __Pyx_Generator_USED - PyTypeObject *__pyx_GeneratorType; - #endif - #ifdef __Pyx_IterableCoroutine_USED - PyTypeObject *__pyx_IterableCoroutineType; - #endif - #ifdef __Pyx_Coroutine_USED - PyTypeObject *__pyx_CoroutineAwaitType; - #endif - #ifdef __Pyx_Coroutine_USED - PyTypeObject *__pyx_CoroutineType; - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - PyTypeObject *__pyx_ptype_7cpython_4type_type; - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - PyTypeObject *__pyx_ptype_5numpy_dtype; - PyTypeObject *__pyx_ptype_5numpy_flatiter; - PyTypeObject *__pyx_ptype_5numpy_broadcast; - PyTypeObject *__pyx_ptype_5numpy_ndarray; - PyTypeObject *__pyx_ptype_5numpy_generic; - PyTypeObject *__pyx_ptype_5numpy_number; - PyTypeObject *__pyx_ptype_5numpy_integer; - PyTypeObject *__pyx_ptype_5numpy_signedinteger; - PyTypeObject *__pyx_ptype_5numpy_unsignedinteger; - PyTypeObject *__pyx_ptype_5numpy_inexact; - PyTypeObject *__pyx_ptype_5numpy_floating; - PyTypeObject *__pyx_ptype_5numpy_complexfloating; - PyTypeObject *__pyx_ptype_5numpy_flexible; - PyTypeObject *__pyx_ptype_5numpy_character; - PyTypeObject *__pyx_ptype_5numpy_ufunc; - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - PyObject *__pyx_type___pyx_array; - PyObject *__pyx_type___pyx_MemviewEnum; - PyObject *__pyx_type___pyx_memoryview; - PyObject *__pyx_type___pyx_memoryviewslice; - #endif - PyTypeObject *__pyx_array_type; - PyTypeObject *__pyx_MemviewEnum_type; - PyTypeObject *__pyx_memoryview_type; - PyTypeObject *__pyx_memoryviewslice_type; - PyObject *__pyx_kp_u_; - PyObject *__pyx_n_s_ASCII; - PyObject *__pyx_kp_s_All_dimensions_preceding_dimensi; - PyObject *__pyx_n_s_AssertionError; - PyObject *__pyx_kp_s_Buffer_view_does_not_expose_stri; - PyObject *__pyx_kp_s_Can_only_create_a_buffer_that_is; - PyObject *__pyx_kp_s_Cannot_assign_to_read_only_memor; - PyObject *__pyx_kp_s_Cannot_create_writable_memory_vi; - PyObject *__pyx_kp_u_Cannot_index_with_type; - PyObject *__pyx_kp_s_Cannot_transpose_memoryview_with; - PyObject *__pyx_kp_s_Dimension_d_is_not_direct; - PyObject *__pyx_n_s_Ellipsis; - PyObject *__pyx_kp_s_Empty_shape_tuple_for_cython_arr; - PyObject *__pyx_n_s_ImportError; - PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; - PyObject *__pyx_n_s_IndexError; - PyObject *__pyx_kp_s_Index_out_of_bounds_axis_d; - PyObject *__pyx_kp_s_Indirect_dimensions_not_supporte; - PyObject *__pyx_kp_u_Invalid_mode_expected_c_or_fortr; - PyObject *__pyx_kp_u_Invalid_shape_in_axis; - PyObject *__pyx_n_s_MemoryError; - PyObject *__pyx_kp_s_MemoryView_of_r_at_0x_x; - PyObject *__pyx_kp_s_MemoryView_of_r_object; - PyObject *__pyx_n_b_O; - PyObject *__pyx_kp_u_Out_of_bounds_on_buffer_access_a; - PyObject *__pyx_n_s_PickleError; - PyObject *__pyx_n_s_Sequence; - PyObject *__pyx_kp_s_Step_may_not_be_zero_axis_d; - PyObject *__pyx_n_s_TypeError; - PyObject *__pyx_kp_s_Unable_to_convert_item_to_object; - PyObject *__pyx_n_s_ValueError; - PyObject *__pyx_n_s_View_MemoryView; - PyObject *__pyx_kp_u__2; - PyObject *__pyx_n_s__25; - PyObject *__pyx_n_s__3; - PyObject *__pyx_kp_u__6; - PyObject *__pyx_kp_u__7; - PyObject *__pyx_n_s_abc; - PyObject *__pyx_n_s_allocate_buffer; - PyObject *__pyx_kp_u_and; - PyObject *__pyx_n_s_asyncio_coroutines; - PyObject *__pyx_n_s_base; - PyObject *__pyx_n_s_c; - PyObject *__pyx_n_u_c; - PyObject *__pyx_n_s_class; - PyObject *__pyx_n_s_class_getitem; - PyObject *__pyx_n_s_cline_in_traceback; - PyObject *__pyx_n_s_collections; - PyObject *__pyx_kp_s_collections_abc; - PyObject *__pyx_kp_s_contiguous_and_direct; - PyObject *__pyx_kp_s_contiguous_and_indirect; - PyObject *__pyx_kp_s_core_pyx; - PyObject *__pyx_n_s_count; - PyObject *__pyx_n_s_dict; - PyObject *__pyx_kp_u_disable; - PyObject *__pyx_n_s_dtype_is_object; - PyObject *__pyx_kp_u_enable; - PyObject *__pyx_n_s_encode; - PyObject *__pyx_n_s_enumerate; - PyObject *__pyx_n_s_error; - PyObject *__pyx_n_s_flags; - PyObject *__pyx_n_s_format; - PyObject *__pyx_n_s_fortran; - PyObject *__pyx_n_u_fortran; - PyObject *__pyx_kp_u_gc; - PyObject *__pyx_n_s_getstate; - PyObject *__pyx_kp_u_got; - PyObject *__pyx_kp_u_got_differing_extents_in_dimensi; - PyObject *__pyx_n_s_id; - PyObject *__pyx_n_s_import; - PyObject *__pyx_n_s_index; - PyObject *__pyx_n_s_initializing; - PyObject *__pyx_n_s_is_coroutine; - PyObject *__pyx_kp_u_isenabled; - PyObject *__pyx_n_s_itemsize; - PyObject *__pyx_kp_s_itemsize_0_for_cython_array; - PyObject *__pyx_n_s_main; - PyObject *__pyx_n_s_max_neg_val; - PyObject *__pyx_n_s_maximum_path_c; - PyObject *__pyx_n_s_memview; - PyObject *__pyx_n_s_mode; - PyObject *__pyx_n_s_monotonic_align_core; - PyObject *__pyx_n_s_name; - PyObject *__pyx_n_s_name_2; - PyObject *__pyx_n_s_ndim; - PyObject *__pyx_n_s_new; - PyObject *__pyx_kp_s_no_default___reduce___due_to_non; - PyObject *__pyx_n_s_np; - PyObject *__pyx_n_s_numpy; - PyObject *__pyx_kp_s_numpy_core_multiarray_failed_to; - PyObject *__pyx_kp_s_numpy_core_umath_failed_to_impor; - PyObject *__pyx_n_s_obj; - PyObject *__pyx_n_s_pack; - PyObject *__pyx_n_s_paths; - PyObject *__pyx_n_s_pickle; - PyObject *__pyx_n_s_pyx_PickleError; - PyObject *__pyx_n_s_pyx_checksum; - PyObject *__pyx_n_s_pyx_result; - PyObject *__pyx_n_s_pyx_state; - PyObject *__pyx_n_s_pyx_type; - PyObject *__pyx_n_s_pyx_unpickle_Enum; - PyObject *__pyx_n_s_pyx_vtable; - PyObject *__pyx_n_s_range; - PyObject *__pyx_n_s_reduce; - PyObject *__pyx_n_s_reduce_cython; - PyObject *__pyx_n_s_reduce_ex; - PyObject *__pyx_n_s_register; - PyObject *__pyx_n_s_setstate; - PyObject *__pyx_n_s_setstate_cython; - PyObject *__pyx_n_s_shape; - PyObject *__pyx_n_s_size; - PyObject *__pyx_n_s_spec; - PyObject *__pyx_n_s_start; - PyObject *__pyx_n_s_step; - PyObject *__pyx_n_s_stop; - PyObject *__pyx_kp_s_strided_and_direct; - PyObject *__pyx_kp_s_strided_and_direct_or_indirect; - PyObject *__pyx_kp_s_strided_and_indirect; - PyObject *__pyx_kp_s_stringsource; - PyObject *__pyx_n_s_struct; - PyObject *__pyx_n_s_sys; - PyObject *__pyx_n_s_t_xs; - PyObject *__pyx_n_s_t_ys; - PyObject *__pyx_n_s_test; - PyObject *__pyx_kp_s_unable_to_allocate_array_data; - PyObject *__pyx_kp_s_unable_to_allocate_shape_and_str; - PyObject *__pyx_n_s_unpack; - PyObject *__pyx_n_s_update; - PyObject *__pyx_n_s_values; - PyObject *__pyx_n_s_version_info; - PyObject *__pyx_int_0; - PyObject *__pyx_int_1; - PyObject *__pyx_int_3; - PyObject *__pyx_int_112105877; - PyObject *__pyx_int_136983863; - PyObject *__pyx_int_184977713; - PyObject *__pyx_int_neg_1; - float __pyx_k__11; - PyObject *__pyx_slice__5; - PyObject *__pyx_tuple__4; - PyObject *__pyx_tuple__8; - PyObject *__pyx_tuple__9; - PyObject *__pyx_tuple__10; - PyObject *__pyx_tuple__12; - PyObject *__pyx_tuple__13; - PyObject *__pyx_tuple__14; - PyObject *__pyx_tuple__15; - PyObject *__pyx_tuple__16; - PyObject *__pyx_tuple__17; - PyObject *__pyx_tuple__18; - PyObject *__pyx_tuple__19; - PyObject *__pyx_tuple__20; - PyObject *__pyx_tuple__21; - PyObject *__pyx_tuple__23; - PyObject *__pyx_codeobj__22; - PyObject *__pyx_codeobj__24; -} __pyx_mstate; - -#if CYTHON_USE_MODULE_STATE -#ifdef __cplusplus -namespace { - extern struct PyModuleDef __pyx_moduledef; -} /* anonymous namespace */ -#else -static struct PyModuleDef __pyx_moduledef; -#endif - -#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) - -#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) - -#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) -#else -static __pyx_mstate __pyx_mstate_global_static = -#ifdef __cplusplus - {}; -#else - {0}; -#endif -static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; -#endif -/* #### Code section: module_state_clear ### */ -#if CYTHON_USE_MODULE_STATE -static int __pyx_m_clear(PyObject *m) { - __pyx_mstate *clear_module_state = __pyx_mstate(m); - if (!clear_module_state) return 0; - Py_CLEAR(clear_module_state->__pyx_d); - Py_CLEAR(clear_module_state->__pyx_b); - Py_CLEAR(clear_module_state->__pyx_cython_runtime); - Py_CLEAR(clear_module_state->__pyx_empty_tuple); - Py_CLEAR(clear_module_state->__pyx_empty_bytes); - Py_CLEAR(clear_module_state->__pyx_empty_unicode); - #ifdef __Pyx_CyFunction_USED - Py_CLEAR(clear_module_state->__pyx_CyFunctionType); - #endif - #ifdef __Pyx_FusedFunction_USED - Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); - #endif - Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4type_type); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_dtype); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_flatiter); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_broadcast); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_ndarray); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_generic); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_number); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_integer); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_signedinteger); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_unsignedinteger); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_inexact); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_floating); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_complexfloating); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_flexible); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_character); - Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_ufunc); - Py_CLEAR(clear_module_state->__pyx_array_type); - Py_CLEAR(clear_module_state->__pyx_type___pyx_array); - Py_CLEAR(clear_module_state->__pyx_MemviewEnum_type); - Py_CLEAR(clear_module_state->__pyx_type___pyx_MemviewEnum); - Py_CLEAR(clear_module_state->__pyx_memoryview_type); - Py_CLEAR(clear_module_state->__pyx_type___pyx_memoryview); - Py_CLEAR(clear_module_state->__pyx_memoryviewslice_type); - Py_CLEAR(clear_module_state->__pyx_type___pyx_memoryviewslice); - Py_CLEAR(clear_module_state->__pyx_kp_u_); - Py_CLEAR(clear_module_state->__pyx_n_s_ASCII); - Py_CLEAR(clear_module_state->__pyx_kp_s_All_dimensions_preceding_dimensi); - Py_CLEAR(clear_module_state->__pyx_n_s_AssertionError); - Py_CLEAR(clear_module_state->__pyx_kp_s_Buffer_view_does_not_expose_stri); - Py_CLEAR(clear_module_state->__pyx_kp_s_Can_only_create_a_buffer_that_is); - Py_CLEAR(clear_module_state->__pyx_kp_s_Cannot_assign_to_read_only_memor); - Py_CLEAR(clear_module_state->__pyx_kp_s_Cannot_create_writable_memory_vi); - Py_CLEAR(clear_module_state->__pyx_kp_u_Cannot_index_with_type); - Py_CLEAR(clear_module_state->__pyx_kp_s_Cannot_transpose_memoryview_with); - Py_CLEAR(clear_module_state->__pyx_kp_s_Dimension_d_is_not_direct); - Py_CLEAR(clear_module_state->__pyx_n_s_Ellipsis); - Py_CLEAR(clear_module_state->__pyx_kp_s_Empty_shape_tuple_for_cython_arr); - Py_CLEAR(clear_module_state->__pyx_n_s_ImportError); - Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); - Py_CLEAR(clear_module_state->__pyx_n_s_IndexError); - Py_CLEAR(clear_module_state->__pyx_kp_s_Index_out_of_bounds_axis_d); - Py_CLEAR(clear_module_state->__pyx_kp_s_Indirect_dimensions_not_supporte); - Py_CLEAR(clear_module_state->__pyx_kp_u_Invalid_mode_expected_c_or_fortr); - Py_CLEAR(clear_module_state->__pyx_kp_u_Invalid_shape_in_axis); - Py_CLEAR(clear_module_state->__pyx_n_s_MemoryError); - Py_CLEAR(clear_module_state->__pyx_kp_s_MemoryView_of_r_at_0x_x); - Py_CLEAR(clear_module_state->__pyx_kp_s_MemoryView_of_r_object); - Py_CLEAR(clear_module_state->__pyx_n_b_O); - Py_CLEAR(clear_module_state->__pyx_kp_u_Out_of_bounds_on_buffer_access_a); - Py_CLEAR(clear_module_state->__pyx_n_s_PickleError); - Py_CLEAR(clear_module_state->__pyx_n_s_Sequence); - Py_CLEAR(clear_module_state->__pyx_kp_s_Step_may_not_be_zero_axis_d); - Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); - Py_CLEAR(clear_module_state->__pyx_kp_s_Unable_to_convert_item_to_object); - Py_CLEAR(clear_module_state->__pyx_n_s_ValueError); - Py_CLEAR(clear_module_state->__pyx_n_s_View_MemoryView); - Py_CLEAR(clear_module_state->__pyx_kp_u__2); - Py_CLEAR(clear_module_state->__pyx_n_s__25); - Py_CLEAR(clear_module_state->__pyx_n_s__3); - Py_CLEAR(clear_module_state->__pyx_kp_u__6); - Py_CLEAR(clear_module_state->__pyx_kp_u__7); - Py_CLEAR(clear_module_state->__pyx_n_s_abc); - Py_CLEAR(clear_module_state->__pyx_n_s_allocate_buffer); - Py_CLEAR(clear_module_state->__pyx_kp_u_and); - Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); - Py_CLEAR(clear_module_state->__pyx_n_s_base); - Py_CLEAR(clear_module_state->__pyx_n_s_c); - Py_CLEAR(clear_module_state->__pyx_n_u_c); - Py_CLEAR(clear_module_state->__pyx_n_s_class); - Py_CLEAR(clear_module_state->__pyx_n_s_class_getitem); - Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); - Py_CLEAR(clear_module_state->__pyx_n_s_collections); - Py_CLEAR(clear_module_state->__pyx_kp_s_collections_abc); - Py_CLEAR(clear_module_state->__pyx_kp_s_contiguous_and_direct); - Py_CLEAR(clear_module_state->__pyx_kp_s_contiguous_and_indirect); - Py_CLEAR(clear_module_state->__pyx_kp_s_core_pyx); - Py_CLEAR(clear_module_state->__pyx_n_s_count); - Py_CLEAR(clear_module_state->__pyx_n_s_dict); - Py_CLEAR(clear_module_state->__pyx_kp_u_disable); - Py_CLEAR(clear_module_state->__pyx_n_s_dtype_is_object); - Py_CLEAR(clear_module_state->__pyx_kp_u_enable); - Py_CLEAR(clear_module_state->__pyx_n_s_encode); - Py_CLEAR(clear_module_state->__pyx_n_s_enumerate); - Py_CLEAR(clear_module_state->__pyx_n_s_error); - Py_CLEAR(clear_module_state->__pyx_n_s_flags); - Py_CLEAR(clear_module_state->__pyx_n_s_format); - Py_CLEAR(clear_module_state->__pyx_n_s_fortran); - Py_CLEAR(clear_module_state->__pyx_n_u_fortran); - Py_CLEAR(clear_module_state->__pyx_kp_u_gc); - Py_CLEAR(clear_module_state->__pyx_n_s_getstate); - Py_CLEAR(clear_module_state->__pyx_kp_u_got); - Py_CLEAR(clear_module_state->__pyx_kp_u_got_differing_extents_in_dimensi); - Py_CLEAR(clear_module_state->__pyx_n_s_id); - Py_CLEAR(clear_module_state->__pyx_n_s_import); - Py_CLEAR(clear_module_state->__pyx_n_s_index); - Py_CLEAR(clear_module_state->__pyx_n_s_initializing); - Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); - Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); - Py_CLEAR(clear_module_state->__pyx_n_s_itemsize); - Py_CLEAR(clear_module_state->__pyx_kp_s_itemsize_0_for_cython_array); - Py_CLEAR(clear_module_state->__pyx_n_s_main); - Py_CLEAR(clear_module_state->__pyx_n_s_max_neg_val); - Py_CLEAR(clear_module_state->__pyx_n_s_maximum_path_c); - Py_CLEAR(clear_module_state->__pyx_n_s_memview); - Py_CLEAR(clear_module_state->__pyx_n_s_mode); - Py_CLEAR(clear_module_state->__pyx_n_s_monotonic_align_core); - Py_CLEAR(clear_module_state->__pyx_n_s_name); - Py_CLEAR(clear_module_state->__pyx_n_s_name_2); - Py_CLEAR(clear_module_state->__pyx_n_s_ndim); - Py_CLEAR(clear_module_state->__pyx_n_s_new); - Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non); - Py_CLEAR(clear_module_state->__pyx_n_s_np); - Py_CLEAR(clear_module_state->__pyx_n_s_numpy); - Py_CLEAR(clear_module_state->__pyx_kp_s_numpy_core_multiarray_failed_to); - Py_CLEAR(clear_module_state->__pyx_kp_s_numpy_core_umath_failed_to_impor); - Py_CLEAR(clear_module_state->__pyx_n_s_obj); - Py_CLEAR(clear_module_state->__pyx_n_s_pack); - Py_CLEAR(clear_module_state->__pyx_n_s_paths); - Py_CLEAR(clear_module_state->__pyx_n_s_pickle); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_PickleError); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_checksum); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_result); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_type); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Enum); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_vtable); - Py_CLEAR(clear_module_state->__pyx_n_s_range); - Py_CLEAR(clear_module_state->__pyx_n_s_reduce); - Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex); - Py_CLEAR(clear_module_state->__pyx_n_s_register); - Py_CLEAR(clear_module_state->__pyx_n_s_setstate); - Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_shape); - Py_CLEAR(clear_module_state->__pyx_n_s_size); - Py_CLEAR(clear_module_state->__pyx_n_s_spec); - Py_CLEAR(clear_module_state->__pyx_n_s_start); - Py_CLEAR(clear_module_state->__pyx_n_s_step); - Py_CLEAR(clear_module_state->__pyx_n_s_stop); - Py_CLEAR(clear_module_state->__pyx_kp_s_strided_and_direct); - Py_CLEAR(clear_module_state->__pyx_kp_s_strided_and_direct_or_indirect); - Py_CLEAR(clear_module_state->__pyx_kp_s_strided_and_indirect); - Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource); - Py_CLEAR(clear_module_state->__pyx_n_s_struct); - Py_CLEAR(clear_module_state->__pyx_n_s_sys); - Py_CLEAR(clear_module_state->__pyx_n_s_t_xs); - Py_CLEAR(clear_module_state->__pyx_n_s_t_ys); - Py_CLEAR(clear_module_state->__pyx_n_s_test); - Py_CLEAR(clear_module_state->__pyx_kp_s_unable_to_allocate_array_data); - Py_CLEAR(clear_module_state->__pyx_kp_s_unable_to_allocate_shape_and_str); - Py_CLEAR(clear_module_state->__pyx_n_s_unpack); - Py_CLEAR(clear_module_state->__pyx_n_s_update); - Py_CLEAR(clear_module_state->__pyx_n_s_values); - Py_CLEAR(clear_module_state->__pyx_n_s_version_info); - Py_CLEAR(clear_module_state->__pyx_int_0); - Py_CLEAR(clear_module_state->__pyx_int_1); - Py_CLEAR(clear_module_state->__pyx_int_3); - Py_CLEAR(clear_module_state->__pyx_int_112105877); - Py_CLEAR(clear_module_state->__pyx_int_136983863); - Py_CLEAR(clear_module_state->__pyx_int_184977713); - Py_CLEAR(clear_module_state->__pyx_int_neg_1); - Py_CLEAR(clear_module_state->__pyx_slice__5); - Py_CLEAR(clear_module_state->__pyx_tuple__4); - Py_CLEAR(clear_module_state->__pyx_tuple__8); - Py_CLEAR(clear_module_state->__pyx_tuple__9); - Py_CLEAR(clear_module_state->__pyx_tuple__10); - Py_CLEAR(clear_module_state->__pyx_tuple__12); - Py_CLEAR(clear_module_state->__pyx_tuple__13); - Py_CLEAR(clear_module_state->__pyx_tuple__14); - Py_CLEAR(clear_module_state->__pyx_tuple__15); - Py_CLEAR(clear_module_state->__pyx_tuple__16); - Py_CLEAR(clear_module_state->__pyx_tuple__17); - Py_CLEAR(clear_module_state->__pyx_tuple__18); - Py_CLEAR(clear_module_state->__pyx_tuple__19); - Py_CLEAR(clear_module_state->__pyx_tuple__20); - Py_CLEAR(clear_module_state->__pyx_tuple__21); - Py_CLEAR(clear_module_state->__pyx_tuple__23); - Py_CLEAR(clear_module_state->__pyx_codeobj__22); - Py_CLEAR(clear_module_state->__pyx_codeobj__24); - return 0; -} -#endif -/* #### Code section: module_state_traverse ### */ -#if CYTHON_USE_MODULE_STATE -static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { - __pyx_mstate *traverse_module_state = __pyx_mstate(m); - if (!traverse_module_state) return 0; - Py_VISIT(traverse_module_state->__pyx_d); - Py_VISIT(traverse_module_state->__pyx_b); - Py_VISIT(traverse_module_state->__pyx_cython_runtime); - Py_VISIT(traverse_module_state->__pyx_empty_tuple); - Py_VISIT(traverse_module_state->__pyx_empty_bytes); - Py_VISIT(traverse_module_state->__pyx_empty_unicode); - #ifdef __Pyx_CyFunction_USED - Py_VISIT(traverse_module_state->__pyx_CyFunctionType); - #endif - #ifdef __Pyx_FusedFunction_USED - Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); - #endif - Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_4type_type); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_dtype); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_flatiter); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_broadcast); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_ndarray); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_generic); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_number); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_integer); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_signedinteger); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_unsignedinteger); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_inexact); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_floating); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_complexfloating); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_flexible); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_character); - Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_ufunc); - Py_VISIT(traverse_module_state->__pyx_array_type); - Py_VISIT(traverse_module_state->__pyx_type___pyx_array); - Py_VISIT(traverse_module_state->__pyx_MemviewEnum_type); - Py_VISIT(traverse_module_state->__pyx_type___pyx_MemviewEnum); - Py_VISIT(traverse_module_state->__pyx_memoryview_type); - Py_VISIT(traverse_module_state->__pyx_type___pyx_memoryview); - Py_VISIT(traverse_module_state->__pyx_memoryviewslice_type); - Py_VISIT(traverse_module_state->__pyx_type___pyx_memoryviewslice); - Py_VISIT(traverse_module_state->__pyx_kp_u_); - Py_VISIT(traverse_module_state->__pyx_n_s_ASCII); - Py_VISIT(traverse_module_state->__pyx_kp_s_All_dimensions_preceding_dimensi); - Py_VISIT(traverse_module_state->__pyx_n_s_AssertionError); - Py_VISIT(traverse_module_state->__pyx_kp_s_Buffer_view_does_not_expose_stri); - Py_VISIT(traverse_module_state->__pyx_kp_s_Can_only_create_a_buffer_that_is); - Py_VISIT(traverse_module_state->__pyx_kp_s_Cannot_assign_to_read_only_memor); - Py_VISIT(traverse_module_state->__pyx_kp_s_Cannot_create_writable_memory_vi); - Py_VISIT(traverse_module_state->__pyx_kp_u_Cannot_index_with_type); - Py_VISIT(traverse_module_state->__pyx_kp_s_Cannot_transpose_memoryview_with); - Py_VISIT(traverse_module_state->__pyx_kp_s_Dimension_d_is_not_direct); - Py_VISIT(traverse_module_state->__pyx_n_s_Ellipsis); - Py_VISIT(traverse_module_state->__pyx_kp_s_Empty_shape_tuple_for_cython_arr); - Py_VISIT(traverse_module_state->__pyx_n_s_ImportError); - Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); - Py_VISIT(traverse_module_state->__pyx_n_s_IndexError); - Py_VISIT(traverse_module_state->__pyx_kp_s_Index_out_of_bounds_axis_d); - Py_VISIT(traverse_module_state->__pyx_kp_s_Indirect_dimensions_not_supporte); - Py_VISIT(traverse_module_state->__pyx_kp_u_Invalid_mode_expected_c_or_fortr); - Py_VISIT(traverse_module_state->__pyx_kp_u_Invalid_shape_in_axis); - Py_VISIT(traverse_module_state->__pyx_n_s_MemoryError); - Py_VISIT(traverse_module_state->__pyx_kp_s_MemoryView_of_r_at_0x_x); - Py_VISIT(traverse_module_state->__pyx_kp_s_MemoryView_of_r_object); - Py_VISIT(traverse_module_state->__pyx_n_b_O); - Py_VISIT(traverse_module_state->__pyx_kp_u_Out_of_bounds_on_buffer_access_a); - Py_VISIT(traverse_module_state->__pyx_n_s_PickleError); - Py_VISIT(traverse_module_state->__pyx_n_s_Sequence); - Py_VISIT(traverse_module_state->__pyx_kp_s_Step_may_not_be_zero_axis_d); - Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); - Py_VISIT(traverse_module_state->__pyx_kp_s_Unable_to_convert_item_to_object); - Py_VISIT(traverse_module_state->__pyx_n_s_ValueError); - Py_VISIT(traverse_module_state->__pyx_n_s_View_MemoryView); - Py_VISIT(traverse_module_state->__pyx_kp_u__2); - Py_VISIT(traverse_module_state->__pyx_n_s__25); - Py_VISIT(traverse_module_state->__pyx_n_s__3); - Py_VISIT(traverse_module_state->__pyx_kp_u__6); - Py_VISIT(traverse_module_state->__pyx_kp_u__7); - Py_VISIT(traverse_module_state->__pyx_n_s_abc); - Py_VISIT(traverse_module_state->__pyx_n_s_allocate_buffer); - Py_VISIT(traverse_module_state->__pyx_kp_u_and); - Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); - Py_VISIT(traverse_module_state->__pyx_n_s_base); - Py_VISIT(traverse_module_state->__pyx_n_s_c); - Py_VISIT(traverse_module_state->__pyx_n_u_c); - Py_VISIT(traverse_module_state->__pyx_n_s_class); - Py_VISIT(traverse_module_state->__pyx_n_s_class_getitem); - Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); - Py_VISIT(traverse_module_state->__pyx_n_s_collections); - Py_VISIT(traverse_module_state->__pyx_kp_s_collections_abc); - Py_VISIT(traverse_module_state->__pyx_kp_s_contiguous_and_direct); - Py_VISIT(traverse_module_state->__pyx_kp_s_contiguous_and_indirect); - Py_VISIT(traverse_module_state->__pyx_kp_s_core_pyx); - Py_VISIT(traverse_module_state->__pyx_n_s_count); - Py_VISIT(traverse_module_state->__pyx_n_s_dict); - Py_VISIT(traverse_module_state->__pyx_kp_u_disable); - Py_VISIT(traverse_module_state->__pyx_n_s_dtype_is_object); - Py_VISIT(traverse_module_state->__pyx_kp_u_enable); - Py_VISIT(traverse_module_state->__pyx_n_s_encode); - Py_VISIT(traverse_module_state->__pyx_n_s_enumerate); - Py_VISIT(traverse_module_state->__pyx_n_s_error); - Py_VISIT(traverse_module_state->__pyx_n_s_flags); - Py_VISIT(traverse_module_state->__pyx_n_s_format); - Py_VISIT(traverse_module_state->__pyx_n_s_fortran); - Py_VISIT(traverse_module_state->__pyx_n_u_fortran); - Py_VISIT(traverse_module_state->__pyx_kp_u_gc); - Py_VISIT(traverse_module_state->__pyx_n_s_getstate); - Py_VISIT(traverse_module_state->__pyx_kp_u_got); - Py_VISIT(traverse_module_state->__pyx_kp_u_got_differing_extents_in_dimensi); - Py_VISIT(traverse_module_state->__pyx_n_s_id); - Py_VISIT(traverse_module_state->__pyx_n_s_import); - Py_VISIT(traverse_module_state->__pyx_n_s_index); - Py_VISIT(traverse_module_state->__pyx_n_s_initializing); - Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); - Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); - Py_VISIT(traverse_module_state->__pyx_n_s_itemsize); - Py_VISIT(traverse_module_state->__pyx_kp_s_itemsize_0_for_cython_array); - Py_VISIT(traverse_module_state->__pyx_n_s_main); - Py_VISIT(traverse_module_state->__pyx_n_s_max_neg_val); - Py_VISIT(traverse_module_state->__pyx_n_s_maximum_path_c); - Py_VISIT(traverse_module_state->__pyx_n_s_memview); - Py_VISIT(traverse_module_state->__pyx_n_s_mode); - Py_VISIT(traverse_module_state->__pyx_n_s_monotonic_align_core); - Py_VISIT(traverse_module_state->__pyx_n_s_name); - Py_VISIT(traverse_module_state->__pyx_n_s_name_2); - Py_VISIT(traverse_module_state->__pyx_n_s_ndim); - Py_VISIT(traverse_module_state->__pyx_n_s_new); - Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non); - Py_VISIT(traverse_module_state->__pyx_n_s_np); - Py_VISIT(traverse_module_state->__pyx_n_s_numpy); - Py_VISIT(traverse_module_state->__pyx_kp_s_numpy_core_multiarray_failed_to); - Py_VISIT(traverse_module_state->__pyx_kp_s_numpy_core_umath_failed_to_impor); - Py_VISIT(traverse_module_state->__pyx_n_s_obj); - Py_VISIT(traverse_module_state->__pyx_n_s_pack); - Py_VISIT(traverse_module_state->__pyx_n_s_paths); - Py_VISIT(traverse_module_state->__pyx_n_s_pickle); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_PickleError); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_checksum); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_result); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_type); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Enum); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_vtable); - Py_VISIT(traverse_module_state->__pyx_n_s_range); - Py_VISIT(traverse_module_state->__pyx_n_s_reduce); - Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex); - Py_VISIT(traverse_module_state->__pyx_n_s_register); - Py_VISIT(traverse_module_state->__pyx_n_s_setstate); - Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_shape); - Py_VISIT(traverse_module_state->__pyx_n_s_size); - Py_VISIT(traverse_module_state->__pyx_n_s_spec); - Py_VISIT(traverse_module_state->__pyx_n_s_start); - Py_VISIT(traverse_module_state->__pyx_n_s_step); - Py_VISIT(traverse_module_state->__pyx_n_s_stop); - Py_VISIT(traverse_module_state->__pyx_kp_s_strided_and_direct); - Py_VISIT(traverse_module_state->__pyx_kp_s_strided_and_direct_or_indirect); - Py_VISIT(traverse_module_state->__pyx_kp_s_strided_and_indirect); - Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource); - Py_VISIT(traverse_module_state->__pyx_n_s_struct); - Py_VISIT(traverse_module_state->__pyx_n_s_sys); - Py_VISIT(traverse_module_state->__pyx_n_s_t_xs); - Py_VISIT(traverse_module_state->__pyx_n_s_t_ys); - Py_VISIT(traverse_module_state->__pyx_n_s_test); - Py_VISIT(traverse_module_state->__pyx_kp_s_unable_to_allocate_array_data); - Py_VISIT(traverse_module_state->__pyx_kp_s_unable_to_allocate_shape_and_str); - Py_VISIT(traverse_module_state->__pyx_n_s_unpack); - Py_VISIT(traverse_module_state->__pyx_n_s_update); - Py_VISIT(traverse_module_state->__pyx_n_s_values); - Py_VISIT(traverse_module_state->__pyx_n_s_version_info); - Py_VISIT(traverse_module_state->__pyx_int_0); - Py_VISIT(traverse_module_state->__pyx_int_1); - Py_VISIT(traverse_module_state->__pyx_int_3); - Py_VISIT(traverse_module_state->__pyx_int_112105877); - Py_VISIT(traverse_module_state->__pyx_int_136983863); - Py_VISIT(traverse_module_state->__pyx_int_184977713); - Py_VISIT(traverse_module_state->__pyx_int_neg_1); - Py_VISIT(traverse_module_state->__pyx_slice__5); - Py_VISIT(traverse_module_state->__pyx_tuple__4); - Py_VISIT(traverse_module_state->__pyx_tuple__8); - Py_VISIT(traverse_module_state->__pyx_tuple__9); - Py_VISIT(traverse_module_state->__pyx_tuple__10); - Py_VISIT(traverse_module_state->__pyx_tuple__12); - Py_VISIT(traverse_module_state->__pyx_tuple__13); - Py_VISIT(traverse_module_state->__pyx_tuple__14); - Py_VISIT(traverse_module_state->__pyx_tuple__15); - Py_VISIT(traverse_module_state->__pyx_tuple__16); - Py_VISIT(traverse_module_state->__pyx_tuple__17); - Py_VISIT(traverse_module_state->__pyx_tuple__18); - Py_VISIT(traverse_module_state->__pyx_tuple__19); - Py_VISIT(traverse_module_state->__pyx_tuple__20); - Py_VISIT(traverse_module_state->__pyx_tuple__21); - Py_VISIT(traverse_module_state->__pyx_tuple__23); - Py_VISIT(traverse_module_state->__pyx_codeobj__22); - Py_VISIT(traverse_module_state->__pyx_codeobj__24); - return 0; -} -#endif -/* #### Code section: module_state_defines ### */ -#define __pyx_d __pyx_mstate_global->__pyx_d -#define __pyx_b __pyx_mstate_global->__pyx_b -#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime -#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple -#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes -#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode -#ifdef __Pyx_CyFunction_USED -#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType -#endif -#ifdef __Pyx_FusedFunction_USED -#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType -#endif -#ifdef __Pyx_Generator_USED -#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType -#endif -#ifdef __Pyx_IterableCoroutine_USED -#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType -#endif -#ifdef __Pyx_Coroutine_USED -#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType -#endif -#ifdef __Pyx_Coroutine_USED -#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#define __pyx_ptype_7cpython_4type_type __pyx_mstate_global->__pyx_ptype_7cpython_4type_type -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#define __pyx_ptype_5numpy_dtype __pyx_mstate_global->__pyx_ptype_5numpy_dtype -#define __pyx_ptype_5numpy_flatiter __pyx_mstate_global->__pyx_ptype_5numpy_flatiter -#define __pyx_ptype_5numpy_broadcast __pyx_mstate_global->__pyx_ptype_5numpy_broadcast -#define __pyx_ptype_5numpy_ndarray __pyx_mstate_global->__pyx_ptype_5numpy_ndarray -#define __pyx_ptype_5numpy_generic __pyx_mstate_global->__pyx_ptype_5numpy_generic -#define __pyx_ptype_5numpy_number __pyx_mstate_global->__pyx_ptype_5numpy_number -#define __pyx_ptype_5numpy_integer __pyx_mstate_global->__pyx_ptype_5numpy_integer -#define __pyx_ptype_5numpy_signedinteger __pyx_mstate_global->__pyx_ptype_5numpy_signedinteger -#define __pyx_ptype_5numpy_unsignedinteger __pyx_mstate_global->__pyx_ptype_5numpy_unsignedinteger -#define __pyx_ptype_5numpy_inexact __pyx_mstate_global->__pyx_ptype_5numpy_inexact -#define __pyx_ptype_5numpy_floating __pyx_mstate_global->__pyx_ptype_5numpy_floating -#define __pyx_ptype_5numpy_complexfloating __pyx_mstate_global->__pyx_ptype_5numpy_complexfloating -#define __pyx_ptype_5numpy_flexible __pyx_mstate_global->__pyx_ptype_5numpy_flexible -#define __pyx_ptype_5numpy_character __pyx_mstate_global->__pyx_ptype_5numpy_character -#define __pyx_ptype_5numpy_ufunc __pyx_mstate_global->__pyx_ptype_5numpy_ufunc -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#define __pyx_type___pyx_array __pyx_mstate_global->__pyx_type___pyx_array -#define __pyx_type___pyx_MemviewEnum __pyx_mstate_global->__pyx_type___pyx_MemviewEnum -#define __pyx_type___pyx_memoryview __pyx_mstate_global->__pyx_type___pyx_memoryview -#define __pyx_type___pyx_memoryviewslice __pyx_mstate_global->__pyx_type___pyx_memoryviewslice -#endif -#define __pyx_array_type __pyx_mstate_global->__pyx_array_type -#define __pyx_MemviewEnum_type __pyx_mstate_global->__pyx_MemviewEnum_type -#define __pyx_memoryview_type __pyx_mstate_global->__pyx_memoryview_type -#define __pyx_memoryviewslice_type __pyx_mstate_global->__pyx_memoryviewslice_type -#define __pyx_kp_u_ __pyx_mstate_global->__pyx_kp_u_ -#define __pyx_n_s_ASCII __pyx_mstate_global->__pyx_n_s_ASCII -#define __pyx_kp_s_All_dimensions_preceding_dimensi __pyx_mstate_global->__pyx_kp_s_All_dimensions_preceding_dimensi -#define __pyx_n_s_AssertionError __pyx_mstate_global->__pyx_n_s_AssertionError -#define __pyx_kp_s_Buffer_view_does_not_expose_stri __pyx_mstate_global->__pyx_kp_s_Buffer_view_does_not_expose_stri -#define __pyx_kp_s_Can_only_create_a_buffer_that_is __pyx_mstate_global->__pyx_kp_s_Can_only_create_a_buffer_that_is -#define __pyx_kp_s_Cannot_assign_to_read_only_memor __pyx_mstate_global->__pyx_kp_s_Cannot_assign_to_read_only_memor -#define __pyx_kp_s_Cannot_create_writable_memory_vi __pyx_mstate_global->__pyx_kp_s_Cannot_create_writable_memory_vi -#define __pyx_kp_u_Cannot_index_with_type __pyx_mstate_global->__pyx_kp_u_Cannot_index_with_type -#define __pyx_kp_s_Cannot_transpose_memoryview_with __pyx_mstate_global->__pyx_kp_s_Cannot_transpose_memoryview_with -#define __pyx_kp_s_Dimension_d_is_not_direct __pyx_mstate_global->__pyx_kp_s_Dimension_d_is_not_direct -#define __pyx_n_s_Ellipsis __pyx_mstate_global->__pyx_n_s_Ellipsis -#define __pyx_kp_s_Empty_shape_tuple_for_cython_arr __pyx_mstate_global->__pyx_kp_s_Empty_shape_tuple_for_cython_arr -#define __pyx_n_s_ImportError __pyx_mstate_global->__pyx_n_s_ImportError -#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0 -#define __pyx_n_s_IndexError __pyx_mstate_global->__pyx_n_s_IndexError -#define __pyx_kp_s_Index_out_of_bounds_axis_d __pyx_mstate_global->__pyx_kp_s_Index_out_of_bounds_axis_d -#define __pyx_kp_s_Indirect_dimensions_not_supporte __pyx_mstate_global->__pyx_kp_s_Indirect_dimensions_not_supporte -#define __pyx_kp_u_Invalid_mode_expected_c_or_fortr __pyx_mstate_global->__pyx_kp_u_Invalid_mode_expected_c_or_fortr -#define __pyx_kp_u_Invalid_shape_in_axis __pyx_mstate_global->__pyx_kp_u_Invalid_shape_in_axis -#define __pyx_n_s_MemoryError __pyx_mstate_global->__pyx_n_s_MemoryError -#define __pyx_kp_s_MemoryView_of_r_at_0x_x __pyx_mstate_global->__pyx_kp_s_MemoryView_of_r_at_0x_x -#define __pyx_kp_s_MemoryView_of_r_object __pyx_mstate_global->__pyx_kp_s_MemoryView_of_r_object -#define __pyx_n_b_O __pyx_mstate_global->__pyx_n_b_O -#define __pyx_kp_u_Out_of_bounds_on_buffer_access_a __pyx_mstate_global->__pyx_kp_u_Out_of_bounds_on_buffer_access_a -#define __pyx_n_s_PickleError __pyx_mstate_global->__pyx_n_s_PickleError -#define __pyx_n_s_Sequence __pyx_mstate_global->__pyx_n_s_Sequence -#define __pyx_kp_s_Step_may_not_be_zero_axis_d __pyx_mstate_global->__pyx_kp_s_Step_may_not_be_zero_axis_d -#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError -#define __pyx_kp_s_Unable_to_convert_item_to_object __pyx_mstate_global->__pyx_kp_s_Unable_to_convert_item_to_object -#define __pyx_n_s_ValueError __pyx_mstate_global->__pyx_n_s_ValueError -#define __pyx_n_s_View_MemoryView __pyx_mstate_global->__pyx_n_s_View_MemoryView -#define __pyx_kp_u__2 __pyx_mstate_global->__pyx_kp_u__2 -#define __pyx_n_s__25 __pyx_mstate_global->__pyx_n_s__25 -#define __pyx_n_s__3 __pyx_mstate_global->__pyx_n_s__3 -#define __pyx_kp_u__6 __pyx_mstate_global->__pyx_kp_u__6 -#define __pyx_kp_u__7 __pyx_mstate_global->__pyx_kp_u__7 -#define __pyx_n_s_abc __pyx_mstate_global->__pyx_n_s_abc -#define __pyx_n_s_allocate_buffer __pyx_mstate_global->__pyx_n_s_allocate_buffer -#define __pyx_kp_u_and __pyx_mstate_global->__pyx_kp_u_and -#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines -#define __pyx_n_s_base __pyx_mstate_global->__pyx_n_s_base -#define __pyx_n_s_c __pyx_mstate_global->__pyx_n_s_c -#define __pyx_n_u_c __pyx_mstate_global->__pyx_n_u_c -#define __pyx_n_s_class __pyx_mstate_global->__pyx_n_s_class -#define __pyx_n_s_class_getitem __pyx_mstate_global->__pyx_n_s_class_getitem -#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback -#define __pyx_n_s_collections __pyx_mstate_global->__pyx_n_s_collections -#define __pyx_kp_s_collections_abc __pyx_mstate_global->__pyx_kp_s_collections_abc -#define __pyx_kp_s_contiguous_and_direct __pyx_mstate_global->__pyx_kp_s_contiguous_and_direct -#define __pyx_kp_s_contiguous_and_indirect __pyx_mstate_global->__pyx_kp_s_contiguous_and_indirect -#define __pyx_kp_s_core_pyx __pyx_mstate_global->__pyx_kp_s_core_pyx -#define __pyx_n_s_count __pyx_mstate_global->__pyx_n_s_count -#define __pyx_n_s_dict __pyx_mstate_global->__pyx_n_s_dict -#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable -#define __pyx_n_s_dtype_is_object __pyx_mstate_global->__pyx_n_s_dtype_is_object -#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable -#define __pyx_n_s_encode __pyx_mstate_global->__pyx_n_s_encode -#define __pyx_n_s_enumerate __pyx_mstate_global->__pyx_n_s_enumerate -#define __pyx_n_s_error __pyx_mstate_global->__pyx_n_s_error -#define __pyx_n_s_flags __pyx_mstate_global->__pyx_n_s_flags -#define __pyx_n_s_format __pyx_mstate_global->__pyx_n_s_format -#define __pyx_n_s_fortran __pyx_mstate_global->__pyx_n_s_fortran -#define __pyx_n_u_fortran __pyx_mstate_global->__pyx_n_u_fortran -#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc -#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate -#define __pyx_kp_u_got __pyx_mstate_global->__pyx_kp_u_got -#define __pyx_kp_u_got_differing_extents_in_dimensi __pyx_mstate_global->__pyx_kp_u_got_differing_extents_in_dimensi -#define __pyx_n_s_id __pyx_mstate_global->__pyx_n_s_id -#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import -#define __pyx_n_s_index __pyx_mstate_global->__pyx_n_s_index -#define __pyx_n_s_initializing __pyx_mstate_global->__pyx_n_s_initializing -#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine -#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled -#define __pyx_n_s_itemsize __pyx_mstate_global->__pyx_n_s_itemsize -#define __pyx_kp_s_itemsize_0_for_cython_array __pyx_mstate_global->__pyx_kp_s_itemsize_0_for_cython_array -#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main -#define __pyx_n_s_max_neg_val __pyx_mstate_global->__pyx_n_s_max_neg_val -#define __pyx_n_s_maximum_path_c __pyx_mstate_global->__pyx_n_s_maximum_path_c -#define __pyx_n_s_memview __pyx_mstate_global->__pyx_n_s_memview -#define __pyx_n_s_mode __pyx_mstate_global->__pyx_n_s_mode -#define __pyx_n_s_monotonic_align_core __pyx_mstate_global->__pyx_n_s_monotonic_align_core -#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name -#define __pyx_n_s_name_2 __pyx_mstate_global->__pyx_n_s_name_2 -#define __pyx_n_s_ndim __pyx_mstate_global->__pyx_n_s_ndim -#define __pyx_n_s_new __pyx_mstate_global->__pyx_n_s_new -#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non -#define __pyx_n_s_np __pyx_mstate_global->__pyx_n_s_np -#define __pyx_n_s_numpy __pyx_mstate_global->__pyx_n_s_numpy -#define __pyx_kp_s_numpy_core_multiarray_failed_to __pyx_mstate_global->__pyx_kp_s_numpy_core_multiarray_failed_to -#define __pyx_kp_s_numpy_core_umath_failed_to_impor __pyx_mstate_global->__pyx_kp_s_numpy_core_umath_failed_to_impor -#define __pyx_n_s_obj __pyx_mstate_global->__pyx_n_s_obj -#define __pyx_n_s_pack __pyx_mstate_global->__pyx_n_s_pack -#define __pyx_n_s_paths __pyx_mstate_global->__pyx_n_s_paths -#define __pyx_n_s_pickle __pyx_mstate_global->__pyx_n_s_pickle -#define __pyx_n_s_pyx_PickleError __pyx_mstate_global->__pyx_n_s_pyx_PickleError -#define __pyx_n_s_pyx_checksum __pyx_mstate_global->__pyx_n_s_pyx_checksum -#define __pyx_n_s_pyx_result __pyx_mstate_global->__pyx_n_s_pyx_result -#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state -#define __pyx_n_s_pyx_type __pyx_mstate_global->__pyx_n_s_pyx_type -#define __pyx_n_s_pyx_unpickle_Enum __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Enum -#define __pyx_n_s_pyx_vtable __pyx_mstate_global->__pyx_n_s_pyx_vtable -#define __pyx_n_s_range __pyx_mstate_global->__pyx_n_s_range -#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce -#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython -#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex -#define __pyx_n_s_register __pyx_mstate_global->__pyx_n_s_register -#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate -#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython -#define __pyx_n_s_shape __pyx_mstate_global->__pyx_n_s_shape -#define __pyx_n_s_size __pyx_mstate_global->__pyx_n_s_size -#define __pyx_n_s_spec __pyx_mstate_global->__pyx_n_s_spec -#define __pyx_n_s_start __pyx_mstate_global->__pyx_n_s_start -#define __pyx_n_s_step __pyx_mstate_global->__pyx_n_s_step -#define __pyx_n_s_stop __pyx_mstate_global->__pyx_n_s_stop -#define __pyx_kp_s_strided_and_direct __pyx_mstate_global->__pyx_kp_s_strided_and_direct -#define __pyx_kp_s_strided_and_direct_or_indirect __pyx_mstate_global->__pyx_kp_s_strided_and_direct_or_indirect -#define __pyx_kp_s_strided_and_indirect __pyx_mstate_global->__pyx_kp_s_strided_and_indirect -#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource -#define __pyx_n_s_struct __pyx_mstate_global->__pyx_n_s_struct -#define __pyx_n_s_sys __pyx_mstate_global->__pyx_n_s_sys -#define __pyx_n_s_t_xs __pyx_mstate_global->__pyx_n_s_t_xs -#define __pyx_n_s_t_ys __pyx_mstate_global->__pyx_n_s_t_ys -#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test -#define __pyx_kp_s_unable_to_allocate_array_data __pyx_mstate_global->__pyx_kp_s_unable_to_allocate_array_data -#define __pyx_kp_s_unable_to_allocate_shape_and_str __pyx_mstate_global->__pyx_kp_s_unable_to_allocate_shape_and_str -#define __pyx_n_s_unpack __pyx_mstate_global->__pyx_n_s_unpack -#define __pyx_n_s_update __pyx_mstate_global->__pyx_n_s_update -#define __pyx_n_s_values __pyx_mstate_global->__pyx_n_s_values -#define __pyx_n_s_version_info __pyx_mstate_global->__pyx_n_s_version_info -#define __pyx_int_0 __pyx_mstate_global->__pyx_int_0 -#define __pyx_int_1 __pyx_mstate_global->__pyx_int_1 -#define __pyx_int_3 __pyx_mstate_global->__pyx_int_3 -#define __pyx_int_112105877 __pyx_mstate_global->__pyx_int_112105877 -#define __pyx_int_136983863 __pyx_mstate_global->__pyx_int_136983863 -#define __pyx_int_184977713 __pyx_mstate_global->__pyx_int_184977713 -#define __pyx_int_neg_1 __pyx_mstate_global->__pyx_int_neg_1 -#define __pyx_k__11 __pyx_mstate_global->__pyx_k__11 -#define __pyx_slice__5 __pyx_mstate_global->__pyx_slice__5 -#define __pyx_tuple__4 __pyx_mstate_global->__pyx_tuple__4 -#define __pyx_tuple__8 __pyx_mstate_global->__pyx_tuple__8 -#define __pyx_tuple__9 __pyx_mstate_global->__pyx_tuple__9 -#define __pyx_tuple__10 __pyx_mstate_global->__pyx_tuple__10 -#define __pyx_tuple__12 __pyx_mstate_global->__pyx_tuple__12 -#define __pyx_tuple__13 __pyx_mstate_global->__pyx_tuple__13 -#define __pyx_tuple__14 __pyx_mstate_global->__pyx_tuple__14 -#define __pyx_tuple__15 __pyx_mstate_global->__pyx_tuple__15 -#define __pyx_tuple__16 __pyx_mstate_global->__pyx_tuple__16 -#define __pyx_tuple__17 __pyx_mstate_global->__pyx_tuple__17 -#define __pyx_tuple__18 __pyx_mstate_global->__pyx_tuple__18 -#define __pyx_tuple__19 __pyx_mstate_global->__pyx_tuple__19 -#define __pyx_tuple__20 __pyx_mstate_global->__pyx_tuple__20 -#define __pyx_tuple__21 __pyx_mstate_global->__pyx_tuple__21 -#define __pyx_tuple__23 __pyx_mstate_global->__pyx_tuple__23 -#define __pyx_codeobj__22 __pyx_mstate_global->__pyx_codeobj__22 -#define __pyx_codeobj__24 __pyx_mstate_global->__pyx_codeobj__24 -/* #### Code section: module_code ### */ - -/* "View.MemoryView":131 - * cdef bint dtype_is_object - * - * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< - * mode="c", bint allocate_buffer=True): - * - */ - -/* 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; - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[5] = {0,0,0,0,0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; - #endif - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - { - 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}; - values[3] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)__pyx_n_s_c)); - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_VARARGS(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_VARARGS(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_shape)) != 0)) { - (void)__Pyx_Arg_NewRef_VARARGS(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_itemsize)) != 0)) { - (void)__Pyx_Arg_NewRef_VARARGS(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 1); __PYX_ERR(1, 131, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_format)) != 0)) { - (void)__Pyx_Arg_NewRef_VARARGS(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 2); __PYX_ERR(1, 131, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_mode); - if (value) { values[3] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_allocate_buffer); - if (value) { values[4] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(1, 131, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_VARARGS(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_VARARGS(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); - values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); - values[0] = __Pyx_Arg_VARARGS(__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(1, 131, __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(1, 132, __pyx_L3_error) - } else { - - /* "View.MemoryView":132 - * - * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, - * mode="c", bint allocate_buffer=True): # <<<<<<<<<<<<<< - * - * cdef int idx - */ - __pyx_v_allocate_buffer = ((int)1); - } - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, __pyx_nargs); __PYX_ERR(1, 131, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); - } - } - __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(1, 131, __pyx_L1_error) - if (unlikely(((PyObject *)__pyx_v_format) == Py_None)) { - PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "format"); __PYX_ERR(1, 131, __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); - - /* "View.MemoryView":131 - * cdef bint dtype_is_object - * - * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< - * mode="c", bint allocate_buffer=True): - * - */ - - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __pyx_r = -1; - __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); - } - } - __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_dim; - char __pyx_v_order; - int __pyx_r; - __Pyx_RefNannyDeclarations - Py_ssize_t __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - int __pyx_t_7; - char *__pyx_t_8; - Py_ssize_t __pyx_t_9; - Py_UCS4 __pyx_t_10; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__cinit__", 0); - __Pyx_INCREF(__pyx_v_format); - - /* "View.MemoryView":137 - * cdef Py_ssize_t dim - * - * self.ndim = len(shape) # <<<<<<<<<<<<<< - * self.itemsize = itemsize - * - */ - if (unlikely(__pyx_v_shape == Py_None)) { - PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(1, 137, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 137, __pyx_L1_error) - __pyx_v_self->ndim = ((int)__pyx_t_1); - - /* "View.MemoryView":138 - * - * self.ndim = len(shape) - * self.itemsize = itemsize # <<<<<<<<<<<<<< - * - * if not self.ndim: - */ - __pyx_v_self->itemsize = __pyx_v_itemsize; - - /* "View.MemoryView":140 - * self.itemsize = itemsize - * - * if not self.ndim: # <<<<<<<<<<<<<< - * raise ValueError, "Empty shape tuple for cython.array" - * - */ - __pyx_t_2 = (!(__pyx_v_self->ndim != 0)); - if (unlikely(__pyx_t_2)) { - - /* "View.MemoryView":141 - * - * if not self.ndim: - * raise ValueError, "Empty shape tuple for cython.array" # <<<<<<<<<<<<<< - * - * if itemsize <= 0: - */ - __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Empty_shape_tuple_for_cython_arr, 0, 0); - __PYX_ERR(1, 141, __pyx_L1_error) - - /* "View.MemoryView":140 - * self.itemsize = itemsize - * - * if not self.ndim: # <<<<<<<<<<<<<< - * raise ValueError, "Empty shape tuple for cython.array" - * - */ - } - - /* "View.MemoryView":143 - * raise ValueError, "Empty shape tuple for cython.array" - * - * if itemsize <= 0: # <<<<<<<<<<<<<< - * raise ValueError, "itemsize <= 0 for cython.array" - * - */ - __pyx_t_2 = (__pyx_v_itemsize <= 0); - if (unlikely(__pyx_t_2)) { - - /* "View.MemoryView":144 - * - * if itemsize <= 0: - * raise ValueError, "itemsize <= 0 for cython.array" # <<<<<<<<<<<<<< - * - * if not isinstance(format, bytes): - */ - __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_itemsize_0_for_cython_array, 0, 0); - __PYX_ERR(1, 144, __pyx_L1_error) - - /* "View.MemoryView":143 - * raise ValueError, "Empty shape tuple for cython.array" - * - * if itemsize <= 0: # <<<<<<<<<<<<<< - * raise ValueError, "itemsize <= 0 for cython.array" - * - */ - } - - /* "View.MemoryView":146 - * 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_2 = PyBytes_Check(__pyx_v_format); - __pyx_t_3 = (!__pyx_t_2); - if (__pyx_t_3) { - - /* "View.MemoryView":147 - * - * 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_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = NULL; - __pyx_t_7 = 0; - #if CYTHON_UNPACK_METHODS - if (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_7 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_n_s_ASCII}; - __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } - __Pyx_DECREF_SET(__pyx_v_format, __pyx_t_4); - __pyx_t_4 = 0; - - /* "View.MemoryView":146 - * 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 - */ - } - - /* "View.MemoryView":148 - * if not isinstance(format, bytes): - * format = format.encode('ASCII') - * self._format = format # keep a reference to the byte string # <<<<<<<<<<<<<< - * self.format = self._format - * - */ - if (!(likely(PyBytes_CheckExact(__pyx_v_format))||((__pyx_v_format) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_v_format))) __PYX_ERR(1, 148, __pyx_L1_error) - __pyx_t_4 = __pyx_v_format; - __Pyx_INCREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_4); - __Pyx_GOTREF(__pyx_v_self->_format); - __Pyx_DECREF(__pyx_v_self->_format); - __pyx_v_self->_format = ((PyObject*)__pyx_t_4); - __pyx_t_4 = 0; - - /* "View.MemoryView":149 - * format = format.encode('ASCII') - * self._format = format # keep a reference to the byte string - * self.format = self._format # <<<<<<<<<<<<<< - * - * - */ - if (unlikely(__pyx_v_self->_format == Py_None)) { - PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); - __PYX_ERR(1, 149, __pyx_L1_error) - } - __pyx_t_8 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_8) && PyErr_Occurred())) __PYX_ERR(1, 149, __pyx_L1_error) - __pyx_v_self->format = __pyx_t_8; - - /* "View.MemoryView":152 - * - * - * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) # <<<<<<<<<<<<<< - * self._strides = self._shape + self.ndim - * - */ - __pyx_v_self->_shape = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * __pyx_v_self->ndim) * 2))); - - /* "View.MemoryView":153 - * - * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) - * self._strides = self._shape + self.ndim # <<<<<<<<<<<<<< - * - * if not self._shape: - */ - __pyx_v_self->_strides = (__pyx_v_self->_shape + __pyx_v_self->ndim); - - /* "View.MemoryView":155 - * self._strides = self._shape + self.ndim - * - * if not self._shape: # <<<<<<<<<<<<<< - * raise MemoryError, "unable to allocate shape and strides." - * - */ - __pyx_t_3 = (!(__pyx_v_self->_shape != 0)); - if (unlikely(__pyx_t_3)) { - - /* "View.MemoryView":156 - * - * if not self._shape: - * raise MemoryError, "unable to allocate shape and strides." # <<<<<<<<<<<<<< - * - * - */ - __Pyx_Raise(__pyx_builtin_MemoryError, __pyx_kp_s_unable_to_allocate_shape_and_str, 0, 0); - __PYX_ERR(1, 156, __pyx_L1_error) - - /* "View.MemoryView":155 - * self._strides = self._shape + self.ndim - * - * if not self._shape: # <<<<<<<<<<<<<< - * raise MemoryError, "unable to allocate shape and strides." - * - */ - } - - /* "View.MemoryView":159 - * - * - * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< - * if dim <= 0: - * raise ValueError, f"Invalid shape in axis {idx}: {dim}." - */ - __pyx_t_7 = 0; - __pyx_t_4 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_4); - __pyx_t_1 = 0; - for (;;) { - { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_4); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 159, __pyx_L1_error) - #endif - if (__pyx_t_1 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(1, 159, __pyx_L1_error) - #else - __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 159, __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(1, 159, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_dim = __pyx_t_9; - __pyx_v_idx = __pyx_t_7; - __pyx_t_7 = (__pyx_t_7 + 1); - - /* "View.MemoryView":160 - * - * for idx, dim in enumerate(shape): - * if dim <= 0: # <<<<<<<<<<<<<< - * raise ValueError, f"Invalid shape in axis {idx}: {dim}." - * self._shape[idx] = dim - */ - __pyx_t_3 = (__pyx_v_dim <= 0); - if (unlikely(__pyx_t_3)) { - - /* "View.MemoryView":161 - * for idx, dim in enumerate(shape): - * if dim <= 0: - * raise ValueError, f"Invalid shape in axis {idx}: {dim}." # <<<<<<<<<<<<<< - * self._shape[idx] = dim - * - */ - __pyx_t_5 = PyTuple_New(5); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_9 = 0; - __pyx_t_10 = 127; - __Pyx_INCREF(__pyx_kp_u_Invalid_shape_in_axis); - __pyx_t_9 += 22; - __Pyx_GIVEREF(__pyx_kp_u_Invalid_shape_in_axis); - PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_kp_u_Invalid_shape_in_axis); - __pyx_t_6 = __Pyx_PyUnicode_From_int(__pyx_v_idx, 0, ' ', 'd'); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_6); - __pyx_t_6 = 0; - __Pyx_INCREF(__pyx_kp_u_); - __pyx_t_9 += 2; - __Pyx_GIVEREF(__pyx_kp_u_); - PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_kp_u_); - __pyx_t_6 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_dim, 0, ' ', 'd'); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_6); - __pyx_t_6 = 0; - __Pyx_INCREF(__pyx_kp_u__2); - __pyx_t_9 += 1; - __Pyx_GIVEREF(__pyx_kp_u__2); - PyTuple_SET_ITEM(__pyx_t_5, 4, __pyx_kp_u__2); - __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_5, 5, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_Raise(__pyx_builtin_ValueError, __pyx_t_6, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(1, 161, __pyx_L1_error) - - /* "View.MemoryView":160 - * - * for idx, dim in enumerate(shape): - * if dim <= 0: # <<<<<<<<<<<<<< - * raise ValueError, f"Invalid shape in axis {idx}: {dim}." - * self._shape[idx] = dim - */ - } - - /* "View.MemoryView":162 - * if dim <= 0: - * raise ValueError, f"Invalid shape in axis {idx}: {dim}." - * self._shape[idx] = dim # <<<<<<<<<<<<<< - * - * cdef char order - */ - (__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim; - - /* "View.MemoryView":159 - * - * - * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< - * if dim <= 0: - * raise ValueError, f"Invalid shape in axis {idx}: {dim}." - */ - } - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - - /* "View.MemoryView":165 - * - * cdef char order - * if mode == 'c': # <<<<<<<<<<<<<< - * order = b'C' - * self.mode = u'c' - */ - __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_c, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 165, __pyx_L1_error) - if (__pyx_t_3) { - - /* "View.MemoryView":166 - * cdef char order - * if mode == 'c': - * order = b'C' # <<<<<<<<<<<<<< - * self.mode = u'c' - * elif mode == 'fortran': - */ - __pyx_v_order = 'C'; - - /* "View.MemoryView":167 - * if mode == 'c': - * order = b'C' - * self.mode = u'c' # <<<<<<<<<<<<<< - * elif mode == 'fortran': - * order = b'F' - */ - __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":165 - * - * cdef char order - * if mode == 'c': # <<<<<<<<<<<<<< - * order = b'C' - * self.mode = u'c' - */ - goto __pyx_L11; - } - - /* "View.MemoryView":168 - * order = b'C' - * self.mode = u'c' - * elif mode == 'fortran': # <<<<<<<<<<<<<< - * order = b'F' - * self.mode = u'fortran' - */ - __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_fortran, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 168, __pyx_L1_error) - if (likely(__pyx_t_3)) { - - /* "View.MemoryView":169 - * self.mode = u'c' - * elif mode == 'fortran': - * order = b'F' # <<<<<<<<<<<<<< - * self.mode = u'fortran' - * else: - */ - __pyx_v_order = 'F'; - - /* "View.MemoryView":170 - * elif mode == 'fortran': - * order = b'F' - * self.mode = u'fortran' # <<<<<<<<<<<<<< - * else: - * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}" - */ - __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; - - /* "View.MemoryView":168 - * order = b'C' - * self.mode = u'c' - * elif mode == 'fortran': # <<<<<<<<<<<<<< - * order = b'F' - * self.mode = u'fortran' - */ - goto __pyx_L11; - } - - /* "View.MemoryView":172 - * self.mode = u'fortran' - * else: - * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}" # <<<<<<<<<<<<<< - * - * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order) - */ - /*else*/ { - __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_v_mode, __pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 172, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Invalid_mode_expected_c_or_fortr, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 172, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_Raise(__pyx_builtin_ValueError, __pyx_t_6, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(1, 172, __pyx_L1_error) - } - __pyx_L11:; - - /* "View.MemoryView":174 - * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}" - * - * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order) # <<<<<<<<<<<<<< - * - * self.free_data = allocate_buffer - */ - __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); - - /* "View.MemoryView":176 - * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order) - * - * self.free_data = allocate_buffer # <<<<<<<<<<<<<< - * self.dtype_is_object = format == b'O' - * - */ - __pyx_v_self->free_data = __pyx_v_allocate_buffer; - - /* "View.MemoryView":177 - * - * self.free_data = allocate_buffer - * self.dtype_is_object = format == b'O' # <<<<<<<<<<<<<< - * - * if allocate_buffer: - */ - __pyx_t_6 = PyObject_RichCompare(__pyx_v_format, __pyx_n_b_O, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 177, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 177, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_v_self->dtype_is_object = __pyx_t_3; - - /* "View.MemoryView":179 - * self.dtype_is_object = format == b'O' - * - * if allocate_buffer: # <<<<<<<<<<<<<< - * _allocate_buffer(self) - * - */ - if (__pyx_v_allocate_buffer) { - - /* "View.MemoryView":180 - * - * if allocate_buffer: - * _allocate_buffer(self) # <<<<<<<<<<<<<< - * - * @cname('getbuffer') - */ - __pyx_t_7 = __pyx_array_allocate_buffer(__pyx_v_self); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(1, 180, __pyx_L1_error) - - /* "View.MemoryView":179 - * self.dtype_is_object = format == b'O' - * - * if allocate_buffer: # <<<<<<<<<<<<<< - * _allocate_buffer(self) - * - */ - } - - /* "View.MemoryView":131 - * cdef bint dtype_is_object - * - * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< - * mode="c", bint allocate_buffer=True): - * - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __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; -} - -/* "View.MemoryView":182 - * _allocate_buffer(self) - * - * @cname('getbuffer') # <<<<<<<<<<<<<< - * def __getbuffer__(self, Py_buffer *info, int flags): - * cdef int bufmode = -1 - */ - -/* Python wrapper */ -CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ -CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __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; - char *__pyx_t_2; - Py_ssize_t __pyx_t_3; - int __pyx_t_4; - Py_ssize_t *__pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - if (unlikely(__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); - - /* "View.MemoryView":184 - * @cname('getbuffer') - * def __getbuffer__(self, Py_buffer *info, int flags): - * cdef int bufmode = -1 # <<<<<<<<<<<<<< - * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): - * if self.mode == u"c": - */ - __pyx_v_bufmode = -1; - - /* "View.MemoryView":185 - * def __getbuffer__(self, Py_buffer *info, int flags): - * cdef int bufmode = -1 - * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): # <<<<<<<<<<<<<< - * if self.mode == u"c": - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - */ - __pyx_t_1 = ((__pyx_v_flags & ((PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS) | PyBUF_ANY_CONTIGUOUS)) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":186 - * cdef int bufmode = -1 - * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): - * if self.mode == u"c": # <<<<<<<<<<<<<< - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * elif self.mode == u"fortran": - */ - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_c, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 186, __pyx_L1_error) - if (__pyx_t_1) { - - /* "View.MemoryView":187 - * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): - * 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); - - /* "View.MemoryView":186 - * cdef int bufmode = -1 - * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): - * if self.mode == u"c": # <<<<<<<<<<<<<< - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * elif self.mode == u"fortran": - */ - goto __pyx_L4; - } - - /* "View.MemoryView":188 - * 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_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_fortran, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 188, __pyx_L1_error) - if (__pyx_t_1) { - - /* "View.MemoryView":189 - * 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":188 - * 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_L4:; - - /* "View.MemoryView":190 - * 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)); - if (unlikely(__pyx_t_1)) { - - /* "View.MemoryView":191 - * 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_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Can_only_create_a_buffer_that_is, 0, 0); - __PYX_ERR(1, 191, __pyx_L1_error) - - /* "View.MemoryView":190 - * 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":185 - * def __getbuffer__(self, Py_buffer *info, int flags): - * cdef int bufmode = -1 - * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): # <<<<<<<<<<<<<< - * if self.mode == u"c": - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - */ - } - - /* "View.MemoryView":192 - * 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_2 = __pyx_v_self->data; - __pyx_v_info->buf = __pyx_t_2; - - /* "View.MemoryView":193 - * raise ValueError, "Can only create a buffer that is contiguous in memory." - * info.buf = self.data - * info.len = self.len # <<<<<<<<<<<<<< - * - * if flags & PyBUF_STRIDES: - */ - __pyx_t_3 = __pyx_v_self->len; - __pyx_v_info->len = __pyx_t_3; - - /* "View.MemoryView":195 - * info.len = self.len - * - * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< - * info.ndim = self.ndim - * info.shape = self._shape - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":196 - * - * if flags & PyBUF_STRIDES: - * info.ndim = self.ndim # <<<<<<<<<<<<<< - * info.shape = self._shape - * info.strides = self._strides - */ - __pyx_t_4 = __pyx_v_self->ndim; - __pyx_v_info->ndim = __pyx_t_4; - - /* "View.MemoryView":197 - * if flags & PyBUF_STRIDES: - * info.ndim = self.ndim - * info.shape = self._shape # <<<<<<<<<<<<<< - * info.strides = self._strides - * else: - */ - __pyx_t_5 = __pyx_v_self->_shape; - __pyx_v_info->shape = __pyx_t_5; - - /* "View.MemoryView":198 - * info.ndim = self.ndim - * info.shape = self._shape - * info.strides = self._strides # <<<<<<<<<<<<<< - * else: - * info.ndim = 1 - */ - __pyx_t_5 = __pyx_v_self->_strides; - __pyx_v_info->strides = __pyx_t_5; - - /* "View.MemoryView":195 - * info.len = self.len - * - * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< - * info.ndim = self.ndim - * info.shape = self._shape - */ - goto __pyx_L6; - } - - /* "View.MemoryView":200 - * info.strides = self._strides - * else: - * info.ndim = 1 # <<<<<<<<<<<<<< - * info.shape = &self.len if flags & PyBUF_ND else NULL - * info.strides = NULL - */ - /*else*/ { - __pyx_v_info->ndim = 1; - - /* "View.MemoryView":201 - * else: - * info.ndim = 1 - * info.shape = &self.len if flags & PyBUF_ND else NULL # <<<<<<<<<<<<<< - * info.strides = NULL - * - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0); - if (__pyx_t_1) { - __pyx_t_5 = (&__pyx_v_self->len); - } else { - __pyx_t_5 = NULL; - } - __pyx_v_info->shape = __pyx_t_5; - - /* "View.MemoryView":202 - * info.ndim = 1 - * info.shape = &self.len if flags & PyBUF_ND else NULL - * info.strides = NULL # <<<<<<<<<<<<<< - * - * info.suboffsets = NULL - */ - __pyx_v_info->strides = NULL; - } - __pyx_L6:; - - /* "View.MemoryView":204 - * info.strides = NULL - * - * info.suboffsets = NULL # <<<<<<<<<<<<<< - * info.itemsize = self.itemsize - * info.readonly = 0 - */ - __pyx_v_info->suboffsets = NULL; - - /* "View.MemoryView":205 - * - * info.suboffsets = NULL - * info.itemsize = self.itemsize # <<<<<<<<<<<<<< - * info.readonly = 0 - * info.format = self.format if flags & PyBUF_FORMAT else NULL - */ - __pyx_t_3 = __pyx_v_self->itemsize; - __pyx_v_info->itemsize = __pyx_t_3; - - /* "View.MemoryView":206 - * info.suboffsets = NULL - * info.itemsize = self.itemsize - * info.readonly = 0 # <<<<<<<<<<<<<< - * info.format = self.format if flags & PyBUF_FORMAT else NULL - * info.obj = self - */ - __pyx_v_info->readonly = 0; - - /* "View.MemoryView":207 - * info.itemsize = self.itemsize - * info.readonly = 0 - * info.format = self.format if flags & PyBUF_FORMAT else NULL # <<<<<<<<<<<<<< - * info.obj = self - * - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); - if (__pyx_t_1) { - __pyx_t_2 = __pyx_v_self->format; - } else { - __pyx_t_2 = NULL; - } - __pyx_v_info->format = __pyx_t_2; - - /* "View.MemoryView":208 - * info.readonly = 0 - * info.format = self.format if flags & PyBUF_FORMAT else NULL - * info.obj = self # <<<<<<<<<<<<<< - * - * def __dealloc__(array self): - */ - __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":182 - * _allocate_buffer(self) - * - * @cname('getbuffer') # <<<<<<<<<<<<<< - * def __getbuffer__(self, Py_buffer *info, int flags): - * cdef int bufmode = -1 - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __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":210 - * info.obj = self - * - * def __dealloc__(array self): # <<<<<<<<<<<<<< - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) - */ - -/* Python wrapper */ -static void __pyx_array___dealloc__(PyObject *__pyx_v_self); /*proto*/ -static void __pyx_array___dealloc__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __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) { - int __pyx_t_1; - int __pyx_t_2; - - /* "View.MemoryView":211 - * - * def __dealloc__(array self): - * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< - * self.callback_free_data(self.data) - * elif self.free_data and self.data is not NULL: - */ - __pyx_t_1 = (__pyx_v_self->callback_free_data != NULL); - if (__pyx_t_1) { - - /* "View.MemoryView":212 - * def __dealloc__(array self): - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) # <<<<<<<<<<<<<< - * elif self.free_data and self.data is not NULL: - * if self.dtype_is_object: - */ - __pyx_v_self->callback_free_data(__pyx_v_self->data); - - /* "View.MemoryView":211 - * - * def __dealloc__(array self): - * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< - * self.callback_free_data(self.data) - * elif self.free_data and self.data is not NULL: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":213 - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) - * elif self.free_data and self.data is not NULL: # <<<<<<<<<<<<<< - * if self.dtype_is_object: - * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) - */ - if (__pyx_v_self->free_data) { - } else { - __pyx_t_1 = __pyx_v_self->free_data; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_2 = (__pyx_v_self->data != NULL); - __pyx_t_1 = __pyx_t_2; - __pyx_L4_bool_binop_done:; - if (__pyx_t_1) { - - /* "View.MemoryView":214 - * self.callback_free_data(self.data) - * elif self.free_data and self.data is not NULL: - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) - * free(self.data) - */ - if (__pyx_v_self->dtype_is_object) { - - /* "View.MemoryView":215 - * elif self.free_data and self.data is not NULL: - * if self.dtype_is_object: - * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) # <<<<<<<<<<<<<< - * free(self.data) - * PyObject_Free(self._shape) - */ - __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":214 - * self.callback_free_data(self.data) - * elif self.free_data and self.data is not NULL: - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) - * free(self.data) - */ - } - - /* "View.MemoryView":216 - * if self.dtype_is_object: - * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) - * free(self.data) # <<<<<<<<<<<<<< - * PyObject_Free(self._shape) - * - */ - free(__pyx_v_self->data); - - /* "View.MemoryView":213 - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) - * elif self.free_data and self.data is not NULL: # <<<<<<<<<<<<<< - * if self.dtype_is_object: - * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) - */ - } - __pyx_L3:; - - /* "View.MemoryView":217 - * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) - * free(self.data) - * PyObject_Free(self._shape) # <<<<<<<<<<<<<< - * - * @property - */ - PyObject_Free(__pyx_v_self->_shape); - - /* "View.MemoryView":210 - * info.obj = self - * - * def __dealloc__(array self): # <<<<<<<<<<<<<< - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) - */ - - /* function exit code */ -} - -/* "View.MemoryView":219 - * PyObject_Free(self._shape) - * - * @property # <<<<<<<<<<<<<< - * def memview(self): - * return self.get_memview() - */ - -/* 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) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 1); - - /* "View.MemoryView":221 - * @property - * def memview(self): - * return self.get_memview() # <<<<<<<<<<<<<< - * - * @cname('get_memview') - */ - __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(1, 221, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "View.MemoryView":219 - * PyObject_Free(self._shape) - * - * @property # <<<<<<<<<<<<<< - * def memview(self): - * return self.get_memview() - */ - - /* 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":224 - * - * @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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_memview", 1); - - /* "View.MemoryView":225 - * @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":226 - * 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(1, 226, __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(1, 226, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 226, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF((PyObject *)__pyx_v_self); - __Pyx_GIVEREF((PyObject *)__pyx_v_self); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self))) __PYX_ERR(1, 226, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 226, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2)) __PYX_ERR(1, 226, __pyx_L1_error); - __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(1, 226, __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":224 - * - * @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":228 - * 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) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - Py_ssize_t __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __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; - - /* "View.MemoryView":229 - * - * def __len__(self): - * return self._shape[0] # <<<<<<<<<<<<<< - * - * def __getattr__(self, attr): - */ - __pyx_r = (__pyx_v_self->_shape[0]); - goto __pyx_L0; - - /* "View.MemoryView":228 - * return memoryview(self, flags, self.dtype_is_object) - * - * def __len__(self): # <<<<<<<<<<<<<< - * return self._shape[0] - * - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":231 - * return self._shape[0] - * - * def __getattr__(self, attr): # <<<<<<<<<<<<<< - * return getattr(self.memview, attr) - * - */ - -/* 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) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__getattr__", 1); - - /* "View.MemoryView":232 - * - * def __getattr__(self, attr): - * return getattr(self.memview, attr) # <<<<<<<<<<<<<< - * - * def __getitem__(self, item): - */ - __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(1, 232, __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(1, 232, __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":231 - * return self._shape[0] - * - * def __getattr__(self, attr): # <<<<<<<<<<<<<< - * return getattr(self.memview, attr) - * - */ - - /* 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":234 - * return getattr(self.memview, attr) - * - * def __getitem__(self, item): # <<<<<<<<<<<<<< - * return self.memview[item] - * - */ - -/* 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) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__getitem__", 1); - - /* "View.MemoryView":235 - * - * def __getitem__(self, item): - * return self.memview[item] # <<<<<<<<<<<<<< - * - * def __setitem__(self, item, value): - */ - __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(1, 235, __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(1, 235, __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":234 - * return getattr(self.memview, attr) - * - * def __getitem__(self, item): # <<<<<<<<<<<<<< - * return self.memview[item] - * - */ - - /* 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":237 - * return self.memview[item] - * - * def __setitem__(self, item, value): # <<<<<<<<<<<<<< - * self.memview[item] = value - * - */ - -/* 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) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __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; -} - -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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setitem__", 1); - - /* "View.MemoryView":238 - * - * def __setitem__(self, item, value): - * self.memview[item] = value # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 238, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_v_item, __pyx_v_value) < 0))) __PYX_ERR(1, 238, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "View.MemoryView":237 - * return self.memview[item] - * - * def __setitem__(self, item, value): # <<<<<<<<<<<<<< - * self.memview[item] = value - * - */ - - /* 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; -} - -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" - * def __setstate_cython__(self, __pyx_state): - */ - -/* Python wrapper */ -static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; - __pyx_r = __pyx_pf___pyx_array___reduce_cython__(((struct __pyx_array_obj *)__pyx_v_self)); - - /* 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) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__reduce_cython__", 1); - - /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); - __PYX_ERR(1, 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): - */ - - /* function exit code */ - __pyx_L1_error:; - __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; -} - -/* "(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, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v___pyx_state = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf___pyx_array_2__setstate_cython__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v___pyx_state); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __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 - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setstate_cython__", 1); - - /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); - __PYX_ERR(1, 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_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":248 - * - * @cname("__pyx_array_allocate_buffer") - * cdef int _allocate_buffer(array self) except -1: # <<<<<<<<<<<<<< - * - * - */ - -static int __pyx_array_allocate_buffer(struct __pyx_array_obj *__pyx_v_self) { - Py_ssize_t __pyx_v_i; - PyObject **__pyx_v_p; - int __pyx_r; - int __pyx_t_1; - Py_ssize_t __pyx_t_2; - Py_ssize_t __pyx_t_3; - Py_ssize_t __pyx_t_4; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - - /* "View.MemoryView":254 - * cdef PyObject **p - * - * self.free_data = True # <<<<<<<<<<<<<< - * self.data = malloc(self.len) - * if not self.data: - */ - __pyx_v_self->free_data = 1; - - /* "View.MemoryView":255 - * - * self.free_data = True - * 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":256 - * self.free_data = True - * self.data = malloc(self.len) - * if not self.data: # <<<<<<<<<<<<<< - * raise MemoryError, "unable to allocate array data." - * - */ - __pyx_t_1 = (!(__pyx_v_self->data != 0)); - if (unlikely(__pyx_t_1)) { - - /* "View.MemoryView":257 - * self.data = malloc(self.len) - * if not self.data: - * raise MemoryError, "unable to allocate array data." # <<<<<<<<<<<<<< - * - * if self.dtype_is_object: - */ - __Pyx_Raise(__pyx_builtin_MemoryError, __pyx_kp_s_unable_to_allocate_array_data, 0, 0); - __PYX_ERR(1, 257, __pyx_L1_error) - - /* "View.MemoryView":256 - * self.free_data = True - * self.data = malloc(self.len) - * if not self.data: # <<<<<<<<<<<<<< - * raise MemoryError, "unable to allocate array data." - * - */ - } - - /* "View.MemoryView":259 - * raise MemoryError, "unable to allocate array data." - * - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * p = self.data - * for i in range(self.len // self.itemsize): - */ - if (__pyx_v_self->dtype_is_object) { - - /* "View.MemoryView":260 - * - * if self.dtype_is_object: - * p = self.data # <<<<<<<<<<<<<< - * for i in range(self.len // self.itemsize): - * p[i] = Py_None - */ - __pyx_v_p = ((PyObject **)__pyx_v_self->data); - - /* "View.MemoryView":261 - * if self.dtype_is_object: - * p = self.data - * for i in range(self.len // self.itemsize): # <<<<<<<<<<<<<< - * p[i] = Py_None - * Py_INCREF(Py_None) - */ - if (unlikely(__pyx_v_self->itemsize == 0)) { - PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); - __PYX_ERR(1, 261, __pyx_L1_error) - } - else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_self->itemsize == (Py_ssize_t)-1) && unlikely(__Pyx_UNARY_NEG_WOULD_OVERFLOW(__pyx_v_self->len))) { - PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); - __PYX_ERR(1, 261, __pyx_L1_error) - } - __pyx_t_2 = __Pyx_div_Py_ssize_t(__pyx_v_self->len, __pyx_v_self->itemsize); - __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":262 - * p = self.data - * for i in range(self.len // self.itemsize): - * p[i] = Py_None # <<<<<<<<<<<<<< - * Py_INCREF(Py_None) - * return 0 - */ - (__pyx_v_p[__pyx_v_i]) = Py_None; - - /* "View.MemoryView":263 - * for i in range(self.len // self.itemsize): - * p[i] = Py_None - * Py_INCREF(Py_None) # <<<<<<<<<<<<<< - * return 0 - * - */ - Py_INCREF(Py_None); - } - - /* "View.MemoryView":259 - * raise MemoryError, "unable to allocate array data." - * - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * p = self.data - * for i in range(self.len // self.itemsize): - */ - } - - /* "View.MemoryView":264 - * p[i] = Py_None - * Py_INCREF(Py_None) - * return 0 # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = 0; - goto __pyx_L0; - - /* "View.MemoryView":248 - * - * @cname("__pyx_array_allocate_buffer") - * cdef int _allocate_buffer(array self) except -1: # <<<<<<<<<<<<<< - * - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("View.MemoryView._allocate_buffer", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":268 - * - * @cname("__pyx_array_new") - * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, char *c_mode, char *buf): # <<<<<<<<<<<<<< - * cdef array result - * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. - */ - -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_c_mode, char *__pyx_v_buf) { - struct __pyx_array_obj *__pyx_v_result = 0; - PyObject *__pyx_v_mode = 0; - struct __pyx_array_obj *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - 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("array_cwrapper", 1); - - /* "View.MemoryView":270 - * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, char *c_mode, char *buf): - * cdef array result - * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. # <<<<<<<<<<<<<< - * - * if buf is NULL: - */ - __pyx_t_2 = ((__pyx_v_c_mode[0]) == 'f'); - if (__pyx_t_2) { - __Pyx_INCREF(__pyx_n_s_fortran); - __pyx_t_1 = __pyx_n_s_fortran; - } else { - __Pyx_INCREF(__pyx_n_s_c); - __pyx_t_1 = __pyx_n_s_c; - } - __pyx_v_mode = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - - /* "View.MemoryView":272 - * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. - * - * if buf is NULL: # <<<<<<<<<<<<<< - * result = array.__new__(array, shape, itemsize, format, mode) - * else: - */ - __pyx_t_2 = (__pyx_v_buf == NULL); - if (__pyx_t_2) { - - /* "View.MemoryView":273 - * - * if buf is NULL: - * result = array.__new__(array, shape, itemsize, format, mode) # <<<<<<<<<<<<<< - * else: - * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False) - */ - __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 273, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 273, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 273, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_INCREF(__pyx_v_shape); - __Pyx_GIVEREF(__pyx_v_shape); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_shape)) __PYX_ERR(1, 273, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(1, 273, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3)) __PYX_ERR(1, 273, __pyx_L1_error); - __Pyx_INCREF(__pyx_v_mode); - __Pyx_GIVEREF(__pyx_v_mode); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_v_mode)) __PYX_ERR(1, 273, __pyx_L1_error); - __pyx_t_1 = 0; - __pyx_t_3 = 0; - __pyx_t_3 = ((PyObject *)__pyx_tp_new_array(((PyTypeObject *)__pyx_array_type), __pyx_t_4, NULL)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 273, __pyx_L1_error) - __Pyx_GOTREF((PyObject *)__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_3); - __pyx_t_3 = 0; - - /* "View.MemoryView":272 - * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. - * - * if buf is NULL: # <<<<<<<<<<<<<< - * result = array.__new__(array, shape, itemsize, format, mode) - * else: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":275 - * result = array.__new__(array, shape, itemsize, format, mode) - * else: - * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False) # <<<<<<<<<<<<<< - * result.data = buf - * - */ - /*else*/ { - __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 275, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 275, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 275, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_shape); - __Pyx_GIVEREF(__pyx_v_shape); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_shape)) __PYX_ERR(1, 275, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3)) __PYX_ERR(1, 275, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_t_4)) __PYX_ERR(1, 275, __pyx_L1_error); - __Pyx_INCREF(__pyx_v_mode); - __Pyx_GIVEREF(__pyx_v_mode); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_v_mode)) __PYX_ERR(1, 275, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 275, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_allocate_buffer, Py_False) < 0) __PYX_ERR(1, 275, __pyx_L1_error) - __pyx_t_3 = ((PyObject *)__pyx_tp_new_array(((PyTypeObject *)__pyx_array_type), __pyx_t_1, __pyx_t_4)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 275, __pyx_L1_error) - __Pyx_GOTREF((PyObject *)__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_3); - __pyx_t_3 = 0; - - /* "View.MemoryView":276 - * else: - * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False) - * result.data = buf # <<<<<<<<<<<<<< - * - * return result - */ - __pyx_v_result->data = __pyx_v_buf; - } - __pyx_L3:; - - /* "View.MemoryView":278 - * result.data = buf - * - * return result # <<<<<<<<<<<<<< - * - * - */ - __Pyx_XDECREF((PyObject *)__pyx_r); - __Pyx_INCREF((PyObject *)__pyx_v_result); - __pyx_r = __pyx_v_result; - goto __pyx_L0; - - /* "View.MemoryView":268 - * - * @cname("__pyx_array_new") - * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, char *c_mode, char *buf): # <<<<<<<<<<<<<< - * cdef array result - * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("View.MemoryView.array_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_result); - __Pyx_XDECREF(__pyx_v_mode); - __Pyx_XGIVEREF((PyObject *)__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":304 - * cdef class Enum(object): - * cdef object name - * def __init__(self, name): # <<<<<<<<<<<<<< - * self.name = name - * def __repr__(self): - */ - -/* 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; - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; - #endif - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { - (void)__Pyx_Arg_NewRef_VARARGS(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 304, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(1, 304, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - } - __pyx_v_name = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 304, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); - } - } - __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 */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); - } - } - __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) { - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__", 1); - - /* "View.MemoryView":305 - * cdef object name - * def __init__(self, name): - * self.name = name # <<<<<<<<<<<<<< - * def __repr__(self): - * return self.name - */ - __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":304 - * 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":306 - * def __init__(self, name): - * self.name = name - * def __repr__(self): # <<<<<<<<<<<<<< - * return self.name - * - */ - -/* Python wrapper */ -static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __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_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__", 1); - - /* "View.MemoryView":307 - * self.name = name - * def __repr__(self): - * return self.name # <<<<<<<<<<<<<< - * - * cdef generic = Enum("") - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->name); - __pyx_r = __pyx_v_self->name; - goto __pyx_L0; - - /* "View.MemoryView":306 - * def __init__(self, name): - * self.name = name - * def __repr__(self): # <<<<<<<<<<<<<< - * return self.name - * - */ - - /* function exit code */ - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ - -/* Python wrapper */ -static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; - __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_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; - 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("__reduce_cython__", 1); - - /* "(tree fragment)":5 - * cdef object _dict - * cdef bint use_setstate - * state = (self.name,) # <<<<<<<<<<<<<< - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: - */ - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_self->name); - __Pyx_GIVEREF(__pyx_v_self->name); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->name)) __PYX_ERR(1, 5, __pyx_L1_error); - __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,) - */ - __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v__dict = __pyx_t_1; - __pyx_t_1 = 0; - - /* "(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); - if (__pyx_t_2) { - - /* "(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(1, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v__dict); - __Pyx_GIVEREF(__pyx_v__dict); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(1, 8, __pyx_L1_error); - __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); - __pyx_t_3 = 0; - - /* "(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; - - /* "(tree fragment)":7 - * state = (self.name,) - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True - */ - 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), 0x82a3537, None), state - */ - /*else*/ { - __pyx_t_2 = (__pyx_v_self->name != Py_None); - __pyx_v_use_setstate = __pyx_t_2; - } - __pyx_L3:; - - /* "(tree fragment)":12 - * else: - * use_setstate = self.name is not None - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state - * else: - */ - if (__pyx_v_use_setstate) { - - /* "(tree fragment)":13 - * use_setstate = self.name is not None - * if use_setstate: - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state # <<<<<<<<<<<<<< - * else: - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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)))); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(1, 13, __pyx_L1_error); - __Pyx_INCREF(__pyx_int_136983863); - __Pyx_GIVEREF(__pyx_int_136983863); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_136983863)) __PYX_ERR(1, 13, __pyx_L1_error); - __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(Py_None); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(1, 13, __pyx_L1_error); - __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(1, 13, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_1 = 0; - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; - goto __pyx_L0; - - /* "(tree fragment)":12 - * else: - * use_setstate = self.name is not None - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state - * else: - */ - } - - /* "(tree fragment)":15 - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state - * else: - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_Enum__set_state(self, __pyx_state) - */ - /*else*/ { - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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)))); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(1, 15, __pyx_L1_error); - __Pyx_INCREF(__pyx_int_136983863); - __Pyx_GIVEREF(__pyx_int_136983863); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_136983863)) __PYX_ERR(1, 15, __pyx_L1_error); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(1, 15, __pyx_L1_error); - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error); - __pyx_t_4 = 0; - __pyx_t_1 = 0; - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L0; - } - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __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)":16 - * else: - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_Enum__set_state(self, __pyx_state) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - PyObject *__pyx_v___pyx_state = 0; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 16, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 16, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v___pyx_state = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v___pyx_state); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __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; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setstate_cython__", 1); - - /* "(tree fragment)":17 - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_Enum__set_state(self, __pyx_state) # <<<<<<<<<<<<<< - */ - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 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(1, 17, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "(tree fragment)":16 - * else: - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, 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.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":349 - * 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_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; - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[3] = {0,0,0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; - #endif - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_obj,&__pyx_n_s_flags,&__pyx_n_s_dtype_is_object,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_obj)) != 0)) { - (void)__Pyx_Arg_NewRef_VARARGS(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_flags)) != 0)) { - (void)__Pyx_Arg_NewRef_VARARGS(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, 1); __PYX_ERR(1, 349, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dtype_is_object); - if (value) { values[2] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(1, 349, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); - values[0] = __Pyx_Arg_VARARGS(__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(1, 349, __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(1, 349, __pyx_L3_error) - } else { - __pyx_v_dtype_is_object = ((int)0); - } - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, __pyx_nargs); __PYX_ERR(1, 349, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); - } - } - __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); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); - } - } - __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; - Py_intptr_t __pyx_t_4; - size_t __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__cinit__", 1); - - /* "View.MemoryView":350 - * - * 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_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":351 - * 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; - - /* "View.MemoryView":352 - * 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)); - if (!__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_2 = (__pyx_v_obj != Py_None); - __pyx_t_1 = __pyx_t_2; - __pyx_L4_bool_binop_done:; - if (__pyx_t_1) { - - /* "View.MemoryView":353 - * 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_3 = __Pyx_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 353, __pyx_L1_error) - - /* "View.MemoryView":354 - * 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); - if (__pyx_t_1) { - - /* "View.MemoryView":355 - * __Pyx_GetBuffer(obj, &self.view, flags) - * if self.view.obj == NULL: - * (<__pyx_buffer *> &self.view).obj = Py_None # <<<<<<<<<<<<<< - * Py_INCREF(Py_None) - * - */ - ((Py_buffer *)(&__pyx_v_self->view))->obj = Py_None; - - /* "View.MemoryView":356 - * if self.view.obj == NULL: - * (<__pyx_buffer *> &self.view).obj = Py_None - * Py_INCREF(Py_None) # <<<<<<<<<<<<<< - * - * if not __PYX_CYTHON_ATOMICS_ENABLED(): - */ - Py_INCREF(Py_None); - - /* "View.MemoryView":354 - * 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":352 - * 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":358 - * Py_INCREF(Py_None) - * - * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< - * global __pyx_memoryview_thread_locks_used - * if __pyx_memoryview_thread_locks_used < 8: - */ - __pyx_t_1 = (!__PYX_CYTHON_ATOMICS_ENABLED()); - if (__pyx_t_1) { - - /* "View.MemoryView":360 - * if not __PYX_CYTHON_ATOMICS_ENABLED(): - * global __pyx_memoryview_thread_locks_used - * if __pyx_memoryview_thread_locks_used < 8: # <<<<<<<<<<<<<< - * 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); - if (__pyx_t_1) { - - /* "View.MemoryView":361 - * global __pyx_memoryview_thread_locks_used - * if __pyx_memoryview_thread_locks_used < 8: - * 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":362 - * if __pyx_memoryview_thread_locks_used < 8: - * 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":360 - * if not __PYX_CYTHON_ATOMICS_ENABLED(): - * global __pyx_memoryview_thread_locks_used - * if __pyx_memoryview_thread_locks_used < 8: # <<<<<<<<<<<<<< - * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] - * __pyx_memoryview_thread_locks_used += 1 - */ - } - - /* "View.MemoryView":363 - * 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); - if (__pyx_t_1) { - - /* "View.MemoryView":364 - * __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":365 - * 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); - if (unlikely(__pyx_t_1)) { - - /* "View.MemoryView":366 - * self.lock = PyThread_allocate_lock() - * if self.lock is NULL: - * raise MemoryError # <<<<<<<<<<<<<< - * - * if flags & PyBUF_FORMAT: - */ - PyErr_NoMemory(); __PYX_ERR(1, 366, __pyx_L1_error) - - /* "View.MemoryView":365 - * if self.lock is NULL: - * self.lock = PyThread_allocate_lock() - * if self.lock is NULL: # <<<<<<<<<<<<<< - * raise MemoryError - * - */ - } - - /* "View.MemoryView":363 - * 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":358 - * Py_INCREF(Py_None) - * - * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< - * global __pyx_memoryview_thread_locks_used - * if __pyx_memoryview_thread_locks_used < 8: - */ - } - - /* "View.MemoryView":368 - * 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":369 - * - * 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'); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L12_bool_binop_done; - } - __pyx_t_2 = ((__pyx_v_self->view.format[1]) == '\x00'); - __pyx_t_1 = __pyx_t_2; - __pyx_L12_bool_binop_done:; - __pyx_v_self->dtype_is_object = __pyx_t_1; - - /* "View.MemoryView":368 - * 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_L11; - } - - /* "View.MemoryView":371 - * 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 # <<<<<<<<<<<<<< - * - * assert (&self.acquisition_count) % sizeof(__pyx_atomic_int_type) == 0 - */ - /*else*/ { - __pyx_v_self->dtype_is_object = __pyx_v_dtype_is_object; - } - __pyx_L11:; - - /* "View.MemoryView":373 - * self.dtype_is_object = dtype_is_object - * - * assert (&self.acquisition_count) % sizeof(__pyx_atomic_int_type) == 0 # <<<<<<<<<<<<<< - * self.typeinfo = NULL - * - */ - #ifndef CYTHON_WITHOUT_ASSERTIONS - if (unlikely(__pyx_assertions_enabled())) { - __pyx_t_4 = ((Py_intptr_t)((void *)(&__pyx_v_self->acquisition_count))); - __pyx_t_5 = (sizeof(__pyx_atomic_int_type)); - if (unlikely(__pyx_t_5 == 0)) { - PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); - __PYX_ERR(1, 373, __pyx_L1_error) - } - __pyx_t_1 = ((__pyx_t_4 % __pyx_t_5) == 0); - if (unlikely(!__pyx_t_1)) { - __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); - __PYX_ERR(1, 373, __pyx_L1_error) - } - } - #else - if ((1)); else __PYX_ERR(1, 373, __pyx_L1_error) - #endif - - /* "View.MemoryView":374 - * - * assert (&self.acquisition_count) % sizeof(__pyx_atomic_int_type) == 0 - * self.typeinfo = NULL # <<<<<<<<<<<<<< - * - * def __dealloc__(memoryview self): - */ - __pyx_v_self->typeinfo = NULL; - - /* "View.MemoryView":349 - * 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; -} - -/* "View.MemoryView":376 - * self.typeinfo = NULL - * - * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< - * if self.obj is not None: - * __Pyx_ReleaseBuffer(&self.view) - */ - -/* Python wrapper */ -static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self); /*proto*/ -static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self) { - int __pyx_v_i; - int __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - int __pyx_t_4; - PyThread_type_lock __pyx_t_5; - PyThread_type_lock __pyx_t_6; - - /* "View.MemoryView":377 - * - * 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); - if (__pyx_t_1) { - - /* "View.MemoryView":378 - * def __dealloc__(memoryview self): - * if self.obj is not None: - * __Pyx_ReleaseBuffer(&self.view) # <<<<<<<<<<<<<< - * elif (<__pyx_buffer *> &self.view).obj == Py_None: - * - */ - __Pyx_ReleaseBuffer((&__pyx_v_self->view)); - - /* "View.MemoryView":377 - * - * 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":379 - * 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_1 = (((Py_buffer *)(&__pyx_v_self->view))->obj == Py_None); - if (__pyx_t_1) { - - /* "View.MemoryView":381 - * 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":382 - * - * (<__pyx_buffer *> &self.view).obj = NULL - * Py_DECREF(Py_None) # <<<<<<<<<<<<<< - * - * cdef int i - */ - Py_DECREF(Py_None); - - /* "View.MemoryView":379 - * 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":386 - * 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_1 = (__pyx_v_self->lock != NULL); - if (__pyx_t_1) { - - /* "View.MemoryView":387 - * 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_2 = __pyx_memoryview_thread_locks_used; - __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":388 - * 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_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock); - if (__pyx_t_1) { - - /* "View.MemoryView":389 - * 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":390 - * 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_1 = (__pyx_v_i != __pyx_memoryview_thread_locks_used); - if (__pyx_t_1) { - - /* "View.MemoryView":392 - * 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_5 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); - __pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_v_i]); - - /* "View.MemoryView":391 - * __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_5; - (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_6; - - /* "View.MemoryView":390 - * 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":393 - * __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; - - /* "View.MemoryView":388 - * 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: - */ - } - } - /*else*/ { - - /* "View.MemoryView":395 - * 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":386 - * 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":376 - * self.typeinfo = NULL - * - * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< - * if self.obj is not None: - * __Pyx_ReleaseBuffer(&self.view) - */ - - /* function exit code */ -} - -/* "View.MemoryView":397 - * 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 - */ - -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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_item_pointer", 1); - - /* "View.MemoryView":399 - * 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":401 - * 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(1, 401, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 401, __pyx_L1_error) - } - for (;;) { - if (likely(!__pyx_t_4)) { - if (likely(PyList_CheckExact(__pyx_t_2))) { - { - Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 401, __pyx_L1_error) - #endif - if (__pyx_t_3 >= __pyx_temp) 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(1, 401, __pyx_L1_error) - #else - __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 401, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - #endif - } else { - { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 401, __pyx_L1_error) - #endif - if (__pyx_t_3 >= __pyx_temp) 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(1, 401, __pyx_L1_error) - #else - __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 401, __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(1, 401, __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":402 - * - * 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(1, 402, __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(1, 402, __pyx_L1_error) - __pyx_v_itemp = __pyx_t_7; - - /* "View.MemoryView":401 - * 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":404 - * itemp = pybuffer_index(&self.view, itemp, idx, dim) - * - * return itemp # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = __pyx_v_itemp; - goto __pyx_L0; - - /* "View.MemoryView":397 - * 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":407 - * - * - * 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) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __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 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; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - char *__pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__getitem__", 1); - - /* "View.MemoryView":408 - * - * def __getitem__(memoryview self, object index): - * if index is Ellipsis: # <<<<<<<<<<<<<< - * return self - * - */ - __pyx_t_1 = (__pyx_v_index == __pyx_builtin_Ellipsis); - if (__pyx_t_1) { - - /* "View.MemoryView":409 - * def __getitem__(memoryview self, object index): - * if index is Ellipsis: - * return self # <<<<<<<<<<<<<< - * - * have_slices, indices = _unellipsify(index, self.view.ndim) - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF((PyObject *)__pyx_v_self); - __pyx_r = ((PyObject *)__pyx_v_self); - goto __pyx_L0; - - /* "View.MemoryView":408 - * - * def __getitem__(memoryview self, object index): - * if index is Ellipsis: # <<<<<<<<<<<<<< - * return self - * - */ - } - - /* "View.MemoryView":411 - * return self - * - * have_slices, indices = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< - * - * cdef char *itemp - */ - __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 411, __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(1, 411, __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, 411, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 411, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } else { - __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 411, __pyx_L1_error) - } - __pyx_v_have_slices = __pyx_t_3; - __pyx_t_3 = 0; - __pyx_v_indices = __pyx_t_4; - __pyx_t_4 = 0; - - /* "View.MemoryView":414 - * - * cdef char *itemp - * if have_slices: # <<<<<<<<<<<<<< - * return memview_slice(self, indices) - * else: - */ - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 414, __pyx_L1_error) - if (__pyx_t_1) { - - /* "View.MemoryView":415 - * cdef char *itemp - * if have_slices: - * return memview_slice(self, indices) # <<<<<<<<<<<<<< - * else: - * itemp = self.get_item_pointer(indices) - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 415, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":414 - * - * cdef char *itemp - * if have_slices: # <<<<<<<<<<<<<< - * return memview_slice(self, indices) - * else: - */ - } - - /* "View.MemoryView":417 - * return memview_slice(self, indices) - * else: - * itemp = self.get_item_pointer(indices) # <<<<<<<<<<<<<< - * return self.convert_item_to_object(itemp) - * - */ - /*else*/ { - __pyx_t_5 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_5 == ((char *)NULL))) __PYX_ERR(1, 417, __pyx_L1_error) - __pyx_v_itemp = __pyx_t_5; - - /* "View.MemoryView":418 - * 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_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 418, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - } - - /* "View.MemoryView":407 - * - * - * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< - * if index is Ellipsis: - * return self - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __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":420 - * 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) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __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 - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setitem__", 0); - __Pyx_INCREF(__pyx_v_index); - - /* "View.MemoryView":421 - * - * def __setitem__(memoryview self, object index, object value): - * if self.view.readonly: # <<<<<<<<<<<<<< - * raise TypeError, "Cannot assign to read-only memoryview" - * - */ - if (unlikely(__pyx_v_self->view.readonly)) { - - /* "View.MemoryView":422 - * 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_Cannot_assign_to_read_only_memor, 0, 0); - __PYX_ERR(1, 422, __pyx_L1_error) - - /* "View.MemoryView":421 - * - * def __setitem__(memoryview self, object index, object value): - * if self.view.readonly: # <<<<<<<<<<<<<< - * raise TypeError, "Cannot assign to read-only memoryview" - * - */ - } - - /* "View.MemoryView":424 - * raise TypeError, "Cannot assign to read-only memoryview" - * - * have_slices, index = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< - * - * if have_slices: - */ - __pyx_t_1 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 424, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (likely(__pyx_t_1 != Py_None)) { - PyObject* sequence = __pyx_t_1; - 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, 424, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - #else - __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 424, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 424, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } else { - __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 424, __pyx_L1_error) - } - __pyx_v_have_slices = __pyx_t_2; - __pyx_t_2 = 0; - __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_3); - __pyx_t_3 = 0; - - /* "View.MemoryView":426 - * have_slices, index = _unellipsify(index, self.view.ndim) - * - * if have_slices: # <<<<<<<<<<<<<< - * obj = self.is_slice(value) - * if obj: - */ - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(1, 426, __pyx_L1_error) - if (__pyx_t_4) { - - /* "View.MemoryView":427 - * - * if have_slices: - * obj = self.is_slice(value) # <<<<<<<<<<<<<< - * if obj: - * self.setitem_slice_assignment(self[index], obj) - */ - __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->is_slice(__pyx_v_self, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 427, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_obj = __pyx_t_1; - __pyx_t_1 = 0; - - /* "View.MemoryView":428 - * if have_slices: - * obj = self.is_slice(value) - * if obj: # <<<<<<<<<<<<<< - * self.setitem_slice_assignment(self[index], obj) - * else: - */ - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_obj); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(1, 428, __pyx_L1_error) - if (__pyx_t_4) { - - /* "View.MemoryView":429 - * 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_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 429, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assignment(__pyx_v_self, __pyx_t_1, __pyx_v_obj); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 429, __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; - - /* "View.MemoryView":428 - * if have_slices: - * obj = self.is_slice(value) - * if obj: # <<<<<<<<<<<<<< - * self.setitem_slice_assignment(self[index], obj) - * else: - */ - goto __pyx_L5; - } - - /* "View.MemoryView":431 - * self.setitem_slice_assignment(self[index], obj) - * else: - * self.setitem_slice_assign_scalar(self[index], value) # <<<<<<<<<<<<<< - * else: - * self.setitem_indexed(index, value) - */ - /*else*/ { - __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 431, __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(1, 431, __pyx_L1_error) - __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_3), __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 431, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } - __pyx_L5:; - - /* "View.MemoryView":426 - * have_slices, index = _unellipsify(index, self.view.ndim) - * - * if have_slices: # <<<<<<<<<<<<<< - * obj = self.is_slice(value) - * if obj: - */ - goto __pyx_L4; - } - - /* "View.MemoryView":433 - * self.setitem_slice_assign_scalar(self[index], value) - * else: - * self.setitem_indexed(index, value) # <<<<<<<<<<<<<< - * - * cdef is_slice(self, obj): - */ - /*else*/ { - __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 433, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } - __pyx_L4:; - - /* "View.MemoryView":420 - * 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" - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.memoryview.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_have_slices); - __Pyx_XDECREF(__pyx_v_obj); - __Pyx_XDECREF(__pyx_v_index); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":435 - * self.setitem_indexed(index, value) - * - * cdef is_slice(self, obj): # <<<<<<<<<<<<<< - * if not isinstance(obj, memoryview): - * try: - */ - -static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - 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":436 - * - * cdef is_slice(self, obj): - * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< - * try: - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - */ - __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_obj, __pyx_memoryview_type); - __pyx_t_2 = (!__pyx_t_1); - if (__pyx_t_2) { - - /* "View.MemoryView":437 - * cdef is_slice(self, obj): - * if not isinstance(obj, memoryview): - * try: # <<<<<<<<<<<<<< - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - * self.dtype_is_object) - */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); - __Pyx_XGOTREF(__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_4); - __Pyx_XGOTREF(__pyx_t_5); - /*try:*/ { - - /* "View.MemoryView":438 - * 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(1, 438, __pyx_L4_error) - __Pyx_GOTREF(__pyx_t_6); - - /* "View.MemoryView":439 - * 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(1, 439, __pyx_L4_error) - __Pyx_GOTREF(__pyx_t_7); - - /* "View.MemoryView":438 - * 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(1, 438, __pyx_L4_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_INCREF(__pyx_v_obj); - __Pyx_GIVEREF(__pyx_v_obj); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_obj)) __PYX_ERR(1, 438, __pyx_L4_error); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6)) __PYX_ERR(1, 438, __pyx_L4_error); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7)) __PYX_ERR(1, 438, __pyx_L4_error); - __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(1, 438, __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":437 - * cdef is_slice(self, obj): - * if not isinstance(obj, memoryview): - * try: # <<<<<<<<<<<<<< - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - * self.dtype_is_object) - */ - } - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - goto __pyx_L9_try_end; - __pyx_L4_error:; - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - - /* "View.MemoryView":440 - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - * self.dtype_is_object) - * except TypeError: # <<<<<<<<<<<<<< - * return None - * - */ - __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(1, 440, __pyx_L6_except_error) - __Pyx_XGOTREF(__pyx_t_7); - __Pyx_XGOTREF(__pyx_t_8); - __Pyx_XGOTREF(__pyx_t_6); - - /* "View.MemoryView":441 - * self.dtype_is_object) - * except TypeError: - * return None # <<<<<<<<<<<<<< - * - * return obj - */ - __Pyx_XDECREF(__pyx_r); - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - goto __pyx_L7_except_return; - } - goto __pyx_L6_except_error; - - /* "View.MemoryView":437 - * cdef is_slice(self, obj): - * if not isinstance(obj, memoryview): - * try: # <<<<<<<<<<<<<< - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - * self.dtype_is_object) - */ - __pyx_L6_except_error:; - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_XGIVEREF(__pyx_t_4); - __Pyx_XGIVEREF(__pyx_t_5); - __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); - goto __pyx_L1_error; - __pyx_L7_except_return:; - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_XGIVEREF(__pyx_t_4); - __Pyx_XGIVEREF(__pyx_t_5); - __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); - goto __pyx_L0; - __pyx_L9_try_end:; - } - - /* "View.MemoryView":436 - * - * cdef is_slice(self, obj): - * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< - * try: - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - */ - } - - /* "View.MemoryView":443 - * return None - * - * return obj # <<<<<<<<<<<<<< - * - * cdef setitem_slice_assignment(self, dst, src): - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_obj); - __pyx_r = __pyx_v_obj; - goto __pyx_L0; - - /* "View.MemoryView":435 - * self.setitem_indexed(index, value) - * - * cdef is_slice(self, obj): # <<<<<<<<<<<<<< - * if not isinstance(obj, memoryview): - * try: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_obj); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":445 - * return obj - * - * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice dst_slice - * cdef __Pyx_memviewslice src_slice - */ - -static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src) { - __Pyx_memviewslice __pyx_v_dst_slice; - __Pyx_memviewslice __pyx_v_src_slice; - __Pyx_memviewslice __pyx_v_msrc; - __Pyx_memviewslice __pyx_v_mdst; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_memviewslice *__pyx_t_1; - PyObject *__pyx_t_2 = NULL; - int __pyx_t_3; - int __pyx_t_4; - int __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("setitem_slice_assignment", 1); - - /* "View.MemoryView":448 - * cdef __Pyx_memviewslice dst_slice - * cdef __Pyx_memviewslice src_slice - * cdef __Pyx_memviewslice msrc = get_slice_from_memview(src, &src_slice)[0] # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0] - * - */ - if (!(likely(((__pyx_v_src) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_src, __pyx_memoryview_type))))) __PYX_ERR(1, 448, __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(1, 448, __pyx_L1_error) - __pyx_v_msrc = (__pyx_t_1[0]); - - /* "View.MemoryView":449 - * cdef __Pyx_memviewslice src_slice - * cdef __Pyx_memviewslice msrc = get_slice_from_memview(src, &src_slice)[0] - * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0] # <<<<<<<<<<<<<< - * - * memoryview_copy_contents(msrc, mdst, 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(1, 449, __pyx_L1_error) - __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 449, __pyx_L1_error) - __pyx_v_mdst = (__pyx_t_1[0]); - - /* "View.MemoryView":451 - * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0] - * - * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) # <<<<<<<<<<<<<< - * - * cdef setitem_slice_assign_scalar(self, memoryview dst, value): - */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_n_s_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 451, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 451, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_dst, __pyx_n_s_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 451, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 451, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_5 = __pyx_memoryview_copy_contents(__pyx_v_msrc, __pyx_v_mdst, __pyx_t_3, __pyx_t_4, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 451, __pyx_L1_error) - - /* "View.MemoryView":445 - * return obj - * - * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice dst_slice - * cdef __Pyx_memviewslice src_slice - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assignment", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":453 - * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) - * - * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< - * cdef int array[128] - * cdef void *tmp = NULL - */ - -static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value) { - int __pyx_v_array[0x80]; - void *__pyx_v_tmp; - void *__pyx_v_item; - __Pyx_memviewslice *__pyx_v_dst_slice; - __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_4; - int __pyx_t_5; - char const *__pyx_t_6; - 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", 1); - - /* "View.MemoryView":455 - * cdef setitem_slice_assign_scalar(self, memoryview dst, value): - * cdef int array[128] - * cdef void *tmp = NULL # <<<<<<<<<<<<<< - * cdef void *item - * - */ - __pyx_v_tmp = NULL; - - /* "View.MemoryView":460 - * 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(1, 460, __pyx_L1_error) - __pyx_v_dst_slice = __pyx_t_1; - - /* "View.MemoryView":462 - * 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))); - if (__pyx_t_2) { - - /* "View.MemoryView":463 - * - * if self.view.itemsize > sizeof(array): - * tmp = PyMem_Malloc(self.view.itemsize) # <<<<<<<<<<<<<< - * if tmp == NULL: - * raise MemoryError - */ - __pyx_v_tmp = PyMem_Malloc(__pyx_v_self->view.itemsize); - - /* "View.MemoryView":464 - * 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); - if (unlikely(__pyx_t_2)) { - - /* "View.MemoryView":465 - * tmp = PyMem_Malloc(self.view.itemsize) - * if tmp == NULL: - * raise MemoryError # <<<<<<<<<<<<<< - * item = tmp - * else: - */ - PyErr_NoMemory(); __PYX_ERR(1, 465, __pyx_L1_error) - - /* "View.MemoryView":464 - * if self.view.itemsize > sizeof(array): - * tmp = PyMem_Malloc(self.view.itemsize) - * if tmp == NULL: # <<<<<<<<<<<<<< - * raise MemoryError - * item = tmp - */ - } - - /* "View.MemoryView":466 - * if tmp == NULL: - * raise MemoryError - * item = tmp # <<<<<<<<<<<<<< - * else: - * item = array - */ - __pyx_v_item = __pyx_v_tmp; - - /* "View.MemoryView":462 - * dst_slice = get_slice_from_memview(dst, &tmp_slice) - * - * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< - * tmp = PyMem_Malloc(self.view.itemsize) - * if tmp == NULL: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":468 - * item = tmp - * else: - * item = array # <<<<<<<<<<<<<< - * - * try: - */ - /*else*/ { - __pyx_v_item = ((void *)__pyx_v_array); - } - __pyx_L3:; - - /* "View.MemoryView":470 - * item = array - * - * try: # <<<<<<<<<<<<<< - * if self.dtype_is_object: - * ( item)[0] = value - */ - /*try:*/ { - - /* "View.MemoryView":471 - * - * try: - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * ( item)[0] = value - * else: - */ - if (__pyx_v_self->dtype_is_object) { - - /* "View.MemoryView":472 - * try: - * if self.dtype_is_object: - * ( item)[0] = value # <<<<<<<<<<<<<< - * else: - * self.assign_item_from_object( item, value) - */ - (((PyObject **)__pyx_v_item)[0]) = ((PyObject *)__pyx_v_value); - - /* "View.MemoryView":471 - * - * try: - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * ( item)[0] = value - * else: - */ - goto __pyx_L8; - } - - /* "View.MemoryView":474 - * ( item)[0] = value - * else: - * self.assign_item_from_object( item, value) # <<<<<<<<<<<<<< - * - * - */ - /*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(1, 474, __pyx_L6_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } - __pyx_L8:; - - /* "View.MemoryView":478 - * - * - * 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); - if (__pyx_t_2) { - - /* "View.MemoryView":479 - * - * 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_4 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 479, __pyx_L6_error) - - /* "View.MemoryView":478 - * - * - * 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, - */ - } - - /* "View.MemoryView":480 - * 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) - * finally: - */ - __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":483 - * item, self.dtype_is_object) - * finally: - * PyMem_Free(tmp) # <<<<<<<<<<<<<< - * - * cdef setitem_indexed(self, index, value): - */ - /*finally:*/ { - /*normal exit:*/{ - PyMem_Free(__pyx_v_tmp); - goto __pyx_L7; - } - __pyx_L6_error:; - /*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_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; - { - PyMem_Free(__pyx_v_tmp); - } - if (PY_MAJOR_VERSION >= 3) { - __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_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; - goto __pyx_L1_error; - } - __pyx_L7:; - } - - /* "View.MemoryView":453 - * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) - * - * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< - * cdef int array[128] - * cdef void *tmp = NULL - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assign_scalar", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":485 - * PyMem_Free(tmp) - * - * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< - * cdef char *itemp = self.get_item_pointer(index) - * self.assign_item_from_object(itemp, value) - */ - -static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { - char *__pyx_v_itemp; - PyObject *__pyx_r = NULL; - __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", 1); - - /* "View.MemoryView":486 - * - * 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(1, 486, __pyx_L1_error) - __pyx_v_itemp = __pyx_t_1; - - /* "View.MemoryView":487 - * 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(1, 487, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "View.MemoryView":485 - * PyMem_Free(tmp) - * - * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< - * cdef char *itemp = self.get_item_pointer(index) - * self.assign_item_from_object(itemp, value) - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_indexed", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":489 - * self.assign_item_from_object(itemp, value) - * - * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< - * """Only used if instantiated manually by the user, or if Cython doesn't - * know how to convert the type""" - */ - -static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp) { - PyObject *__pyx_v_struct = NULL; - PyObject *__pyx_v_bytesitem = 0; - PyObject *__pyx_v_result = NULL; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - int __pyx_t_8; - Py_ssize_t __pyx_t_9; - int __pyx_t_10; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("convert_item_to_object", 1); - - /* "View.MemoryView":492 - * """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_ImportDottedModule(__pyx_n_s_struct, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 492, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_struct = __pyx_t_1; - __pyx_t_1 = 0; - - /* "View.MemoryView":495 - * 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(1, 495, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_bytesitem = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - - /* "View.MemoryView":496 - * - * bytesitem = itemp[:self.view.itemsize] - * try: # <<<<<<<<<<<<<< - * result = struct.unpack(self.view.format, bytesitem) - * except struct.error: - */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); - __Pyx_XGOTREF(__pyx_t_2); - __Pyx_XGOTREF(__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_4); - /*try:*/ { - - /* "View.MemoryView":497 - * 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(1, 497, __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(1, 497, __pyx_L3_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = NULL; - __pyx_t_8 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - __pyx_t_8 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_8, 2+__pyx_t_8); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 497, __pyx_L3_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } - __pyx_v_result = __pyx_t_1; - __pyx_t_1 = 0; - - /* "View.MemoryView":496 - * - * bytesitem = itemp[:self.view.itemsize] - * try: # <<<<<<<<<<<<<< - * result = struct.unpack(self.view.format, bytesitem) - * except struct.error: - */ - } - - /* "View.MemoryView":501 - * raise ValueError, "Unable to convert item to object" - * else: - * if len(self.view.format) == 1: # <<<<<<<<<<<<<< - * return result[0] - * return result - */ - /*else:*/ { - __pyx_t_9 = __Pyx_ssize_strlen(__pyx_v_self->view.format); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(1, 501, __pyx_L5_except_error) - __pyx_t_10 = (__pyx_t_9 == 1); - if (__pyx_t_10) { - - /* "View.MemoryView":502 - * else: - * if len(self.view.format) == 1: - * return result[0] # <<<<<<<<<<<<<< - * return result - * - */ - __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(1, 502, __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":501 - * raise ValueError, "Unable to convert item to object" - * else: - * if len(self.view.format) == 1: # <<<<<<<<<<<<<< - * return result[0] - * return result - */ - } - - /* "View.MemoryView":503 - * if len(self.view.format) == 1: - * return result[0] - * return result # <<<<<<<<<<<<<< - * - * cdef assign_item_from_object(self, char *itemp, object value): - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_result); - __pyx_r = __pyx_v_result; - goto __pyx_L6_except_return; - } - __pyx_L3_error:; - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "View.MemoryView":498 - * try: - * result = struct.unpack(self.view.format, bytesitem) - * except struct.error: # <<<<<<<<<<<<<< - * raise ValueError, "Unable to convert item to object" - * else: - */ - __Pyx_ErrFetch(&__pyx_t_1, &__pyx_t_5, &__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_error); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 498, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_7); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_ErrRestore(__pyx_t_1, __pyx_t_5, __pyx_t_6); - __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_6 = 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_6, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(1, 498, __pyx_L5_except_error) - __Pyx_XGOTREF(__pyx_t_6); - __Pyx_XGOTREF(__pyx_t_5); - __Pyx_XGOTREF(__pyx_t_1); - - /* "View.MemoryView":499 - * 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_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Unable_to_convert_item_to_object, 0, 0); - __PYX_ERR(1, 499, __pyx_L5_except_error) - } - goto __pyx_L5_except_error; - - /* "View.MemoryView":496 - * - * bytesitem = itemp[:self.view.itemsize] - * try: # <<<<<<<<<<<<<< - * result = struct.unpack(self.view.format, bytesitem) - * except struct.error: - */ - __pyx_L5_except_error:; - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_XGIVEREF(__pyx_t_4); - __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); - goto __pyx_L1_error; - __pyx_L6_except_return:; - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_XGIVEREF(__pyx_t_4); - __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); - goto __pyx_L0; - } - - /* "View.MemoryView":489 - * self.assign_item_from_object(itemp, value) - * - * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< - * """Only used if instantiated manually by the user, or if Cython doesn't - * know how to convert the type""" - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_struct); - __Pyx_XDECREF(__pyx_v_bytesitem); - __Pyx_XDECREF(__pyx_v_result); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":505 - * return result - * - * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< - * """Only used if instantiated manually by the user, or if Cython doesn't - * know how to convert the type""" - */ - -static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) { - PyObject *__pyx_v_struct = NULL; - char __pyx_v_c; - PyObject *__pyx_v_bytesvalue = 0; - Py_ssize_t __pyx_v_i; - 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; - int __pyx_t_6; - Py_ssize_t __pyx_t_7; - PyObject *__pyx_t_8 = NULL; - char *__pyx_t_9; - char *__pyx_t_10; - char *__pyx_t_11; - char *__pyx_t_12; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("assign_item_from_object", 1); - - /* "View.MemoryView":508 - * """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_ImportDottedModule(__pyx_n_s_struct, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 508, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_struct = __pyx_t_1; - __pyx_t_1 = 0; - - /* "View.MemoryView":513 - * cdef Py_ssize_t i - * - * if isinstance(value, tuple): # <<<<<<<<<<<<<< - * bytesvalue = struct.pack(self.view.format, *value) - * else: - */ - __pyx_t_2 = PyTuple_Check(__pyx_v_value); - if (__pyx_t_2) { - - /* "View.MemoryView":514 - * - * 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(1, 514, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = PyNumber_Add(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 514, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (!(likely(PyBytes_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_3))) __PYX_ERR(1, 514, __pyx_L1_error) - __pyx_v_bytesvalue = ((PyObject*)__pyx_t_3); - __pyx_t_3 = 0; - - /* "View.MemoryView":513 - * cdef Py_ssize_t i - * - * if isinstance(value, tuple): # <<<<<<<<<<<<<< - * bytesvalue = struct.pack(self.view.format, *value) - * else: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":516 - * bytesvalue = struct.pack(self.view.format, *value) - * else: - * bytesvalue = struct.pack(self.view.format, value) # <<<<<<<<<<<<<< - * - * for i, c in enumerate(bytesvalue): - */ - /*else*/ { - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 516, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 516, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = NULL; - __pyx_t_6 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - __pyx_t_6 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_1, __pyx_v_value}; - __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 516, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } - if (!(likely(PyBytes_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_3))) __PYX_ERR(1, 516, __pyx_L1_error) - __pyx_v_bytesvalue = ((PyObject*)__pyx_t_3); - __pyx_t_3 = 0; - } - __pyx_L3:; - - /* "View.MemoryView":518 - * bytesvalue = struct.pack(self.view.format, value) - * - * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< - * itemp[i] = c - * - */ - __pyx_t_7 = 0; - if (unlikely(__pyx_v_bytesvalue == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable"); - __PYX_ERR(1, 518, __pyx_L1_error) - } - __Pyx_INCREF(__pyx_v_bytesvalue); - __pyx_t_8 = __pyx_v_bytesvalue; - __pyx_t_10 = PyBytes_AS_STRING(__pyx_t_8); - __pyx_t_11 = (__pyx_t_10 + PyBytes_GET_SIZE(__pyx_t_8)); - for (__pyx_t_12 = __pyx_t_10; __pyx_t_12 < __pyx_t_11; __pyx_t_12++) { - __pyx_t_9 = __pyx_t_12; - __pyx_v_c = (__pyx_t_9[0]); - - /* "View.MemoryView":519 - * - * for i, c in enumerate(bytesvalue): - * itemp[i] = c # <<<<<<<<<<<<<< - * - * @cname('getbuffer') - */ - __pyx_v_i = __pyx_t_7; - - /* "View.MemoryView":518 - * bytesvalue = struct.pack(self.view.format, value) - * - * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< - * itemp[i] = c - * - */ - __pyx_t_7 = (__pyx_t_7 + 1); - - /* "View.MemoryView":519 - * - * for i, c in enumerate(bytesvalue): - * itemp[i] = c # <<<<<<<<<<<<<< - * - * @cname('getbuffer') - */ - (__pyx_v_itemp[__pyx_v_i]) = __pyx_v_c; - } - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - - /* "View.MemoryView":505 - * return result - * - * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< - * """Only used if instantiated manually by the user, or if Cython doesn't - * know how to convert the type""" - */ - - /* 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_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("View.MemoryView.memoryview.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_struct); - __Pyx_XDECREF(__pyx_v_bytesvalue); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":521 - * itemp[i] = c - * - * @cname('getbuffer') # <<<<<<<<<<<<<< - * def __getbuffer__(self, Py_buffer *info, int flags): - * if flags & PyBUF_WRITABLE and self.view.readonly: - */ - -/* Python wrapper */ -CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ -CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { - int __pyx_r; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - Py_ssize_t *__pyx_t_3; - char *__pyx_t_4; - void *__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 (unlikely(__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); - - /* "View.MemoryView":523 - * @cname('getbuffer') - * 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" - * - */ - __pyx_t_2 = ((__pyx_v_flags & PyBUF_WRITABLE) != 0); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_1 = __pyx_v_self->view.readonly; - __pyx_L4_bool_binop_done:; - if (unlikely(__pyx_t_1)) { - - /* "View.MemoryView":524 - * 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_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Cannot_create_writable_memory_vi, 0, 0); - __PYX_ERR(1, 524, __pyx_L1_error) - - /* "View.MemoryView":523 - * @cname('getbuffer') - * 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" - * - */ - } - - /* "View.MemoryView":526 - * raise ValueError, "Cannot create writable memory view from read-only memoryview" - * - * if flags & PyBUF_ND: # <<<<<<<<<<<<<< - * info.shape = self.view.shape - * else: - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":527 - * - * if flags & PyBUF_ND: - * info.shape = self.view.shape # <<<<<<<<<<<<<< - * else: - * info.shape = NULL - */ - __pyx_t_3 = __pyx_v_self->view.shape; - __pyx_v_info->shape = __pyx_t_3; - - /* "View.MemoryView":526 - * raise ValueError, "Cannot create writable memory view from read-only memoryview" - * - * if flags & PyBUF_ND: # <<<<<<<<<<<<<< - * info.shape = self.view.shape - * else: - */ - goto __pyx_L6; - } - - /* "View.MemoryView":529 - * info.shape = self.view.shape - * else: - * info.shape = NULL # <<<<<<<<<<<<<< - * - * if flags & PyBUF_STRIDES: - */ - /*else*/ { - __pyx_v_info->shape = NULL; - } - __pyx_L6:; - - /* "View.MemoryView":531 - * info.shape = NULL - * - * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< - * info.strides = self.view.strides - * else: - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":532 - * - * if flags & PyBUF_STRIDES: - * info.strides = self.view.strides # <<<<<<<<<<<<<< - * else: - * info.strides = NULL - */ - __pyx_t_3 = __pyx_v_self->view.strides; - __pyx_v_info->strides = __pyx_t_3; - - /* "View.MemoryView":531 - * info.shape = NULL - * - * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< - * info.strides = self.view.strides - * else: - */ - goto __pyx_L7; - } - - /* "View.MemoryView":534 - * info.strides = self.view.strides - * else: - * info.strides = NULL # <<<<<<<<<<<<<< - * - * if flags & PyBUF_INDIRECT: - */ - /*else*/ { - __pyx_v_info->strides = NULL; - } - __pyx_L7:; - - /* "View.MemoryView":536 - * info.strides = NULL - * - * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< - * info.suboffsets = self.view.suboffsets - * else: - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_INDIRECT) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":537 - * - * if flags & PyBUF_INDIRECT: - * info.suboffsets = self.view.suboffsets # <<<<<<<<<<<<<< - * else: - * info.suboffsets = NULL - */ - __pyx_t_3 = __pyx_v_self->view.suboffsets; - __pyx_v_info->suboffsets = __pyx_t_3; - - /* "View.MemoryView":536 - * info.strides = NULL - * - * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< - * info.suboffsets = self.view.suboffsets - * else: - */ - goto __pyx_L8; - } - - /* "View.MemoryView":539 - * info.suboffsets = self.view.suboffsets - * else: - * info.suboffsets = NULL # <<<<<<<<<<<<<< - * - * if flags & PyBUF_FORMAT: - */ - /*else*/ { - __pyx_v_info->suboffsets = NULL; - } - __pyx_L8:; - - /* "View.MemoryView":541 - * info.suboffsets = NULL - * - * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< - * info.format = self.view.format - * else: - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":542 - * - * if flags & PyBUF_FORMAT: - * info.format = self.view.format # <<<<<<<<<<<<<< - * else: - * info.format = NULL - */ - __pyx_t_4 = __pyx_v_self->view.format; - __pyx_v_info->format = __pyx_t_4; - - /* "View.MemoryView":541 - * info.suboffsets = NULL - * - * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< - * info.format = self.view.format - * else: - */ - goto __pyx_L9; - } - - /* "View.MemoryView":544 - * info.format = self.view.format - * else: - * info.format = NULL # <<<<<<<<<<<<<< - * - * info.buf = self.view.buf - */ - /*else*/ { - __pyx_v_info->format = NULL; - } - __pyx_L9:; - - /* "View.MemoryView":546 - * info.format = NULL - * - * info.buf = self.view.buf # <<<<<<<<<<<<<< - * info.ndim = self.view.ndim - * info.itemsize = self.view.itemsize - */ - __pyx_t_5 = __pyx_v_self->view.buf; - __pyx_v_info->buf = __pyx_t_5; - - /* "View.MemoryView":547 - * - * info.buf = self.view.buf - * info.ndim = self.view.ndim # <<<<<<<<<<<<<< - * info.itemsize = self.view.itemsize - * info.len = self.view.len - */ - __pyx_t_6 = __pyx_v_self->view.ndim; - __pyx_v_info->ndim = __pyx_t_6; - - /* "View.MemoryView":548 - * info.buf = self.view.buf - * info.ndim = self.view.ndim - * info.itemsize = self.view.itemsize # <<<<<<<<<<<<<< - * info.len = self.view.len - * info.readonly = self.view.readonly - */ - __pyx_t_7 = __pyx_v_self->view.itemsize; - __pyx_v_info->itemsize = __pyx_t_7; - - /* "View.MemoryView":549 - * info.ndim = self.view.ndim - * info.itemsize = self.view.itemsize - * info.len = self.view.len # <<<<<<<<<<<<<< - * info.readonly = self.view.readonly - * info.obj = self - */ - __pyx_t_7 = __pyx_v_self->view.len; - __pyx_v_info->len = __pyx_t_7; - - /* "View.MemoryView":550 - * info.itemsize = self.view.itemsize - * info.len = self.view.len - * info.readonly = self.view.readonly # <<<<<<<<<<<<<< - * info.obj = self - * - */ - __pyx_t_1 = __pyx_v_self->view.readonly; - __pyx_v_info->readonly = __pyx_t_1; - - /* "View.MemoryView":551 - * info.len = self.view.len - * info.readonly = self.view.readonly - * info.obj = self # <<<<<<<<<<<<<< - * - * - */ - __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":521 - * itemp[i] = c - * - * @cname('getbuffer') # <<<<<<<<<<<<<< - * def __getbuffer__(self, Py_buffer *info, int flags): - * if flags & PyBUF_WRITABLE and self.view.readonly: - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_AddTraceback("View.MemoryView.memoryview.__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":554 - * - * - * @property # <<<<<<<<<<<<<< - * def T(self): - * cdef _memoryviewslice result = memoryview_copy(self) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - struct __pyx_memoryviewslice_obj *__pyx_v_result = 0; - PyObject *__pyx_r = NULL; - __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__", 1); - - /* "View.MemoryView":556 - * @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(1, 556, __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(1, 556, __pyx_L1_error) - __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_1); - __pyx_t_1 = 0; - - /* "View.MemoryView":557 - * 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)-1))) __PYX_ERR(1, 557, __pyx_L1_error) - - /* "View.MemoryView":558 - * cdef _memoryviewslice result = memoryview_copy(self) - * transpose_memslice(&result.from_slice) - * return result # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF((PyObject *)__pyx_v_result); - __pyx_r = ((PyObject *)__pyx_v_result); - goto __pyx_L0; - - /* "View.MemoryView":554 - * - * - * @property # <<<<<<<<<<<<<< - * def T(self): - * cdef _memoryviewslice result = memoryview_copy(self) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.memoryview.T.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_result); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":560 - * return result - * - * @property # <<<<<<<<<<<<<< - * def base(self): - * return self._get_base() - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - 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__", 1); - - /* "View.MemoryView":562 - * @property - * def base(self): - * return self._get_base() # <<<<<<<<<<<<<< - * - * cdef _get_base(self): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->_get_base(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 562, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "View.MemoryView":560 - * return result - * - * @property # <<<<<<<<<<<<<< - * def base(self): - * return self._get_base() - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.memoryview.base.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":564 - * return self._get_base() - * - * cdef _get_base(self): # <<<<<<<<<<<<<< - * return self.obj - * - */ - -static PyObject *__pyx_memoryview__get_base(struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("_get_base", 1); - - /* "View.MemoryView":565 - * - * cdef _get_base(self): - * return self.obj # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->obj); - __pyx_r = __pyx_v_self->obj; - goto __pyx_L0; - - /* "View.MemoryView":564 - * return self._get_base() - * - * cdef _get_base(self): # <<<<<<<<<<<<<< - * return self.obj - * - */ - - /* function exit code */ - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":567 - * return self.obj - * - * @property # <<<<<<<<<<<<<< - * def shape(self): - * return tuple([length for length in self.view.shape[:self.view.ndim]]) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - Py_ssize_t __pyx_7genexpr__pyx_v_length; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - Py_ssize_t *__pyx_t_2; - 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__", 1); - - /* "View.MemoryView":569 - * @property - * def shape(self): - * return tuple([length for length in self.view.shape[:self.view.ndim]]) # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - { /* enter inner scope */ - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 569, __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_7genexpr__pyx_v_length = (__pyx_t_2[0]); - __pyx_t_5 = PyInt_FromSsize_t(__pyx_7genexpr__pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 569, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(1, 569, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } - } /* exit inner scope */ - __pyx_t_5 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 569, __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":567 - * return self.obj - * - * @property # <<<<<<<<<<<<<< - * def shape(self): - * return tuple([length for length in self.view.shape[:self.view.ndim]]) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("View.MemoryView.memoryview.shape.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":571 - * return tuple([length for length in self.view.shape[:self.view.ndim]]) - * - * @property # <<<<<<<<<<<<<< - * def strides(self): - * if self.view.strides == NULL: - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - Py_ssize_t __pyx_8genexpr1__pyx_v_stride; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - Py_ssize_t *__pyx_t_3; - 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__", 1); - - /* "View.MemoryView":573 - * @property - * def strides(self): - * if self.view.strides == NULL: # <<<<<<<<<<<<<< - * - * raise ValueError, "Buffer view does not expose strides" - */ - __pyx_t_1 = (__pyx_v_self->view.strides == NULL); - if (unlikely(__pyx_t_1)) { - - /* "View.MemoryView":575 - * 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_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Buffer_view_does_not_expose_stri, 0, 0); - __PYX_ERR(1, 575, __pyx_L1_error) - - /* "View.MemoryView":573 - * @property - * def strides(self): - * if self.view.strides == NULL: # <<<<<<<<<<<<<< - * - * raise ValueError, "Buffer view does not expose strides" - */ - } - - /* "View.MemoryView":577 - * raise ValueError, "Buffer view does not expose strides" - * - * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - { /* enter inner scope */ - __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 577, __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_8genexpr1__pyx_v_stride = (__pyx_t_3[0]); - __pyx_t_6 = PyInt_FromSsize_t(__pyx_8genexpr1__pyx_v_stride); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 577, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 577, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - } - } /* exit inner scope */ - __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 577, __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":571 - * return tuple([length for length in self.view.shape[:self.view.ndim]]) - * - * @property # <<<<<<<<<<<<<< - * def strides(self): - * if self.view.strides == NULL: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_AddTraceback("View.MemoryView.memoryview.strides.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":579 - * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) - * - * @property # <<<<<<<<<<<<<< - * def suboffsets(self): - * if self.view.suboffsets == NULL: - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - Py_ssize_t __pyx_8genexpr2__pyx_v_suboffset; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - Py_ssize_t *__pyx_t_3; - 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__", 1); - - /* "View.MemoryView":581 - * @property - * def suboffsets(self): - * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< - * return (-1,) * self.view.ndim - * - */ - __pyx_t_1 = (__pyx_v_self->view.suboffsets == NULL); - if (__pyx_t_1) { - - /* "View.MemoryView":582 - * 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_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PySequence_Multiply(__pyx_tuple__4, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 582, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":581 - * @property - * def suboffsets(self): - * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< - * return (-1,) * self.view.ndim - * - */ - } - - /* "View.MemoryView":584 - * return (-1,) * self.view.ndim - * - * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - { /* enter inner scope */ - __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 584, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = (__pyx_v_self->view.suboffsets + __pyx_v_self->view.ndim); - for (__pyx_t_5 = __pyx_v_self->view.suboffsets; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { - __pyx_t_3 = __pyx_t_5; - __pyx_8genexpr2__pyx_v_suboffset = (__pyx_t_3[0]); - __pyx_t_6 = PyInt_FromSsize_t(__pyx_8genexpr2__pyx_v_suboffset); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 584, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 584, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - } - } /* exit inner scope */ - __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 584, __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":579 - * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) - * - * @property # <<<<<<<<<<<<<< - * def suboffsets(self): - * if self.view.suboffsets == NULL: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_AddTraceback("View.MemoryView.memoryview.suboffsets.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":586 - * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) - * - * @property # <<<<<<<<<<<<<< - * def ndim(self): - * return self.view.ndim - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - 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__", 1); - - /* "View.MemoryView":588 - * @property - * def ndim(self): - * return self.view.ndim # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 588, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "View.MemoryView":586 - * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) - * - * @property # <<<<<<<<<<<<<< - * def ndim(self): - * return self.view.ndim - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.memoryview.ndim.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":590 - * return self.view.ndim - * - * @property # <<<<<<<<<<<<<< - * def itemsize(self): - * return self.view.itemsize - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - 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__", 1); - - /* "View.MemoryView":592 - * @property - * def itemsize(self): - * return self.view.itemsize # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 592, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "View.MemoryView":590 - * return self.view.ndim - * - * @property # <<<<<<<<<<<<<< - * def itemsize(self): - * return self.view.itemsize - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.memoryview.itemsize.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":594 - * return self.view.itemsize - * - * @property # <<<<<<<<<<<<<< - * def nbytes(self): - * return self.size * self.view.itemsize - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - 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__", 1); - - /* "View.MemoryView":596 - * @property - * def nbytes(self): - * return self.size * self.view.itemsize # <<<<<<<<<<<<<< - * - * @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(1, 596, __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(1, 596, __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(1, 596, __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; - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L0; - - /* "View.MemoryView":594 - * return self.view.itemsize - * - * @property # <<<<<<<<<<<<<< - * def nbytes(self): - * return self.size * self.view.itemsize - */ - - /* 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.memoryview.nbytes.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":598 - * return self.size * self.view.itemsize - * - * @property # <<<<<<<<<<<<<< - * def size(self): - * if self._size is None: - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_v_result = NULL; - PyObject *__pyx_v_length = NULL; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - Py_ssize_t *__pyx_t_2; - 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__", 1); - - /* "View.MemoryView":600 - * @property - * def size(self): - * if self._size is None: # <<<<<<<<<<<<<< - * result = 1 - * - */ - __pyx_t_1 = (__pyx_v_self->_size == Py_None); - if (__pyx_t_1) { - - /* "View.MemoryView":601 - * def size(self): - * if self._size is None: - * result = 1 # <<<<<<<<<<<<<< - * - * for length in self.view.shape[:self.view.ndim]: - */ - __Pyx_INCREF(__pyx_int_1); - __pyx_v_result = __pyx_int_1; - - /* "View.MemoryView":603 - * result = 1 - * - * for length in self.view.shape[:self.view.ndim]: # <<<<<<<<<<<<<< - * result *= length - * - */ - __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_t_5 = PyInt_FromSsize_t((__pyx_t_2[0])); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 603, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_5); - __pyx_t_5 = 0; - - /* "View.MemoryView":604 - * - * for length in self.view.shape[:self.view.ndim]: - * result *= length # <<<<<<<<<<<<<< - * - * self._size = result - */ - __pyx_t_5 = PyNumber_InPlaceMultiply(__pyx_v_result, __pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 604, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_5); - __pyx_t_5 = 0; - } - - /* "View.MemoryView":606 - * result *= length - * - * self._size = result # <<<<<<<<<<<<<< - * - * return self._size - */ - __Pyx_INCREF(__pyx_v_result); - __Pyx_GIVEREF(__pyx_v_result); - __Pyx_GOTREF(__pyx_v_self->_size); - __Pyx_DECREF(__pyx_v_self->_size); - __pyx_v_self->_size = __pyx_v_result; - - /* "View.MemoryView":600 - * @property - * def size(self): - * if self._size is None: # <<<<<<<<<<<<<< - * result = 1 - * - */ - } - - /* "View.MemoryView":608 - * self._size = result - * - * return self._size # <<<<<<<<<<<<<< - * - * def __len__(self): - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->_size); - __pyx_r = __pyx_v_self->_size; - goto __pyx_L0; - - /* "View.MemoryView":598 - * return self.size * self.view.itemsize - * - * @property # <<<<<<<<<<<<<< - * def size(self): - * if self._size is None: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("View.MemoryView.memoryview.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_result); - __Pyx_XDECREF(__pyx_v_length); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":610 - * return self._size - * - * def __len__(self): # <<<<<<<<<<<<<< - * if self.view.ndim >= 1: - * return self.view.shape[0] - */ - -/* Python wrapper */ -static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self); /*proto*/ -static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - Py_ssize_t __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self) { - Py_ssize_t __pyx_r; - int __pyx_t_1; - - /* "View.MemoryView":611 - * - * def __len__(self): - * if self.view.ndim >= 1: # <<<<<<<<<<<<<< - * return self.view.shape[0] - * - */ - __pyx_t_1 = (__pyx_v_self->view.ndim >= 1); - if (__pyx_t_1) { - - /* "View.MemoryView":612 - * def __len__(self): - * if self.view.ndim >= 1: - * return self.view.shape[0] # <<<<<<<<<<<<<< - * - * return 0 - */ - __pyx_r = (__pyx_v_self->view.shape[0]); - goto __pyx_L0; - - /* "View.MemoryView":611 - * - * def __len__(self): - * if self.view.ndim >= 1: # <<<<<<<<<<<<<< - * return self.view.shape[0] - * - */ - } - - /* "View.MemoryView":614 - * return self.view.shape[0] - * - * return 0 # <<<<<<<<<<<<<< - * - * def __repr__(self): - */ - __pyx_r = 0; - goto __pyx_L0; - - /* "View.MemoryView":610 - * return self._size - * - * def __len__(self): # <<<<<<<<<<<<<< - * if self.view.ndim >= 1: - * return self.view.shape[0] - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":616 - * return 0 - * - * def __repr__(self): # <<<<<<<<<<<<<< - * return "" % (self.base.__class__.__name__, - * id(self)) - */ - -/* Python wrapper */ -static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - 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__", 1); - - /* "View.MemoryView":617 - * - * def __repr__(self): - * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< - * id(self)) - * - */ - __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(1, 617, __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(1, 617, __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(1, 617, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "View.MemoryView":618 - * 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(1, 618, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - - /* "View.MemoryView":617 - * - * def __repr__(self): - * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< - * id(self)) - * - */ - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 617, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1)) __PYX_ERR(1, 617, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2)) __PYX_ERR(1, 617, __pyx_L1_error); - __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(1, 617, __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":616 - * return 0 - * - * def __repr__(self): # <<<<<<<<<<<<<< - * return "" % (self.base.__class__.__name__, - * id(self)) - */ - - /* 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.memoryview.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":620 - * id(self)) - * - * def __str__(self): # <<<<<<<<<<<<<< - * return "" % (self.base.__class__.__name__,) - * - */ - -/* Python wrapper */ -static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __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__", 1); - - /* "View.MemoryView":621 - * - * def __str__(self): - * return "" % (self.base.__class__.__name__,) # <<<<<<<<<<<<<< - * - * - */ - __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(1, 621, __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(1, 621, __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(1, 621, __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(1, 621, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1)) __PYX_ERR(1, 621, __pyx_L1_error); - __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(1, 621, __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":620 - * id(self)) - * - * def __str__(self): # <<<<<<<<<<<<<< - * return "" % (self.base.__class__.__name__,) - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.memoryview.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":624 - * - * - * def is_c_contig(self): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice *mslice - * cdef __Pyx_memviewslice tmp - */ - -/* Python wrapper */ -static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("is_c_contig (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("is_c_contig", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "is_c_contig", 0))) return NULL; - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self) { - __Pyx_memviewslice *__pyx_v_mslice; - __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; - __Pyx_RefNannySetupContext("is_c_contig", 1); - - /* "View.MemoryView":627 - * 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(1, 627, __pyx_L1_error) - __pyx_v_mslice = __pyx_t_1; - - /* "View.MemoryView":628 - * cdef __Pyx_memviewslice tmp - * mslice = get_slice_from_memview(self, &tmp) - * return slice_is_contig(mslice[0], 'C', self.view.ndim) # <<<<<<<<<<<<<< - * - * 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(1, 628, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":624 - * - * - * def is_c_contig(self): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice *mslice - * cdef __Pyx_memviewslice tmp - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.memoryview.is_c_contig", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":630 - * return slice_is_contig(mslice[0], 'C', self.view.ndim) - * - * def is_f_contig(self): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice *mslice - * cdef __Pyx_memviewslice tmp - */ - -/* Python wrapper */ -static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("is_f_contig (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("is_f_contig", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "is_f_contig", 0))) return NULL; - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self) { - __Pyx_memviewslice *__pyx_v_mslice; - __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; - __Pyx_RefNannySetupContext("is_f_contig", 1); - - /* "View.MemoryView":633 - * 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(1, 633, __pyx_L1_error) - __pyx_v_mslice = __pyx_t_1; - - /* "View.MemoryView":634 - * cdef __Pyx_memviewslice tmp - * mslice = get_slice_from_memview(self, &tmp) - * return slice_is_contig(mslice[0], 'F', self.view.ndim) # <<<<<<<<<<<<<< - * - * 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(1, 634, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":630 - * return slice_is_contig(mslice[0], 'C', self.view.ndim) - * - * def is_f_contig(self): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice *mslice - * cdef __Pyx_memviewslice tmp - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.memoryview.is_f_contig", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":636 - * return slice_is_contig(mslice[0], 'F', self.view.ndim) - * - * def copy(self): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice mslice - * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS - */ - -/* Python wrapper */ -static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("copy (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("copy", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "copy", 0))) return NULL; - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self) { - __Pyx_memviewslice __pyx_v_mslice; - int __pyx_v_flags; - 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; - __Pyx_RefNannySetupContext("copy", 1); - - /* "View.MemoryView":638 - * def copy(self): - * cdef __Pyx_memviewslice mslice - * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS # <<<<<<<<<<<<<< - * - * slice_copy(self, &mslice) - */ - __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_F_CONTIGUOUS)); - - /* "View.MemoryView":640 - * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS - * - * slice_copy(self, &mslice) # <<<<<<<<<<<<<< - * mslice = slice_copy_contig(&mslice, "c", self.view.ndim, - * self.view.itemsize, - */ - __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_mslice)); - - /* "View.MemoryView":641 - * - * 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(1, 641, __pyx_L1_error) - __pyx_v_mslice = __pyx_t_1; - - /* "View.MemoryView":646 - * self.dtype_is_object) - * - * return memoryview_copy_from_slice(self, &mslice) # <<<<<<<<<<<<<< - * - * 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(1, 646, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":636 - * return slice_is_contig(mslice[0], 'F', self.view.ndim) - * - * def copy(self): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice mslice - * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.memoryview.copy", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":648 - * return memoryview_copy_from_slice(self, &mslice) - * - * def copy_fortran(self): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice src, dst - * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS - */ - -/* Python wrapper */ -static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("copy_fortran (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("copy_fortran", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "copy_fortran", 0))) return NULL; - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self) { - __Pyx_memviewslice __pyx_v_src; - __Pyx_memviewslice __pyx_v_dst; - int __pyx_v_flags; - 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; - __Pyx_RefNannySetupContext("copy_fortran", 1); - - /* "View.MemoryView":650 - * def copy_fortran(self): - * cdef __Pyx_memviewslice src, dst - * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS # <<<<<<<<<<<<<< - * - * slice_copy(self, &src) - */ - __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_C_CONTIGUOUS)); - - /* "View.MemoryView":652 - * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS - * - * slice_copy(self, &src) # <<<<<<<<<<<<<< - * dst = slice_copy_contig(&src, "fortran", self.view.ndim, - * self.view.itemsize, - */ - __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_src)); - - /* "View.MemoryView":653 - * - * 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(1, 653, __pyx_L1_error) - __pyx_v_dst = __pyx_t_1; - - /* "View.MemoryView":658 - * self.dtype_is_object) - * - * return memoryview_copy_from_slice(self, &dst) # <<<<<<<<<<<<<< - * - * - */ - __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(1, 658, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":648 - * return memoryview_copy_from_slice(self, &mslice) - * - * def copy_fortran(self): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice src, dst - * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.memoryview.copy_fortran", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __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): - */ - -/* Python wrapper */ -static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; - __pyx_r = __pyx_pf___pyx_memoryview___reduce_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__reduce_cython__", 1); - - /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); - __PYX_ERR(1, 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): - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("View.MemoryView.memoryview.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __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_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v___pyx_state = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("View.MemoryView.memoryview.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf___pyx_memoryview_2__setstate_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v___pyx_state); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setstate_cython__", 1); - - /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); - __PYX_ERR(1, 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_AddTraceback("View.MemoryView.memoryview.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":662 - * - * @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 - */ - -static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, int __pyx_v_dtype_is_object, __Pyx_TypeInfo *__pyx_v_typeinfo) { - struct __pyx_memoryview_obj *__pyx_v_result = 0; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - 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", 1); - - /* "View.MemoryView":663 - * @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(1, 663, __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(1, 663, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 663, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_v_o); - __Pyx_GIVEREF(__pyx_v_o); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_o)) __PYX_ERR(1, 663, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 663, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2)) __PYX_ERR(1, 663, __pyx_L1_error); - __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(1, 663, __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":664 - * 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_v_result->typeinfo = __pyx_v_typeinfo; - - /* "View.MemoryView":665 - * cdef memoryview result = memoryview(o, flags, dtype_is_object) - * result.typeinfo = typeinfo - * return result # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_check') - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF((PyObject *)__pyx_v_result); - __pyx_r = ((PyObject *)__pyx_v_result); - goto __pyx_L0; - - /* "View.MemoryView":662 - * - * @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 - */ - - /* 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.memoryview_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_result); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":668 - * - * @cname('__pyx_memoryview_check') - * cdef inline bint memoryview_check(object o) noexcept: # <<<<<<<<<<<<<< - * return isinstance(o, memoryview) - * - */ - -static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) { - int __pyx_r; - int __pyx_t_1; - - /* "View.MemoryView":669 - * @cname('__pyx_memoryview_check') - * cdef inline bint memoryview_check(object o) noexcept: - * return isinstance(o, memoryview) # <<<<<<<<<<<<<< - * - * cdef tuple _unellipsify(object index, int ndim): - */ - __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_o, __pyx_memoryview_type); - __pyx_r = __pyx_t_1; - goto __pyx_L0; - - /* "View.MemoryView":668 - * - * @cname('__pyx_memoryview_check') - * cdef inline bint memoryview_check(object o) noexcept: # <<<<<<<<<<<<<< - * return isinstance(o, memoryview) - * - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":671 - * return isinstance(o, memoryview) - * - * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< - * """ - * Replace all ellipses with full slices and fill incomplete indices with - */ - -static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { - Py_ssize_t __pyx_v_idx; - PyObject *__pyx_v_tup = NULL; - PyObject *__pyx_v_result = NULL; - int __pyx_v_have_slices; - int __pyx_v_seen_ellipsis; - PyObject *__pyx_v_item = NULL; - Py_ssize_t __pyx_v_nslices; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - Py_ssize_t __pyx_t_4; - Py_ssize_t __pyx_t_5; - Py_UCS4 __pyx_t_6; - PyObject *__pyx_t_7 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_unellipsify", 1); - - /* "View.MemoryView":677 - * """ - * cdef Py_ssize_t idx - * tup = index if isinstance(index, tuple) else (index,) # <<<<<<<<<<<<<< - * - * result = [slice(None)] * ndim - */ - __pyx_t_2 = PyTuple_Check(__pyx_v_index); - if (__pyx_t_2) { - __Pyx_INCREF(((PyObject*)__pyx_v_index)); - __pyx_t_1 = __pyx_v_index; - } else { - __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 677, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_v_index); - __Pyx_GIVEREF(__pyx_v_index); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_index)) __PYX_ERR(1, 677, __pyx_L1_error); - __pyx_t_1 = __pyx_t_3; - __pyx_t_3 = 0; - } - __pyx_v_tup = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - - /* "View.MemoryView":679 - * tup = index if isinstance(index, tuple) else (index,) - * - * result = [slice(None)] * ndim # <<<<<<<<<<<<<< - * have_slices = False - * seen_ellipsis = False - */ - __pyx_t_1 = PyList_New(1 * ((__pyx_v_ndim<0) ? 0:__pyx_v_ndim)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 679, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - { Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < __pyx_v_ndim; __pyx_temp++) { - __Pyx_INCREF(__pyx_slice__5); - __Pyx_GIVEREF(__pyx_slice__5); - if (__Pyx_PyList_SET_ITEM(__pyx_t_1, __pyx_temp, __pyx_slice__5)) __PYX_ERR(1, 679, __pyx_L1_error); - } - } - __pyx_v_result = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - - /* "View.MemoryView":680 - * - * result = [slice(None)] * ndim - * have_slices = False # <<<<<<<<<<<<<< - * seen_ellipsis = False - * idx = 0 - */ - __pyx_v_have_slices = 0; - - /* "View.MemoryView":681 - * result = [slice(None)] * ndim - * have_slices = False - * seen_ellipsis = False # <<<<<<<<<<<<<< - * idx = 0 - * for item in tup: - */ - __pyx_v_seen_ellipsis = 0; - - /* "View.MemoryView":682 - * have_slices = False - * seen_ellipsis = False - * idx = 0 # <<<<<<<<<<<<<< - * for item in tup: - * if item is Ellipsis: - */ - __pyx_v_idx = 0; - - /* "View.MemoryView":683 - * seen_ellipsis = False - * idx = 0 - * for item in tup: # <<<<<<<<<<<<<< - * if item is Ellipsis: - * if not seen_ellipsis: - */ - if (unlikely(__pyx_v_tup == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(1, 683, __pyx_L1_error) - } - __pyx_t_1 = __pyx_v_tup; __Pyx_INCREF(__pyx_t_1); - __pyx_t_4 = 0; - for (;;) { - { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 683, __pyx_L1_error) - #endif - if (__pyx_t_4 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_3); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(1, 683, __pyx_L1_error) - #else - __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 683, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_3); - __pyx_t_3 = 0; - - /* "View.MemoryView":684 - * idx = 0 - * for item in tup: - * if item is Ellipsis: # <<<<<<<<<<<<<< - * if not seen_ellipsis: - * idx += ndim - len(tup) - */ - __pyx_t_2 = (__pyx_v_item == __pyx_builtin_Ellipsis); - if (__pyx_t_2) { - - /* "View.MemoryView":685 - * for item in tup: - * if item is Ellipsis: - * if not seen_ellipsis: # <<<<<<<<<<<<<< - * idx += ndim - len(tup) - * seen_ellipsis = True - */ - __pyx_t_2 = (!__pyx_v_seen_ellipsis); - if (__pyx_t_2) { - - /* "View.MemoryView":686 - * if item is Ellipsis: - * if not seen_ellipsis: - * idx += ndim - len(tup) # <<<<<<<<<<<<<< - * seen_ellipsis = True - * have_slices = True - */ - if (unlikely(__pyx_v_tup == Py_None)) { - PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(1, 686, __pyx_L1_error) - } - __pyx_t_5 = __Pyx_PyTuple_GET_SIZE(__pyx_v_tup); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 686, __pyx_L1_error) - __pyx_v_idx = (__pyx_v_idx + (__pyx_v_ndim - __pyx_t_5)); - - /* "View.MemoryView":687 - * if not seen_ellipsis: - * idx += ndim - len(tup) - * seen_ellipsis = True # <<<<<<<<<<<<<< - * have_slices = True - * else: - */ - __pyx_v_seen_ellipsis = 1; - - /* "View.MemoryView":685 - * for item in tup: - * if item is Ellipsis: - * if not seen_ellipsis: # <<<<<<<<<<<<<< - * idx += ndim - len(tup) - * seen_ellipsis = True - */ - } - - /* "View.MemoryView":688 - * idx += ndim - len(tup) - * seen_ellipsis = True - * have_slices = True # <<<<<<<<<<<<<< - * else: - * if isinstance(item, slice): - */ - __pyx_v_have_slices = 1; - - /* "View.MemoryView":684 - * idx = 0 - * for item in tup: - * if item is Ellipsis: # <<<<<<<<<<<<<< - * if not seen_ellipsis: - * idx += ndim - len(tup) - */ - goto __pyx_L5; - } - - /* "View.MemoryView":690 - * have_slices = True - * else: - * if isinstance(item, slice): # <<<<<<<<<<<<<< - * have_slices = True - * elif not PyIndex_Check(item): - */ - /*else*/ { - __pyx_t_2 = PySlice_Check(__pyx_v_item); - if (__pyx_t_2) { - - /* "View.MemoryView":691 - * else: - * if isinstance(item, slice): - * have_slices = True # <<<<<<<<<<<<<< - * elif not PyIndex_Check(item): - * raise TypeError, f"Cannot index with type '{type(item)}'" - */ - __pyx_v_have_slices = 1; - - /* "View.MemoryView":690 - * have_slices = True - * else: - * if isinstance(item, slice): # <<<<<<<<<<<<<< - * have_slices = True - * elif not PyIndex_Check(item): - */ - goto __pyx_L7; - } - - /* "View.MemoryView":692 - * if isinstance(item, slice): - * have_slices = True - * elif not PyIndex_Check(item): # <<<<<<<<<<<<<< - * raise TypeError, f"Cannot index with type '{type(item)}'" - * result[idx] = item - */ - __pyx_t_2 = (!(PyIndex_Check(__pyx_v_item) != 0)); - if (unlikely(__pyx_t_2)) { - - /* "View.MemoryView":693 - * have_slices = True - * elif not PyIndex_Check(item): - * raise TypeError, f"Cannot index with type '{type(item)}'" # <<<<<<<<<<<<<< - * result[idx] = item - * idx += 1 - */ - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 693, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = 0; - __pyx_t_6 = 127; - __Pyx_INCREF(__pyx_kp_u_Cannot_index_with_type); - __pyx_t_5 += 24; - __Pyx_GIVEREF(__pyx_kp_u_Cannot_index_with_type); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_Cannot_index_with_type); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(((PyObject *)Py_TYPE(__pyx_v_item)), __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 693, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_6; - __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7); - __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_kp_u__6); - __pyx_t_5 += 1; - __Pyx_GIVEREF(__pyx_kp_u__6); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__6); - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 693, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_builtin_TypeError, __pyx_t_7, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(1, 693, __pyx_L1_error) - - /* "View.MemoryView":692 - * if isinstance(item, slice): - * have_slices = True - * elif not PyIndex_Check(item): # <<<<<<<<<<<<<< - * raise TypeError, f"Cannot index with type '{type(item)}'" - * result[idx] = item - */ - } - __pyx_L7:; - - /* "View.MemoryView":694 - * elif not PyIndex_Check(item): - * raise TypeError, f"Cannot index with type '{type(item)}'" - * result[idx] = item # <<<<<<<<<<<<<< - * idx += 1 - * - */ - if (unlikely((__Pyx_SetItemInt(__pyx_v_result, __pyx_v_idx, __pyx_v_item, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1) < 0))) __PYX_ERR(1, 694, __pyx_L1_error) - } - __pyx_L5:; - - /* "View.MemoryView":695 - * raise TypeError, f"Cannot index with type '{type(item)}'" - * result[idx] = item - * idx += 1 # <<<<<<<<<<<<<< - * - * nslices = ndim - idx - */ - __pyx_v_idx = (__pyx_v_idx + 1); - - /* "View.MemoryView":683 - * seen_ellipsis = False - * idx = 0 - * for item in tup: # <<<<<<<<<<<<<< - * if item is Ellipsis: - * if not seen_ellipsis: - */ - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "View.MemoryView":697 - * idx += 1 - * - * nslices = ndim - idx # <<<<<<<<<<<<<< - * return have_slices or nslices, tuple(result) - * - */ - __pyx_v_nslices = (__pyx_v_ndim - __pyx_v_idx); - - /* "View.MemoryView":698 - * - * nslices = ndim - idx - * return have_slices or nslices, tuple(result) # <<<<<<<<<<<<<< - * - * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: - */ - __Pyx_XDECREF(__pyx_r); - if (!__pyx_v_have_slices) { - } else { - __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_have_slices); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 698, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_1 = __pyx_t_7; - __pyx_t_7 = 0; - goto __pyx_L9_bool_binop_done; - } - __pyx_t_7 = PyInt_FromSsize_t(__pyx_v_nslices); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 698, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_1 = __pyx_t_7; - __pyx_t_7 = 0; - __pyx_L9_bool_binop_done:; - __pyx_t_7 = PyList_AsTuple(__pyx_v_result); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 698, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 698, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1)) __PYX_ERR(1, 698, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7)) __PYX_ERR(1, 698, __pyx_L1_error); - __pyx_t_1 = 0; - __pyx_t_7 = 0; - __pyx_r = ((PyObject*)__pyx_t_3); - __pyx_t_3 = 0; - goto __pyx_L0; - - /* "View.MemoryView":671 - * return isinstance(o, memoryview) - * - * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< - * """ - * Replace all ellipses with full slices and fill incomplete indices with - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_AddTraceback("View.MemoryView._unellipsify", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_tup); - __Pyx_XDECREF(__pyx_v_result); - __Pyx_XDECREF(__pyx_v_item); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":700 - * return have_slices or nslices, tuple(result) - * - * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: # <<<<<<<<<<<<<< - * for suboffset in suboffsets[:ndim]: - * if suboffset >= 0: - */ - -static int assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __pyx_v_ndim) { - Py_ssize_t __pyx_v_suboffset; - int __pyx_r; - Py_ssize_t *__pyx_t_1; - Py_ssize_t *__pyx_t_2; - Py_ssize_t *__pyx_t_3; - int __pyx_t_4; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - - /* "View.MemoryView":701 - * - * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: - * for suboffset in suboffsets[:ndim]: # <<<<<<<<<<<<<< - * if suboffset >= 0: - * raise ValueError, "Indirect dimensions not supported" - */ - __pyx_t_2 = (__pyx_v_suboffsets + __pyx_v_ndim); - for (__pyx_t_3 = __pyx_v_suboffsets; __pyx_t_3 < __pyx_t_2; __pyx_t_3++) { - __pyx_t_1 = __pyx_t_3; - __pyx_v_suboffset = (__pyx_t_1[0]); - - /* "View.MemoryView":702 - * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: - * for suboffset in suboffsets[:ndim]: - * if suboffset >= 0: # <<<<<<<<<<<<<< - * raise ValueError, "Indirect dimensions not supported" - * return 0 # return type just used as an error flag - */ - __pyx_t_4 = (__pyx_v_suboffset >= 0); - if (unlikely(__pyx_t_4)) { - - /* "View.MemoryView":703 - * for suboffset in suboffsets[:ndim]: - * if suboffset >= 0: - * raise ValueError, "Indirect dimensions not supported" # <<<<<<<<<<<<<< - * return 0 # return type just used as an error flag - * - */ - __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Indirect_dimensions_not_supporte, 0, 0); - __PYX_ERR(1, 703, __pyx_L1_error) - - /* "View.MemoryView":702 - * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: - * for suboffset in suboffsets[:ndim]: - * if suboffset >= 0: # <<<<<<<<<<<<<< - * raise ValueError, "Indirect dimensions not supported" - * return 0 # return type just used as an error flag - */ - } - } - - /* "View.MemoryView":704 - * if suboffset >= 0: - * raise ValueError, "Indirect dimensions not supported" - * return 0 # return type just used as an error flag # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = 0; - goto __pyx_L0; - - /* "View.MemoryView":700 - * return have_slices or nslices, tuple(result) - * - * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: # <<<<<<<<<<<<<< - * for suboffset in suboffsets[:ndim]: - * if suboffset >= 0: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("View.MemoryView.assert_direct_dimensions", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":711 - * - * @cname('__pyx_memview_slice') - * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< - * cdef int new_ndim = 0, suboffset_dim = -1, dim - * cdef bint negative_step - */ - -static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *__pyx_v_memview, PyObject *__pyx_v_indices) { - int __pyx_v_new_ndim; - int __pyx_v_suboffset_dim; - int __pyx_v_dim; - __Pyx_memviewslice __pyx_v_src; - __Pyx_memviewslice __pyx_v_dst; - __Pyx_memviewslice *__pyx_v_p_src; - struct __pyx_memoryviewslice_obj *__pyx_v_memviewsliceobj = 0; - __Pyx_memviewslice *__pyx_v_p_dst; - int *__pyx_v_p_suboffset_dim; - Py_ssize_t __pyx_v_start; - Py_ssize_t __pyx_v_stop; - Py_ssize_t __pyx_v_step; - Py_ssize_t __pyx_v_cindex; - int __pyx_v_have_start; - int __pyx_v_have_stop; - int __pyx_v_have_step; - PyObject *__pyx_v_index = NULL; - struct __pyx_memoryview_obj *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - struct __pyx_memoryview_obj *__pyx_t_3; - char *__pyx_t_4; - int __pyx_t_5; - Py_ssize_t __pyx_t_6; - PyObject *(*__pyx_t_7)(PyObject *); - PyObject *__pyx_t_8 = NULL; - Py_ssize_t __pyx_t_9; - int __pyx_t_10; - Py_ssize_t __pyx_t_11; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("memview_slice", 1); - - /* "View.MemoryView":712 - * @cname('__pyx_memview_slice') - * cdef memoryview memview_slice(memoryview memview, object indices): - * cdef int new_ndim = 0, suboffset_dim = -1, dim # <<<<<<<<<<<<<< - * cdef bint negative_step - * cdef __Pyx_memviewslice src, dst - */ - __pyx_v_new_ndim = 0; - __pyx_v_suboffset_dim = -1; - - /* "View.MemoryView":719 - * - * - * memset(&dst, 0, sizeof(dst)) # <<<<<<<<<<<<<< - * - * cdef _memoryviewslice memviewsliceobj - */ - (void)(memset((&__pyx_v_dst), 0, (sizeof(__pyx_v_dst)))); - - /* "View.MemoryView":723 - * cdef _memoryviewslice memviewsliceobj - * - * assert memview.view.ndim > 0 # <<<<<<<<<<<<<< - * - * if isinstance(memview, _memoryviewslice): - */ - #ifndef CYTHON_WITHOUT_ASSERTIONS - if (unlikely(__pyx_assertions_enabled())) { - __pyx_t_1 = (__pyx_v_memview->view.ndim > 0); - if (unlikely(!__pyx_t_1)) { - __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); - __PYX_ERR(1, 723, __pyx_L1_error) - } - } - #else - if ((1)); else __PYX_ERR(1, 723, __pyx_L1_error) - #endif - - /* "View.MemoryView":725 - * assert memview.view.ndim > 0 - * - * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< - * memviewsliceobj = memview - * p_src = &memviewsliceobj.from_slice - */ - __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); - if (__pyx_t_1) { - - /* "View.MemoryView":726 - * - * 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(1, 726, __pyx_L1_error) - __pyx_t_2 = ((PyObject *)__pyx_v_memview); - __Pyx_INCREF(__pyx_t_2); - __pyx_v_memviewsliceobj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); - __pyx_t_2 = 0; - - /* "View.MemoryView":727 - * if isinstance(memview, _memoryviewslice): - * memviewsliceobj = memview - * p_src = &memviewsliceobj.from_slice # <<<<<<<<<<<<<< - * else: - * slice_copy(memview, &src) - */ - __pyx_v_p_src = (&__pyx_v_memviewsliceobj->from_slice); - - /* "View.MemoryView":725 - * assert memview.view.ndim > 0 - * - * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< - * memviewsliceobj = memview - * p_src = &memviewsliceobj.from_slice - */ - goto __pyx_L3; - } - - /* "View.MemoryView":729 - * p_src = &memviewsliceobj.from_slice - * else: - * slice_copy(memview, &src) # <<<<<<<<<<<<<< - * p_src = &src - * - */ - /*else*/ { - __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_src)); - - /* "View.MemoryView":730 - * else: - * slice_copy(memview, &src) - * p_src = &src # <<<<<<<<<<<<<< - * - * - */ - __pyx_v_p_src = (&__pyx_v_src); - } - __pyx_L3:; - - /* "View.MemoryView":736 - * - * - * dst.memview = p_src.memview # <<<<<<<<<<<<<< - * dst.data = p_src.data - * - */ - __pyx_t_3 = __pyx_v_p_src->memview; - __pyx_v_dst.memview = __pyx_t_3; - - /* "View.MemoryView":737 - * - * dst.memview = p_src.memview - * dst.data = p_src.data # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_4 = __pyx_v_p_src->data; - __pyx_v_dst.data = __pyx_t_4; - - /* "View.MemoryView":742 - * - * - * cdef __Pyx_memviewslice *p_dst = &dst # <<<<<<<<<<<<<< - * cdef int *p_suboffset_dim = &suboffset_dim - * cdef Py_ssize_t start, stop, step, cindex - */ - __pyx_v_p_dst = (&__pyx_v_dst); - - /* "View.MemoryView":743 - * - * cdef __Pyx_memviewslice *p_dst = &dst - * cdef int *p_suboffset_dim = &suboffset_dim # <<<<<<<<<<<<<< - * cdef Py_ssize_t start, stop, step, cindex - * cdef bint have_start, have_stop, have_step - */ - __pyx_v_p_suboffset_dim = (&__pyx_v_suboffset_dim); - - /* "View.MemoryView":747 - * cdef bint have_start, have_stop, have_step - * - * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< - * if PyIndex_Check(index): - * cindex = index - */ - __pyx_t_5 = 0; - if (likely(PyList_CheckExact(__pyx_v_indices)) || PyTuple_CheckExact(__pyx_v_indices)) { - __pyx_t_2 = __pyx_v_indices; __Pyx_INCREF(__pyx_t_2); - __pyx_t_6 = 0; - __pyx_t_7 = NULL; - } else { - __pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_indices); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 747, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 747, __pyx_L1_error) - } - for (;;) { - if (likely(!__pyx_t_7)) { - if (likely(PyList_CheckExact(__pyx_t_2))) { - { - Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 747, __pyx_L1_error) - #endif - if (__pyx_t_6 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_8 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_8); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(1, 747, __pyx_L1_error) - #else - __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 747, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - #endif - } else { - { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 747, __pyx_L1_error) - #endif - if (__pyx_t_6 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_8); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(1, 747, __pyx_L1_error) - #else - __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 747, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - #endif - } - } else { - __pyx_t_8 = __pyx_t_7(__pyx_t_2); - if (unlikely(!__pyx_t_8)) { - PyObject* exc_type = PyErr_Occurred(); - if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 747, __pyx_L1_error) - } - break; - } - __Pyx_GOTREF(__pyx_t_8); - } - __Pyx_XDECREF_SET(__pyx_v_index, __pyx_t_8); - __pyx_t_8 = 0; - __pyx_v_dim = __pyx_t_5; - __pyx_t_5 = (__pyx_t_5 + 1); - - /* "View.MemoryView":748 - * - * for dim, index in enumerate(indices): - * if PyIndex_Check(index): # <<<<<<<<<<<<<< - * cindex = index - * slice_memviewslice( - */ - __pyx_t_1 = (PyIndex_Check(__pyx_v_index) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":749 - * for dim, index in enumerate(indices): - * if PyIndex_Check(index): - * cindex = index # <<<<<<<<<<<<<< - * slice_memviewslice( - * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], - */ - __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_v_index); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 749, __pyx_L1_error) - __pyx_v_cindex = __pyx_t_9; - - /* "View.MemoryView":750 - * if PyIndex_Check(index): - * cindex = 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_10 = __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_cindex, 0, 0, 0, 0, 0, 0); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(1, 750, __pyx_L1_error) - - /* "View.MemoryView":748 - * - * for dim, index in enumerate(indices): - * if PyIndex_Check(index): # <<<<<<<<<<<<<< - * cindex = index - * slice_memviewslice( - */ - goto __pyx_L6; - } - - /* "View.MemoryView":756 - * 0, 0, 0, # have_{start,stop,step} - * False) - * elif index is None: # <<<<<<<<<<<<<< - * p_dst.shape[new_ndim] = 1 - * p_dst.strides[new_ndim] = 0 - */ - __pyx_t_1 = (__pyx_v_index == Py_None); - if (__pyx_t_1) { - - /* "View.MemoryView":757 - * False) - * elif index is None: - * p_dst.shape[new_ndim] = 1 # <<<<<<<<<<<<<< - * p_dst.strides[new_ndim] = 0 - * p_dst.suboffsets[new_ndim] = -1 - */ - (__pyx_v_p_dst->shape[__pyx_v_new_ndim]) = 1; - - /* "View.MemoryView":758 - * elif index is None: - * p_dst.shape[new_ndim] = 1 - * p_dst.strides[new_ndim] = 0 # <<<<<<<<<<<<<< - * p_dst.suboffsets[new_ndim] = -1 - * new_ndim += 1 - */ - (__pyx_v_p_dst->strides[__pyx_v_new_ndim]) = 0; - - /* "View.MemoryView":759 - * p_dst.shape[new_ndim] = 1 - * p_dst.strides[new_ndim] = 0 - * p_dst.suboffsets[new_ndim] = -1 # <<<<<<<<<<<<<< - * new_ndim += 1 - * else: - */ - (__pyx_v_p_dst->suboffsets[__pyx_v_new_ndim]) = -1L; - - /* "View.MemoryView":760 - * p_dst.strides[new_ndim] = 0 - * p_dst.suboffsets[new_ndim] = -1 - * new_ndim += 1 # <<<<<<<<<<<<<< - * else: - * start = index.start or 0 - */ - __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); - - /* "View.MemoryView":756 - * 0, 0, 0, # have_{start,stop,step} - * False) - * elif index is None: # <<<<<<<<<<<<<< - * p_dst.shape[new_ndim] = 1 - * p_dst.strides[new_ndim] = 0 - */ - goto __pyx_L6; - } - - /* "View.MemoryView":762 - * new_ndim += 1 - * else: - * start = index.start or 0 # <<<<<<<<<<<<<< - * stop = index.stop or 0 - * step = index.step or 0 - */ - /*else*/ { - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 762, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 762, __pyx_L1_error) - if (!__pyx_t_1) { - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - } else { - __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_t_8); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 762, __pyx_L1_error) - __pyx_t_9 = __pyx_t_11; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - goto __pyx_L7_bool_binop_done; - } - __pyx_t_9 = 0; - __pyx_L7_bool_binop_done:; - __pyx_v_start = __pyx_t_9; - - /* "View.MemoryView":763 - * else: - * start = index.start or 0 - * stop = index.stop or 0 # <<<<<<<<<<<<<< - * step = index.step or 0 - * - */ - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 763, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 763, __pyx_L1_error) - if (!__pyx_t_1) { - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - } else { - __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_t_8); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 763, __pyx_L1_error) - __pyx_t_9 = __pyx_t_11; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - goto __pyx_L9_bool_binop_done; - } - __pyx_t_9 = 0; - __pyx_L9_bool_binop_done:; - __pyx_v_stop = __pyx_t_9; - - /* "View.MemoryView":764 - * start = index.start or 0 - * stop = index.stop or 0 - * step = index.step or 0 # <<<<<<<<<<<<<< - * - * have_start = index.start is not None - */ - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 764, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 764, __pyx_L1_error) - if (!__pyx_t_1) { - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - } else { - __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_t_8); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 764, __pyx_L1_error) - __pyx_t_9 = __pyx_t_11; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - goto __pyx_L11_bool_binop_done; - } - __pyx_t_9 = 0; - __pyx_L11_bool_binop_done:; - __pyx_v_step = __pyx_t_9; - - /* "View.MemoryView":766 - * 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_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 766, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_1 = (__pyx_t_8 != Py_None); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_v_have_start = __pyx_t_1; - - /* "View.MemoryView":767 - * - * have_start = index.start is not None - * have_stop = index.stop is not None # <<<<<<<<<<<<<< - * have_step = index.step is not None - * - */ - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 767, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_1 = (__pyx_t_8 != Py_None); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_v_have_stop = __pyx_t_1; - - /* "View.MemoryView":768 - * 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_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 768, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_1 = (__pyx_t_8 != Py_None); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_v_have_step = __pyx_t_1; - - /* "View.MemoryView":770 - * 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_10 = __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_10 == ((int)-1))) __PYX_ERR(1, 770, __pyx_L1_error) - - /* "View.MemoryView":776 - * have_start, have_stop, have_step, - * True) - * new_ndim += 1 # <<<<<<<<<<<<<< - * - * if isinstance(memview, _memoryviewslice): - */ - __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); - } - __pyx_L6:; - - /* "View.MemoryView":747 - * cdef bint have_start, have_stop, have_step - * - * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< - * if PyIndex_Check(index): - * cindex = index - */ - } - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "View.MemoryView":778 - * new_ndim += 1 - * - * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< - * return memoryview_fromslice(dst, new_ndim, - * memviewsliceobj.to_object_func, - */ - __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); - if (__pyx_t_1) { - - /* "View.MemoryView":779 - * - * if isinstance(memview, _memoryviewslice): - * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< - * memviewsliceobj.to_object_func, - * memviewsliceobj.to_dtype_func, - */ - __Pyx_XDECREF((PyObject *)__pyx_r); - - /* "View.MemoryView":780 - * 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(1, 780, __pyx_L1_error) } - - /* "View.MemoryView":781 - * 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(1, 781, __pyx_L1_error) } - - /* "View.MemoryView":779 - * - * if isinstance(memview, _memoryviewslice): - * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< - * memviewsliceobj.to_object_func, - * memviewsliceobj.to_dtype_func, - */ - __pyx_t_2 = __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_2)) __PYX_ERR(1, 779, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_memoryview_type))))) __PYX_ERR(1, 779, __pyx_L1_error) - __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_2); - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":778 - * new_ndim += 1 - * - * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< - * return memoryview_fromslice(dst, new_ndim, - * memviewsliceobj.to_object_func, - */ - } - - /* "View.MemoryView":784 - * memview.dtype_is_object) - * else: - * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< - * memview.dtype_is_object) - * - */ - /*else*/ { - __Pyx_XDECREF((PyObject *)__pyx_r); - - /* "View.MemoryView":785 - * else: - * return memoryview_fromslice(dst, new_ndim, NULL, NULL, - * memview.dtype_is_object) # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_2 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, NULL, NULL, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 784, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - - /* "View.MemoryView":784 - * memview.dtype_is_object) - * else: - * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< - * memview.dtype_is_object) - * - */ - if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_memoryview_type))))) __PYX_ERR(1, 784, __pyx_L1_error) - __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_2); - __pyx_t_2 = 0; - goto __pyx_L0; - } - - /* "View.MemoryView":711 - * - * @cname('__pyx_memview_slice') - * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< - * cdef int new_ndim = 0, suboffset_dim = -1, dim - * cdef bint negative_step - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("View.MemoryView.memview_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_memviewsliceobj); - __Pyx_XDECREF(__pyx_v_index); - __Pyx_XGIVEREF((PyObject *)__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":793 - * - * @cname('__pyx_memoryview_slice_memviewslice') - * cdef int slice_memviewslice( # <<<<<<<<<<<<<< - * __Pyx_memviewslice *dst, - * Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, - */ - -static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, Py_ssize_t __pyx_v_shape, Py_ssize_t __pyx_v_stride, Py_ssize_t __pyx_v_suboffset, int __pyx_v_dim, int __pyx_v_new_ndim, int *__pyx_v_suboffset_dim, Py_ssize_t __pyx_v_start, Py_ssize_t __pyx_v_stop, Py_ssize_t __pyx_v_step, int __pyx_v_have_start, int __pyx_v_have_stop, int __pyx_v_have_step, int __pyx_v_is_slice) { - Py_ssize_t __pyx_v_new_shape; - int __pyx_v_negative_step; - int __pyx_r; - 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; - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save; - #endif - - /* "View.MemoryView":813 - * cdef bint negative_step - * - * if not is_slice: # <<<<<<<<<<<<<< - * - * if start < 0: - */ - __pyx_t_1 = (!__pyx_v_is_slice); - if (__pyx_t_1) { - - /* "View.MemoryView":815 - * if not is_slice: - * - * if start < 0: # <<<<<<<<<<<<<< - * start += shape - * if not 0 <= start < shape: - */ - __pyx_t_1 = (__pyx_v_start < 0); - if (__pyx_t_1) { - - /* "View.MemoryView":816 - * - * if start < 0: - * start += shape # <<<<<<<<<<<<<< - * if not 0 <= start < shape: - * _err_dim(PyExc_IndexError, "Index out of bounds (axis %d)", dim) - */ - __pyx_v_start = (__pyx_v_start + __pyx_v_shape); - - /* "View.MemoryView":815 - * if not is_slice: - * - * if start < 0: # <<<<<<<<<<<<<< - * start += shape - * if not 0 <= start < shape: - */ - } - - /* "View.MemoryView":817 - * if start < 0: - * start += shape - * if not 0 <= start < shape: # <<<<<<<<<<<<<< - * _err_dim(PyExc_IndexError, "Index out of bounds (axis %d)", dim) - * else: - */ - __pyx_t_1 = (0 <= __pyx_v_start); - if (__pyx_t_1) { - __pyx_t_1 = (__pyx_v_start < __pyx_v_shape); - } - __pyx_t_2 = (!__pyx_t_1); - if (__pyx_t_2) { - - /* "View.MemoryView":818 - * start += shape - * if not 0 <= start < shape: - * _err_dim(PyExc_IndexError, "Index out of bounds (axis %d)", dim) # <<<<<<<<<<<<<< - * else: - * - */ - __pyx_t_3 = __pyx_memoryview_err_dim(PyExc_IndexError, __pyx_kp_s_Index_out_of_bounds_axis_d, __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 818, __pyx_L1_error) - - /* "View.MemoryView":817 - * if start < 0: - * start += shape - * if not 0 <= start < shape: # <<<<<<<<<<<<<< - * _err_dim(PyExc_IndexError, "Index out of bounds (axis %d)", dim) - * else: - */ - } - - /* "View.MemoryView":813 - * cdef bint negative_step - * - * if not is_slice: # <<<<<<<<<<<<<< - * - * if start < 0: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":821 - * else: - * - * if have_step: # <<<<<<<<<<<<<< - * negative_step = step < 0 - * if step == 0: - */ - /*else*/ { - __pyx_t_2 = (__pyx_v_have_step != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":822 - * - * if have_step: - * negative_step = step < 0 # <<<<<<<<<<<<<< - * if step == 0: - * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) - */ - __pyx_v_negative_step = (__pyx_v_step < 0); - - /* "View.MemoryView":823 - * if have_step: - * negative_step = step < 0 - * if step == 0: # <<<<<<<<<<<<<< - * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) - * else: - */ - __pyx_t_2 = (__pyx_v_step == 0); - if (__pyx_t_2) { - - /* "View.MemoryView":824 - * negative_step = step < 0 - * if step == 0: - * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) # <<<<<<<<<<<<<< - * else: - * negative_step = False - */ - __pyx_t_3 = __pyx_memoryview_err_dim(PyExc_ValueError, __pyx_kp_s_Step_may_not_be_zero_axis_d, __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 824, __pyx_L1_error) - - /* "View.MemoryView":823 - * if have_step: - * negative_step = step < 0 - * if step == 0: # <<<<<<<<<<<<<< - * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) - * else: - */ - } - - /* "View.MemoryView":821 - * else: - * - * if have_step: # <<<<<<<<<<<<<< - * negative_step = step < 0 - * if step == 0: - */ - goto __pyx_L6; - } - - /* "View.MemoryView":826 - * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) - * else: - * negative_step = False # <<<<<<<<<<<<<< - * step = 1 - * - */ - /*else*/ { - __pyx_v_negative_step = 0; - - /* "View.MemoryView":827 - * else: - * negative_step = False - * step = 1 # <<<<<<<<<<<<<< - * - * - */ - __pyx_v_step = 1; - } - __pyx_L6:; - - /* "View.MemoryView":830 - * - * - * if have_start: # <<<<<<<<<<<<<< - * if start < 0: - * start += shape - */ - __pyx_t_2 = (__pyx_v_have_start != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":831 - * - * if have_start: - * if start < 0: # <<<<<<<<<<<<<< - * start += shape - * if start < 0: - */ - __pyx_t_2 = (__pyx_v_start < 0); - if (__pyx_t_2) { - - /* "View.MemoryView":832 - * if have_start: - * if start < 0: - * start += shape # <<<<<<<<<<<<<< - * if start < 0: - * start = 0 - */ - __pyx_v_start = (__pyx_v_start + __pyx_v_shape); - - /* "View.MemoryView":833 - * if start < 0: - * start += shape - * if start < 0: # <<<<<<<<<<<<<< - * start = 0 - * elif start >= shape: - */ - __pyx_t_2 = (__pyx_v_start < 0); - if (__pyx_t_2) { - - /* "View.MemoryView":834 - * start += shape - * if start < 0: - * start = 0 # <<<<<<<<<<<<<< - * elif start >= shape: - * if negative_step: - */ - __pyx_v_start = 0; - - /* "View.MemoryView":833 - * if start < 0: - * start += shape - * if start < 0: # <<<<<<<<<<<<<< - * start = 0 - * elif start >= shape: - */ - } - - /* "View.MemoryView":831 - * - * if have_start: - * if start < 0: # <<<<<<<<<<<<<< - * start += shape - * if start < 0: - */ - goto __pyx_L9; - } - - /* "View.MemoryView":835 - * if start < 0: - * start = 0 - * elif start >= shape: # <<<<<<<<<<<<<< - * if negative_step: - * start = shape - 1 - */ - __pyx_t_2 = (__pyx_v_start >= __pyx_v_shape); - if (__pyx_t_2) { - - /* "View.MemoryView":836 - * start = 0 - * elif start >= shape: - * if negative_step: # <<<<<<<<<<<<<< - * start = shape - 1 - * else: - */ - if (__pyx_v_negative_step) { - - /* "View.MemoryView":837 - * elif start >= shape: - * if negative_step: - * start = shape - 1 # <<<<<<<<<<<<<< - * else: - * start = shape - */ - __pyx_v_start = (__pyx_v_shape - 1); - - /* "View.MemoryView":836 - * start = 0 - * elif start >= shape: - * if negative_step: # <<<<<<<<<<<<<< - * start = shape - 1 - * else: - */ - goto __pyx_L11; - } - - /* "View.MemoryView":839 - * start = shape - 1 - * else: - * start = shape # <<<<<<<<<<<<<< - * else: - * if negative_step: - */ - /*else*/ { - __pyx_v_start = __pyx_v_shape; - } - __pyx_L11:; - - /* "View.MemoryView":835 - * if start < 0: - * start = 0 - * elif start >= shape: # <<<<<<<<<<<<<< - * if negative_step: - * start = shape - 1 - */ - } - __pyx_L9:; - - /* "View.MemoryView":830 - * - * - * if have_start: # <<<<<<<<<<<<<< - * if start < 0: - * start += shape - */ - goto __pyx_L8; - } - - /* "View.MemoryView":841 - * start = shape - * else: - * if negative_step: # <<<<<<<<<<<<<< - * start = shape - 1 - * else: - */ - /*else*/ { - if (__pyx_v_negative_step) { - - /* "View.MemoryView":842 - * else: - * if negative_step: - * start = shape - 1 # <<<<<<<<<<<<<< - * else: - * start = 0 - */ - __pyx_v_start = (__pyx_v_shape - 1); - - /* "View.MemoryView":841 - * start = shape - * else: - * if negative_step: # <<<<<<<<<<<<<< - * start = shape - 1 - * else: - */ - goto __pyx_L12; - } - - /* "View.MemoryView":844 - * start = shape - 1 - * else: - * start = 0 # <<<<<<<<<<<<<< - * - * if have_stop: - */ - /*else*/ { - __pyx_v_start = 0; - } - __pyx_L12:; - } - __pyx_L8:; - - /* "View.MemoryView":846 - * start = 0 - * - * if have_stop: # <<<<<<<<<<<<<< - * if stop < 0: - * stop += shape - */ - __pyx_t_2 = (__pyx_v_have_stop != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":847 - * - * if have_stop: - * if stop < 0: # <<<<<<<<<<<<<< - * stop += shape - * if stop < 0: - */ - __pyx_t_2 = (__pyx_v_stop < 0); - if (__pyx_t_2) { - - /* "View.MemoryView":848 - * if have_stop: - * if stop < 0: - * stop += shape # <<<<<<<<<<<<<< - * if stop < 0: - * stop = 0 - */ - __pyx_v_stop = (__pyx_v_stop + __pyx_v_shape); - - /* "View.MemoryView":849 - * if stop < 0: - * stop += shape - * if stop < 0: # <<<<<<<<<<<<<< - * stop = 0 - * elif stop > shape: - */ - __pyx_t_2 = (__pyx_v_stop < 0); - if (__pyx_t_2) { - - /* "View.MemoryView":850 - * stop += shape - * if stop < 0: - * stop = 0 # <<<<<<<<<<<<<< - * elif stop > shape: - * stop = shape - */ - __pyx_v_stop = 0; - - /* "View.MemoryView":849 - * if stop < 0: - * stop += shape - * if stop < 0: # <<<<<<<<<<<<<< - * stop = 0 - * elif stop > shape: - */ - } - - /* "View.MemoryView":847 - * - * if have_stop: - * if stop < 0: # <<<<<<<<<<<<<< - * stop += shape - * if stop < 0: - */ - goto __pyx_L14; - } - - /* "View.MemoryView":851 - * if stop < 0: - * stop = 0 - * elif stop > shape: # <<<<<<<<<<<<<< - * stop = shape - * else: - */ - __pyx_t_2 = (__pyx_v_stop > __pyx_v_shape); - if (__pyx_t_2) { - - /* "View.MemoryView":852 - * stop = 0 - * elif stop > shape: - * stop = shape # <<<<<<<<<<<<<< - * else: - * if negative_step: - */ - __pyx_v_stop = __pyx_v_shape; - - /* "View.MemoryView":851 - * if stop < 0: - * stop = 0 - * elif stop > shape: # <<<<<<<<<<<<<< - * stop = shape - * else: - */ - } - __pyx_L14:; - - /* "View.MemoryView":846 - * start = 0 - * - * if have_stop: # <<<<<<<<<<<<<< - * if stop < 0: - * stop += shape - */ - goto __pyx_L13; - } - - /* "View.MemoryView":854 - * stop = shape - * else: - * if negative_step: # <<<<<<<<<<<<<< - * stop = -1 - * else: - */ - /*else*/ { - if (__pyx_v_negative_step) { - - /* "View.MemoryView":855 - * else: - * if negative_step: - * stop = -1 # <<<<<<<<<<<<<< - * else: - * stop = shape - */ - __pyx_v_stop = -1L; - - /* "View.MemoryView":854 - * stop = shape - * else: - * if negative_step: # <<<<<<<<<<<<<< - * stop = -1 - * else: - */ - goto __pyx_L16; - } - - /* "View.MemoryView":857 - * stop = -1 - * else: - * stop = shape # <<<<<<<<<<<<<< - * - * - */ - /*else*/ { - __pyx_v_stop = __pyx_v_shape; - } - __pyx_L16:; - } - __pyx_L13:; - - /* "View.MemoryView":861 - * - * with cython.cdivision(True): - * new_shape = (stop - start) // step # <<<<<<<<<<<<<< - * - * if (stop - start) - step * new_shape: - */ - __pyx_v_new_shape = ((__pyx_v_stop - __pyx_v_start) / __pyx_v_step); - - /* "View.MemoryView":863 - * new_shape = (stop - start) // step - * - * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< - * new_shape += 1 - * - */ - __pyx_t_2 = (((__pyx_v_stop - __pyx_v_start) - (__pyx_v_step * __pyx_v_new_shape)) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":864 - * - * if (stop - start) - step * new_shape: - * new_shape += 1 # <<<<<<<<<<<<<< - * - * if new_shape < 0: - */ - __pyx_v_new_shape = (__pyx_v_new_shape + 1); - - /* "View.MemoryView":863 - * new_shape = (stop - start) // step - * - * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< - * new_shape += 1 - * - */ - } - - /* "View.MemoryView":866 - * new_shape += 1 - * - * if new_shape < 0: # <<<<<<<<<<<<<< - * new_shape = 0 - * - */ - __pyx_t_2 = (__pyx_v_new_shape < 0); - if (__pyx_t_2) { - - /* "View.MemoryView":867 - * - * if new_shape < 0: - * new_shape = 0 # <<<<<<<<<<<<<< - * - * - */ - __pyx_v_new_shape = 0; - - /* "View.MemoryView":866 - * new_shape += 1 - * - * if new_shape < 0: # <<<<<<<<<<<<<< - * new_shape = 0 - * - */ - } - - /* "View.MemoryView":870 - * - * - * dst.strides[new_ndim] = stride * step # <<<<<<<<<<<<<< - * dst.shape[new_ndim] = new_shape - * dst.suboffsets[new_ndim] = suboffset - */ - (__pyx_v_dst->strides[__pyx_v_new_ndim]) = (__pyx_v_stride * __pyx_v_step); - - /* "View.MemoryView":871 - * - * dst.strides[new_ndim] = stride * step - * dst.shape[new_ndim] = new_shape # <<<<<<<<<<<<<< - * dst.suboffsets[new_ndim] = suboffset - * - */ - (__pyx_v_dst->shape[__pyx_v_new_ndim]) = __pyx_v_new_shape; - - /* "View.MemoryView":872 - * dst.strides[new_ndim] = stride * step - * dst.shape[new_ndim] = new_shape - * dst.suboffsets[new_ndim] = suboffset # <<<<<<<<<<<<<< - * - * - */ - (__pyx_v_dst->suboffsets[__pyx_v_new_ndim]) = __pyx_v_suboffset; - } - __pyx_L3:; - - /* "View.MemoryView":875 - * - * - * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< - * dst.data += start * stride - * else: - */ - __pyx_t_2 = ((__pyx_v_suboffset_dim[0]) < 0); - if (__pyx_t_2) { - - /* "View.MemoryView":876 - * - * if suboffset_dim[0] < 0: - * dst.data += start * stride # <<<<<<<<<<<<<< - * else: - * dst.suboffsets[suboffset_dim[0]] += start * stride - */ - __pyx_v_dst->data = (__pyx_v_dst->data + (__pyx_v_start * __pyx_v_stride)); - - /* "View.MemoryView":875 - * - * - * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< - * dst.data += start * stride - * else: - */ - goto __pyx_L19; - } - - /* "View.MemoryView":878 - * dst.data += start * stride - * else: - * dst.suboffsets[suboffset_dim[0]] += start * stride # <<<<<<<<<<<<<< - * - * if suboffset >= 0: - */ - /*else*/ { - __pyx_t_3 = (__pyx_v_suboffset_dim[0]); - (__pyx_v_dst->suboffsets[__pyx_t_3]) = ((__pyx_v_dst->suboffsets[__pyx_t_3]) + (__pyx_v_start * __pyx_v_stride)); - } - __pyx_L19:; - - /* "View.MemoryView":880 - * dst.suboffsets[suboffset_dim[0]] += start * stride - * - * if suboffset >= 0: # <<<<<<<<<<<<<< - * if not is_slice: - * if new_ndim == 0: - */ - __pyx_t_2 = (__pyx_v_suboffset >= 0); - if (__pyx_t_2) { - - /* "View.MemoryView":881 - * - * if suboffset >= 0: - * if not is_slice: # <<<<<<<<<<<<<< - * if new_ndim == 0: - * dst.data = ( dst.data)[0] + suboffset - */ - __pyx_t_2 = (!__pyx_v_is_slice); - if (__pyx_t_2) { - - /* "View.MemoryView":882 - * if suboffset >= 0: - * if not is_slice: - * if new_ndim == 0: # <<<<<<<<<<<<<< - * dst.data = ( dst.data)[0] + suboffset - * else: - */ - __pyx_t_2 = (__pyx_v_new_ndim == 0); - if (__pyx_t_2) { - - /* "View.MemoryView":883 - * if not is_slice: - * if new_ndim == 0: - * dst.data = ( dst.data)[0] + suboffset # <<<<<<<<<<<<<< - * else: - * _err_dim(PyExc_IndexError, "All dimensions preceding dimension %d " - */ - __pyx_v_dst->data = ((((char **)__pyx_v_dst->data)[0]) + __pyx_v_suboffset); - - /* "View.MemoryView":882 - * if suboffset >= 0: - * if not is_slice: - * if new_ndim == 0: # <<<<<<<<<<<<<< - * dst.data = ( dst.data)[0] + suboffset - * else: - */ - goto __pyx_L22; - } - - /* "View.MemoryView":885 - * dst.data = ( dst.data)[0] + suboffset - * else: - * _err_dim(PyExc_IndexError, "All dimensions preceding dimension %d " # <<<<<<<<<<<<<< - * "must be indexed and not sliced", dim) - * else: - */ - /*else*/ { - - /* "View.MemoryView":886 - * else: - * _err_dim(PyExc_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(PyExc_IndexError, __pyx_kp_s_All_dimensions_preceding_dimensi, __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 885, __pyx_L1_error) - } - __pyx_L22:; - - /* "View.MemoryView":881 - * - * if suboffset >= 0: - * if not is_slice: # <<<<<<<<<<<<<< - * if new_ndim == 0: - * dst.data = ( dst.data)[0] + suboffset - */ - goto __pyx_L21; - } - - /* "View.MemoryView":888 - * "must be indexed and not sliced", dim) - * else: - * suboffset_dim[0] = new_ndim # <<<<<<<<<<<<<< - * - * return 0 - */ - /*else*/ { - (__pyx_v_suboffset_dim[0]) = __pyx_v_new_ndim; - } - __pyx_L21:; - - /* "View.MemoryView":880 - * dst.suboffsets[suboffset_dim[0]] += start * stride - * - * if suboffset >= 0: # <<<<<<<<<<<<<< - * if not is_slice: - * if new_ndim == 0: - */ - } - - /* "View.MemoryView":890 - * suboffset_dim[0] = new_ndim - * - * return 0 # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = 0; - goto __pyx_L0; - - /* "View.MemoryView":793 - * - * @cname('__pyx_memoryview_slice_memviewslice') - * cdef int slice_memviewslice( # <<<<<<<<<<<<<< - * __Pyx_memviewslice *dst, - * Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, - */ - - /* function exit code */ - __pyx_L1_error:; - #ifdef WITH_THREAD - __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_AddTraceback("View.MemoryView.slice_memviewslice", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":896 - * - * @cname('__pyx_pybuffer_index') - * 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 - */ - -static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, Py_ssize_t __pyx_v_index, Py_ssize_t __pyx_v_dim) { - Py_ssize_t __pyx_v_shape; - Py_ssize_t __pyx_v_stride; - Py_ssize_t __pyx_v_suboffset; - Py_ssize_t __pyx_v_itemsize; - char *__pyx_v_resultp; - char *__pyx_r; - __Pyx_RefNannyDeclarations - Py_ssize_t __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - Py_UCS4 __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("pybuffer_index", 1); - - /* "View.MemoryView":898 - * 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 # <<<<<<<<<<<<<< - * cdef Py_ssize_t itemsize = view.itemsize - * cdef char *resultp - */ - __pyx_v_suboffset = -1L; - - /* "View.MemoryView":899 - * Py_ssize_t dim) except NULL: - * cdef Py_ssize_t shape, stride, suboffset = -1 - * cdef Py_ssize_t itemsize = view.itemsize # <<<<<<<<<<<<<< - * cdef char *resultp - * - */ - __pyx_t_1 = __pyx_v_view->itemsize; - __pyx_v_itemsize = __pyx_t_1; - - /* "View.MemoryView":902 - * cdef char *resultp - * - * if view.ndim == 0: # <<<<<<<<<<<<<< - * shape = view.len // itemsize - * stride = itemsize - */ - __pyx_t_2 = (__pyx_v_view->ndim == 0); - if (__pyx_t_2) { - - /* "View.MemoryView":903 - * - * if view.ndim == 0: - * shape = view.len // itemsize # <<<<<<<<<<<<<< - * stride = itemsize - * else: - */ - if (unlikely(__pyx_v_itemsize == 0)) { - PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); - __PYX_ERR(1, 903, __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(__Pyx_UNARY_NEG_WOULD_OVERFLOW(__pyx_v_view->len))) { - PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); - __PYX_ERR(1, 903, __pyx_L1_error) - } - __pyx_v_shape = __Pyx_div_Py_ssize_t(__pyx_v_view->len, __pyx_v_itemsize); - - /* "View.MemoryView":904 - * if view.ndim == 0: - * shape = view.len // itemsize - * stride = itemsize # <<<<<<<<<<<<<< - * else: - * shape = view.shape[dim] - */ - __pyx_v_stride = __pyx_v_itemsize; - - /* "View.MemoryView":902 - * cdef char *resultp - * - * if view.ndim == 0: # <<<<<<<<<<<<<< - * shape = view.len // itemsize - * stride = itemsize - */ - goto __pyx_L3; - } - - /* "View.MemoryView":906 - * stride = itemsize - * else: - * shape = view.shape[dim] # <<<<<<<<<<<<<< - * stride = view.strides[dim] - * if view.suboffsets != NULL: - */ - /*else*/ { - __pyx_v_shape = (__pyx_v_view->shape[__pyx_v_dim]); - - /* "View.MemoryView":907 - * else: - * shape = view.shape[dim] - * stride = view.strides[dim] # <<<<<<<<<<<<<< - * if view.suboffsets != NULL: - * suboffset = view.suboffsets[dim] - */ - __pyx_v_stride = (__pyx_v_view->strides[__pyx_v_dim]); - - /* "View.MemoryView":908 - * shape = view.shape[dim] - * stride = view.strides[dim] - * if view.suboffsets != NULL: # <<<<<<<<<<<<<< - * suboffset = view.suboffsets[dim] - * - */ - __pyx_t_2 = (__pyx_v_view->suboffsets != NULL); - if (__pyx_t_2) { - - /* "View.MemoryView":909 - * stride = view.strides[dim] - * if view.suboffsets != NULL: - * suboffset = view.suboffsets[dim] # <<<<<<<<<<<<<< - * - * if index < 0: - */ - __pyx_v_suboffset = (__pyx_v_view->suboffsets[__pyx_v_dim]); - - /* "View.MemoryView":908 - * shape = view.shape[dim] - * stride = view.strides[dim] - * if view.suboffsets != NULL: # <<<<<<<<<<<<<< - * suboffset = view.suboffsets[dim] - * - */ - } - } - __pyx_L3:; - - /* "View.MemoryView":911 - * suboffset = view.suboffsets[dim] - * - * if index < 0: # <<<<<<<<<<<<<< - * index += view.shape[dim] - * if index < 0: - */ - __pyx_t_2 = (__pyx_v_index < 0); - if (__pyx_t_2) { - - /* "View.MemoryView":912 - * - * if index < 0: - * index += view.shape[dim] # <<<<<<<<<<<<<< - * if index < 0: - * raise IndexError, f"Out of bounds on buffer access (axis {dim})" - */ - __pyx_v_index = (__pyx_v_index + (__pyx_v_view->shape[__pyx_v_dim])); - - /* "View.MemoryView":913 - * if index < 0: - * index += view.shape[dim] - * if index < 0: # <<<<<<<<<<<<<< - * raise IndexError, f"Out of bounds on buffer access (axis {dim})" - * - */ - __pyx_t_2 = (__pyx_v_index < 0); - if (unlikely(__pyx_t_2)) { - - /* "View.MemoryView":914 - * index += view.shape[dim] - * if index < 0: - * raise IndexError, f"Out of bounds on buffer access (axis {dim})" # <<<<<<<<<<<<<< - * - * if index >= shape: - */ - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 914, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = 0; - __pyx_t_4 = 127; - __Pyx_INCREF(__pyx_kp_u_Out_of_bounds_on_buffer_access_a); - __pyx_t_1 += 37; - __Pyx_GIVEREF(__pyx_kp_u_Out_of_bounds_on_buffer_access_a); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_Out_of_bounds_on_buffer_access_a); - __pyx_t_5 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_dim, 0, ' ', 'd'); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 914, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_5); - __pyx_t_5 = 0; - __Pyx_INCREF(__pyx_kp_u__7); - __pyx_t_1 += 1; - __Pyx_GIVEREF(__pyx_kp_u__7); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__7); - __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 914, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_builtin_IndexError, __pyx_t_5, 0, 0); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __PYX_ERR(1, 914, __pyx_L1_error) - - /* "View.MemoryView":913 - * if index < 0: - * index += view.shape[dim] - * if index < 0: # <<<<<<<<<<<<<< - * raise IndexError, f"Out of bounds on buffer access (axis {dim})" - * - */ - } - - /* "View.MemoryView":911 - * suboffset = view.suboffsets[dim] - * - * if index < 0: # <<<<<<<<<<<<<< - * index += view.shape[dim] - * if index < 0: - */ - } - - /* "View.MemoryView":916 - * raise IndexError, f"Out of bounds on buffer access (axis {dim})" - * - * if index >= shape: # <<<<<<<<<<<<<< - * raise IndexError, f"Out of bounds on buffer access (axis {dim})" - * - */ - __pyx_t_2 = (__pyx_v_index >= __pyx_v_shape); - if (unlikely(__pyx_t_2)) { - - /* "View.MemoryView":917 - * - * if index >= shape: - * raise IndexError, f"Out of bounds on buffer access (axis {dim})" # <<<<<<<<<<<<<< - * - * resultp = bufp + index * stride - */ - __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 917, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = 0; - __pyx_t_4 = 127; - __Pyx_INCREF(__pyx_kp_u_Out_of_bounds_on_buffer_access_a); - __pyx_t_1 += 37; - __Pyx_GIVEREF(__pyx_kp_u_Out_of_bounds_on_buffer_access_a); - PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_kp_u_Out_of_bounds_on_buffer_access_a); - __pyx_t_3 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_dim, 0, ' ', 'd'); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 917, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3); - __pyx_t_3 = 0; - __Pyx_INCREF(__pyx_kp_u__7); - __pyx_t_1 += 1; - __Pyx_GIVEREF(__pyx_kp_u__7); - PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_kp_u__7); - __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_5, 3, __pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 917, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_Raise(__pyx_builtin_IndexError, __pyx_t_3, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 917, __pyx_L1_error) - - /* "View.MemoryView":916 - * raise IndexError, f"Out of bounds on buffer access (axis {dim})" - * - * if index >= shape: # <<<<<<<<<<<<<< - * raise IndexError, f"Out of bounds on buffer access (axis {dim})" - * - */ - } - - /* "View.MemoryView":919 - * raise IndexError, f"Out of bounds on buffer access (axis {dim})" - * - * resultp = bufp + index * stride # <<<<<<<<<<<<<< - * if suboffset >= 0: - * resultp = ( resultp)[0] + suboffset - */ - __pyx_v_resultp = (__pyx_v_bufp + (__pyx_v_index * __pyx_v_stride)); - - /* "View.MemoryView":920 - * - * resultp = bufp + index * stride - * if suboffset >= 0: # <<<<<<<<<<<<<< - * resultp = ( resultp)[0] + suboffset - * - */ - __pyx_t_2 = (__pyx_v_suboffset >= 0); - if (__pyx_t_2) { - - /* "View.MemoryView":921 - * resultp = bufp + index * stride - * if suboffset >= 0: - * resultp = ( resultp)[0] + suboffset # <<<<<<<<<<<<<< - * - * return resultp - */ - __pyx_v_resultp = ((((char **)__pyx_v_resultp)[0]) + __pyx_v_suboffset); - - /* "View.MemoryView":920 - * - * resultp = bufp + index * stride - * if suboffset >= 0: # <<<<<<<<<<<<<< - * resultp = ( resultp)[0] + suboffset - * - */ - } - - /* "View.MemoryView":923 - * resultp = ( resultp)[0] + suboffset - * - * return resultp # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = __pyx_v_resultp; - goto __pyx_L0; - - /* "View.MemoryView":896 - * - * @cname('__pyx_pybuffer_index') - * 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 - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("View.MemoryView.pybuffer_index", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":929 - * - * @cname('__pyx_memslice_transpose') - * cdef int transpose_memslice(__Pyx_memviewslice *memslice) except -1 nogil: # <<<<<<<<<<<<<< - * cdef int ndim = memslice.memview.view.ndim - * - */ - -static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { - int __pyx_v_ndim; - Py_ssize_t *__pyx_v_shape; - Py_ssize_t *__pyx_v_strides; - int __pyx_v_i; - int __pyx_v_j; - int __pyx_r; - int __pyx_t_1; - Py_ssize_t *__pyx_t_2; - long __pyx_t_3; - long __pyx_t_4; - Py_ssize_t __pyx_t_5; - Py_ssize_t __pyx_t_6; - 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; - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save; - #endif - - /* "View.MemoryView":930 - * @cname('__pyx_memslice_transpose') - * cdef int transpose_memslice(__Pyx_memviewslice *memslice) except -1 nogil: - * cdef int ndim = memslice.memview.view.ndim # <<<<<<<<<<<<<< - * - * cdef Py_ssize_t *shape = memslice.shape - */ - __pyx_t_1 = __pyx_v_memslice->memview->view.ndim; - __pyx_v_ndim = __pyx_t_1; - - /* "View.MemoryView":932 - * cdef int ndim = memslice.memview.view.ndim - * - * cdef Py_ssize_t *shape = memslice.shape # <<<<<<<<<<<<<< - * cdef Py_ssize_t *strides = memslice.strides - * - */ - __pyx_t_2 = __pyx_v_memslice->shape; - __pyx_v_shape = __pyx_t_2; - - /* "View.MemoryView":933 - * - * cdef Py_ssize_t *shape = memslice.shape - * cdef Py_ssize_t *strides = memslice.strides # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_2 = __pyx_v_memslice->strides; - __pyx_v_strides = __pyx_t_2; - - /* "View.MemoryView":937 - * - * cdef int i, j - * for i in range(ndim // 2): # <<<<<<<<<<<<<< - * j = ndim - 1 - i - * strides[i], strides[j] = strides[j], strides[i] - */ - __pyx_t_3 = __Pyx_div_long(__pyx_v_ndim, 2); - __pyx_t_4 = __pyx_t_3; - for (__pyx_t_1 = 0; __pyx_t_1 < __pyx_t_4; __pyx_t_1+=1) { - __pyx_v_i = __pyx_t_1; - - /* "View.MemoryView":938 - * cdef int i, j - * for i in range(ndim // 2): - * j = ndim - 1 - i # <<<<<<<<<<<<<< - * strides[i], strides[j] = strides[j], strides[i] - * shape[i], shape[j] = shape[j], shape[i] - */ - __pyx_v_j = ((__pyx_v_ndim - 1) - __pyx_v_i); - - /* "View.MemoryView":939 - * for i in range(ndim // 2): - * j = ndim - 1 - i - * strides[i], strides[j] = strides[j], strides[i] # <<<<<<<<<<<<<< - * shape[i], shape[j] = shape[j], shape[i] - * - */ - __pyx_t_5 = (__pyx_v_strides[__pyx_v_j]); - __pyx_t_6 = (__pyx_v_strides[__pyx_v_i]); - (__pyx_v_strides[__pyx_v_i]) = __pyx_t_5; - (__pyx_v_strides[__pyx_v_j]) = __pyx_t_6; - - /* "View.MemoryView":940 - * j = ndim - 1 - i - * strides[i], strides[j] = strides[j], strides[i] - * shape[i], shape[j] = shape[j], shape[i] # <<<<<<<<<<<<<< - * - * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: - */ - __pyx_t_6 = (__pyx_v_shape[__pyx_v_j]); - __pyx_t_5 = (__pyx_v_shape[__pyx_v_i]); - (__pyx_v_shape[__pyx_v_i]) = __pyx_t_6; - (__pyx_v_shape[__pyx_v_j]) = __pyx_t_5; - - /* "View.MemoryView":942 - * shape[i], shape[j] = shape[j], shape[i] - * - * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< - * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") - * - */ - __pyx_t_8 = ((__pyx_v_memslice->suboffsets[__pyx_v_i]) >= 0); - if (!__pyx_t_8) { - } else { - __pyx_t_7 = __pyx_t_8; - goto __pyx_L6_bool_binop_done; - } - __pyx_t_8 = ((__pyx_v_memslice->suboffsets[__pyx_v_j]) >= 0); - __pyx_t_7 = __pyx_t_8; - __pyx_L6_bool_binop_done:; - if (__pyx_t_7) { - - /* "View.MemoryView":943 - * - * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: - * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") # <<<<<<<<<<<<<< - * - * return 0 - */ - __pyx_t_9 = __pyx_memoryview_err(PyExc_ValueError, __pyx_kp_s_Cannot_transpose_memoryview_with); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 943, __pyx_L1_error) - - /* "View.MemoryView":942 - * shape[i], shape[j] = shape[j], shape[i] - * - * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< - * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") - * - */ - } - } - - /* "View.MemoryView":945 - * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") - * - * return 0 # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = 0; - goto __pyx_L0; - - /* "View.MemoryView":929 - * - * @cname('__pyx_memslice_transpose') - * cdef int transpose_memslice(__Pyx_memviewslice *memslice) except -1 nogil: # <<<<<<<<<<<<<< - * cdef int ndim = memslice.memview.view.ndim - * - */ - - /* function exit code */ - __pyx_L1_error:; - #ifdef WITH_THREAD - __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_AddTraceback("View.MemoryView.transpose_memslice", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":963 - * cdef int (*to_dtype_func)(char *, object) except 0 - * - * def __dealloc__(self): # <<<<<<<<<<<<<< - * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) - * - */ - -/* Python wrapper */ -static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self); /*proto*/ -static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self) { - - /* "View.MemoryView":964 - * - * def __dealloc__(self): - * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) # <<<<<<<<<<<<<< - * - * cdef convert_item_to_object(self, char *itemp): - */ - __PYX_XCLEAR_MEMVIEW((&__pyx_v_self->from_slice), 1); - - /* "View.MemoryView":963 - * cdef int (*to_dtype_func)(char *, object) except 0 - * - * def __dealloc__(self): # <<<<<<<<<<<<<< - * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) - * - */ - - /* function exit code */ -} - -/* "View.MemoryView":966 - * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) - * - * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< - * if self.to_object_func != NULL: - * return self.to_object_func(itemp) - */ - -static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp) { - PyObject *__pyx_r = NULL; - __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", 1); - - /* "View.MemoryView":967 - * - * cdef convert_item_to_object(self, char *itemp): - * if self.to_object_func != NULL: # <<<<<<<<<<<<<< - * return self.to_object_func(itemp) - * else: - */ - __pyx_t_1 = (__pyx_v_self->to_object_func != NULL); - if (__pyx_t_1) { - - /* "View.MemoryView":968 - * cdef convert_item_to_object(self, char *itemp): - * if self.to_object_func != NULL: - * return self.to_object_func(itemp) # <<<<<<<<<<<<<< - * else: - * 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(1, 968, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":967 - * - * cdef convert_item_to_object(self, char *itemp): - * if self.to_object_func != NULL: # <<<<<<<<<<<<<< - * return self.to_object_func(itemp) - * else: - */ - } - - /* "View.MemoryView":970 - * return self.to_object_func(itemp) - * else: - * return memoryview.convert_item_to_object(self, itemp) # <<<<<<<<<<<<<< - * - * cdef assign_item_from_object(self, char *itemp, object value): - */ - /*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(1, 970, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - } - - /* "View.MemoryView":966 - * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) - * - * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< - * if self.to_object_func != NULL: - * return self.to_object_func(itemp) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView._memoryviewslice.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":972 - * return memoryview.convert_item_to_object(self, itemp) - * - * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< - * if self.to_dtype_func != NULL: - * self.to_dtype_func(itemp, value) - */ - -static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - 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", 1); - - /* "View.MemoryView":973 - * - * cdef assign_item_from_object(self, char *itemp, object value): - * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< - * self.to_dtype_func(itemp, value) - * else: - */ - __pyx_t_1 = (__pyx_v_self->to_dtype_func != NULL); - if (__pyx_t_1) { - - /* "View.MemoryView":974 - * 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(1, 974, __pyx_L1_error) - - /* "View.MemoryView":973 - * - * cdef assign_item_from_object(self, char *itemp, object value): - * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< - * self.to_dtype_func(itemp, value) - * else: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":976 - * self.to_dtype_func(itemp, value) - * else: - * memoryview.assign_item_from_object(self, itemp, value) # <<<<<<<<<<<<<< - * - * cdef _get_base(self): - */ - /*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(1, 976, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } - __pyx_L3:; - - /* "View.MemoryView":972 - * return memoryview.convert_item_to_object(self, itemp) - * - * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< - * if self.to_dtype_func != NULL: - * self.to_dtype_func(itemp, value) - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView._memoryviewslice.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":978 - * memoryview.assign_item_from_object(self, itemp, value) - * - * cdef _get_base(self): # <<<<<<<<<<<<<< - * return self.from_object - * - */ - -static PyObject *__pyx_memoryviewslice__get_base(struct __pyx_memoryviewslice_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("_get_base", 1); - - /* "View.MemoryView":979 - * - * cdef _get_base(self): - * return self.from_object # <<<<<<<<<<<<<< - * - * - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->from_object); - __pyx_r = __pyx_v_self->from_object; - goto __pyx_L0; - - /* "View.MemoryView":978 - * memoryview.assign_item_from_object(self, itemp, value) - * - * cdef _get_base(self): # <<<<<<<<<<<<<< - * return self.from_object - * - */ - - /* function exit code */ - __pyx_L0:; - __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): - */ - -/* Python wrapper */ -static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; - __pyx_r = __pyx_pf___pyx_memoryviewslice___reduce_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__reduce_cython__", 1); - - /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); - __PYX_ERR(1, 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): - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __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_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v___pyx_state = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf___pyx_memoryviewslice_2__setstate_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self), __pyx_v___pyx_state); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setstate_cython__", 1); - - /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); - __PYX_ERR(1, 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_AddTraceback("View.MemoryView._memoryviewslice.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":999 - * - * @cname('__pyx_memoryview_fromslice') - * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< - * int ndim, - * object (*to_object_func)(char *), - */ - -static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewslice, int __pyx_v_ndim, PyObject *(*__pyx_v_to_object_func)(char *), int (*__pyx_v_to_dtype_func)(char *, PyObject *), int __pyx_v_dtype_is_object) { - struct __pyx_memoryviewslice_obj *__pyx_v_result = 0; - Py_ssize_t __pyx_v_suboffset; - PyObject *__pyx_v_length = NULL; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - __Pyx_TypeInfo *__pyx_t_4; - Py_buffer __pyx_t_5; - Py_ssize_t *__pyx_t_6; - 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", 1); - - /* "View.MemoryView":1007 - * cdef _memoryviewslice result - * - * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< - * return None - * - */ - __pyx_t_1 = (((PyObject *)__pyx_v_memviewslice.memview) == Py_None); - if (__pyx_t_1) { - - /* "View.MemoryView":1008 - * - * if memviewslice.memview == Py_None: - * return None # <<<<<<<<<<<<<< - * - * - */ - __Pyx_XDECREF(__pyx_r); - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - - /* "View.MemoryView":1007 - * cdef _memoryviewslice result - * - * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< - * return None - * - */ - } - - /* "View.MemoryView":1013 - * - * - * result = _memoryviewslice.__new__(_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(1, 1013, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1013, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(Py_None); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, Py_None)) __PYX_ERR(1, 1013, __pyx_L1_error); - __Pyx_INCREF(__pyx_int_0); - __Pyx_GIVEREF(__pyx_int_0); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_0)) __PYX_ERR(1, 1013, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2)) __PYX_ERR(1, 1013, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_2 = ((PyObject *)__pyx_tp_new__memoryviewslice(((PyTypeObject *)__pyx_memoryviewslice_type), __pyx_t_3, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1013, __pyx_L1_error) - __Pyx_GOTREF((PyObject *)__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 - * result = _memoryviewslice.__new__(_memoryviewslice, None, 0, dtype_is_object) - * - * result.from_slice = memviewslice # <<<<<<<<<<<<<< - * __PYX_INC_MEMVIEW(&memviewslice, 1) - * - */ - __pyx_v_result->from_slice = __pyx_v_memviewslice; - - /* "View.MemoryView":1016 - * - * result.from_slice = memviewslice - * __PYX_INC_MEMVIEW(&memviewslice, 1) # <<<<<<<<<<<<<< - * - * result.from_object = ( memviewslice.memview)._get_base() - */ - __PYX_INC_MEMVIEW((&__pyx_v_memviewslice), 1); - - /* "View.MemoryView":1018 - * __PYX_INC_MEMVIEW(&memviewslice, 1) - * - * result.from_object = ( memviewslice.memview)._get_base() # <<<<<<<<<<<<<< - * result.typeinfo = memviewslice.memview.typeinfo - * - */ - __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->__pyx_vtab)->_get_base(((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1018, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_result->from_object); - __Pyx_DECREF(__pyx_v_result->from_object); - __pyx_v_result->from_object = __pyx_t_2; - __pyx_t_2 = 0; - - /* "View.MemoryView":1019 - * - * result.from_object = ( memviewslice.memview)._get_base() - * result.typeinfo = memviewslice.memview.typeinfo # <<<<<<<<<<<<<< - * - * result.view = memviewslice.memview.view - */ - __pyx_t_4 = __pyx_v_memviewslice.memview->typeinfo; - __pyx_v_result->__pyx_base.typeinfo = __pyx_t_4; - - /* "View.MemoryView":1021 - * result.typeinfo = memviewslice.memview.typeinfo - * - * result.view = memviewslice.memview.view # <<<<<<<<<<<<<< - * result.view.buf = memviewslice.data - * result.view.ndim = ndim - */ - __pyx_t_5 = __pyx_v_memviewslice.memview->view; - __pyx_v_result->__pyx_base.view = __pyx_t_5; - - /* "View.MemoryView":1022 - * - * result.view = memviewslice.memview.view - * result.view.buf = memviewslice.data # <<<<<<<<<<<<<< - * result.view.ndim = ndim - * (<__pyx_buffer *> &result.view).obj = Py_None - */ - __pyx_v_result->__pyx_base.view.buf = ((void *)__pyx_v_memviewslice.data); - - /* "View.MemoryView":1023 - * result.view = memviewslice.memview.view - * result.view.buf = memviewslice.data - * result.view.ndim = ndim # <<<<<<<<<<<<<< - * (<__pyx_buffer *> &result.view).obj = Py_None - * Py_INCREF(Py_None) - */ - __pyx_v_result->__pyx_base.view.ndim = __pyx_v_ndim; - - /* "View.MemoryView":1024 - * result.view.buf = memviewslice.data - * result.view.ndim = ndim - * (<__pyx_buffer *> &result.view).obj = Py_None # <<<<<<<<<<<<<< - * Py_INCREF(Py_None) - * - */ - ((Py_buffer *)(&__pyx_v_result->__pyx_base.view))->obj = Py_None; - - /* "View.MemoryView":1025 - * result.view.ndim = ndim - * (<__pyx_buffer *> &result.view).obj = Py_None - * Py_INCREF(Py_None) # <<<<<<<<<<<<<< - * - * if (memviewslice.memview).flags & PyBUF_WRITABLE: - */ - Py_INCREF(Py_None); - - /* "View.MemoryView":1027 - * Py_INCREF(Py_None) - * - * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< - * result.flags = PyBUF_RECORDS - * else: - */ - __pyx_t_1 = ((((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->flags & PyBUF_WRITABLE) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":1028 - * - * if (memviewslice.memview).flags & PyBUF_WRITABLE: - * result.flags = PyBUF_RECORDS # <<<<<<<<<<<<<< - * else: - * result.flags = PyBUF_RECORDS_RO - */ - __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS; - - /* "View.MemoryView":1027 - * Py_INCREF(Py_None) - * - * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< - * result.flags = PyBUF_RECORDS - * else: - */ - goto __pyx_L4; - } - - /* "View.MemoryView":1030 - * result.flags = PyBUF_RECORDS - * else: - * result.flags = PyBUF_RECORDS_RO # <<<<<<<<<<<<<< - * - * result.view.shape = result.from_slice.shape - */ - /*else*/ { - __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS_RO; - } - __pyx_L4:; - - /* "View.MemoryView":1032 - * result.flags = PyBUF_RECORDS_RO - * - * result.view.shape = result.from_slice.shape # <<<<<<<<<<<<<< - * result.view.strides = result.from_slice.strides - * - */ - __pyx_v_result->__pyx_base.view.shape = ((Py_ssize_t *)__pyx_v_result->from_slice.shape); - - /* "View.MemoryView":1033 - * - * result.view.shape = result.from_slice.shape - * result.view.strides = result.from_slice.strides # <<<<<<<<<<<<<< - * - * - */ - __pyx_v_result->__pyx_base.view.strides = ((Py_ssize_t *)__pyx_v_result->from_slice.strides); - - /* "View.MemoryView":1036 - * - * - * result.view.suboffsets = NULL # <<<<<<<<<<<<<< - * for suboffset in result.from_slice.suboffsets[:ndim]: - * if suboffset >= 0: - */ - __pyx_v_result->__pyx_base.view.suboffsets = NULL; - - /* "View.MemoryView":1037 - * - * result.view.suboffsets = NULL - * for suboffset in result.from_slice.suboffsets[:ndim]: # <<<<<<<<<<<<<< - * if suboffset >= 0: - * result.view.suboffsets = result.from_slice.suboffsets - */ - __pyx_t_7 = (__pyx_v_result->from_slice.suboffsets + __pyx_v_ndim); - for (__pyx_t_8 = __pyx_v_result->from_slice.suboffsets; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) { - __pyx_t_6 = __pyx_t_8; - __pyx_v_suboffset = (__pyx_t_6[0]); - - /* "View.MemoryView":1038 - * result.view.suboffsets = NULL - * for suboffset in result.from_slice.suboffsets[:ndim]: - * if suboffset >= 0: # <<<<<<<<<<<<<< - * result.view.suboffsets = result.from_slice.suboffsets - * break - */ - __pyx_t_1 = (__pyx_v_suboffset >= 0); - if (__pyx_t_1) { - - /* "View.MemoryView":1039 - * for suboffset in result.from_slice.suboffsets[:ndim]: - * if suboffset >= 0: - * result.view.suboffsets = result.from_slice.suboffsets # <<<<<<<<<<<<<< - * break - * - */ - __pyx_v_result->__pyx_base.view.suboffsets = ((Py_ssize_t *)__pyx_v_result->from_slice.suboffsets); - - /* "View.MemoryView":1040 - * if suboffset >= 0: - * result.view.suboffsets = result.from_slice.suboffsets - * break # <<<<<<<<<<<<<< - * - * result.view.len = result.view.itemsize - */ - goto __pyx_L6_break; - - /* "View.MemoryView":1038 - * result.view.suboffsets = NULL - * for suboffset in result.from_slice.suboffsets[:ndim]: - * if suboffset >= 0: # <<<<<<<<<<<<<< - * result.view.suboffsets = result.from_slice.suboffsets - * break - */ - } - } - __pyx_L6_break:; - - /* "View.MemoryView":1042 - * break - * - * result.view.len = result.view.itemsize # <<<<<<<<<<<<<< - * for length in result.view.shape[:ndim]: - * result.view.len *= length - */ - __pyx_t_9 = __pyx_v_result->__pyx_base.view.itemsize; - __pyx_v_result->__pyx_base.view.len = __pyx_t_9; - - /* "View.MemoryView":1043 - * - * result.view.len = result.view.itemsize - * for length in result.view.shape[:ndim]: # <<<<<<<<<<<<<< - * result.view.len *= length - * - */ - __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(1, 1043, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_2); - __pyx_t_2 = 0; - - /* "View.MemoryView":1044 - * 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(1, 1044, __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(1, 1044, __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(1, 1044, __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 - * result.view.len *= length - * - * result.to_object_func = to_object_func # <<<<<<<<<<<<<< - * result.to_dtype_func = to_dtype_func - * - */ - __pyx_v_result->to_object_func = __pyx_v_to_object_func; - - /* "View.MemoryView":1047 - * - * result.to_object_func = to_object_func - * result.to_dtype_func = to_dtype_func # <<<<<<<<<<<<<< - * - * return result - */ - __pyx_v_result->to_dtype_func = __pyx_v_to_dtype_func; - - /* "View.MemoryView":1049 - * result.to_dtype_func = to_dtype_func - * - * return result # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_get_slice_from_memoryview') - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF((PyObject *)__pyx_v_result); - __pyx_r = ((PyObject *)__pyx_v_result); - goto __pyx_L0; - - /* "View.MemoryView":999 - * - * @cname('__pyx_memoryview_fromslice') - * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< - * int ndim, - * object (*to_object_func)(char *), - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.memoryview_fromslice", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_result); - __Pyx_XDECREF(__pyx_v_length); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":1052 - * - * @cname('__pyx_memoryview_get_slice_from_memoryview') - * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< - * __Pyx_memviewslice *mslice) except NULL: - * cdef _memoryviewslice obj - */ - -static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_mslice) { - struct __pyx_memoryviewslice_obj *__pyx_v_obj = 0; - __Pyx_memviewslice *__pyx_r; - __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("get_slice_from_memview", 1); - - /* "View.MemoryView":1055 - * __Pyx_memviewslice *mslice) except NULL: - * cdef _memoryviewslice obj - * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< - * obj = memview - * return &obj.from_slice - */ - __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); - if (__pyx_t_1) { - - /* "View.MemoryView":1056 - * 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(1, 1056, __pyx_L1_error) - __pyx_t_2 = ((PyObject *)__pyx_v_memview); - __Pyx_INCREF(__pyx_t_2); - __pyx_v_obj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); - __pyx_t_2 = 0; - - /* "View.MemoryView":1057 - * if isinstance(memview, _memoryviewslice): - * obj = memview - * return &obj.from_slice # <<<<<<<<<<<<<< - * else: - * slice_copy(memview, mslice) - */ - __pyx_r = (&__pyx_v_obj->from_slice); - goto __pyx_L0; - - /* "View.MemoryView":1055 - * __Pyx_memviewslice *mslice) except NULL: - * cdef _memoryviewslice obj - * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< - * obj = memview - * return &obj.from_slice - */ - } - - /* "View.MemoryView":1059 - * return &obj.from_slice - * else: - * slice_copy(memview, mslice) # <<<<<<<<<<<<<< - * return mslice - * - */ - /*else*/ { - __pyx_memoryview_slice_copy(__pyx_v_memview, __pyx_v_mslice); - - /* "View.MemoryView":1060 - * else: - * slice_copy(memview, mslice) - * return mslice # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_slice_copy') - */ - __pyx_r = __pyx_v_mslice; - goto __pyx_L0; - } - - /* "View.MemoryView":1052 - * - * @cname('__pyx_memoryview_get_slice_from_memoryview') - * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< - * __Pyx_memviewslice *mslice) except NULL: - * cdef _memoryviewslice obj - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.get_slice_from_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_obj); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":1063 - * - * @cname('__pyx_memoryview_slice_copy') - * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst) noexcept: # <<<<<<<<<<<<<< - * cdef int dim - * cdef (Py_ssize_t*) shape, strides, suboffsets - */ - -static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_dst) { - int __pyx_v_dim; - Py_ssize_t *__pyx_v_shape; - Py_ssize_t *__pyx_v_strides; - Py_ssize_t *__pyx_v_suboffsets; - Py_ssize_t *__pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - int __pyx_t_4; - Py_ssize_t __pyx_t_5; - int __pyx_t_6; - - /* "View.MemoryView":1067 - * cdef (Py_ssize_t*) shape, strides, suboffsets - * - * shape = memview.view.shape # <<<<<<<<<<<<<< - * strides = memview.view.strides - * suboffsets = memview.view.suboffsets - */ - __pyx_t_1 = __pyx_v_memview->view.shape; - __pyx_v_shape = __pyx_t_1; - - /* "View.MemoryView":1068 - * - * shape = memview.view.shape - * strides = memview.view.strides # <<<<<<<<<<<<<< - * suboffsets = memview.view.suboffsets - * - */ - __pyx_t_1 = __pyx_v_memview->view.strides; - __pyx_v_strides = __pyx_t_1; - - /* "View.MemoryView":1069 - * shape = memview.view.shape - * strides = memview.view.strides - * suboffsets = memview.view.suboffsets # <<<<<<<<<<<<<< - * - * dst.memview = <__pyx_memoryview *> memview - */ - __pyx_t_1 = __pyx_v_memview->view.suboffsets; - __pyx_v_suboffsets = __pyx_t_1; - - /* "View.MemoryView":1071 - * suboffsets = memview.view.suboffsets - * - * dst.memview = <__pyx_memoryview *> memview # <<<<<<<<<<<<<< - * dst.data = memview.view.buf - * - */ - __pyx_v_dst->memview = ((struct __pyx_memoryview_obj *)__pyx_v_memview); - - /* "View.MemoryView":1072 - * - * dst.memview = <__pyx_memoryview *> memview - * dst.data = memview.view.buf # <<<<<<<<<<<<<< - * - * for dim in range(memview.view.ndim): - */ - __pyx_v_dst->data = ((char *)__pyx_v_memview->view.buf); - - /* "View.MemoryView":1074 - * dst.data = memview.view.buf - * - * for dim in range(memview.view.ndim): # <<<<<<<<<<<<<< - * dst.shape[dim] = shape[dim] - * dst.strides[dim] = strides[dim] - */ - __pyx_t_2 = __pyx_v_memview->view.ndim; - __pyx_t_3 = __pyx_t_2; - for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { - __pyx_v_dim = __pyx_t_4; - - /* "View.MemoryView":1075 - * - * for dim in range(memview.view.ndim): - * dst.shape[dim] = shape[dim] # <<<<<<<<<<<<<< - * dst.strides[dim] = strides[dim] - * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 - */ - (__pyx_v_dst->shape[__pyx_v_dim]) = (__pyx_v_shape[__pyx_v_dim]); - - /* "View.MemoryView":1076 - * for dim in range(memview.view.ndim): - * dst.shape[dim] = shape[dim] - * dst.strides[dim] = strides[dim] # <<<<<<<<<<<<<< - * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 - * - */ - (__pyx_v_dst->strides[__pyx_v_dim]) = (__pyx_v_strides[__pyx_v_dim]); - - /* "View.MemoryView":1077 - * dst.shape[dim] = shape[dim] - * dst.strides[dim] = strides[dim] - * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_copy_object') - */ - __pyx_t_6 = (__pyx_v_suboffsets != 0); - if (__pyx_t_6) { - __pyx_t_5 = (__pyx_v_suboffsets[__pyx_v_dim]); - } else { - __pyx_t_5 = -1L; - } - (__pyx_v_dst->suboffsets[__pyx_v_dim]) = __pyx_t_5; - } - - /* "View.MemoryView":1063 - * - * @cname('__pyx_memoryview_slice_copy') - * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst) noexcept: # <<<<<<<<<<<<<< - * cdef int dim - * cdef (Py_ssize_t*) shape, strides, suboffsets - */ - - /* function exit code */ -} - -/* "View.MemoryView":1080 - * - * @cname('__pyx_memoryview_copy_object') - * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< - * "Create a new memoryview object" - * cdef __Pyx_memviewslice memviewslice - */ - -static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx_v_memview) { - __Pyx_memviewslice __pyx_v_memviewslice; - 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", 1); - - /* "View.MemoryView":1083 - * "Create a new memoryview object" - * cdef __Pyx_memviewslice memviewslice - * slice_copy(memview, &memviewslice) # <<<<<<<<<<<<<< - * return memoryview_copy_from_slice(memview, &memviewslice) - * - */ - __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_memviewslice)); - - /* "View.MemoryView":1084 - * cdef __Pyx_memviewslice memviewslice - * slice_copy(memview, &memviewslice) - * return memoryview_copy_from_slice(memview, &memviewslice) # <<<<<<<<<<<<<< - * - * @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(1, 1084, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "View.MemoryView":1080 - * - * @cname('__pyx_memoryview_copy_object') - * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< - * "Create a new memoryview object" - * cdef __Pyx_memviewslice memviewslice - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.memoryview_copy", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":1087 - * - * @cname('__pyx_memoryview_copy_object_from_slice') - * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< - * """ - * Create a new memoryview object from a given memoryview object and slice. - */ - -static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_memviewslice) { - PyObject *(*__pyx_v_to_object_func)(char *); - int (*__pyx_v_to_dtype_func)(char *, PyObject *); - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *(*__pyx_t_2)(char *); - int (*__pyx_t_3)(char *, PyObject *); - PyObject *__pyx_t_4 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("memoryview_copy_from_slice", 1); - - /* "View.MemoryView":1094 - * cdef int (*to_dtype_func)(char *, object) except 0 - * - * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< - * to_object_func = (<_memoryviewslice> memview).to_object_func - * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func - */ - __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); - if (__pyx_t_1) { - - /* "View.MemoryView":1095 - * - * if isinstance(memview, _memoryviewslice): - * to_object_func = (<_memoryviewslice> memview).to_object_func # <<<<<<<<<<<<<< - * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func - * else: - */ - __pyx_t_2 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_object_func; - __pyx_v_to_object_func = __pyx_t_2; - - /* "View.MemoryView":1096 - * if isinstance(memview, _memoryviewslice): - * to_object_func = (<_memoryviewslice> memview).to_object_func - * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func # <<<<<<<<<<<<<< - * else: - * to_object_func = NULL - */ - __pyx_t_3 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_dtype_func; - __pyx_v_to_dtype_func = __pyx_t_3; - - /* "View.MemoryView":1094 - * cdef int (*to_dtype_func)(char *, object) except 0 - * - * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< - * to_object_func = (<_memoryviewslice> memview).to_object_func - * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func - */ - goto __pyx_L3; - } - - /* "View.MemoryView":1098 - * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func - * else: - * to_object_func = NULL # <<<<<<<<<<<<<< - * to_dtype_func = NULL - * - */ - /*else*/ { - __pyx_v_to_object_func = NULL; - - /* "View.MemoryView":1099 - * else: - * to_object_func = NULL - * to_dtype_func = NULL # <<<<<<<<<<<<<< - * - * return memoryview_fromslice(memviewslice[0], memview.view.ndim, - */ - __pyx_v_to_dtype_func = NULL; - } - __pyx_L3:; - - /* "View.MemoryView":1101 - * to_dtype_func = NULL - * - * return memoryview_fromslice(memviewslice[0], memview.view.ndim, # <<<<<<<<<<<<<< - * to_object_func, to_dtype_func, - * memview.dtype_is_object) - */ - __Pyx_XDECREF(__pyx_r); - - /* "View.MemoryView":1103 - * return memoryview_fromslice(memviewslice[0], memview.view.ndim, - * to_object_func, to_dtype_func, - * memview.dtype_is_object) # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_4 = __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_4)) __PYX_ERR(1, 1101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; - goto __pyx_L0; - - /* "View.MemoryView":1087 - * - * @cname('__pyx_memoryview_copy_object_from_slice') - * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< - * """ - * Create a new memoryview object from a given memoryview object and slice. - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("View.MemoryView.memoryview_copy_from_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":1109 - * - * - * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) noexcept nogil: # <<<<<<<<<<<<<< - * return -arg if arg < 0 else arg - * - */ - -static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { - Py_ssize_t __pyx_r; - Py_ssize_t __pyx_t_1; - int __pyx_t_2; - - /* "View.MemoryView":1110 - * - * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) noexcept nogil: - * return -arg if arg < 0 else arg # <<<<<<<<<<<<<< - * - * @cname('__pyx_get_best_slice_order') - */ - __pyx_t_2 = (__pyx_v_arg < 0); - if (__pyx_t_2) { - __pyx_t_1 = (-__pyx_v_arg); - } else { - __pyx_t_1 = __pyx_v_arg; - } - __pyx_r = __pyx_t_1; - goto __pyx_L0; - - /* "View.MemoryView":1109 - * - * - * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) noexcept nogil: # <<<<<<<<<<<<<< - * return -arg if arg < 0 else arg - * - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":1113 - * - * @cname('__pyx_get_best_slice_order') - * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) noexcept nogil: # <<<<<<<<<<<<<< - * """ - * Figure out the best memory access order for a given slice. - */ - -static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim) { - int __pyx_v_i; - Py_ssize_t __pyx_v_c_stride; - Py_ssize_t __pyx_v_f_stride; - char __pyx_r; - int __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - int __pyx_t_4; - - /* "View.MemoryView":1118 - * """ - * cdef int i - * cdef Py_ssize_t c_stride = 0 # <<<<<<<<<<<<<< - * cdef Py_ssize_t f_stride = 0 - * - */ - __pyx_v_c_stride = 0; - - /* "View.MemoryView":1119 - * cdef int i - * cdef Py_ssize_t c_stride = 0 - * cdef Py_ssize_t f_stride = 0 # <<<<<<<<<<<<<< - * - * for i in range(ndim - 1, -1, -1): - */ - __pyx_v_f_stride = 0; - - /* "View.MemoryView":1121 - * cdef Py_ssize_t f_stride = 0 - * - * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< - * if mslice.shape[i] > 1: - * c_stride = mslice.strides[i] - */ - for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { - __pyx_v_i = __pyx_t_1; - - /* "View.MemoryView":1122 - * - * for i in range(ndim - 1, -1, -1): - * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< - * c_stride = mslice.strides[i] - * break - */ - __pyx_t_2 = ((__pyx_v_mslice->shape[__pyx_v_i]) > 1); - if (__pyx_t_2) { - - /* "View.MemoryView":1123 - * for i in range(ndim - 1, -1, -1): - * if mslice.shape[i] > 1: - * c_stride = mslice.strides[i] # <<<<<<<<<<<<<< - * break - * - */ - __pyx_v_c_stride = (__pyx_v_mslice->strides[__pyx_v_i]); - - /* "View.MemoryView":1124 - * if mslice.shape[i] > 1: - * c_stride = mslice.strides[i] - * break # <<<<<<<<<<<<<< - * - * for i in range(ndim): - */ - goto __pyx_L4_break; - - /* "View.MemoryView":1122 - * - * for i in range(ndim - 1, -1, -1): - * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< - * c_stride = mslice.strides[i] - * break - */ - } - } - __pyx_L4_break:; - - /* "View.MemoryView":1126 - * break - * - * for i in range(ndim): # <<<<<<<<<<<<<< - * if mslice.shape[i] > 1: - * f_stride = mslice.strides[i] - */ - __pyx_t_1 = __pyx_v_ndim; - __pyx_t_3 = __pyx_t_1; - for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { - __pyx_v_i = __pyx_t_4; - - /* "View.MemoryView":1127 - * - * for i in range(ndim): - * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< - * f_stride = mslice.strides[i] - * break - */ - __pyx_t_2 = ((__pyx_v_mslice->shape[__pyx_v_i]) > 1); - if (__pyx_t_2) { - - /* "View.MemoryView":1128 - * for i in range(ndim): - * if mslice.shape[i] > 1: - * f_stride = mslice.strides[i] # <<<<<<<<<<<<<< - * break - * - */ - __pyx_v_f_stride = (__pyx_v_mslice->strides[__pyx_v_i]); - - /* "View.MemoryView":1129 - * if mslice.shape[i] > 1: - * f_stride = mslice.strides[i] - * break # <<<<<<<<<<<<<< - * - * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): - */ - goto __pyx_L7_break; - - /* "View.MemoryView":1127 - * - * for i in range(ndim): - * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< - * f_stride = mslice.strides[i] - * break - */ - } - } - __pyx_L7_break:; - - /* "View.MemoryView":1131 - * break - * - * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< - * return 'C' - * else: - */ - __pyx_t_2 = (abs_py_ssize_t(__pyx_v_c_stride) <= abs_py_ssize_t(__pyx_v_f_stride)); - if (__pyx_t_2) { - - /* "View.MemoryView":1132 - * - * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): - * return 'C' # <<<<<<<<<<<<<< - * else: - * return 'F' - */ - __pyx_r = 'C'; - goto __pyx_L0; - - /* "View.MemoryView":1131 - * break - * - * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< - * return 'C' - * else: - */ - } - - /* "View.MemoryView":1134 - * return 'C' - * else: - * return 'F' # <<<<<<<<<<<<<< - * - * @cython.cdivision(True) - */ - /*else*/ { - __pyx_r = 'F'; - goto __pyx_L0; - } - - /* "View.MemoryView":1113 - * - * @cname('__pyx_get_best_slice_order') - * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) noexcept nogil: # <<<<<<<<<<<<<< - * """ - * Figure out the best memory access order for a given slice. - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":1137 - * - * @cython.cdivision(True) - * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< - * char *dst_data, Py_ssize_t *dst_strides, - * Py_ssize_t *src_shape, Py_ssize_t *dst_shape, - */ - -static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v_src_strides, char *__pyx_v_dst_data, Py_ssize_t *__pyx_v_dst_strides, Py_ssize_t *__pyx_v_src_shape, Py_ssize_t *__pyx_v_dst_shape, int __pyx_v_ndim, size_t __pyx_v_itemsize) { - CYTHON_UNUSED Py_ssize_t __pyx_v_i; - CYTHON_UNUSED Py_ssize_t __pyx_v_src_extent; - Py_ssize_t __pyx_v_dst_extent; - Py_ssize_t __pyx_v_src_stride; - Py_ssize_t __pyx_v_dst_stride; - int __pyx_t_1; - int __pyx_t_2; - Py_ssize_t __pyx_t_3; - Py_ssize_t __pyx_t_4; - Py_ssize_t __pyx_t_5; - - /* "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] - * cdef Py_ssize_t src_stride = src_strides[0] - */ - __pyx_v_src_extent = (__pyx_v_src_shape[0]); - - /* "View.MemoryView":1145 - * cdef Py_ssize_t i - * 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] - * cdef Py_ssize_t dst_stride = dst_strides[0] - */ - __pyx_v_dst_extent = (__pyx_v_dst_shape[0]); - - /* "View.MemoryView":1146 - * 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] # <<<<<<<<<<<<<< - * cdef Py_ssize_t dst_stride = dst_strides[0] - * - */ - __pyx_v_src_stride = (__pyx_v_src_strides[0]); - - /* "View.MemoryView":1147 - * 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] # <<<<<<<<<<<<<< - * - * if ndim == 1: - */ - __pyx_v_dst_stride = (__pyx_v_dst_strides[0]); - - /* "View.MemoryView":1149 - * cdef Py_ssize_t dst_stride = dst_strides[0] - * - * if ndim == 1: # <<<<<<<<<<<<<< - * if (src_stride > 0 and dst_stride > 0 and - * src_stride == itemsize == dst_stride): - */ - __pyx_t_1 = (__pyx_v_ndim == 1); - if (__pyx_t_1) { - - /* "View.MemoryView":1150 - * - * if ndim == 1: - * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< - * src_stride == itemsize == dst_stride): - * memcpy(dst_data, src_data, itemsize * dst_extent) - */ - __pyx_t_2 = (__pyx_v_src_stride > 0); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L5_bool_binop_done; - } - __pyx_t_2 = (__pyx_v_dst_stride > 0); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L5_bool_binop_done; - } - - /* "View.MemoryView":1151 - * if ndim == 1: - * if (src_stride > 0 and dst_stride > 0 and - * src_stride == itemsize == dst_stride): # <<<<<<<<<<<<<< - * memcpy(dst_data, src_data, itemsize * dst_extent) - * else: - */ - __pyx_t_2 = (((size_t)__pyx_v_src_stride) == __pyx_v_itemsize); - if (__pyx_t_2) { - __pyx_t_2 = (__pyx_v_itemsize == ((size_t)__pyx_v_dst_stride)); - } - __pyx_t_1 = __pyx_t_2; - __pyx_L5_bool_binop_done:; - - /* "View.MemoryView":1150 - * - * if ndim == 1: - * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< - * src_stride == itemsize == dst_stride): - * memcpy(dst_data, src_data, itemsize * dst_extent) - */ - if (__pyx_t_1) { - - /* "View.MemoryView":1152 - * if (src_stride > 0 and dst_stride > 0 and - * src_stride == itemsize == dst_stride): - * memcpy(dst_data, src_data, itemsize * dst_extent) # <<<<<<<<<<<<<< - * else: - * for i in range(dst_extent): - */ - (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, (__pyx_v_itemsize * __pyx_v_dst_extent))); - - /* "View.MemoryView":1150 - * - * if ndim == 1: - * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< - * src_stride == itemsize == dst_stride): - * memcpy(dst_data, src_data, itemsize * dst_extent) - */ - goto __pyx_L4; - } - - /* "View.MemoryView":1154 - * memcpy(dst_data, src_data, itemsize * dst_extent) - * else: - * for i in range(dst_extent): # <<<<<<<<<<<<<< - * memcpy(dst_data, src_data, itemsize) - * src_data += src_stride - */ - /*else*/ { - __pyx_t_3 = __pyx_v_dst_extent; - __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":1155 - * else: - * for i in range(dst_extent): - * memcpy(dst_data, src_data, itemsize) # <<<<<<<<<<<<<< - * src_data += src_stride - * dst_data += dst_stride - */ - (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, __pyx_v_itemsize)); - - /* "View.MemoryView":1156 - * for i in range(dst_extent): - * memcpy(dst_data, src_data, itemsize) - * src_data += src_stride # <<<<<<<<<<<<<< - * dst_data += dst_stride - * else: - */ - __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); - - /* "View.MemoryView":1157 - * memcpy(dst_data, src_data, itemsize) - * src_data += src_stride - * dst_data += dst_stride # <<<<<<<<<<<<<< - * else: - * for i in range(dst_extent): - */ - __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride); - } - } - __pyx_L4:; - - /* "View.MemoryView":1149 - * cdef Py_ssize_t dst_stride = dst_strides[0] - * - * if ndim == 1: # <<<<<<<<<<<<<< - * if (src_stride > 0 and dst_stride > 0 and - * src_stride == itemsize == dst_stride): - */ - goto __pyx_L3; - } - - /* "View.MemoryView":1159 - * dst_data += dst_stride - * else: - * for i in range(dst_extent): # <<<<<<<<<<<<<< - * _copy_strided_to_strided(src_data, src_strides + 1, - * dst_data, dst_strides + 1, - */ - /*else*/ { - __pyx_t_3 = __pyx_v_dst_extent; - __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":1160 - * else: - * for i in range(dst_extent): - * _copy_strided_to_strided(src_data, src_strides + 1, # <<<<<<<<<<<<<< - * dst_data, dst_strides + 1, - * src_shape + 1, dst_shape + 1, - */ - _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":1164 - * src_shape + 1, dst_shape + 1, - * ndim - 1, itemsize) - * src_data += src_stride # <<<<<<<<<<<<<< - * dst_data += dst_stride - * - */ - __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); - - /* "View.MemoryView":1165 - * ndim - 1, itemsize) - * src_data += src_stride - * dst_data += dst_stride # <<<<<<<<<<<<<< - * - * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, - */ - __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride); - } - } - __pyx_L3:; - - /* "View.MemoryView":1137 - * - * @cython.cdivision(True) - * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< - * char *dst_data, Py_ssize_t *dst_strides, - * Py_ssize_t *src_shape, Py_ssize_t *dst_shape, - */ - - /* function exit code */ -} - -/* "View.MemoryView":1167 - * dst_data += dst_stride - * - * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< - * __Pyx_memviewslice *dst, - * int ndim, size_t itemsize) noexcept nogil: - */ - -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":1170 - * __Pyx_memviewslice *dst, - * int ndim, size_t itemsize) noexcept nogil: - * _copy_strided_to_strided(src.data, src.strides, dst.data, dst.strides, # <<<<<<<<<<<<<< - * src.shape, dst.shape, ndim, itemsize) - * - */ - _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":1167 - * dst_data += dst_stride - * - * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< - * __Pyx_memviewslice *dst, - * int ndim, size_t itemsize) noexcept nogil: - */ - - /* function exit code */ -} - -/* "View.MemoryView":1174 - * - * @cname('__pyx_memoryview_slice_get_size') - * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) noexcept 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 - */ - -static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_src, int __pyx_v_ndim) { - Py_ssize_t __pyx_v_shape; - 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; - - /* "View.MemoryView":1176 - * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) noexcept 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 # <<<<<<<<<<<<<< - * - * for shape in src.shape[:ndim]: - */ - __pyx_t_1 = __pyx_v_src->memview->view.itemsize; - __pyx_v_size = __pyx_t_1; - - /* "View.MemoryView":1178 - * cdef Py_ssize_t shape, size = src.memview.view.itemsize - * - * for shape in src.shape[:ndim]: # <<<<<<<<<<<<<< - * size *= shape - * - */ - __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]); - - /* "View.MemoryView":1179 - * - * for shape in src.shape[:ndim]: - * size *= shape # <<<<<<<<<<<<<< - * - * return size - */ - __pyx_v_size = (__pyx_v_size * __pyx_v_shape); - } - - /* "View.MemoryView":1181 - * size *= shape - * - * return size # <<<<<<<<<<<<<< - * - * @cname('__pyx_fill_contig_strides_array') - */ - __pyx_r = __pyx_v_size; - goto __pyx_L0; - - /* "View.MemoryView":1174 - * - * @cname('__pyx_memoryview_slice_get_size') - * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) noexcept 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 - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":1184 - * - * @cname('__pyx_fill_contig_strides_array') - * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< - * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, - * int ndim, char order) noexcept nogil: - */ - -static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, Py_ssize_t __pyx_v_stride, int __pyx_v_ndim, char __pyx_v_order) { - int __pyx_v_idx; - Py_ssize_t __pyx_r; - int __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - int __pyx_t_4; - - /* "View.MemoryView":1193 - * cdef int idx - * - * if order == 'F': # <<<<<<<<<<<<<< - * for idx in range(ndim): - * strides[idx] = stride - */ - __pyx_t_1 = (__pyx_v_order == 'F'); - if (__pyx_t_1) { - - /* "View.MemoryView":1194 - * - * if order == 'F': - * for idx in range(ndim): # <<<<<<<<<<<<<< - * strides[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":1195 - * if order == 'F': - * for idx in range(ndim): - * strides[idx] = stride # <<<<<<<<<<<<<< - * stride *= shape[idx] - * else: - */ - (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; - - /* "View.MemoryView":1196 - * for idx in range(ndim): - * strides[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":1193 - * cdef int idx - * - * if order == 'F': # <<<<<<<<<<<<<< - * for idx in range(ndim): - * strides[idx] = stride - */ - goto __pyx_L3; - } - - /* "View.MemoryView":1198 - * stride *= shape[idx] - * else: - * for idx in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< - * strides[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":1199 - * else: - * for idx in range(ndim - 1, -1, -1): - * strides[idx] = stride # <<<<<<<<<<<<<< - * stride *= shape[idx] - * - */ - (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; - - /* "View.MemoryView":1200 - * for idx in range(ndim - 1, -1, -1): - * strides[idx] = stride - * stride *= shape[idx] # <<<<<<<<<<<<<< - * - * return stride - */ - __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx])); - } - } - __pyx_L3:; - - /* "View.MemoryView":1202 - * stride *= shape[idx] - * - * return stride # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_copy_data_to_temp') - */ - __pyx_r = __pyx_v_stride; - goto __pyx_L0; - - /* "View.MemoryView":1184 - * - * @cname('__pyx_fill_contig_strides_array') - * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< - * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, - * int ndim, char order) noexcept nogil: - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":1205 - * - * @cname('__pyx_memoryview_copy_data_to_temp') - * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< - * __Pyx_memviewslice *tmpslice, - * char order, - */ - -static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_tmpslice, char __pyx_v_order, int __pyx_v_ndim) { - int __pyx_v_i; - void *__pyx_v_result; - size_t __pyx_v_itemsize; - size_t __pyx_v_size; - void *__pyx_r; - Py_ssize_t __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - 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; - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save; - #endif - - /* "View.MemoryView":1216 - * cdef void *result - * - * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< - * cdef size_t size = slice_get_size(src, ndim) - * - */ - __pyx_t_1 = __pyx_v_src->memview->view.itemsize; - __pyx_v_itemsize = __pyx_t_1; - - /* "View.MemoryView":1217 - * - * cdef size_t itemsize = src.memview.view.itemsize - * cdef size_t size = slice_get_size(src, ndim) # <<<<<<<<<<<<<< - * - * result = malloc(size) - */ - __pyx_v_size = __pyx_memoryview_slice_get_size(__pyx_v_src, __pyx_v_ndim); - - /* "View.MemoryView":1219 - * cdef size_t size = slice_get_size(src, ndim) - * - * result = malloc(size) # <<<<<<<<<<<<<< - * if not result: - * _err_no_memory() - */ - __pyx_v_result = malloc(__pyx_v_size); - - /* "View.MemoryView":1220 - * - * result = malloc(size) - * if not result: # <<<<<<<<<<<<<< - * _err_no_memory() - * - */ - __pyx_t_2 = (!(__pyx_v_result != 0)); - if (__pyx_t_2) { - - /* "View.MemoryView":1221 - * result = malloc(size) - * if not result: - * _err_no_memory() # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_3 = __pyx_memoryview_err_no_memory(); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 1221, __pyx_L1_error) - - /* "View.MemoryView":1220 - * - * result = malloc(size) - * if not result: # <<<<<<<<<<<<<< - * _err_no_memory() - * - */ - } - - /* "View.MemoryView":1224 - * - * - * tmpslice.data = result # <<<<<<<<<<<<<< - * tmpslice.memview = src.memview - * for i in range(ndim): - */ - __pyx_v_tmpslice->data = ((char *)__pyx_v_result); - - /* "View.MemoryView":1225 - * - * tmpslice.data = result - * tmpslice.memview = src.memview # <<<<<<<<<<<<<< - * for i in range(ndim): - * tmpslice.shape[i] = src.shape[i] - */ - __pyx_t_4 = __pyx_v_src->memview; - __pyx_v_tmpslice->memview = __pyx_t_4; - - /* "View.MemoryView":1226 - * tmpslice.data = result - * tmpslice.memview = src.memview - * for i in range(ndim): # <<<<<<<<<<<<<< - * tmpslice.shape[i] = src.shape[i] - * tmpslice.suboffsets[i] = -1 - */ - __pyx_t_3 = __pyx_v_ndim; - __pyx_t_5 = __pyx_t_3; - for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { - __pyx_v_i = __pyx_t_6; - - /* "View.MemoryView":1227 - * tmpslice.memview = src.memview - * for i in range(ndim): - * tmpslice.shape[i] = src.shape[i] # <<<<<<<<<<<<<< - * tmpslice.suboffsets[i] = -1 - * - */ - (__pyx_v_tmpslice->shape[__pyx_v_i]) = (__pyx_v_src->shape[__pyx_v_i]); - - /* "View.MemoryView":1228 - * for i in range(ndim): - * tmpslice.shape[i] = src.shape[i] - * tmpslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< - * - * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, ndim, order) - */ - (__pyx_v_tmpslice->suboffsets[__pyx_v_i]) = -1L; - } - - /* "View.MemoryView":1230 - * tmpslice.suboffsets[i] = -1 - * - * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, ndim, order) # <<<<<<<<<<<<<< - * - * - */ - (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":1233 - * - * - * for i in range(ndim): # <<<<<<<<<<<<<< - * if tmpslice.shape[i] == 1: - * tmpslice.strides[i] = 0 - */ - __pyx_t_3 = __pyx_v_ndim; - __pyx_t_5 = __pyx_t_3; - for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { - __pyx_v_i = __pyx_t_6; - - /* "View.MemoryView":1234 - * - * for i in range(ndim): - * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< - * tmpslice.strides[i] = 0 - * - */ - __pyx_t_2 = ((__pyx_v_tmpslice->shape[__pyx_v_i]) == 1); - if (__pyx_t_2) { - - /* "View.MemoryView":1235 - * for i in range(ndim): - * if tmpslice.shape[i] == 1: - * tmpslice.strides[i] = 0 # <<<<<<<<<<<<<< - * - * if slice_is_contig(src[0], order, ndim): - */ - (__pyx_v_tmpslice->strides[__pyx_v_i]) = 0; - - /* "View.MemoryView":1234 - * - * for i in range(ndim): - * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< - * tmpslice.strides[i] = 0 - * - */ - } - } - - /* "View.MemoryView":1237 - * tmpslice.strides[i] = 0 - * - * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< - * memcpy(result, src.data, size) - * else: - */ - __pyx_t_2 = __pyx_memviewslice_is_contig((__pyx_v_src[0]), __pyx_v_order, __pyx_v_ndim); - if (__pyx_t_2) { - - /* "View.MemoryView":1238 - * - * if slice_is_contig(src[0], order, ndim): - * memcpy(result, src.data, size) # <<<<<<<<<<<<<< - * else: - * copy_strided_to_strided(src, tmpslice, ndim, itemsize) - */ - (void)(memcpy(__pyx_v_result, __pyx_v_src->data, __pyx_v_size)); - - /* "View.MemoryView":1237 - * tmpslice.strides[i] = 0 - * - * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< - * memcpy(result, src.data, size) - * else: - */ - goto __pyx_L9; - } - - /* "View.MemoryView":1240 - * memcpy(result, src.data, size) - * else: - * copy_strided_to_strided(src, tmpslice, ndim, itemsize) # <<<<<<<<<<<<<< - * - * return result - */ - /*else*/ { - copy_strided_to_strided(__pyx_v_src, __pyx_v_tmpslice, __pyx_v_ndim, __pyx_v_itemsize); - } - __pyx_L9:; - - /* "View.MemoryView":1242 - * copy_strided_to_strided(src, tmpslice, ndim, itemsize) - * - * return result # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = __pyx_v_result; - goto __pyx_L0; - - /* "View.MemoryView":1205 - * - * @cname('__pyx_memoryview_copy_data_to_temp') - * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< - * __Pyx_memviewslice *tmpslice, - * char order, - */ - - /* function exit code */ - __pyx_L1_error:; - #ifdef WITH_THREAD - __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_AddTraceback("View.MemoryView.copy_data_to_temp", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":1247 - * - * @cname('__pyx_memoryview_err_extents') - * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< - * Py_ssize_t extent2) except -1 with gil: - * raise ValueError, f"got differing extents in dimension {i} (got {extent1} and {extent2})" - */ - -static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent1, Py_ssize_t __pyx_v_extent2) { - int __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - Py_ssize_t __pyx_t_2; - Py_UCS4 __pyx_t_3; - 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":1249 - * cdef int _err_extents(int i, Py_ssize_t extent1, - * Py_ssize_t extent2) except -1 with gil: - * raise ValueError, f"got differing extents in dimension {i} (got {extent1} and {extent2})" # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_err_dim') - */ - __pyx_t_1 = PyTuple_New(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = 0; - __pyx_t_3 = 127; - __Pyx_INCREF(__pyx_kp_u_got_differing_extents_in_dimensi); - __pyx_t_2 += 35; - __Pyx_GIVEREF(__pyx_kp_u_got_differing_extents_in_dimensi); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_got_differing_extents_in_dimensi); - __pyx_t_4 = __Pyx_PyUnicode_From_int(__pyx_v_i, 0, ' ', 'd'); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_4); - __pyx_t_4 = 0; - __Pyx_INCREF(__pyx_kp_u_got); - __pyx_t_2 += 6; - __Pyx_GIVEREF(__pyx_kp_u_got); - PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_got); - __pyx_t_4 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_extent1, 0, ' ', 'd'); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_4); - __pyx_t_4 = 0; - __Pyx_INCREF(__pyx_kp_u_and); - __pyx_t_2 += 5; - __Pyx_GIVEREF(__pyx_kp_u_and); - PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_kp_u_and); - __pyx_t_4 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_extent2, 0, ' ', 'd'); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_1, 5, __pyx_t_4); - __pyx_t_4 = 0; - __Pyx_INCREF(__pyx_kp_u__7); - __pyx_t_2 += 1; - __Pyx_GIVEREF(__pyx_kp_u__7); - PyTuple_SET_ITEM(__pyx_t_1, 6, __pyx_kp_u__7); - __pyx_t_4 = __Pyx_PyUnicode_Join(__pyx_t_1, 7, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_Raise(__pyx_builtin_ValueError, __pyx_t_4, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(1, 1249, __pyx_L1_error) - - /* "View.MemoryView":1247 - * - * @cname('__pyx_memoryview_err_extents') - * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< - * Py_ssize_t extent2) except -1 with gil: - * raise ValueError, f"got differing extents in dimension {i} (got {extent1} and {extent2})" - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("View.MemoryView._err_extents", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __Pyx_RefNannyFinishContext(); - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - return __pyx_r; -} - -/* "View.MemoryView":1252 - * - * @cname('__pyx_memoryview_err_dim') - * cdef int _err_dim(PyObject *error, str msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< - * raise error, msg % dim - * - */ - -static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, PyObject *__pyx_v_msg, int __pyx_v_dim) { - int __pyx_r; - __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; - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_RefNannySetupContext("_err_dim", 0); - __Pyx_INCREF(__pyx_v_msg); - - /* "View.MemoryView":1253 - * @cname('__pyx_memoryview_err_dim') - * cdef int _err_dim(PyObject *error, str msg, int dim) except -1 with gil: - * raise error, msg % dim # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_err') - */ - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1253, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyString_FormatSafe(__pyx_v_msg, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1253, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_Raise(((PyObject *)__pyx_v_error), __pyx_t_2, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(1, 1253, __pyx_L1_error) - - /* "View.MemoryView":1252 - * - * @cname('__pyx_memoryview_err_dim') - * cdef int _err_dim(PyObject *error, str msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< - * raise error, msg % dim - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView._err_dim", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __Pyx_XDECREF(__pyx_v_msg); - __Pyx_RefNannyFinishContext(); - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - return __pyx_r; -} - -/* "View.MemoryView":1256 - * - * @cname('__pyx_memoryview_err') - * cdef int _err(PyObject *error, str msg) except -1 with gil: # <<<<<<<<<<<<<< - * raise error, msg - * - */ - -static int __pyx_memoryview_err(PyObject *__pyx_v_error, PyObject *__pyx_v_msg) { - int __pyx_r; - __Pyx_RefNannyDeclarations - 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_msg); - - /* "View.MemoryView":1257 - * @cname('__pyx_memoryview_err') - * cdef int _err(PyObject *error, str msg) except -1 with gil: - * raise error, msg # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_err_no_memory') - */ - __Pyx_Raise(((PyObject *)__pyx_v_error), __pyx_v_msg, 0, 0); - __PYX_ERR(1, 1257, __pyx_L1_error) - - /* "View.MemoryView":1256 - * - * @cname('__pyx_memoryview_err') - * cdef int _err(PyObject *error, str msg) except -1 with gil: # <<<<<<<<<<<<<< - * raise error, msg - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("View.MemoryView._err", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __Pyx_XDECREF(__pyx_v_msg); - __Pyx_RefNannyFinishContext(); - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - return __pyx_r; -} - -/* "View.MemoryView":1260 - * - * @cname('__pyx_memoryview_err_no_memory') - * cdef int _err_no_memory() except -1 with gil: # <<<<<<<<<<<<<< - * raise MemoryError - * - */ - -static int __pyx_memoryview_err_no_memory(void) { - int __pyx_r; - 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 - - /* "View.MemoryView":1261 - * @cname('__pyx_memoryview_err_no_memory') - * cdef int _err_no_memory() except -1 with gil: - * raise MemoryError # <<<<<<<<<<<<<< - * - * - */ - PyErr_NoMemory(); __PYX_ERR(1, 1261, __pyx_L1_error) - - /* "View.MemoryView":1260 - * - * @cname('__pyx_memoryview_err_no_memory') - * cdef int _err_no_memory() except -1 with gil: # <<<<<<<<<<<<<< - * raise MemoryError - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("View.MemoryView._err_no_memory", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - return __pyx_r; -} - -/* "View.MemoryView":1265 - * - * @cname('__pyx_memoryview_copy_contents') - * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< - * __Pyx_memviewslice dst, - * int src_ndim, int dst_ndim, - */ - -static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_memviewslice __pyx_v_dst, int __pyx_v_src_ndim, int __pyx_v_dst_ndim, int __pyx_v_dtype_is_object) { - void *__pyx_v_tmpdata; - size_t __pyx_v_itemsize; - int __pyx_v_i; - char __pyx_v_order; - int __pyx_v_broadcasting; - int __pyx_v_direct_copy; - __Pyx_memviewslice __pyx_v_tmp; - int __pyx_v_ndim; - int __pyx_r; - Py_ssize_t __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - int __pyx_t_4; - int __pyx_t_5; - int __pyx_t_6; - void *__pyx_t_7; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save; - #endif - - /* "View.MemoryView":1273 - * Check for overlapping memory and verify the shapes. - * """ - * cdef void *tmpdata = NULL # <<<<<<<<<<<<<< - * cdef size_t itemsize = src.memview.view.itemsize - * cdef int i - */ - __pyx_v_tmpdata = NULL; - - /* "View.MemoryView":1274 - * """ - * cdef void *tmpdata = NULL - * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< - * cdef int i - * cdef char order = get_best_order(&src, src_ndim) - */ - __pyx_t_1 = __pyx_v_src.memview->view.itemsize; - __pyx_v_itemsize = __pyx_t_1; - - /* "View.MemoryView":1276 - * cdef size_t itemsize = src.memview.view.itemsize - * cdef int i - * cdef char order = get_best_order(&src, src_ndim) # <<<<<<<<<<<<<< - * cdef bint broadcasting = False - * cdef bint direct_copy = False - */ - __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_src), __pyx_v_src_ndim); - - /* "View.MemoryView":1277 - * cdef int i - * cdef char order = get_best_order(&src, src_ndim) - * cdef bint broadcasting = False # <<<<<<<<<<<<<< - * cdef bint direct_copy = False - * cdef __Pyx_memviewslice tmp - */ - __pyx_v_broadcasting = 0; - - /* "View.MemoryView":1278 - * cdef char order = get_best_order(&src, src_ndim) - * cdef bint broadcasting = False - * cdef bint direct_copy = False # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice tmp - * - */ - __pyx_v_direct_copy = 0; - - /* "View.MemoryView":1281 - * cdef __Pyx_memviewslice tmp - * - * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< - * broadcast_leading(&src, src_ndim, dst_ndim) - * elif dst_ndim < src_ndim: - */ - __pyx_t_2 = (__pyx_v_src_ndim < __pyx_v_dst_ndim); - if (__pyx_t_2) { - - /* "View.MemoryView":1282 - * - * if src_ndim < dst_ndim: - * broadcast_leading(&src, src_ndim, dst_ndim) # <<<<<<<<<<<<<< - * elif dst_ndim < src_ndim: - * broadcast_leading(&dst, dst_ndim, src_ndim) - */ - __pyx_memoryview_broadcast_leading((&__pyx_v_src), __pyx_v_src_ndim, __pyx_v_dst_ndim); - - /* "View.MemoryView":1281 - * cdef __Pyx_memviewslice tmp - * - * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< - * broadcast_leading(&src, src_ndim, dst_ndim) - * elif dst_ndim < src_ndim: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":1283 - * if src_ndim < dst_ndim: - * broadcast_leading(&src, src_ndim, dst_ndim) - * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< - * broadcast_leading(&dst, dst_ndim, src_ndim) - * - */ - __pyx_t_2 = (__pyx_v_dst_ndim < __pyx_v_src_ndim); - if (__pyx_t_2) { - - /* "View.MemoryView":1284 - * broadcast_leading(&src, src_ndim, dst_ndim) - * elif dst_ndim < src_ndim: - * broadcast_leading(&dst, dst_ndim, src_ndim) # <<<<<<<<<<<<<< - * - * cdef int ndim = max(src_ndim, dst_ndim) - */ - __pyx_memoryview_broadcast_leading((&__pyx_v_dst), __pyx_v_dst_ndim, __pyx_v_src_ndim); - - /* "View.MemoryView":1283 - * if src_ndim < dst_ndim: - * broadcast_leading(&src, src_ndim, dst_ndim) - * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< - * broadcast_leading(&dst, dst_ndim, src_ndim) - * - */ - } - __pyx_L3:; - - /* "View.MemoryView":1286 - * broadcast_leading(&dst, dst_ndim, src_ndim) - * - * cdef int ndim = max(src_ndim, dst_ndim) # <<<<<<<<<<<<<< - * - * for i in range(ndim): - */ - __pyx_t_3 = __pyx_v_dst_ndim; - __pyx_t_4 = __pyx_v_src_ndim; - __pyx_t_2 = (__pyx_t_3 > __pyx_t_4); - if (__pyx_t_2) { - __pyx_t_5 = __pyx_t_3; - } else { - __pyx_t_5 = __pyx_t_4; - } - __pyx_v_ndim = __pyx_t_5; - - /* "View.MemoryView":1288 - * cdef int ndim = max(src_ndim, dst_ndim) - * - * for i in range(ndim): # <<<<<<<<<<<<<< - * if src.shape[i] != dst.shape[i]: - * if src.shape[i] == 1: - */ - __pyx_t_5 = __pyx_v_ndim; - __pyx_t_3 = __pyx_t_5; - for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { - __pyx_v_i = __pyx_t_4; - - /* "View.MemoryView":1289 - * - * for i in range(ndim): - * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< - * if src.shape[i] == 1: - * broadcasting = True - */ - __pyx_t_2 = ((__pyx_v_src.shape[__pyx_v_i]) != (__pyx_v_dst.shape[__pyx_v_i])); - if (__pyx_t_2) { - - /* "View.MemoryView":1290 - * for i in range(ndim): - * if src.shape[i] != dst.shape[i]: - * if src.shape[i] == 1: # <<<<<<<<<<<<<< - * broadcasting = True - * src.strides[i] = 0 - */ - __pyx_t_2 = ((__pyx_v_src.shape[__pyx_v_i]) == 1); - if (__pyx_t_2) { - - /* "View.MemoryView":1291 - * if src.shape[i] != dst.shape[i]: - * if src.shape[i] == 1: - * broadcasting = True # <<<<<<<<<<<<<< - * src.strides[i] = 0 - * else: - */ - __pyx_v_broadcasting = 1; - - /* "View.MemoryView":1292 - * if src.shape[i] == 1: - * broadcasting = True - * src.strides[i] = 0 # <<<<<<<<<<<<<< - * else: - * _err_extents(i, dst.shape[i], src.shape[i]) - */ - (__pyx_v_src.strides[__pyx_v_i]) = 0; - - /* "View.MemoryView":1290 - * for i in range(ndim): - * if src.shape[i] != dst.shape[i]: - * if src.shape[i] == 1: # <<<<<<<<<<<<<< - * broadcasting = True - * src.strides[i] = 0 - */ - goto __pyx_L7; - } - - /* "View.MemoryView":1294 - * src.strides[i] = 0 - * else: - * _err_extents(i, dst.shape[i], src.shape[i]) # <<<<<<<<<<<<<< - * - * 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(1, 1294, __pyx_L1_error) - } - __pyx_L7:; - - /* "View.MemoryView":1289 - * - * for i in range(ndim): - * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< - * if src.shape[i] == 1: - * broadcasting = True - */ - } - - /* "View.MemoryView":1296 - * _err_extents(i, dst.shape[i], src.shape[i]) - * - * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< - * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) - * - */ - __pyx_t_2 = ((__pyx_v_src.suboffsets[__pyx_v_i]) >= 0); - if (__pyx_t_2) { - - /* "View.MemoryView":1297 - * - * if src.suboffsets[i] >= 0: - * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) # <<<<<<<<<<<<<< - * - * if slices_overlap(&src, &dst, ndim, itemsize): - */ - __pyx_t_6 = __pyx_memoryview_err_dim(PyExc_ValueError, __pyx_kp_s_Dimension_d_is_not_direct, __pyx_v_i); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1297, __pyx_L1_error) - - /* "View.MemoryView":1296 - * _err_extents(i, dst.shape[i], src.shape[i]) - * - * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< - * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) - * - */ - } - } - - /* "View.MemoryView":1299 - * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) - * - * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< - * - * if not slice_is_contig(src, order, ndim): - */ - __pyx_t_2 = __pyx_slices_overlap((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize); - if (__pyx_t_2) { - - /* "View.MemoryView":1301 - * if slices_overlap(&src, &dst, ndim, itemsize): - * - * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< - * order = get_best_order(&dst, ndim) - * - */ - __pyx_t_2 = (!__pyx_memviewslice_is_contig(__pyx_v_src, __pyx_v_order, __pyx_v_ndim)); - if (__pyx_t_2) { - - /* "View.MemoryView":1302 - * - * if not slice_is_contig(src, order, ndim): - * order = get_best_order(&dst, ndim) # <<<<<<<<<<<<<< - * - * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) - */ - __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim); - - /* "View.MemoryView":1301 - * if slices_overlap(&src, &dst, ndim, itemsize): - * - * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< - * order = get_best_order(&dst, ndim) - * - */ - } - - /* "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(1, 1304, __pyx_L1_error) - __pyx_v_tmpdata = __pyx_t_7; - - /* "View.MemoryView":1305 - * - * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) - * src = tmp # <<<<<<<<<<<<<< - * - * if not broadcasting: - */ - __pyx_v_src = __pyx_v_tmp; - - /* "View.MemoryView":1299 - * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) - * - * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< - * - * if not slice_is_contig(src, order, ndim): - */ - } - - /* "View.MemoryView":1307 - * src = tmp - * - * if not broadcasting: # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_2 = (!__pyx_v_broadcasting); - if (__pyx_t_2) { - - /* "View.MemoryView":1310 - * - * - * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< - * direct_copy = slice_is_contig(dst, 'C', ndim) - * elif slice_is_contig(src, 'F', ndim): - */ - __pyx_t_2 = __pyx_memviewslice_is_contig(__pyx_v_src, 'C', __pyx_v_ndim); - if (__pyx_t_2) { - - /* "View.MemoryView":1311 - * - * if slice_is_contig(src, 'C', ndim): - * direct_copy = slice_is_contig(dst, 'C', ndim) # <<<<<<<<<<<<<< - * elif slice_is_contig(src, 'F', ndim): - * direct_copy = slice_is_contig(dst, 'F', ndim) - */ - __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'C', __pyx_v_ndim); - - /* "View.MemoryView":1310 - * - * - * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< - * direct_copy = slice_is_contig(dst, 'C', ndim) - * elif slice_is_contig(src, 'F', ndim): - */ - goto __pyx_L12; - } - - /* "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): # <<<<<<<<<<<<<< - * direct_copy = slice_is_contig(dst, 'F', ndim) - * - */ - __pyx_t_2 = __pyx_memviewslice_is_contig(__pyx_v_src, 'F', __pyx_v_ndim); - if (__pyx_t_2) { - - /* "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) # <<<<<<<<<<<<<< - * - * if direct_copy: - */ - __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'F', __pyx_v_ndim); - - /* "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): # <<<<<<<<<<<<<< - * direct_copy = slice_is_contig(dst, 'F', ndim) - * - */ - } - __pyx_L12:; - - /* "View.MemoryView":1315 - * direct_copy = slice_is_contig(dst, 'F', ndim) - * - * if direct_copy: # <<<<<<<<<<<<<< - * - * refcount_copying(&dst, dtype_is_object, ndim, inc=False) - */ - if (__pyx_v_direct_copy) { - - /* "View.MemoryView":1317 - * if direct_copy: - * - * refcount_copying(&dst, dtype_is_object, ndim, inc=False) # <<<<<<<<<<<<<< - * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) - * refcount_copying(&dst, dtype_is_object, ndim, inc=True) - */ - __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); - - /* "View.MemoryView":1318 - * - * refcount_copying(&dst, dtype_is_object, ndim, inc=False) - * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) # <<<<<<<<<<<<<< - * refcount_copying(&dst, dtype_is_object, ndim, inc=True) - * free(tmpdata) - */ - (void)(memcpy(__pyx_v_dst.data, __pyx_v_src.data, __pyx_memoryview_slice_get_size((&__pyx_v_src), __pyx_v_ndim))); - - /* "View.MemoryView":1319 - * refcount_copying(&dst, dtype_is_object, ndim, inc=False) - * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) - * refcount_copying(&dst, dtype_is_object, ndim, inc=True) # <<<<<<<<<<<<<< - * free(tmpdata) - * return 0 - */ - __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); - - /* "View.MemoryView":1320 - * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) - * refcount_copying(&dst, dtype_is_object, ndim, inc=True) - * free(tmpdata) # <<<<<<<<<<<<<< - * return 0 - * - */ - free(__pyx_v_tmpdata); - - /* "View.MemoryView":1321 - * refcount_copying(&dst, dtype_is_object, ndim, inc=True) - * free(tmpdata) - * return 0 # <<<<<<<<<<<<<< - * - * if order == 'F' == get_best_order(&dst, ndim): - */ - __pyx_r = 0; - goto __pyx_L0; - - /* "View.MemoryView":1315 - * direct_copy = slice_is_contig(dst, 'F', ndim) - * - * if direct_copy: # <<<<<<<<<<<<<< - * - * refcount_copying(&dst, dtype_is_object, ndim, inc=False) - */ - } - - /* "View.MemoryView":1307 - * src = tmp - * - * if not broadcasting: # <<<<<<<<<<<<<< - * - * - */ - } - - /* "View.MemoryView":1323 - * return 0 - * - * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_2 = (__pyx_v_order == 'F'); - if (__pyx_t_2) { - __pyx_t_2 = ('F' == __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim)); - } - if (__pyx_t_2) { - - /* "View.MemoryView":1326 - * - * - * transpose_memslice(&src) # <<<<<<<<<<<<<< - * transpose_memslice(&dst) - * - */ - __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_src)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 1326, __pyx_L1_error) - - /* "View.MemoryView":1327 - * - * transpose_memslice(&src) - * transpose_memslice(&dst) # <<<<<<<<<<<<<< - * - * refcount_copying(&dst, dtype_is_object, ndim, inc=False) - */ - __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_dst)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 1327, __pyx_L1_error) - - /* "View.MemoryView":1323 - * return 0 - * - * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< - * - * - */ - } - - /* "View.MemoryView":1329 - * transpose_memslice(&dst) - * - * refcount_copying(&dst, dtype_is_object, ndim, inc=False) # <<<<<<<<<<<<<< - * copy_strided_to_strided(&src, &dst, ndim, itemsize) - * refcount_copying(&dst, dtype_is_object, ndim, inc=True) - */ - __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); - - /* "View.MemoryView":1330 - * - * refcount_copying(&dst, dtype_is_object, ndim, inc=False) - * copy_strided_to_strided(&src, &dst, ndim, itemsize) # <<<<<<<<<<<<<< - * refcount_copying(&dst, dtype_is_object, ndim, inc=True) - * - */ - copy_strided_to_strided((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize); - - /* "View.MemoryView":1331 - * refcount_copying(&dst, dtype_is_object, ndim, inc=False) - * copy_strided_to_strided(&src, &dst, ndim, itemsize) - * refcount_copying(&dst, dtype_is_object, ndim, inc=True) # <<<<<<<<<<<<<< - * - * free(tmpdata) - */ - __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); - - /* "View.MemoryView":1333 - * refcount_copying(&dst, dtype_is_object, ndim, inc=True) - * - * free(tmpdata) # <<<<<<<<<<<<<< - * return 0 - * - */ - free(__pyx_v_tmpdata); - - /* "View.MemoryView":1334 - * - * free(tmpdata) - * return 0 # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_broadcast_leading') - */ - __pyx_r = 0; - goto __pyx_L0; - - /* "View.MemoryView":1265 - * - * @cname('__pyx_memoryview_copy_contents') - * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< - * __Pyx_memviewslice dst, - * int src_ndim, int dst_ndim, - */ - - /* function exit code */ - __pyx_L1_error:; - #ifdef WITH_THREAD - __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_AddTraceback("View.MemoryView.memoryview_copy_contents", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":1337 - * - * @cname('__pyx_memoryview_broadcast_leading') - * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< - * int ndim, - * int ndim_other) noexcept nogil: - */ - -static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim, int __pyx_v_ndim_other) { - int __pyx_v_i; - int __pyx_v_offset; - int __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - - /* "View.MemoryView":1341 - * int ndim_other) noexcept nogil: - * cdef int i - * cdef int offset = ndim_other - ndim # <<<<<<<<<<<<<< - * - * for i in range(ndim - 1, -1, -1): - */ - __pyx_v_offset = (__pyx_v_ndim_other - __pyx_v_ndim); - - /* "View.MemoryView":1343 - * cdef int offset = ndim_other - ndim - * - * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< - * mslice.shape[i + offset] = mslice.shape[i] - * mslice.strides[i + offset] = mslice.strides[i] - */ - for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { - __pyx_v_i = __pyx_t_1; - - /* "View.MemoryView":1344 - * - * for i in range(ndim - 1, -1, -1): - * mslice.shape[i + offset] = mslice.shape[i] # <<<<<<<<<<<<<< - * mslice.strides[i + offset] = mslice.strides[i] - * mslice.suboffsets[i + offset] = mslice.suboffsets[i] - */ - (__pyx_v_mslice->shape[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->shape[__pyx_v_i]); - - /* "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] # <<<<<<<<<<<<<< - * mslice.suboffsets[i + offset] = mslice.suboffsets[i] - * - */ - (__pyx_v_mslice->strides[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->strides[__pyx_v_i]); - - /* "View.MemoryView":1346 - * mslice.shape[i + offset] = mslice.shape[i] - * mslice.strides[i + offset] = mslice.strides[i] - * mslice.suboffsets[i + offset] = mslice.suboffsets[i] # <<<<<<<<<<<<<< - * - * for i in range(offset): - */ - (__pyx_v_mslice->suboffsets[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->suboffsets[__pyx_v_i]); - } - - /* "View.MemoryView":1348 - * mslice.suboffsets[i + offset] = mslice.suboffsets[i] - * - * for i in range(offset): # <<<<<<<<<<<<<< - * mslice.shape[i] = 1 - * mslice.strides[i] = mslice.strides[0] - */ - __pyx_t_1 = __pyx_v_offset; - __pyx_t_2 = __pyx_t_1; - for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { - __pyx_v_i = __pyx_t_3; - - /* "View.MemoryView":1349 - * - * for i in range(offset): - * mslice.shape[i] = 1 # <<<<<<<<<<<<<< - * mslice.strides[i] = mslice.strides[0] - * mslice.suboffsets[i] = -1 - */ - (__pyx_v_mslice->shape[__pyx_v_i]) = 1; - - /* "View.MemoryView":1350 - * for i in range(offset): - * mslice.shape[i] = 1 - * mslice.strides[i] = mslice.strides[0] # <<<<<<<<<<<<<< - * mslice.suboffsets[i] = -1 - * - */ - (__pyx_v_mslice->strides[__pyx_v_i]) = (__pyx_v_mslice->strides[0]); - - /* "View.MemoryView":1351 - * mslice.shape[i] = 1 - * mslice.strides[i] = mslice.strides[0] - * mslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< - * - * - */ - (__pyx_v_mslice->suboffsets[__pyx_v_i]) = -1L; - } - - /* "View.MemoryView":1337 - * - * @cname('__pyx_memoryview_broadcast_leading') - * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< - * int ndim, - * int ndim_other) noexcept nogil: - */ - - /* function exit code */ -} - -/* "View.MemoryView":1359 - * - * @cname('__pyx_memoryview_refcount_copying') - * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil: # <<<<<<<<<<<<<< - * - * if dtype_is_object: - */ - -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) { - - /* "View.MemoryView":1361 - * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil: - * - * if dtype_is_object: # <<<<<<<<<<<<<< - * refcount_objects_in_slice_with_gil(dst.data, dst.shape, dst.strides, ndim, inc) - * - */ - if (__pyx_v_dtype_is_object) { - - /* "View.MemoryView":1362 - * - * if dtype_is_object: - * refcount_objects_in_slice_with_gil(dst.data, dst.shape, dst.strides, ndim, inc) # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') - */ - __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":1361 - * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil: - * - * if dtype_is_object: # <<<<<<<<<<<<<< - * refcount_objects_in_slice_with_gil(dst.data, dst.shape, dst.strides, ndim, inc) - * - */ - } - - /* "View.MemoryView":1359 - * - * @cname('__pyx_memoryview_refcount_copying') - * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil: # <<<<<<<<<<<<<< - * - * if dtype_is_object: - */ - - /* function exit code */ -} - -/* "View.MemoryView":1365 - * - * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') - * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< - * Py_ssize_t *strides, int ndim, - * bint inc) noexcept with gil: - */ - -static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) { - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - - /* "View.MemoryView":1368 - * Py_ssize_t *strides, int ndim, - * bint inc) noexcept with gil: - * refcount_objects_in_slice(data, shape, strides, ndim, inc) # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_refcount_objects_in_slice') - */ - __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, __pyx_v_shape, __pyx_v_strides, __pyx_v_ndim, __pyx_v_inc); - - /* "View.MemoryView":1365 - * - * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') - * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< - * Py_ssize_t *strides, int ndim, - * bint inc) noexcept with gil: - */ - - /* function exit code */ - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif -} - -/* "View.MemoryView":1371 - * - * @cname('__pyx_memoryview_refcount_objects_in_slice') - * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< - * Py_ssize_t *strides, int ndim, bint inc) noexcept: - * cdef Py_ssize_t i - */ - -static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) { - CYTHON_UNUSED Py_ssize_t __pyx_v_i; - Py_ssize_t __pyx_v_stride; - Py_ssize_t __pyx_t_1; - Py_ssize_t __pyx_t_2; - Py_ssize_t __pyx_t_3; - int __pyx_t_4; - - /* "View.MemoryView":1374 - * Py_ssize_t *strides, int ndim, bint inc) noexcept: - * cdef Py_ssize_t i - * cdef Py_ssize_t stride = strides[0] # <<<<<<<<<<<<<< - * - * for i in range(shape[0]): - */ - __pyx_v_stride = (__pyx_v_strides[0]); - - /* "View.MemoryView":1376 - * cdef Py_ssize_t stride = strides[0] - * - * for i in range(shape[0]): # <<<<<<<<<<<<<< - * if ndim == 1: - * if inc: - */ - __pyx_t_1 = (__pyx_v_shape[0]); - __pyx_t_2 = __pyx_t_1; - for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { - __pyx_v_i = __pyx_t_3; - - /* "View.MemoryView":1377 - * - * for i in range(shape[0]): - * if ndim == 1: # <<<<<<<<<<<<<< - * if inc: - * Py_INCREF(( data)[0]) - */ - __pyx_t_4 = (__pyx_v_ndim == 1); - if (__pyx_t_4) { - - /* "View.MemoryView":1378 - * for i in range(shape[0]): - * if ndim == 1: - * if inc: # <<<<<<<<<<<<<< - * Py_INCREF(( data)[0]) - * else: - */ - if (__pyx_v_inc) { - - /* "View.MemoryView":1379 - * if ndim == 1: - * if inc: - * Py_INCREF(( data)[0]) # <<<<<<<<<<<<<< - * else: - * Py_DECREF(( data)[0]) - */ - Py_INCREF((((PyObject **)__pyx_v_data)[0])); - - /* "View.MemoryView":1378 - * for i in range(shape[0]): - * if ndim == 1: - * if inc: # <<<<<<<<<<<<<< - * Py_INCREF(( data)[0]) - * else: - */ - goto __pyx_L6; - } - - /* "View.MemoryView":1381 - * Py_INCREF(( data)[0]) - * else: - * Py_DECREF(( data)[0]) # <<<<<<<<<<<<<< - * else: - * refcount_objects_in_slice(data, shape + 1, strides + 1, ndim - 1, inc) - */ - /*else*/ { - Py_DECREF((((PyObject **)__pyx_v_data)[0])); - } - __pyx_L6:; - - /* "View.MemoryView":1377 - * - * for i in range(shape[0]): - * if ndim == 1: # <<<<<<<<<<<<<< - * if inc: - * Py_INCREF(( data)[0]) - */ - goto __pyx_L5; - } - - /* "View.MemoryView":1383 - * Py_DECREF(( data)[0]) - * else: - * refcount_objects_in_slice(data, shape + 1, strides + 1, ndim - 1, inc) # <<<<<<<<<<<<<< - * - * data += stride - */ - /*else*/ { - __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_inc); - } - __pyx_L5:; - - /* "View.MemoryView":1385 - * refcount_objects_in_slice(data, shape + 1, strides + 1, ndim - 1, inc) - * - * data += stride # <<<<<<<<<<<<<< - * - * - */ - __pyx_v_data = (__pyx_v_data + __pyx_v_stride); - } - - /* "View.MemoryView":1371 - * - * @cname('__pyx_memoryview_refcount_objects_in_slice') - * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< - * Py_ssize_t *strides, int ndim, bint inc) noexcept: - * cdef Py_ssize_t i - */ - - /* function exit code */ -} - -/* "View.MemoryView":1391 - * - * @cname('__pyx_memoryview_slice_assign_scalar') - * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< - * size_t itemsize, void *item, - * bint dtype_is_object) noexcept nogil: - */ - -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":1394 - * size_t itemsize, void *item, - * bint dtype_is_object) noexcept nogil: - * refcount_copying(dst, dtype_is_object, ndim, inc=False) # <<<<<<<<<<<<<< - * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, itemsize, item) - * refcount_copying(dst, dtype_is_object, ndim, inc=True) - */ - __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 0); - - /* "View.MemoryView":1395 - * bint dtype_is_object) noexcept nogil: - * refcount_copying(dst, dtype_is_object, ndim, inc=False) - * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, itemsize, item) # <<<<<<<<<<<<<< - * refcount_copying(dst, dtype_is_object, ndim, inc=True) - * - */ - __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":1396 - * refcount_copying(dst, dtype_is_object, ndim, inc=False) - * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, itemsize, item) - * refcount_copying(dst, dtype_is_object, ndim, inc=True) # <<<<<<<<<<<<<< - * - * - */ - __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 1); - - /* "View.MemoryView":1391 - * - * @cname('__pyx_memoryview_slice_assign_scalar') - * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< - * size_t itemsize, void *item, - * bint dtype_is_object) noexcept nogil: - */ - - /* function exit code */ -} - -/* "View.MemoryView":1400 - * - * @cname('__pyx_memoryview__slice_assign_scalar') - * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< - * Py_ssize_t *strides, int ndim, - * size_t itemsize, void *item) noexcept nogil: - */ - -static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item) { - CYTHON_UNUSED Py_ssize_t __pyx_v_i; - Py_ssize_t __pyx_v_stride; - Py_ssize_t __pyx_v_extent; - int __pyx_t_1; - Py_ssize_t __pyx_t_2; - Py_ssize_t __pyx_t_3; - Py_ssize_t __pyx_t_4; - - /* "View.MemoryView":1404 - * size_t itemsize, void *item) noexcept nogil: - * cdef Py_ssize_t i - * cdef Py_ssize_t stride = strides[0] # <<<<<<<<<<<<<< - * cdef Py_ssize_t extent = shape[0] - * - */ - __pyx_v_stride = (__pyx_v_strides[0]); - - /* "View.MemoryView":1405 - * cdef Py_ssize_t i - * cdef Py_ssize_t stride = strides[0] - * cdef Py_ssize_t extent = shape[0] # <<<<<<<<<<<<<< - * - * if ndim == 1: - */ - __pyx_v_extent = (__pyx_v_shape[0]); - - /* "View.MemoryView":1407 - * cdef Py_ssize_t extent = shape[0] - * - * if ndim == 1: # <<<<<<<<<<<<<< - * for i in range(extent): - * memcpy(data, item, itemsize) - */ - __pyx_t_1 = (__pyx_v_ndim == 1); - if (__pyx_t_1) { - - /* "View.MemoryView":1408 - * - * if ndim == 1: - * for i in range(extent): # <<<<<<<<<<<<<< - * memcpy(data, item, itemsize) - * data += stride - */ - __pyx_t_2 = __pyx_v_extent; - __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":1409 - * if ndim == 1: - * for i in range(extent): - * memcpy(data, item, itemsize) # <<<<<<<<<<<<<< - * data += stride - * else: - */ - (void)(memcpy(__pyx_v_data, __pyx_v_item, __pyx_v_itemsize)); - - /* "View.MemoryView":1410 - * for i in range(extent): - * memcpy(data, item, itemsize) - * data += stride # <<<<<<<<<<<<<< - * else: - * for i in range(extent): - */ - __pyx_v_data = (__pyx_v_data + __pyx_v_stride); - } - - /* "View.MemoryView":1407 - * cdef Py_ssize_t extent = shape[0] - * - * if ndim == 1: # <<<<<<<<<<<<<< - * for i in range(extent): - * memcpy(data, item, itemsize) - */ - goto __pyx_L3; - } - - /* "View.MemoryView":1412 - * data += stride - * else: - * for i in range(extent): # <<<<<<<<<<<<<< - * _slice_assign_scalar(data, shape + 1, strides + 1, ndim - 1, itemsize, item) - * data += stride - */ - /*else*/ { - __pyx_t_2 = __pyx_v_extent; - __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":1413 - * else: - * for i in range(extent): - * _slice_assign_scalar(data, shape + 1, strides + 1, ndim - 1, itemsize, item) # <<<<<<<<<<<<<< - * data += stride - * - */ - __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":1414 - * for i in range(extent): - * _slice_assign_scalar(data, shape + 1, strides + 1, ndim - 1, itemsize, item) - * data += stride # <<<<<<<<<<<<<< - * - * - */ - __pyx_v_data = (__pyx_v_data + __pyx_v_stride); - } - } - __pyx_L3:; - - /* "View.MemoryView":1400 - * - * @cname('__pyx_memoryview__slice_assign_scalar') - * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< - * Py_ssize_t *strides, int ndim, - * size_t itemsize, void *item) noexcept nogil: - */ - - /* function exit code */ -} - -/* "(tree fragment)":1 - * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyMethodDef __pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum = {"__pyx_unpickle_Enum", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - PyObject *__pyx_v___pyx_type = 0; - long __pyx_v___pyx_checksum; - PyObject *__pyx_v___pyx_state = 0; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[3] = {0,0,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); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Enum") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 3)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - } - __pyx_v___pyx_type = values[0]; - __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) - __pyx_v___pyx_state = values[2]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 1, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_v___pyx_PickleError = 0; - PyObject *__pyx_v___pyx_result = 0; - 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; - int __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_unpickle_Enum", 1); - - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * if __pyx_checksum not in (0x82a3537, 0x6ae9995, 0xb068931): # <<<<<<<<<<<<<< - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum - */ - __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__8, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (__pyx_t_2) { - - /* "(tree fragment)":5 - * cdef object __pyx_result - * if __pyx_checksum not in (0x82a3537, 0x6ae9995, 0xb068931): - * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< - * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum - * __pyx_result = Enum.__new__(__pyx_type) - */ - __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_n_s_PickleError); - __Pyx_GIVEREF(__pyx_n_s_PickleError); - if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(1, 5, __pyx_L1_error); - __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_t_1); - __pyx_v___pyx_PickleError = __pyx_t_1; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "(tree fragment)":6 - * if __pyx_checksum not in (0x82a3537, 0x6ae9995, 0xb068931): - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum # <<<<<<<<<<<<<< - * __pyx_result = Enum.__new__(__pyx_type) - * if __pyx_state is not None: - */ - __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(1, 6, __pyx_L1_error) - - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * if __pyx_checksum not in (0x82a3537, 0x6ae9995, 0xb068931): # <<<<<<<<<<<<<< - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum - */ - } - - /* "(tree fragment)":7 - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum - * __pyx_result = Enum.__new__(__pyx_type) # <<<<<<<<<<<<<< - * if __pyx_state is not None: - * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) - */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_MemviewEnum_type), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = NULL; - __pyx_t_5 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_5 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } - __pyx_v___pyx_result = __pyx_t_1; - __pyx_t_1 = 0; - - /* "(tree fragment)":8 - * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum - * __pyx_result = Enum.__new__(__pyx_type) - * if __pyx_state is not None: # <<<<<<<<<<<<<< - * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) - * return __pyx_result - */ - __pyx_t_2 = (__pyx_v___pyx_state != Py_None); - if (__pyx_t_2) { - - /* "(tree fragment)":9 - * __pyx_result = Enum.__new__(__pyx_type) - * if __pyx_state is not None: - * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< - * return __pyx_result - * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): - */ - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 9, __pyx_L1_error) - __pyx_t_1 = __pyx_unpickle_Enum__set_state(((struct __pyx_MemviewEnum_obj *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "(tree fragment)":8 - * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum - * __pyx_result = Enum.__new__(__pyx_type) - * if __pyx_state is not None: # <<<<<<<<<<<<<< - * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) - * return __pyx_result - */ - } - - /* "(tree fragment)":10 - * if __pyx_state is not None: - * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) - * return __pyx_result # <<<<<<<<<<<<<< - * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): - * __pyx_result.name = __pyx_state[0] - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v___pyx_result); - __pyx_r = __pyx_v___pyx_result; - goto __pyx_L0; - - /* "(tree fragment)":1 - * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v___pyx_PickleError); - __Pyx_XDECREF(__pyx_v___pyx_result); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":11 - * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result.name = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - */ - -static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - Py_ssize_t __pyx_t_3; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - int __pyx_t_8; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_unpickle_Enum__set_state", 1); - - /* "(tree fragment)":12 - * return __pyx_result - * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): - * __pyx_result.name = __pyx_state[0] # <<<<<<<<<<<<<< - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - * __pyx_result.__dict__.update(__pyx_state[1]) - */ - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->name); - __Pyx_DECREF(__pyx_v___pyx_result->name); - __pyx_v___pyx_result->name = __pyx_t_1; - __pyx_t_1 = 0; - - /* "(tree fragment)":13 - * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): - * __pyx_result.name = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< - * __pyx_result.__dict__.update(__pyx_state[1]) - */ - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(1, 13, __pyx_L1_error) - } - __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) - __pyx_t_4 = (__pyx_t_3 > 1); - if (__pyx_t_4) { - } else { - __pyx_t_2 = __pyx_t_4; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) - __pyx_t_2 = __pyx_t_4; - __pyx_L4_bool_binop_done:; - if (__pyx_t_2) { - - /* "(tree fragment)":14 - * __pyx_result.name = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< - */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 14, __pyx_L1_error) - } - __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_7 = NULL; - __pyx_t_8 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_6))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_6, function); - __pyx_t_8 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "(tree fragment)":13 - * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): - * __pyx_result.name = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< - * __pyx_result.__dict__.update(__pyx_state[1]) - */ - } - - /* "(tree fragment)":11 - * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result.name = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - */ - - /* 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_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":245 - * - * @property - * cdef inline PyObject* base(self) nogil: # <<<<<<<<<<<<<< - * """Returns a borrowed reference to the object owning the data/memory. - * """ - */ - -static CYTHON_INLINE PyObject *__pyx_f_5numpy_7ndarray_4base_base(PyArrayObject *__pyx_v_self) { - PyObject *__pyx_r; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":248 - * """Returns a borrowed reference to the object owning the data/memory. - * """ - * return PyArray_BASE(self) # <<<<<<<<<<<<<< - * - * @property - */ - __pyx_r = PyArray_BASE(__pyx_v_self); - goto __pyx_L0; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":245 - * - * @property - * cdef inline PyObject* base(self) nogil: # <<<<<<<<<<<<<< - * """Returns a borrowed reference to the object owning the data/memory. - * """ - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":251 - * - * @property - * cdef inline dtype descr(self): # <<<<<<<<<<<<<< - * """Returns an owned reference to the dtype of the array. - * """ - */ - -static CYTHON_INLINE PyArray_Descr *__pyx_f_5numpy_7ndarray_5descr_descr(PyArrayObject *__pyx_v_self) { - PyArray_Descr *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyArray_Descr *__pyx_t_1; - __Pyx_RefNannySetupContext("descr", 1); - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":254 - * """Returns an owned reference to the dtype of the array. - * """ - * return PyArray_DESCR(self) # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF((PyObject *)__pyx_r); - __pyx_t_1 = PyArray_DESCR(__pyx_v_self); - __Pyx_INCREF((PyObject *)((PyArray_Descr *)__pyx_t_1)); - __pyx_r = ((PyArray_Descr *)__pyx_t_1); - goto __pyx_L0; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":251 - * - * @property - * cdef inline dtype descr(self): # <<<<<<<<<<<<<< - * """Returns an owned reference to the dtype of the array. - * """ - */ - - /* function exit code */ - __pyx_L0:; - __Pyx_XGIVEREF((PyObject *)__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":257 - * - * @property - * cdef inline int ndim(self) nogil: # <<<<<<<<<<<<<< - * """Returns the number of dimensions in the array. - * """ - */ - -static CYTHON_INLINE int __pyx_f_5numpy_7ndarray_4ndim_ndim(PyArrayObject *__pyx_v_self) { - int __pyx_r; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":260 - * """Returns the number of dimensions in the array. - * """ - * return PyArray_NDIM(self) # <<<<<<<<<<<<<< - * - * @property - */ - __pyx_r = PyArray_NDIM(__pyx_v_self); - goto __pyx_L0; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":257 - * - * @property - * cdef inline int ndim(self) nogil: # <<<<<<<<<<<<<< - * """Returns the number of dimensions in the array. - * """ - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":263 - * - * @property - * cdef inline npy_intp *shape(self) nogil: # <<<<<<<<<<<<<< - * """Returns a pointer to the dimensions/shape of the array. - * The number of elements matches the number of dimensions of the array (ndim). - */ - -static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_5shape_shape(PyArrayObject *__pyx_v_self) { - npy_intp *__pyx_r; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":268 - * Can return NULL for 0-dimensional arrays. - * """ - * return PyArray_DIMS(self) # <<<<<<<<<<<<<< - * - * @property - */ - __pyx_r = PyArray_DIMS(__pyx_v_self); - goto __pyx_L0; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":263 - * - * @property - * cdef inline npy_intp *shape(self) nogil: # <<<<<<<<<<<<<< - * """Returns a pointer to the dimensions/shape of the array. - * The number of elements matches the number of dimensions of the array (ndim). - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":271 - * - * @property - * cdef inline npy_intp *strides(self) nogil: # <<<<<<<<<<<<<< - * """Returns a pointer to the strides of the array. - * The number of elements matches the number of dimensions of the array (ndim). - */ - -static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_7strides_strides(PyArrayObject *__pyx_v_self) { - npy_intp *__pyx_r; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":275 - * The number of elements matches the number of dimensions of the array (ndim). - * """ - * return PyArray_STRIDES(self) # <<<<<<<<<<<<<< - * - * @property - */ - __pyx_r = PyArray_STRIDES(__pyx_v_self); - goto __pyx_L0; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":271 - * - * @property - * cdef inline npy_intp *strides(self) nogil: # <<<<<<<<<<<<<< - * """Returns a pointer to the strides of the array. - * The number of elements matches the number of dimensions of the array (ndim). - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":278 - * - * @property - * cdef inline npy_intp size(self) nogil: # <<<<<<<<<<<<<< - * """Returns the total size (in number of elements) of the array. - * """ - */ - -static CYTHON_INLINE npy_intp __pyx_f_5numpy_7ndarray_4size_size(PyArrayObject *__pyx_v_self) { - npy_intp __pyx_r; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":281 - * """Returns the total size (in number of elements) of the array. - * """ - * return PyArray_SIZE(self) # <<<<<<<<<<<<<< - * - * @property - */ - __pyx_r = PyArray_SIZE(__pyx_v_self); - goto __pyx_L0; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":278 - * - * @property - * cdef inline npy_intp size(self) nogil: # <<<<<<<<<<<<<< - * """Returns the total size (in number of elements) of the array. - * """ - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":284 - * - * @property - * cdef inline char* data(self) nogil: # <<<<<<<<<<<<<< - * """The pointer to the data buffer as a char*. - * This is provided for legacy reasons to avoid direct struct field access. - */ - -static CYTHON_INLINE char *__pyx_f_5numpy_7ndarray_4data_data(PyArrayObject *__pyx_v_self) { - char *__pyx_r; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":290 - * of `PyArray_DATA()` instead, which returns a 'void*'. - * """ - * return PyArray_BYTES(self) # <<<<<<<<<<<<<< - * - * ctypedef unsigned char npy_bool - */ - __pyx_r = PyArray_BYTES(__pyx_v_self); - goto __pyx_L0; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":284 - * - * @property - * cdef inline char* data(self) nogil: # <<<<<<<<<<<<<< - * """The pointer to the data buffer as a char*. - * This is provided for legacy reasons to avoid direct struct field access. - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":776 - * 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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 1); - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":777 - * - * 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(2, 777, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":776 - * 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; -} - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":779 - * return PyArray_MultiIterNew(1, a) - * - * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(2, a, b) - * - */ - -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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 1); - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":780 - * - * 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(2, 780, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":779 - * return PyArray_MultiIterNew(1, a) - * - * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(2, a, b) - * - */ - - /* 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; -} - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":782 - * return PyArray_MultiIterNew(2, a, b) - * - * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(3, a, b, c) - * - */ - -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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 1); - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":783 - * - * cdef inline object PyArray_MultiIterNew3(a, b, c): - * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< - * - * 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(2, 783, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":782 - * return PyArray_MultiIterNew(2, a, b) - * - * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(3, a, b, c) - * - */ - - /* 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; -} - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":785 - * return PyArray_MultiIterNew(3, a, b, c) - * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(4, a, b, c, d) - * - */ - -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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 1); - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":786 - * - * 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_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(2, 786, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":785 - * return PyArray_MultiIterNew(3, a, b, c) - * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(4, a, b, c, d) - * - */ - - /* 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; -} - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":788 - * 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) - * - */ - -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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 1); - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":789 - * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): - * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< - * - * 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(2, 789, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":788 - * 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) - * - */ - - /* 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; -} - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":791 - * return PyArray_MultiIterNew(5, a, b, c, d, e) - * - * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< - * if PyDataType_HASSUBARRAY(d): - * return d.subarray.shape - */ - -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", 1); - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":792 - * - * cdef inline tuple PyDataType_SHAPE(dtype d): - * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< - * return d.subarray.shape - * else: - */ - __pyx_t_1 = PyDataType_HASSUBARRAY(__pyx_v_d); - if (__pyx_t_1) { - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":793 - * 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; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":792 - * - * cdef inline tuple PyDataType_SHAPE(dtype d): - * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< - * return d.subarray.shape - * else: - */ - } - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":795 - * return d.subarray.shape - * else: - * return () # <<<<<<<<<<<<<< - * - * - */ - /*else*/ { - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_empty_tuple); - __pyx_r = __pyx_empty_tuple; - goto __pyx_L0; - } - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":791 - * return PyArray_MultiIterNew(5, a, b, c, d, e) - * - * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< - * if PyDataType_HASSUBARRAY(d): - * return d.subarray.shape - */ - - /* function exit code */ - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":970 - * 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 void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":971 - * - * 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) - * - */ - Py_INCREF(__pyx_v_base); - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":972 - * 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): - */ - (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":970 - * 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 */ -} - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":974 - * 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_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", 1); - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":975 - * - * cdef inline object get_array_base(ndarray arr): - * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< - * if base is NULL: - * return None - */ - __pyx_v_base = PyArray_BASE(__pyx_v_arr); - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":976 - * 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); - if (__pyx_t_1) { - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":977 - * 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; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":976 - * cdef inline object get_array_base(ndarray arr): - * base = PyArray_BASE(arr) - * if base is NULL: # <<<<<<<<<<<<<< - * return None - * return base - */ - } - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":978 - * if base is NULL: - * return None - * return base # <<<<<<<<<<<<<< - * - * # Versions of the import_* functions which are more suitable for - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_base)); - __pyx_r = ((PyObject *)__pyx_v_base); - goto __pyx_L0; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":974 - * PyArray_SetBaseObject(arr, base) - * - * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< - * base = PyArray_BASE(arr) - * if base is NULL: - */ - - /* function exit code */ - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":982 - * # Versions of the import_* functions which are more suitable for - * # Cython code. - * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< - * try: - * __pyx_import_array() - */ - -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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("import_array", 1); - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":983 - * # Cython code. - * cdef inline int import_array() except -1: - * try: # <<<<<<<<<<<<<< - * __pyx_import_array() - * except Exception: - */ - { - __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:*/ { - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":984 - * cdef inline int import_array() except -1: - * try: - * __pyx_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(2, 984, __pyx_L3_error) - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":983 - * # Cython code. - * cdef inline int import_array() except -1: - * try: # <<<<<<<<<<<<<< - * __pyx_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:; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":985 - * try: - * __pyx_import_array() - * except Exception: # <<<<<<<<<<<<<< - * raise ImportError("numpy.core.multiarray failed to import") - * - */ - __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(2, 985, __pyx_L5_except_error) - __Pyx_XGOTREF(__pyx_t_5); - __Pyx_XGOTREF(__pyx_t_6); - __Pyx_XGOTREF(__pyx_t_7); - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":986 - * __pyx_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__9, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 986, __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(2, 986, __pyx_L5_except_error) - } - goto __pyx_L5_except_error; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":983 - * # Cython code. - * cdef inline int import_array() except -1: - * try: # <<<<<<<<<<<<<< - * __pyx_import_array() - * except Exception: - */ - __pyx_L5_except_error:; - __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:; - } - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":982 - * # Versions of the import_* functions which are more suitable for - * # Cython code. - * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< - * try: - * __pyx_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; -} - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":988 - * raise ImportError("numpy.core.multiarray failed to import") - * - * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() - */ - -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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("import_umath", 1); - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":989 - * - * cdef inline int import_umath() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: - */ - { - __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:*/ { - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":990 - * 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(2, 990, __pyx_L3_error) - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":989 - * - * 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:; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":991 - * 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_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(2, 991, __pyx_L5_except_error) - __Pyx_XGOTREF(__pyx_t_5); - __Pyx_XGOTREF(__pyx_t_6); - __Pyx_XGOTREF(__pyx_t_7); - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":992 - * _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__10, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 992, __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(2, 992, __pyx_L5_except_error) - } - goto __pyx_L5_except_error; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":989 - * - * cdef inline int import_umath() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: - */ - __pyx_L5_except_error:; - __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:; - } - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":988 - * raise ImportError("numpy.core.multiarray failed to import") - * - * 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_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; -} - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":994 - * raise ImportError("numpy.core.umath failed to import") - * - * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() - */ - -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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("import_ufunc", 1); - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":995 - * - * cdef inline int import_ufunc() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: - */ - { - __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:*/ { - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":996 - * 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(2, 996, __pyx_L3_error) - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":995 - * - * 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:; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":997 - * 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(2, 997, __pyx_L5_except_error) - __Pyx_XGOTREF(__pyx_t_5); - __Pyx_XGOTREF(__pyx_t_6); - __Pyx_XGOTREF(__pyx_t_7); - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":998 - * _import_umath() - * except Exception: - * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 998, __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(2, 998, __pyx_L5_except_error) - } - goto __pyx_L5_except_error; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":995 - * - * cdef inline int import_ufunc() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: - */ - __pyx_L5_except_error:; - __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:; - } - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":994 - * raise ImportError("numpy.core.umath failed to import") - * - * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() - */ - - /* 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; -} - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":1001 - * - * - * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< - * """ - * Cython equivalent of `isinstance(obj, np.timedelta64)` - */ - -static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_obj) { - int __pyx_r; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":1013 - * bool - * """ - * return PyObject_TypeCheck(obj, &PyTimedeltaArrType_Type) # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyTimedeltaArrType_Type)); - goto __pyx_L0; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":1001 - * - * - * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< - * """ - * Cython equivalent of `isinstance(obj, np.timedelta64)` - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":1016 - * - * - * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< - * """ - * Cython equivalent of `isinstance(obj, np.datetime64)` - */ - -static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_obj) { - int __pyx_r; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":1028 - * bool - * """ - * return PyObject_TypeCheck(obj, &PyDatetimeArrType_Type) # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyDatetimeArrType_Type)); - goto __pyx_L0; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":1016 - * - * - * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< - * """ - * Cython equivalent of `isinstance(obj, np.datetime64)` - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":1031 - * - * - * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< - * """ - * returns the int64 value underlying scalar numpy datetime64 object - */ - -static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject *__pyx_v_obj) { - npy_datetime __pyx_r; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":1038 - * also needed. That can be found using `get_datetime64_unit`. - * """ - * return (obj).obval # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = ((PyDatetimeScalarObject *)__pyx_v_obj)->obval; - goto __pyx_L0; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":1031 - * - * - * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< - * """ - * returns the int64 value underlying scalar numpy datetime64 object - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":1041 - * - * - * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< - * """ - * returns the int64 value underlying scalar numpy timedelta64 object - */ - -static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject *__pyx_v_obj) { - npy_timedelta __pyx_r; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":1045 - * returns the int64 value underlying scalar numpy timedelta64 object - * """ - * return (obj).obval # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = ((PyTimedeltaScalarObject *)__pyx_v_obj)->obval; - goto __pyx_L0; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":1041 - * - * - * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< - * """ - * returns the int64 value underlying scalar numpy timedelta64 object - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":1048 - * - * - * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< - * """ - * returns the unit part of the dtype for a numpy datetime64 object. - */ - -static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObject *__pyx_v_obj) { - NPY_DATETIMEUNIT __pyx_r; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":1052 - * returns the unit part of the dtype for a numpy datetime64 object. - * """ - * return (obj).obmeta.base # <<<<<<<<<<<<<< - */ - __pyx_r = ((NPY_DATETIMEUNIT)((PyDatetimeScalarObject *)__pyx_v_obj)->obmeta.base); - goto __pyx_L0; - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":1048 - * - * - * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< - * """ - * returns the unit part of the dtype for a numpy datetime64 object. - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "monotonic_align/core.pyx":9 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * cdef void maximum_path_each(int[:,::1] path, float[:,::1] value, int t_x, int t_y, float max_neg_val) nogil: # <<<<<<<<<<<<<< - * cdef int x - * cdef int y - */ - -static void __pyx_f_15monotonic_align_4core_maximum_path_each(__Pyx_memviewslice __pyx_v_path, __Pyx_memviewslice __pyx_v_value, int __pyx_v_t_x, int __pyx_v_t_y, float __pyx_v_max_neg_val) { - int __pyx_v_x; - int __pyx_v_y; - float __pyx_v_v_prev; - float __pyx_v_v_cur; - int __pyx_v_index; - int __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - long __pyx_t_4; - int __pyx_t_5; - long __pyx_t_6; - int __pyx_t_7; - long __pyx_t_8; - Py_ssize_t __pyx_t_9; - Py_ssize_t __pyx_t_10; - float __pyx_t_11; - float __pyx_t_12; - float __pyx_t_13; - Py_ssize_t __pyx_t_14; - Py_ssize_t __pyx_t_15; - int __pyx_t_16; - - /* "monotonic_align/core.pyx":15 - * cdef float v_cur - * cdef float tmp - * cdef int index = t_x - 1 # <<<<<<<<<<<<<< - * - * for y in range(t_y): - */ - __pyx_v_index = (__pyx_v_t_x - 1); - - /* "monotonic_align/core.pyx":17 - * cdef int index = t_x - 1 - * - * for y in range(t_y): # <<<<<<<<<<<<<< - * for x in range(max(0, t_x + y - t_y), min(t_x, y + 1)): - * if x == y: - */ - __pyx_t_1 = __pyx_v_t_y; - __pyx_t_2 = __pyx_t_1; - for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { - __pyx_v_y = __pyx_t_3; - - /* "monotonic_align/core.pyx":18 - * - * for y in range(t_y): - * for x in range(max(0, t_x + y - t_y), min(t_x, y + 1)): # <<<<<<<<<<<<<< - * if x == y: - * v_cur = max_neg_val - */ - __pyx_t_4 = (__pyx_v_y + 1); - __pyx_t_5 = __pyx_v_t_x; - __pyx_t_7 = (__pyx_t_4 < __pyx_t_5); - if (__pyx_t_7) { - __pyx_t_6 = __pyx_t_4; - } else { - __pyx_t_6 = __pyx_t_5; - } - __pyx_t_4 = __pyx_t_6; - __pyx_t_5 = ((__pyx_v_t_x + __pyx_v_y) - __pyx_v_t_y); - __pyx_t_6 = 0; - __pyx_t_7 = (__pyx_t_5 > __pyx_t_6); - if (__pyx_t_7) { - __pyx_t_8 = __pyx_t_5; - } else { - __pyx_t_8 = __pyx_t_6; - } - __pyx_t_6 = __pyx_t_4; - for (__pyx_t_5 = __pyx_t_8; __pyx_t_5 < __pyx_t_6; __pyx_t_5+=1) { - __pyx_v_x = __pyx_t_5; - - /* "monotonic_align/core.pyx":19 - * for y in range(t_y): - * for x in range(max(0, t_x + y - t_y), min(t_x, y + 1)): - * if x == y: # <<<<<<<<<<<<<< - * v_cur = max_neg_val - * else: - */ - __pyx_t_7 = (__pyx_v_x == __pyx_v_y); - if (__pyx_t_7) { - - /* "monotonic_align/core.pyx":20 - * for x in range(max(0, t_x + y - t_y), min(t_x, y + 1)): - * if x == y: - * v_cur = max_neg_val # <<<<<<<<<<<<<< - * else: - * v_cur = value[x, y-1] - */ - __pyx_v_v_cur = __pyx_v_max_neg_val; - - /* "monotonic_align/core.pyx":19 - * for y in range(t_y): - * for x in range(max(0, t_x + y - t_y), min(t_x, y + 1)): - * if x == y: # <<<<<<<<<<<<<< - * v_cur = max_neg_val - * else: - */ - goto __pyx_L7; - } - - /* "monotonic_align/core.pyx":22 - * v_cur = max_neg_val - * else: - * v_cur = value[x, y-1] # <<<<<<<<<<<<<< - * if x == 0: - * if y == 0: - */ - /*else*/ { - __pyx_t_9 = __pyx_v_x; - __pyx_t_10 = (__pyx_v_y - 1); - __pyx_v_v_cur = (*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_value.data + __pyx_t_9 * __pyx_v_value.strides[0]) )) + __pyx_t_10)) ))); - } - __pyx_L7:; - - /* "monotonic_align/core.pyx":23 - * else: - * v_cur = value[x, y-1] - * if x == 0: # <<<<<<<<<<<<<< - * if y == 0: - * v_prev = 0. - */ - __pyx_t_7 = (__pyx_v_x == 0); - if (__pyx_t_7) { - - /* "monotonic_align/core.pyx":24 - * v_cur = value[x, y-1] - * if x == 0: - * if y == 0: # <<<<<<<<<<<<<< - * v_prev = 0. - * else: - */ - __pyx_t_7 = (__pyx_v_y == 0); - if (__pyx_t_7) { - - /* "monotonic_align/core.pyx":25 - * if x == 0: - * if y == 0: - * v_prev = 0. # <<<<<<<<<<<<<< - * else: - * v_prev = max_neg_val - */ - __pyx_v_v_prev = 0.; - - /* "monotonic_align/core.pyx":24 - * v_cur = value[x, y-1] - * if x == 0: - * if y == 0: # <<<<<<<<<<<<<< - * v_prev = 0. - * else: - */ - goto __pyx_L9; - } - - /* "monotonic_align/core.pyx":27 - * v_prev = 0. - * else: - * v_prev = max_neg_val # <<<<<<<<<<<<<< - * else: - * v_prev = value[x-1, y-1] - */ - /*else*/ { - __pyx_v_v_prev = __pyx_v_max_neg_val; - } - __pyx_L9:; - - /* "monotonic_align/core.pyx":23 - * else: - * v_cur = value[x, y-1] - * if x == 0: # <<<<<<<<<<<<<< - * if y == 0: - * v_prev = 0. - */ - goto __pyx_L8; - } - - /* "monotonic_align/core.pyx":29 - * v_prev = max_neg_val - * else: - * v_prev = value[x-1, y-1] # <<<<<<<<<<<<<< - * value[x, y] = max(v_cur, v_prev) + value[x, y] - * - */ - /*else*/ { - __pyx_t_10 = (__pyx_v_x - 1); - __pyx_t_9 = (__pyx_v_y - 1); - __pyx_v_v_prev = (*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_value.data + __pyx_t_10 * __pyx_v_value.strides[0]) )) + __pyx_t_9)) ))); - } - __pyx_L8:; - - /* "monotonic_align/core.pyx":30 - * else: - * v_prev = value[x-1, y-1] - * value[x, y] = max(v_cur, v_prev) + value[x, y] # <<<<<<<<<<<<<< - * - * for y in range(t_y - 1, -1, -1): - */ - __pyx_t_11 = __pyx_v_v_prev; - __pyx_t_12 = __pyx_v_v_cur; - __pyx_t_7 = (__pyx_t_11 > __pyx_t_12); - if (__pyx_t_7) { - __pyx_t_13 = __pyx_t_11; - } else { - __pyx_t_13 = __pyx_t_12; - } - __pyx_t_9 = __pyx_v_x; - __pyx_t_10 = __pyx_v_y; - __pyx_t_14 = __pyx_v_x; - __pyx_t_15 = __pyx_v_y; - *((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_value.data + __pyx_t_14 * __pyx_v_value.strides[0]) )) + __pyx_t_15)) )) = (__pyx_t_13 + (*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_value.data + __pyx_t_9 * __pyx_v_value.strides[0]) )) + __pyx_t_10)) )))); - } - } - - /* "monotonic_align/core.pyx":32 - * value[x, y] = max(v_cur, v_prev) + value[x, y] - * - * for y in range(t_y - 1, -1, -1): # <<<<<<<<<<<<<< - * path[index, y] = 1 - * if index != 0 and (index == y or value[index, y-1] < value[index-1, y-1]): - */ - for (__pyx_t_1 = (__pyx_v_t_y - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { - __pyx_v_y = __pyx_t_1; - - /* "monotonic_align/core.pyx":33 - * - * for y in range(t_y - 1, -1, -1): - * path[index, y] = 1 # <<<<<<<<<<<<<< - * if index != 0 and (index == y or value[index, y-1] < value[index-1, y-1]): - * index = index - 1 - */ - __pyx_t_10 = __pyx_v_index; - __pyx_t_9 = __pyx_v_y; - *((int *) ( /* dim=1 */ ((char *) (((int *) ( /* dim=0 */ (__pyx_v_path.data + __pyx_t_10 * __pyx_v_path.strides[0]) )) + __pyx_t_9)) )) = 1; - - /* "monotonic_align/core.pyx":34 - * for y in range(t_y - 1, -1, -1): - * path[index, y] = 1 - * if index != 0 and (index == y or value[index, y-1] < value[index-1, y-1]): # <<<<<<<<<<<<<< - * index = index - 1 - * - */ - __pyx_t_16 = (__pyx_v_index != 0); - if (__pyx_t_16) { - } else { - __pyx_t_7 = __pyx_t_16; - goto __pyx_L13_bool_binop_done; - } - __pyx_t_16 = (__pyx_v_index == __pyx_v_y); - if (!__pyx_t_16) { - } else { - __pyx_t_7 = __pyx_t_16; - goto __pyx_L13_bool_binop_done; - } - __pyx_t_9 = __pyx_v_index; - __pyx_t_10 = (__pyx_v_y - 1); - __pyx_t_15 = (__pyx_v_index - 1); - __pyx_t_14 = (__pyx_v_y - 1); - __pyx_t_16 = ((*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_value.data + __pyx_t_9 * __pyx_v_value.strides[0]) )) + __pyx_t_10)) ))) < (*((float *) ( /* dim=1 */ ((char *) (((float *) ( /* dim=0 */ (__pyx_v_value.data + __pyx_t_15 * __pyx_v_value.strides[0]) )) + __pyx_t_14)) )))); - __pyx_t_7 = __pyx_t_16; - __pyx_L13_bool_binop_done:; - if (__pyx_t_7) { - - /* "monotonic_align/core.pyx":35 - * path[index, y] = 1 - * if index != 0 and (index == y or value[index, y-1] < value[index-1, y-1]): - * index = index - 1 # <<<<<<<<<<<<<< - * - * - */ - __pyx_v_index = (__pyx_v_index - 1); - - /* "monotonic_align/core.pyx":34 - * for y in range(t_y - 1, -1, -1): - * path[index, y] = 1 - * if index != 0 and (index == y or value[index, y-1] < value[index-1, y-1]): # <<<<<<<<<<<<<< - * index = index - 1 - * - */ - } - } - - /* "monotonic_align/core.pyx":9 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * cdef void maximum_path_each(int[:,::1] path, float[:,::1] value, int t_x, int t_y, float max_neg_val) nogil: # <<<<<<<<<<<<<< - * cdef int x - * cdef int y - */ - - /* function exit code */ -} - -/* "monotonic_align/core.pyx":40 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * cpdef void maximum_path_c(int[:,:,::1] paths, float[:,:,::1] values, int[::1] t_xs, int[::1] t_ys, float max_neg_val=-1e9) nogil: # <<<<<<<<<<<<<< - * cdef int b = values.shape[0] - * - */ - -static PyObject *__pyx_pw_15monotonic_align_4core_1maximum_path_c(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static void __pyx_f_15monotonic_align_4core_maximum_path_c(__Pyx_memviewslice __pyx_v_paths, __Pyx_memviewslice __pyx_v_values, __Pyx_memviewslice __pyx_v_t_xs, __Pyx_memviewslice __pyx_v_t_ys, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_15monotonic_align_4core_maximum_path_c *__pyx_optional_args) { - float __pyx_v_max_neg_val = __pyx_k__11; - CYTHON_UNUSED int __pyx_v_b; - int __pyx_v_i; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - __Pyx_memviewslice __pyx_t_4 = { 0, 0, { 0 }, { 0 }, { 0 } }; - __Pyx_memviewslice __pyx_t_5 = { 0, 0, { 0 }, { 0 }, { 0 } }; - Py_ssize_t __pyx_t_6; - Py_ssize_t __pyx_t_7; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save; - #endif - __Pyx_RefNannySetupContext("maximum_path_c", 1); - if (__pyx_optional_args) { - if (__pyx_optional_args->__pyx_n > 0) { - __pyx_v_max_neg_val = __pyx_optional_args->max_neg_val; - } - } - - /* "monotonic_align/core.pyx":41 - * @cython.wraparound(False) - * cpdef void maximum_path_c(int[:,:,::1] paths, float[:,:,::1] values, int[::1] t_xs, int[::1] t_ys, float max_neg_val=-1e9) nogil: - * cdef int b = values.shape[0] # <<<<<<<<<<<<<< - * - * cdef int i - */ - __pyx_v_b = (__pyx_v_values.shape[0]); - - /* "monotonic_align/core.pyx":44 - * - * cdef int i - * for i in prange(b, nogil=True): # <<<<<<<<<<<<<< - * maximum_path_each(paths[i], values[i], t_xs[i], t_ys[i], max_neg_val) - */ - { - #ifdef WITH_THREAD - PyThreadState *_save; - _save = NULL; - if (PyGILState_Check()) { - Py_UNBLOCK_THREADS - } - __Pyx_FastGIL_Remember(); - #endif - /*try:*/ { - __pyx_t_1 = __pyx_v_b; - { - int __pyx_parallel_temp0 = ((int)0xbad0bad0); - const char *__pyx_parallel_filename = NULL; int __pyx_parallel_lineno = 0, __pyx_parallel_clineno = 0; - PyObject *__pyx_parallel_exc_type = NULL, *__pyx_parallel_exc_value = NULL, *__pyx_parallel_exc_tb = NULL; - int __pyx_parallel_why; - __pyx_parallel_why = 0; - #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_3 = (__pyx_t_1 - 0 + 1 - 1/abs(1)) / 1; - if (__pyx_t_3 > 0) - { - #ifdef _OPENMP - #pragma omp parallel private(__pyx_t_6, __pyx_t_7) firstprivate(__pyx_t_4, __pyx_t_5) private(__pyx_filename, __pyx_lineno, __pyx_clineno) shared(__pyx_parallel_why, __pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb) - #endif /* _OPENMP */ - { - #ifdef _OPENMP - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - Py_BEGIN_ALLOW_THREADS - #endif /* _OPENMP */ - #ifdef _OPENMP - #pragma omp for firstprivate(__pyx_v_i) lastprivate(__pyx_v_i) - #endif /* _OPENMP */ - for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_3; __pyx_t_2++){ - if (__pyx_parallel_why < 2) - { - __pyx_v_i = (int)(0 + 1 * __pyx_t_2); - - /* "monotonic_align/core.pyx":45 - * cdef int i - * for i in prange(b, nogil=True): - * maximum_path_each(paths[i], values[i], t_xs[i], t_ys[i], max_neg_val) # <<<<<<<<<<<<<< - */ - __pyx_t_4.data = __pyx_v_paths.data; - __pyx_t_4.memview = __pyx_v_paths.memview; - __PYX_INC_MEMVIEW(&__pyx_t_4, 0); - { - Py_ssize_t __pyx_tmp_idx = __pyx_v_i; - Py_ssize_t __pyx_tmp_stride = __pyx_v_paths.strides[0]; - __pyx_t_4.data += __pyx_tmp_idx * __pyx_tmp_stride; -} - -__pyx_t_4.shape[0] = __pyx_v_paths.shape[1]; -__pyx_t_4.strides[0] = __pyx_v_paths.strides[1]; - __pyx_t_4.suboffsets[0] = -1; - -__pyx_t_4.shape[1] = __pyx_v_paths.shape[2]; -__pyx_t_4.strides[1] = __pyx_v_paths.strides[2]; - __pyx_t_4.suboffsets[1] = -1; - -__pyx_t_5.data = __pyx_v_values.data; - __pyx_t_5.memview = __pyx_v_values.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_values.strides[0]; - __pyx_t_5.data += __pyx_tmp_idx * __pyx_tmp_stride; -} - -__pyx_t_5.shape[0] = __pyx_v_values.shape[1]; -__pyx_t_5.strides[0] = __pyx_v_values.strides[1]; - __pyx_t_5.suboffsets[0] = -1; - -__pyx_t_5.shape[1] = __pyx_v_values.shape[2]; -__pyx_t_5.strides[1] = __pyx_v_values.strides[2]; - __pyx_t_5.suboffsets[1] = -1; - -__pyx_t_6 = __pyx_v_i; - __pyx_t_7 = __pyx_v_i; - __pyx_f_15monotonic_align_4core_maximum_path_each(__pyx_t_4, __pyx_t_5, (*((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_t_xs.data) + __pyx_t_6)) ))), (*((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_t_ys.data) + __pyx_t_7)) ))), __pyx_v_max_neg_val); if (unlikely(__Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 45, __pyx_L8_error) - __PYX_XCLEAR_MEMVIEW(&__pyx_t_4, 0); - __pyx_t_4.memview = NULL; __pyx_t_4.data = NULL; - __PYX_XCLEAR_MEMVIEW(&__pyx_t_5, 0); - __pyx_t_5.memview = NULL; __pyx_t_5.data = NULL; - goto __pyx_L11; - __pyx_L8_error:; - { - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - #ifdef _OPENMP - #pragma omp flush(__pyx_parallel_exc_type) - #endif /* _OPENMP */ - if (!__pyx_parallel_exc_type) { - __Pyx_ErrFetchWithState(&__pyx_parallel_exc_type, &__pyx_parallel_exc_value, &__pyx_parallel_exc_tb); - __pyx_parallel_filename = __pyx_filename; __pyx_parallel_lineno = __pyx_lineno; __pyx_parallel_clineno = __pyx_clineno; - __Pyx_GOTREF(__pyx_parallel_exc_type); - } - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - } - __pyx_parallel_why = 4; - goto __pyx_L10; - __pyx_L10:; - #ifdef _OPENMP - #pragma omp critical(__pyx_parallel_lastprivates0) - #endif /* _OPENMP */ - { - __pyx_parallel_temp0 = __pyx_v_i; - } - __pyx_L11:; - #ifdef _OPENMP - #pragma omp flush(__pyx_parallel_why) - #endif /* _OPENMP */ - } - } - #ifdef _OPENMP - Py_END_ALLOW_THREADS - #else -{ -#ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - #endif /* _OPENMP */ - /* Clean up any temporaries */ - __PYX_XCLEAR_MEMVIEW(&__pyx_t_4, 0); - __pyx_t_4.memview = NULL; __pyx_t_4.data = NULL; - __PYX_XCLEAR_MEMVIEW(&__pyx_t_5, 0); - __pyx_t_5.memview = NULL; __pyx_t_5.data = NULL; - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - #ifndef _OPENMP -} -#endif /* _OPENMP */ - } - } - if (__pyx_parallel_exc_type) { - /* This may have been overridden by a continue, break or return in another thread. Prefer the error. */ - __pyx_parallel_why = 4; - } - if (__pyx_parallel_why) { - __pyx_v_i = __pyx_parallel_temp0; - switch (__pyx_parallel_why) { - case 4: - { - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_GIVEREF(__pyx_parallel_exc_type); - __Pyx_ErrRestoreWithState(__pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb); - __pyx_filename = __pyx_parallel_filename; __pyx_lineno = __pyx_parallel_lineno; __pyx_clineno = __pyx_parallel_clineno; - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - } - goto __pyx_L4_error; - } - } - } - #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 - } - - /* "monotonic_align/core.pyx":44 - * - * cdef int i - * for i in prange(b, nogil=True): # <<<<<<<<<<<<<< - * maximum_path_each(paths[i], values[i], t_xs[i], t_ys[i], max_neg_val) - */ - /*finally:*/ { - /*normal exit:*/{ - #ifdef WITH_THREAD - __Pyx_FastGIL_Forget(); - if (_save) { - Py_BLOCK_THREADS - } - #endif - goto __pyx_L5; - } - __pyx_L4_error: { - #ifdef WITH_THREAD - __Pyx_FastGIL_Forget(); - if (_save) { - Py_BLOCK_THREADS - } - #endif - goto __pyx_L1_error; - } - __pyx_L5:; - } - } - - /* "monotonic_align/core.pyx":40 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * cpdef void maximum_path_c(int[:,:,::1] paths, float[:,:,::1] values, int[::1] t_xs, int[::1] t_ys, float max_neg_val=-1e9) nogil: # <<<<<<<<<<<<<< - * cdef int b = values.shape[0] - * - */ - - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - #ifdef WITH_THREAD - __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __PYX_XCLEAR_MEMVIEW(&__pyx_t_4, 1); - __PYX_XCLEAR_MEMVIEW(&__pyx_t_5, 1); - __Pyx_AddTraceback("monotonic_align.core.maximum_path_c", __pyx_clineno, __pyx_lineno, __pyx_filename); - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - __pyx_L0:; - __Pyx_RefNannyFinishContextNogil() -} - -/* Python wrapper */ -static PyObject *__pyx_pw_15monotonic_align_4core_1maximum_path_c(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyMethodDef __pyx_mdef_15monotonic_align_4core_1maximum_path_c = {"maximum_path_c", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_15monotonic_align_4core_1maximum_path_c, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_15monotonic_align_4core_1maximum_path_c(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - __Pyx_memviewslice __pyx_v_paths = { 0, 0, { 0 }, { 0 }, { 0 } }; - __Pyx_memviewslice __pyx_v_values = { 0, 0, { 0 }, { 0 }, { 0 } }; - __Pyx_memviewslice __pyx_v_t_xs = { 0, 0, { 0 }, { 0 }, { 0 } }; - __Pyx_memviewslice __pyx_v_t_ys = { 0, 0, { 0 }, { 0 }, { 0 } }; - float __pyx_v_max_neg_val; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[5] = {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("maximum_path_c (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_paths,&__pyx_n_s_values,&__pyx_n_s_t_xs,&__pyx_n_s_t_ys,&__pyx_n_s_max_neg_val,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_paths)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 40, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_values)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 40, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("maximum_path_c", 0, 4, 5, 1); __PYX_ERR(0, 40, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_t_xs)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 40, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("maximum_path_c", 0, 4, 5, 2); __PYX_ERR(0, 40, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_t_ys)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 40, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("maximum_path_c", 0, 4, 5, 3); __PYX_ERR(0, 40, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_max_neg_val); - if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 40, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "maximum_path_c") < 0)) __PYX_ERR(0, 40, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } - } - __pyx_v_paths = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_int(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_paths.memview)) __PYX_ERR(0, 40, __pyx_L3_error) - __pyx_v_values = __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_float(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_values.memview)) __PYX_ERR(0, 40, __pyx_L3_error) - __pyx_v_t_xs = __Pyx_PyObject_to_MemoryviewSlice_dc_int(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_t_xs.memview)) __PYX_ERR(0, 40, __pyx_L3_error) - __pyx_v_t_ys = __Pyx_PyObject_to_MemoryviewSlice_dc_int(values[3], PyBUF_WRITABLE); if (unlikely(!__pyx_v_t_ys.memview)) __PYX_ERR(0, 40, __pyx_L3_error) - if (values[4]) { - __pyx_v_max_neg_val = __pyx_PyFloat_AsFloat(values[4]); if (unlikely((__pyx_v_max_neg_val == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 40, __pyx_L3_error) - } else { - __pyx_v_max_neg_val = __pyx_k__11; - } - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("maximum_path_c", 0, 4, 5, __pyx_nargs); __PYX_ERR(0, 40, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __PYX_XCLEAR_MEMVIEW(&__pyx_v_paths, 1); - __PYX_XCLEAR_MEMVIEW(&__pyx_v_values, 1); - __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_xs, 1); - __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_ys, 1); - __Pyx_AddTraceback("monotonic_align.core.maximum_path_c", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_15monotonic_align_4core_maximum_path_c(__pyx_self, __pyx_v_paths, __pyx_v_values, __pyx_v_t_xs, __pyx_v_t_ys, __pyx_v_max_neg_val); - - /* function exit code */ - __PYX_XCLEAR_MEMVIEW(&__pyx_v_paths, 1); - __PYX_XCLEAR_MEMVIEW(&__pyx_v_values, 1); - __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_xs, 1); - __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_ys, 1); - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15monotonic_align_4core_maximum_path_c(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_paths, __Pyx_memviewslice __pyx_v_values, __Pyx_memviewslice __pyx_v_t_xs, __Pyx_memviewslice __pyx_v_t_ys, float __pyx_v_max_neg_val) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - struct __pyx_opt_args_15monotonic_align_4core_maximum_path_c __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("maximum_path_c", 1); - __Pyx_XDECREF(__pyx_r); - if (unlikely(!__pyx_v_paths.memview)) { __Pyx_RaiseUnboundLocalError("paths"); __PYX_ERR(0, 40, __pyx_L1_error) } - if (unlikely(!__pyx_v_values.memview)) { __Pyx_RaiseUnboundLocalError("values"); __PYX_ERR(0, 40, __pyx_L1_error) } - if (unlikely(!__pyx_v_t_xs.memview)) { __Pyx_RaiseUnboundLocalError("t_xs"); __PYX_ERR(0, 40, __pyx_L1_error) } - if (unlikely(!__pyx_v_t_ys.memview)) { __Pyx_RaiseUnboundLocalError("t_ys"); __PYX_ERR(0, 40, __pyx_L1_error) } - __pyx_t_1.__pyx_n = 1; - __pyx_t_1.max_neg_val = __pyx_v_max_neg_val; - __pyx_f_15monotonic_align_4core_maximum_path_c(__pyx_v_paths, __pyx_v_values, __pyx_v_t_xs, __pyx_v_t_ys, 0, &__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 40, __pyx_L1_error) - __pyx_t_2 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 40, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("monotonic_align.core.maximum_path_c", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} -static struct __pyx_vtabstruct_array __pyx_vtable_array; - -static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k) { - struct __pyx_array_obj *p; - PyObject *o; - #if CYTHON_COMPILING_IN_LIMITED_API - allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); - o = alloc_func(t, 0); - #else - if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { - o = (*t->tp_alloc)(t, 0); - } else { - o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); - } - if (unlikely(!o)) return 0; - #endif - p = ((struct __pyx_array_obj *)o); - p->__pyx_vtab = __pyx_vtabptr_array; - p->mode = ((PyObject*)Py_None); Py_INCREF(Py_None); - p->_format = ((PyObject*)Py_None); Py_INCREF(Py_None); - if (unlikely(__pyx_array___cinit__(o, a, k) < 0)) goto bad; - return o; - bad: - Py_DECREF(o); o = 0; - return NULL; -} - -static void __pyx_tp_dealloc_array(PyObject *o) { - struct __pyx_array_obj *p = (struct __pyx_array_obj *)o; - #if CYTHON_USE_TP_FINALIZE - if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { - if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_array) { - if (PyObject_CallFinalizerFromDealloc(o)) return; - } - } - #endif - { - PyObject *etype, *eval, *etb; - PyErr_Fetch(&etype, &eval, &etb); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); - __pyx_array___dealloc__(o); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); - PyErr_Restore(etype, eval, etb); - } - Py_CLEAR(p->mode); - Py_CLEAR(p->_format); - #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY - (*Py_TYPE(o)->tp_free)(o); - #else - { - freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); - if (tp_free) tp_free(o); - } - #endif -} -static PyObject *__pyx_sq_item_array(PyObject *o, Py_ssize_t i) { - PyObject *r; - PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; - r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); - Py_DECREF(x); - return r; -} - -static int __pyx_mp_ass_subscript_array(PyObject *o, PyObject *i, PyObject *v) { - if (v) { - return __pyx_array___setitem__(o, i, v); - } - else { - __Pyx_TypeName o_type_name; - o_type_name = __Pyx_PyType_GetName(Py_TYPE(o)); - PyErr_Format(PyExc_NotImplementedError, - "Subscript deletion not supported by " __Pyx_FMT_TYPENAME, o_type_name); - __Pyx_DECREF_TypeName(o_type_name); - return -1; - } -} - -static PyObject *__pyx_tp_getattro_array(PyObject *o, PyObject *n) { - PyObject *v = __Pyx_PyObject_GenericGetAttr(o, n); - if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) { - PyErr_Clear(); - v = __pyx_array___getattr__(o, n); - } - return v; -} - -static PyObject *__pyx_getprop___pyx_array_memview(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(o); -} - -static PyMethodDef __pyx_methods_array[] = { - {"__getattr__", (PyCFunction)__pyx_array___getattr__, METH_O|METH_COEXIST, 0}, - {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_array_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_array_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {0, 0, 0, 0} -}; - -static struct PyGetSetDef __pyx_getsets_array[] = { - {(char *)"memview", __pyx_getprop___pyx_array_memview, 0, (char *)0, 0}, - {0, 0, 0, 0, 0} -}; -#if CYTHON_USE_TYPE_SPECS -#if !CYTHON_COMPILING_IN_LIMITED_API - -static PyBufferProcs __pyx_tp_as_buffer_array = { - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getreadbuffer*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getwritebuffer*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getsegcount*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getcharbuffer*/ - #endif - __pyx_array_getbuffer, /*bf_getbuffer*/ - 0, /*bf_releasebuffer*/ -}; -#endif -static PyType_Slot __pyx_type___pyx_array_slots[] = { - {Py_tp_dealloc, (void *)__pyx_tp_dealloc_array}, - {Py_sq_length, (void *)__pyx_array___len__}, - {Py_sq_item, (void *)__pyx_sq_item_array}, - {Py_mp_length, (void *)__pyx_array___len__}, - {Py_mp_subscript, (void *)__pyx_array___getitem__}, - {Py_mp_ass_subscript, (void *)__pyx_mp_ass_subscript_array}, - {Py_tp_getattro, (void *)__pyx_tp_getattro_array}, - #if defined(Py_bf_getbuffer) - {Py_bf_getbuffer, (void *)__pyx_array_getbuffer}, - #endif - {Py_tp_methods, (void *)__pyx_methods_array}, - {Py_tp_getset, (void *)__pyx_getsets_array}, - {Py_tp_new, (void *)__pyx_tp_new_array}, - {0, 0}, -}; -static PyType_Spec __pyx_type___pyx_array_spec = { - "monotonic_align.core.array", - sizeof(struct __pyx_array_obj), - 0, - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_SEQUENCE, - __pyx_type___pyx_array_slots, -}; -#else - -static PySequenceMethods __pyx_tp_as_sequence_array = { - __pyx_array___len__, /*sq_length*/ - 0, /*sq_concat*/ - 0, /*sq_repeat*/ - __pyx_sq_item_array, /*sq_item*/ - 0, /*sq_slice*/ - 0, /*sq_ass_item*/ - 0, /*sq_ass_slice*/ - 0, /*sq_contains*/ - 0, /*sq_inplace_concat*/ - 0, /*sq_inplace_repeat*/ -}; - -static PyMappingMethods __pyx_tp_as_mapping_array = { - __pyx_array___len__, /*mp_length*/ - __pyx_array___getitem__, /*mp_subscript*/ - __pyx_mp_ass_subscript_array, /*mp_ass_subscript*/ -}; - -static PyBufferProcs __pyx_tp_as_buffer_array = { - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getreadbuffer*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getwritebuffer*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getsegcount*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getcharbuffer*/ - #endif - __pyx_array_getbuffer, /*bf_getbuffer*/ - 0, /*bf_releasebuffer*/ -}; - -static PyTypeObject __pyx_type___pyx_array = { - PyVarObject_HEAD_INIT(0, 0) - "monotonic_align.core.""array", /*tp_name*/ - 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 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - &__pyx_tp_as_sequence_array, /*tp_as_sequence*/ - &__pyx_tp_as_mapping_array, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - __pyx_tp_getattro_array, /*tp_getattro*/ - 0, /*tp_setattro*/ - &__pyx_tp_as_buffer_array, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_SEQUENCE, /*tp_flags*/ - 0, /*tp_doc*/ - 0, /*tp_traverse*/ - 0, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods_array, /*tp_methods*/ - 0, /*tp_members*/ - __pyx_getsets_array, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - #if !CYTHON_USE_TYPE_SPECS - 0, /*tp_dictoffset*/ - #endif - 0, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_array, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - #if CYTHON_USE_TP_FINALIZE - 0, /*tp_finalize*/ - #else - NULL, /*tp_finalize*/ - #endif - #endif - #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) - 0, /*tp_vectorcall*/ - #endif - #if __PYX_NEED_TP_PRINT_SLOT == 1 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030C0000 - 0, /*tp_watched*/ - #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 - 0, /*tp_pypy_flags*/ - #endif -}; -#endif - -static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - struct __pyx_MemviewEnum_obj *p; - PyObject *o; - #if CYTHON_COMPILING_IN_LIMITED_API - allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); - o = alloc_func(t, 0); - #else - if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { - o = (*t->tp_alloc)(t, 0); - } else { - o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); - } - if (unlikely(!o)) return 0; - #endif - p = ((struct __pyx_MemviewEnum_obj *)o); - p->name = Py_None; Py_INCREF(Py_None); - return o; -} - -static void __pyx_tp_dealloc_Enum(PyObject *o) { - struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; - #if CYTHON_USE_TP_FINALIZE - if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { - if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_Enum) { - if (PyObject_CallFinalizerFromDealloc(o)) return; - } - } - #endif - PyObject_GC_UnTrack(o); - Py_CLEAR(p->name); - #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY - (*Py_TYPE(o)->tp_free)(o); - #else - { - freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); - if (tp_free) tp_free(o); - } - #endif -} - -static int __pyx_tp_traverse_Enum(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; - if (p->name) { - e = (*v)(p->name, a); if (e) return e; - } - return 0; -} - -static int __pyx_tp_clear_Enum(PyObject *o) { - PyObject* tmp; - struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; - tmp = ((PyObject*)p->name); - p->name = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - return 0; -} - -static PyObject *__pyx_specialmethod___pyx_MemviewEnum___repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { - return __pyx_MemviewEnum___repr__(self); -} - -static PyMethodDef __pyx_methods_Enum[] = { - {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_MemviewEnum___repr__, METH_NOARGS|METH_COEXIST, 0}, - {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_MemviewEnum_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_MemviewEnum_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {0, 0, 0, 0} -}; -#if CYTHON_USE_TYPE_SPECS -static PyType_Slot __pyx_type___pyx_MemviewEnum_slots[] = { - {Py_tp_dealloc, (void *)__pyx_tp_dealloc_Enum}, - {Py_tp_repr, (void *)__pyx_MemviewEnum___repr__}, - {Py_tp_traverse, (void *)__pyx_tp_traverse_Enum}, - {Py_tp_clear, (void *)__pyx_tp_clear_Enum}, - {Py_tp_methods, (void *)__pyx_methods_Enum}, - {Py_tp_init, (void *)__pyx_MemviewEnum___init__}, - {Py_tp_new, (void *)__pyx_tp_new_Enum}, - {0, 0}, -}; -static PyType_Spec __pyx_type___pyx_MemviewEnum_spec = { - "monotonic_align.core.Enum", - sizeof(struct __pyx_MemviewEnum_obj), - 0, - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, - __pyx_type___pyx_MemviewEnum_slots, -}; -#else - -static PyTypeObject __pyx_type___pyx_MemviewEnum = { - PyVarObject_HEAD_INIT(0, 0) - "monotonic_align.core.""Enum", /*tp_name*/ - 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 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - __pyx_MemviewEnum___repr__, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - 0, /*tp_doc*/ - __pyx_tp_traverse_Enum, /*tp_traverse*/ - __pyx_tp_clear_Enum, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods_Enum, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - #if !CYTHON_USE_TYPE_SPECS - 0, /*tp_dictoffset*/ - #endif - __pyx_MemviewEnum___init__, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_Enum, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - #if CYTHON_USE_TP_FINALIZE - 0, /*tp_finalize*/ - #else - NULL, /*tp_finalize*/ - #endif - #endif - #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) - 0, /*tp_vectorcall*/ - #endif - #if __PYX_NEED_TP_PRINT_SLOT == 1 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030C0000 - 0, /*tp_watched*/ - #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 - 0, /*tp_pypy_flags*/ - #endif -}; -#endif -static struct __pyx_vtabstruct_memoryview __pyx_vtable_memoryview; - -static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k) { - struct __pyx_memoryview_obj *p; - PyObject *o; - #if CYTHON_COMPILING_IN_LIMITED_API - allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); - o = alloc_func(t, 0); - #else - if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { - o = (*t->tp_alloc)(t, 0); - } else { - o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); - } - if (unlikely(!o)) return 0; - #endif - p = ((struct __pyx_memoryview_obj *)o); - p->__pyx_vtab = __pyx_vtabptr_memoryview; - p->obj = Py_None; Py_INCREF(Py_None); - p->_size = Py_None; Py_INCREF(Py_None); - p->_array_interface = Py_None; Py_INCREF(Py_None); - p->view.obj = NULL; - if (unlikely(__pyx_memoryview___cinit__(o, a, k) < 0)) goto bad; - return o; - bad: - Py_DECREF(o); o = 0; - return NULL; -} - -static void __pyx_tp_dealloc_memoryview(PyObject *o) { - struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; - #if CYTHON_USE_TP_FINALIZE - if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { - if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_memoryview) { - if (PyObject_CallFinalizerFromDealloc(o)) return; - } - } - #endif - PyObject_GC_UnTrack(o); - { - PyObject *etype, *eval, *etb; - PyErr_Fetch(&etype, &eval, &etb); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); - __pyx_memoryview___dealloc__(o); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); - PyErr_Restore(etype, eval, etb); - } - Py_CLEAR(p->obj); - Py_CLEAR(p->_size); - Py_CLEAR(p->_array_interface); - #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY - (*Py_TYPE(o)->tp_free)(o); - #else - { - freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); - if (tp_free) tp_free(o); - } - #endif -} - -static int __pyx_tp_traverse_memoryview(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; - if (p->obj) { - e = (*v)(p->obj, a); if (e) return e; - } - if (p->_size) { - e = (*v)(p->_size, a); if (e) return e; - } - if (p->_array_interface) { - e = (*v)(p->_array_interface, a); if (e) return e; - } - if (p->view.obj) { - e = (*v)(p->view.obj, a); if (e) return e; - } - return 0; -} - -static int __pyx_tp_clear_memoryview(PyObject *o) { - PyObject* tmp; - struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; - tmp = ((PyObject*)p->obj); - p->obj = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->_size); - p->_size = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->_array_interface); - p->_array_interface = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - Py_CLEAR(p->view.obj); - return 0; -} -static PyObject *__pyx_sq_item_memoryview(PyObject *o, Py_ssize_t i) { - PyObject *r; - PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; - r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); - Py_DECREF(x); - return r; -} - -static int __pyx_mp_ass_subscript_memoryview(PyObject *o, PyObject *i, PyObject *v) { - if (v) { - return __pyx_memoryview___setitem__(o, i, v); - } - else { - __Pyx_TypeName o_type_name; - o_type_name = __Pyx_PyType_GetName(Py_TYPE(o)); - PyErr_Format(PyExc_NotImplementedError, - "Subscript deletion not supported by " __Pyx_FMT_TYPENAME, o_type_name); - __Pyx_DECREF_TypeName(o_type_name); - return -1; - } -} - -static PyObject *__pyx_getprop___pyx_memoryview_T(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(o); -} - -static PyObject *__pyx_getprop___pyx_memoryview_base(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(o); -} - -static PyObject *__pyx_getprop___pyx_memoryview_shape(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(o); -} - -static PyObject *__pyx_getprop___pyx_memoryview_strides(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(o); -} - -static PyObject *__pyx_getprop___pyx_memoryview_suboffsets(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(o); -} - -static PyObject *__pyx_getprop___pyx_memoryview_ndim(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(o); -} - -static PyObject *__pyx_getprop___pyx_memoryview_itemsize(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(o); -} - -static PyObject *__pyx_getprop___pyx_memoryview_nbytes(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(o); -} - -static PyObject *__pyx_getprop___pyx_memoryview_size(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(o); -} - -static PyObject *__pyx_specialmethod___pyx_memoryview___repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { - return __pyx_memoryview___repr__(self); -} - -static PyMethodDef __pyx_methods_memoryview[] = { - {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_memoryview___repr__, METH_NOARGS|METH_COEXIST, 0}, - {"is_c_contig", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_memoryview_is_c_contig, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"is_f_contig", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_memoryview_is_f_contig, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"copy", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_memoryview_copy, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"copy_fortran", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_memoryview_copy_fortran, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_memoryview_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_memoryview_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {0, 0, 0, 0} -}; - -static struct PyGetSetDef __pyx_getsets_memoryview[] = { - {(char *)"T", __pyx_getprop___pyx_memoryview_T, 0, (char *)0, 0}, - {(char *)"base", __pyx_getprop___pyx_memoryview_base, 0, (char *)0, 0}, - {(char *)"shape", __pyx_getprop___pyx_memoryview_shape, 0, (char *)0, 0}, - {(char *)"strides", __pyx_getprop___pyx_memoryview_strides, 0, (char *)0, 0}, - {(char *)"suboffsets", __pyx_getprop___pyx_memoryview_suboffsets, 0, (char *)0, 0}, - {(char *)"ndim", __pyx_getprop___pyx_memoryview_ndim, 0, (char *)0, 0}, - {(char *)"itemsize", __pyx_getprop___pyx_memoryview_itemsize, 0, (char *)0, 0}, - {(char *)"nbytes", __pyx_getprop___pyx_memoryview_nbytes, 0, (char *)0, 0}, - {(char *)"size", __pyx_getprop___pyx_memoryview_size, 0, (char *)0, 0}, - {0, 0, 0, 0, 0} -}; -#if CYTHON_USE_TYPE_SPECS -#if !CYTHON_COMPILING_IN_LIMITED_API - -static PyBufferProcs __pyx_tp_as_buffer_memoryview = { - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getreadbuffer*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getwritebuffer*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getsegcount*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getcharbuffer*/ - #endif - __pyx_memoryview_getbuffer, /*bf_getbuffer*/ - 0, /*bf_releasebuffer*/ -}; -#endif -static PyType_Slot __pyx_type___pyx_memoryview_slots[] = { - {Py_tp_dealloc, (void *)__pyx_tp_dealloc_memoryview}, - {Py_tp_repr, (void *)__pyx_memoryview___repr__}, - {Py_sq_length, (void *)__pyx_memoryview___len__}, - {Py_sq_item, (void *)__pyx_sq_item_memoryview}, - {Py_mp_length, (void *)__pyx_memoryview___len__}, - {Py_mp_subscript, (void *)__pyx_memoryview___getitem__}, - {Py_mp_ass_subscript, (void *)__pyx_mp_ass_subscript_memoryview}, - {Py_tp_str, (void *)__pyx_memoryview___str__}, - #if defined(Py_bf_getbuffer) - {Py_bf_getbuffer, (void *)__pyx_memoryview_getbuffer}, - #endif - {Py_tp_traverse, (void *)__pyx_tp_traverse_memoryview}, - {Py_tp_clear, (void *)__pyx_tp_clear_memoryview}, - {Py_tp_methods, (void *)__pyx_methods_memoryview}, - {Py_tp_getset, (void *)__pyx_getsets_memoryview}, - {Py_tp_new, (void *)__pyx_tp_new_memoryview}, - {0, 0}, -}; -static PyType_Spec __pyx_type___pyx_memoryview_spec = { - "monotonic_align.core.memoryview", - sizeof(struct __pyx_memoryview_obj), - 0, - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, - __pyx_type___pyx_memoryview_slots, -}; -#else - -static PySequenceMethods __pyx_tp_as_sequence_memoryview = { - __pyx_memoryview___len__, /*sq_length*/ - 0, /*sq_concat*/ - 0, /*sq_repeat*/ - __pyx_sq_item_memoryview, /*sq_item*/ - 0, /*sq_slice*/ - 0, /*sq_ass_item*/ - 0, /*sq_ass_slice*/ - 0, /*sq_contains*/ - 0, /*sq_inplace_concat*/ - 0, /*sq_inplace_repeat*/ -}; - -static PyMappingMethods __pyx_tp_as_mapping_memoryview = { - __pyx_memoryview___len__, /*mp_length*/ - __pyx_memoryview___getitem__, /*mp_subscript*/ - __pyx_mp_ass_subscript_memoryview, /*mp_ass_subscript*/ -}; - -static PyBufferProcs __pyx_tp_as_buffer_memoryview = { - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getreadbuffer*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getwritebuffer*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getsegcount*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getcharbuffer*/ - #endif - __pyx_memoryview_getbuffer, /*bf_getbuffer*/ - 0, /*bf_releasebuffer*/ -}; - -static PyTypeObject __pyx_type___pyx_memoryview = { - PyVarObject_HEAD_INIT(0, 0) - "monotonic_align.core.""memoryview", /*tp_name*/ - 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 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - __pyx_memoryview___repr__, /*tp_repr*/ - 0, /*tp_as_number*/ - &__pyx_tp_as_sequence_memoryview, /*tp_as_sequence*/ - &__pyx_tp_as_mapping_memoryview, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - __pyx_memoryview___str__, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - &__pyx_tp_as_buffer_memoryview, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - 0, /*tp_doc*/ - __pyx_tp_traverse_memoryview, /*tp_traverse*/ - __pyx_tp_clear_memoryview, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods_memoryview, /*tp_methods*/ - 0, /*tp_members*/ - __pyx_getsets_memoryview, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - #if !CYTHON_USE_TYPE_SPECS - 0, /*tp_dictoffset*/ - #endif - 0, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_memoryview, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - #if CYTHON_USE_TP_FINALIZE - 0, /*tp_finalize*/ - #else - NULL, /*tp_finalize*/ - #endif - #endif - #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) - 0, /*tp_vectorcall*/ - #endif - #if __PYX_NEED_TP_PRINT_SLOT == 1 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030C0000 - 0, /*tp_watched*/ - #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 - 0, /*tp_pypy_flags*/ - #endif -}; -#endif -static struct __pyx_vtabstruct__memoryviewslice __pyx_vtable__memoryviewslice; - -static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k) { - struct __pyx_memoryviewslice_obj *p; - PyObject *o = __pyx_tp_new_memoryview(t, a, k); - if (unlikely(!o)) return 0; - p = ((struct __pyx_memoryviewslice_obj *)o); - p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_memoryview*)__pyx_vtabptr__memoryviewslice; - p->from_object = Py_None; Py_INCREF(Py_None); - p->from_slice.memview = NULL; - return o; -} - -static void __pyx_tp_dealloc__memoryviewslice(PyObject *o) { - struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; - #if CYTHON_USE_TP_FINALIZE - if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { - if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc__memoryviewslice) { - if (PyObject_CallFinalizerFromDealloc(o)) return; - } - } - #endif - PyObject_GC_UnTrack(o); - { - PyObject *etype, *eval, *etb; - PyErr_Fetch(&etype, &eval, &etb); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); - __pyx_memoryviewslice___dealloc__(o); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); - PyErr_Restore(etype, eval, etb); - } - Py_CLEAR(p->from_object); - PyObject_GC_Track(o); - __pyx_tp_dealloc_memoryview(o); -} - -static int __pyx_tp_traverse__memoryviewslice(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; - e = __pyx_tp_traverse_memoryview(o, v, a); if (e) return e; - if (p->from_object) { - e = (*v)(p->from_object, a); if (e) return e; - } - return 0; -} - -static int __pyx_tp_clear__memoryviewslice(PyObject *o) { - PyObject* tmp; - struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; - __pyx_tp_clear_memoryview(o); - tmp = ((PyObject*)p->from_object); - p->from_object = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - __PYX_XCLEAR_MEMVIEW(&p->from_slice, 1); - return 0; -} - -static PyMethodDef __pyx_methods__memoryviewslice[] = { - {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_memoryviewslice_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_memoryviewslice_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {0, 0, 0, 0} -}; -#if CYTHON_USE_TYPE_SPECS -static PyType_Slot __pyx_type___pyx_memoryviewslice_slots[] = { - {Py_tp_dealloc, (void *)__pyx_tp_dealloc__memoryviewslice}, - {Py_tp_doc, (void *)PyDoc_STR("Internal class for passing memoryview slices to Python")}, - {Py_tp_traverse, (void *)__pyx_tp_traverse__memoryviewslice}, - {Py_tp_clear, (void *)__pyx_tp_clear__memoryviewslice}, - {Py_tp_methods, (void *)__pyx_methods__memoryviewslice}, - {Py_tp_new, (void *)__pyx_tp_new__memoryviewslice}, - {0, 0}, -}; -static PyType_Spec __pyx_type___pyx_memoryviewslice_spec = { - "monotonic_align.core._memoryviewslice", - sizeof(struct __pyx_memoryviewslice_obj), - 0, - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_SEQUENCE, - __pyx_type___pyx_memoryviewslice_slots, -}; -#else - -static PyTypeObject __pyx_type___pyx_memoryviewslice = { - PyVarObject_HEAD_INIT(0, 0) - "monotonic_align.core.""_memoryviewslice", /*tp_name*/ - 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 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - #if CYTHON_COMPILING_IN_PYPY || 0 - __pyx_memoryview___repr__, /*tp_repr*/ - #else - 0, /*tp_repr*/ - #endif - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - #if CYTHON_COMPILING_IN_PYPY || 0 - __pyx_memoryview___str__, /*tp_str*/ - #else - 0, /*tp_str*/ - #endif - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_SEQUENCE, /*tp_flags*/ - PyDoc_STR("Internal class for passing memoryview slices to Python"), /*tp_doc*/ - __pyx_tp_traverse__memoryviewslice, /*tp_traverse*/ - __pyx_tp_clear__memoryviewslice, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods__memoryviewslice, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - #if !CYTHON_USE_TYPE_SPECS - 0, /*tp_dictoffset*/ - #endif - 0, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new__memoryviewslice, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - #if CYTHON_USE_TP_FINALIZE - 0, /*tp_finalize*/ - #else - NULL, /*tp_finalize*/ - #endif - #endif - #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) - 0, /*tp_vectorcall*/ - #endif - #if __PYX_NEED_TP_PRINT_SLOT == 1 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030C0000 - 0, /*tp_watched*/ - #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 - 0, /*tp_pypy_flags*/ - #endif -}; -#endif - -static PyMethodDef __pyx_methods[] = { - {0, 0, 0, 0} -}; -#ifndef CYTHON_SMALL_CODE -#if defined(__clang__) - #define CYTHON_SMALL_CODE -#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) - #define CYTHON_SMALL_CODE __attribute__((cold)) -#else - #define CYTHON_SMALL_CODE -#endif -#endif -/* #### Code section: pystring_table ### */ - -static int __Pyx_CreateStringTabAndInitStrings(void) { - __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_kp_u_, __pyx_k_, sizeof(__pyx_k_), 0, 1, 0, 0}, - {&__pyx_n_s_ASCII, __pyx_k_ASCII, sizeof(__pyx_k_ASCII), 0, 0, 1, 1}, - {&__pyx_kp_s_All_dimensions_preceding_dimensi, __pyx_k_All_dimensions_preceding_dimensi, sizeof(__pyx_k_All_dimensions_preceding_dimensi), 0, 0, 1, 0}, - {&__pyx_n_s_AssertionError, __pyx_k_AssertionError, sizeof(__pyx_k_AssertionError), 0, 0, 1, 1}, - {&__pyx_kp_s_Buffer_view_does_not_expose_stri, __pyx_k_Buffer_view_does_not_expose_stri, sizeof(__pyx_k_Buffer_view_does_not_expose_stri), 0, 0, 1, 0}, - {&__pyx_kp_s_Can_only_create_a_buffer_that_is, __pyx_k_Can_only_create_a_buffer_that_is, sizeof(__pyx_k_Can_only_create_a_buffer_that_is), 0, 0, 1, 0}, - {&__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_u_Cannot_index_with_type, __pyx_k_Cannot_index_with_type, sizeof(__pyx_k_Cannot_index_with_type), 0, 1, 0, 0}, - {&__pyx_kp_s_Cannot_transpose_memoryview_with, __pyx_k_Cannot_transpose_memoryview_with, sizeof(__pyx_k_Cannot_transpose_memoryview_with), 0, 0, 1, 0}, - {&__pyx_kp_s_Dimension_d_is_not_direct, __pyx_k_Dimension_d_is_not_direct, sizeof(__pyx_k_Dimension_d_is_not_direct), 0, 0, 1, 0}, - {&__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_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, - {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_k_Incompatible_checksums_0x_x_vs_0, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0), 0, 0, 1, 0}, - {&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1}, - {&__pyx_kp_s_Index_out_of_bounds_axis_d, __pyx_k_Index_out_of_bounds_axis_d, sizeof(__pyx_k_Index_out_of_bounds_axis_d), 0, 0, 1, 0}, - {&__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_u_Invalid_mode_expected_c_or_fortr, __pyx_k_Invalid_mode_expected_c_or_fortr, sizeof(__pyx_k_Invalid_mode_expected_c_or_fortr), 0, 1, 0, 0}, - {&__pyx_kp_u_Invalid_shape_in_axis, __pyx_k_Invalid_shape_in_axis, sizeof(__pyx_k_Invalid_shape_in_axis), 0, 1, 0, 0}, - {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, - {&__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_k_MemoryView_of_r_at_0x_x, sizeof(__pyx_k_MemoryView_of_r_at_0x_x), 0, 0, 1, 0}, - {&__pyx_kp_s_MemoryView_of_r_object, __pyx_k_MemoryView_of_r_object, sizeof(__pyx_k_MemoryView_of_r_object), 0, 0, 1, 0}, - {&__pyx_n_b_O, __pyx_k_O, sizeof(__pyx_k_O), 0, 0, 0, 1}, - {&__pyx_kp_u_Out_of_bounds_on_buffer_access_a, __pyx_k_Out_of_bounds_on_buffer_access_a, sizeof(__pyx_k_Out_of_bounds_on_buffer_access_a), 0, 1, 0, 0}, - {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, - {&__pyx_n_s_Sequence, __pyx_k_Sequence, sizeof(__pyx_k_Sequence), 0, 0, 1, 1}, - {&__pyx_kp_s_Step_may_not_be_zero_axis_d, __pyx_k_Step_may_not_be_zero_axis_d, sizeof(__pyx_k_Step_may_not_be_zero_axis_d), 0, 0, 1, 0}, - {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, - {&__pyx_kp_s_Unable_to_convert_item_to_object, __pyx_k_Unable_to_convert_item_to_object, sizeof(__pyx_k_Unable_to_convert_item_to_object), 0, 0, 1, 0}, - {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, - {&__pyx_n_s_View_MemoryView, __pyx_k_View_MemoryView, sizeof(__pyx_k_View_MemoryView), 0, 0, 1, 1}, - {&__pyx_kp_u__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 1, 0, 0}, - {&__pyx_n_s__25, __pyx_k__25, sizeof(__pyx_k__25), 0, 0, 1, 1}, - {&__pyx_n_s__3, __pyx_k__3, sizeof(__pyx_k__3), 0, 0, 1, 1}, - {&__pyx_kp_u__6, __pyx_k__6, sizeof(__pyx_k__6), 0, 1, 0, 0}, - {&__pyx_kp_u__7, __pyx_k__7, sizeof(__pyx_k__7), 0, 1, 0, 0}, - {&__pyx_n_s_abc, __pyx_k_abc, sizeof(__pyx_k_abc), 0, 0, 1, 1}, - {&__pyx_n_s_allocate_buffer, __pyx_k_allocate_buffer, sizeof(__pyx_k_allocate_buffer), 0, 0, 1, 1}, - {&__pyx_kp_u_and, __pyx_k_and, sizeof(__pyx_k_and), 0, 1, 0, 0}, - {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1}, - {&__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_class, __pyx_k_class, sizeof(__pyx_k_class), 0, 0, 1, 1}, - {&__pyx_n_s_class_getitem, __pyx_k_class_getitem, sizeof(__pyx_k_class_getitem), 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_n_s_collections, __pyx_k_collections, sizeof(__pyx_k_collections), 0, 0, 1, 1}, - {&__pyx_kp_s_collections_abc, __pyx_k_collections_abc, sizeof(__pyx_k_collections_abc), 0, 0, 1, 0}, - {&__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_kp_s_core_pyx, __pyx_k_core_pyx, sizeof(__pyx_k_core_pyx), 0, 0, 1, 0}, - {&__pyx_n_s_count, __pyx_k_count, sizeof(__pyx_k_count), 0, 0, 1, 1}, - {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, - {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0}, - {&__pyx_n_s_dtype_is_object, __pyx_k_dtype_is_object, sizeof(__pyx_k_dtype_is_object), 0, 0, 1, 1}, - {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0}, - {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1}, - {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1}, - {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1}, - {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 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}, - {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0}, - {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, - {&__pyx_kp_u_got, __pyx_k_got, sizeof(__pyx_k_got), 0, 1, 0, 0}, - {&__pyx_kp_u_got_differing_extents_in_dimensi, __pyx_k_got_differing_extents_in_dimensi, sizeof(__pyx_k_got_differing_extents_in_dimensi), 0, 1, 0, 0}, - {&__pyx_n_s_id, __pyx_k_id, sizeof(__pyx_k_id), 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_initializing, __pyx_k_initializing, sizeof(__pyx_k_initializing), 0, 0, 1, 1}, - {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, - {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0}, - {&__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_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, - {&__pyx_n_s_max_neg_val, __pyx_k_max_neg_val, sizeof(__pyx_k_max_neg_val), 0, 0, 1, 1}, - {&__pyx_n_s_maximum_path_c, __pyx_k_maximum_path_c, sizeof(__pyx_k_maximum_path_c), 0, 0, 1, 1}, - {&__pyx_n_s_memview, __pyx_k_memview, sizeof(__pyx_k_memview), 0, 0, 1, 1}, - {&__pyx_n_s_mode, __pyx_k_mode, sizeof(__pyx_k_mode), 0, 0, 1, 1}, - {&__pyx_n_s_monotonic_align_core, __pyx_k_monotonic_align_core, sizeof(__pyx_k_monotonic_align_core), 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_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 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_n_s_obj, __pyx_k_obj, sizeof(__pyx_k_obj), 0, 0, 1, 1}, - {&__pyx_n_s_pack, __pyx_k_pack, sizeof(__pyx_k_pack), 0, 0, 1, 1}, - {&__pyx_n_s_paths, __pyx_k_paths, sizeof(__pyx_k_paths), 0, 0, 1, 1}, - {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 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_result, __pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, - {&__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_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_register, __pyx_k_register, sizeof(__pyx_k_register), 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_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1}, - {&__pyx_n_s_spec, __pyx_k_spec, sizeof(__pyx_k_spec), 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}, - {&__pyx_kp_s_strided_and_direct, __pyx_k_strided_and_direct, sizeof(__pyx_k_strided_and_direct), 0, 0, 1, 0}, - {&__pyx_kp_s_strided_and_direct_or_indirect, __pyx_k_strided_and_direct_or_indirect, sizeof(__pyx_k_strided_and_direct_or_indirect), 0, 0, 1, 0}, - {&__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_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1}, - {&__pyx_n_s_t_xs, __pyx_k_t_xs, sizeof(__pyx_k_t_xs), 0, 0, 1, 1}, - {&__pyx_n_s_t_ys, __pyx_k_t_ys, sizeof(__pyx_k_t_ys), 0, 0, 1, 1}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {&__pyx_kp_s_unable_to_allocate_array_data, __pyx_k_unable_to_allocate_array_data, sizeof(__pyx_k_unable_to_allocate_array_data), 0, 0, 1, 0}, - {&__pyx_kp_s_unable_to_allocate_shape_and_str, __pyx_k_unable_to_allocate_shape_and_str, sizeof(__pyx_k_unable_to_allocate_shape_and_str), 0, 0, 1, 0}, - {&__pyx_n_s_unpack, __pyx_k_unpack, sizeof(__pyx_k_unpack), 0, 0, 1, 1}, - {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, - {&__pyx_n_s_values, __pyx_k_values, sizeof(__pyx_k_values), 0, 0, 1, 1}, - {&__pyx_n_s_version_info, __pyx_k_version_info, sizeof(__pyx_k_version_info), 0, 0, 1, 1}, - {0, 0, 0, 0, 0, 0, 0} - }; - return __Pyx_InitStrings(__pyx_string_tab); -} -/* #### Code section: cached_builtins ### */ -static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { - __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 17, __pyx_L1_error) - __pyx_builtin___import__ = __Pyx_GetBuiltinName(__pyx_n_s_import); if (!__pyx_builtin___import__) __PYX_ERR(1, 100, __pyx_L1_error) - __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 141, __pyx_L1_error) - __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(1, 156, __pyx_L1_error) - __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(1, 159, __pyx_L1_error) - __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error) - __pyx_builtin_AssertionError = __Pyx_GetBuiltinName(__pyx_n_s_AssertionError); if (!__pyx_builtin_AssertionError) __PYX_ERR(1, 373, __pyx_L1_error) - __pyx_builtin_Ellipsis = __Pyx_GetBuiltinName(__pyx_n_s_Ellipsis); if (!__pyx_builtin_Ellipsis) __PYX_ERR(1, 408, __pyx_L1_error) - __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(1, 618, __pyx_L1_error) - __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(1, 914, __pyx_L1_error) - __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(2, 986, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; -} -/* #### Code section: cached_constants ### */ - -static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - - /* "View.MemoryView":582 - * 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__4 = PyTuple_New(1); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 582, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__4); - __Pyx_INCREF(__pyx_int_neg_1); - __Pyx_GIVEREF(__pyx_int_neg_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_tuple__4, 0, __pyx_int_neg_1)) __PYX_ERR(1, 582, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_tuple__4); - - /* "View.MemoryView":679 - * tup = index if isinstance(index, tuple) else (index,) - * - * result = [slice(None)] * ndim # <<<<<<<<<<<<<< - * have_slices = False - * seen_ellipsis = False - */ - __pyx_slice__5 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__5)) __PYX_ERR(1, 679, __pyx_L1_error) - __Pyx_GOTREF(__pyx_slice__5); - __Pyx_GIVEREF(__pyx_slice__5); - - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * if __pyx_checksum not in (0x82a3537, 0x6ae9995, 0xb068931): # <<<<<<<<<<<<<< - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum - */ - __pyx_tuple__8 = PyTuple_Pack(3, __pyx_int_136983863, __pyx_int_112105877, __pyx_int_184977713); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__8); - __Pyx_GIVEREF(__pyx_tuple__8); - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":986 - * __pyx_import_array() - * except Exception: - * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< - * - * cdef inline int import_umath() except -1: - */ - __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(2, 986, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__9); - __Pyx_GIVEREF(__pyx_tuple__9); - - /* "../../../opt/miniconda/lib/python3.9/site-packages/numpy/__init__.cython-30.pxd":992 - * _import_umath() - * except Exception: - * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< - * - * cdef inline int import_ufunc() except -1: - */ - __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(2, 992, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__10); - __Pyx_GIVEREF(__pyx_tuple__10); - - /* "View.MemoryView":100 - * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" - * try: - * if __import__("sys").version_info >= (3, 3): # <<<<<<<<<<<<<< - * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence - * else: - */ - __pyx_tuple__12 = PyTuple_Pack(1, __pyx_n_s_sys); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 100, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__12); - __Pyx_GIVEREF(__pyx_tuple__12); - __pyx_tuple__13 = PyTuple_Pack(2, __pyx_int_3, __pyx_int_3); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 100, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__13); - __Pyx_GIVEREF(__pyx_tuple__13); - - /* "View.MemoryView":101 - * try: - * if __import__("sys").version_info >= (3, 3): - * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence # <<<<<<<<<<<<<< - * else: - * __pyx_collections_abc_Sequence = __import__("collections").Sequence - */ - __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_collections_abc); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__14); - __Pyx_GIVEREF(__pyx_tuple__14); - - /* "View.MemoryView":103 - * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence - * else: - * __pyx_collections_abc_Sequence = __import__("collections").Sequence # <<<<<<<<<<<<<< - * except: - * - */ - __pyx_tuple__15 = PyTuple_Pack(1, __pyx_n_s_collections); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(1, 103, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__15); - __Pyx_GIVEREF(__pyx_tuple__15); - - /* "View.MemoryView":309 - * return self.name - * - * cdef generic = Enum("") # <<<<<<<<<<<<<< - * cdef strided = Enum("") # default - * cdef indirect = Enum("") - */ - __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(1, 309, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__16); - __Pyx_GIVEREF(__pyx_tuple__16); - - /* "View.MemoryView":310 - * - * cdef generic = Enum("") - * cdef strided = Enum("") # default # <<<<<<<<<<<<<< - * cdef indirect = Enum("") - * - */ - __pyx_tuple__17 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(1, 310, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__17); - __Pyx_GIVEREF(__pyx_tuple__17); - - /* "View.MemoryView":311 - * cdef generic = Enum("") - * cdef strided = Enum("") # default - * cdef indirect = Enum("") # <<<<<<<<<<<<<< - * - * - */ - __pyx_tuple__18 = PyTuple_Pack(1, __pyx_kp_s_strided_and_indirect); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(1, 311, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__18); - __Pyx_GIVEREF(__pyx_tuple__18); - - /* "View.MemoryView":314 - * - * - * cdef contiguous = Enum("") # <<<<<<<<<<<<<< - * cdef indirect_contiguous = Enum("") - * - */ - __pyx_tuple__19 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(1, 314, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__19); - __Pyx_GIVEREF(__pyx_tuple__19); - - /* "View.MemoryView":315 - * - * cdef contiguous = Enum("") - * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< - * - * - */ - __pyx_tuple__20 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_indirect); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(1, 315, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__20); - __Pyx_GIVEREF(__pyx_tuple__20); - - /* "(tree fragment)":1 - * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ - __pyx_tuple__21 = 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__21)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__21); - __Pyx_GIVEREF(__pyx_tuple__21); - __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(1, 1, __pyx_L1_error) - - /* "monotonic_align/core.pyx":40 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * cpdef void maximum_path_c(int[:,:,::1] paths, float[:,:,::1] values, int[::1] t_xs, int[::1] t_ys, float max_neg_val=-1e9) nogil: # <<<<<<<<<<<<<< - * cdef int b = values.shape[0] - * - */ - __pyx_tuple__23 = PyTuple_Pack(5, __pyx_n_s_paths, __pyx_n_s_values, __pyx_n_s_t_xs, __pyx_n_s_t_ys, __pyx_n_s_max_neg_val); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(0, 40, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__23); - __Pyx_GIVEREF(__pyx_tuple__23); - __pyx_codeobj__24 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__23, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_core_pyx, __pyx_n_s_maximum_path_c, 40, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__24)) __PYX_ERR(0, 40, __pyx_L1_error) - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} -/* #### Code section: init_constants ### */ - -static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { - if (__Pyx_CreateStringTabAndInitStrings() < 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_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_112105877 = PyInt_FromLong(112105877L); if (unlikely(!__pyx_int_112105877)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_136983863 = PyInt_FromLong(136983863L); if (unlikely(!__pyx_int_136983863)) __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; - __pyx_L1_error:; - return -1; -} -/* #### Code section: init_globals ### */ - -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - /* AssertionsEnabled.init */ - if (likely(__Pyx_init_assertions_enabled() == 0)); else - -if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) - - /* NumpyImportArray.init */ - /* - * Cython has automatically inserted a call to _import_array since - * you didn't include one when you cimported numpy. To disable this - * add the line - * numpy._import_array - */ -#ifdef NPY_FEATURE_VERSION -#ifndef NO_IMPORT_ARRAY -if (unlikely(_import_array() == -1)) { - PyErr_SetString(PyExc_ImportError, "numpy.core.multiarray failed to import " - "(auto-generated because you didn't call 'numpy.import_array()' after cimporting numpy; " - "use 'numpy._import_array' to disable if you are certain you don't need it)."); -} -#endif -#endif - -if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) - - /* InitThreads.init */ - #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 -PyEval_InitThreads(); -#endif - -if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) - - return 0; - __pyx_L1_error:; - return -1; -} -/* #### Code section: init_module ### */ - -static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ - -static int __Pyx_modinit_global_init_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); - /*--- Global init code ---*/ - __pyx_collections_abc_Sequence = Py_None; Py_INCREF(Py_None); - generic = Py_None; Py_INCREF(Py_None); - strided = Py_None; Py_INCREF(Py_None); - indirect = Py_None; Py_INCREF(Py_None); - contiguous = Py_None; Py_INCREF(Py_None); - indirect_contiguous = Py_None; Py_INCREF(Py_None); - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_variable_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); - /*--- Variable export code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_function_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); - /*--- Function export code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_type_init_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_init_code", 0); - /*--- Type init code ---*/ - __pyx_vtabptr_array = &__pyx_vtable_array; - __pyx_vtable_array.get_memview = (PyObject *(*)(struct __pyx_array_obj *))__pyx_array_get_memview; - #if CYTHON_USE_TYPE_SPECS - __pyx_array_type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type___pyx_array_spec, NULL); if (unlikely(!__pyx_array_type)) __PYX_ERR(1, 114, __pyx_L1_error) - #if !CYTHON_COMPILING_IN_LIMITED_API - __pyx_array_type->tp_as_buffer = &__pyx_tp_as_buffer_array; - if (!__pyx_array_type->tp_as_buffer->bf_releasebuffer && __pyx_array_type->tp_base->tp_as_buffer && __pyx_array_type->tp_base->tp_as_buffer->bf_releasebuffer) { - __pyx_array_type->tp_as_buffer->bf_releasebuffer = __pyx_array_type->tp_base->tp_as_buffer->bf_releasebuffer; - } - #elif defined(Py_bf_getbuffer) && defined(Py_bf_releasebuffer) - /* PY_VERSION_HEX >= 0x03090000 || Py_LIMITED_API >= 0x030B0000 */ - #elif defined(_MSC_VER) - #pragma message ("The buffer protocol is not supported in the Limited C-API < 3.11.") - #else - #warning "The buffer protocol is not supported in the Limited C-API < 3.11." - #endif - if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type___pyx_array_spec, __pyx_array_type) < 0) __PYX_ERR(1, 114, __pyx_L1_error) - #else - __pyx_array_type = &__pyx_type___pyx_array; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - #endif - #if !CYTHON_USE_TYPE_SPECS - if (__Pyx_PyType_Ready(__pyx_array_type) < 0) __PYX_ERR(1, 114, __pyx_L1_error) - #endif - #if PY_MAJOR_VERSION < 3 - __pyx_array_type->tp_print = 0; - #endif - if (__Pyx_SetVtable(__pyx_array_type, __pyx_vtabptr_array) < 0) __PYX_ERR(1, 114, __pyx_L1_error) - #if !CYTHON_COMPILING_IN_LIMITED_API - if (__Pyx_MergeVtables(__pyx_array_type) < 0) __PYX_ERR(1, 114, __pyx_L1_error) - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - if (__Pyx_setup_reduce((PyObject *) __pyx_array_type) < 0) __PYX_ERR(1, 114, __pyx_L1_error) - #endif - #if CYTHON_USE_TYPE_SPECS - __pyx_MemviewEnum_type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type___pyx_MemviewEnum_spec, NULL); if (unlikely(!__pyx_MemviewEnum_type)) __PYX_ERR(1, 302, __pyx_L1_error) - if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type___pyx_MemviewEnum_spec, __pyx_MemviewEnum_type) < 0) __PYX_ERR(1, 302, __pyx_L1_error) - #else - __pyx_MemviewEnum_type = &__pyx_type___pyx_MemviewEnum; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - #endif - #if !CYTHON_USE_TYPE_SPECS - if (__Pyx_PyType_Ready(__pyx_MemviewEnum_type) < 0) __PYX_ERR(1, 302, __pyx_L1_error) - #endif - #if PY_MAJOR_VERSION < 3 - __pyx_MemviewEnum_type->tp_print = 0; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_MemviewEnum_type->tp_dictoffset && __pyx_MemviewEnum_type->tp_getattro == PyObject_GenericGetAttr)) { - __pyx_MemviewEnum_type->tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - if (__Pyx_setup_reduce((PyObject *) __pyx_MemviewEnum_type) < 0) __PYX_ERR(1, 302, __pyx_L1_error) - #endif - __pyx_vtabptr_memoryview = &__pyx_vtable_memoryview; - __pyx_vtable_memoryview.get_item_pointer = (char *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_get_item_pointer; - __pyx_vtable_memoryview.is_slice = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_is_slice; - __pyx_vtable_memoryview.setitem_slice_assignment = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_slice_assignment; - __pyx_vtable_memoryview.setitem_slice_assign_scalar = (PyObject *(*)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_setitem_slice_assign_scalar; - __pyx_vtable_memoryview.setitem_indexed = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_indexed; - __pyx_vtable_memoryview.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryview_convert_item_to_object; - __pyx_vtable_memoryview.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryview_assign_item_from_object; - __pyx_vtable_memoryview._get_base = (PyObject *(*)(struct __pyx_memoryview_obj *))__pyx_memoryview__get_base; - #if CYTHON_USE_TYPE_SPECS - __pyx_memoryview_type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type___pyx_memoryview_spec, NULL); if (unlikely(!__pyx_memoryview_type)) __PYX_ERR(1, 337, __pyx_L1_error) - #if !CYTHON_COMPILING_IN_LIMITED_API - __pyx_memoryview_type->tp_as_buffer = &__pyx_tp_as_buffer_memoryview; - if (!__pyx_memoryview_type->tp_as_buffer->bf_releasebuffer && __pyx_memoryview_type->tp_base->tp_as_buffer && __pyx_memoryview_type->tp_base->tp_as_buffer->bf_releasebuffer) { - __pyx_memoryview_type->tp_as_buffer->bf_releasebuffer = __pyx_memoryview_type->tp_base->tp_as_buffer->bf_releasebuffer; - } - #elif defined(Py_bf_getbuffer) && defined(Py_bf_releasebuffer) - /* PY_VERSION_HEX >= 0x03090000 || Py_LIMITED_API >= 0x030B0000 */ - #elif defined(_MSC_VER) - #pragma message ("The buffer protocol is not supported in the Limited C-API < 3.11.") - #else - #warning "The buffer protocol is not supported in the Limited C-API < 3.11." - #endif - if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type___pyx_memoryview_spec, __pyx_memoryview_type) < 0) __PYX_ERR(1, 337, __pyx_L1_error) - #else - __pyx_memoryview_type = &__pyx_type___pyx_memoryview; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - #endif - #if !CYTHON_USE_TYPE_SPECS - if (__Pyx_PyType_Ready(__pyx_memoryview_type) < 0) __PYX_ERR(1, 337, __pyx_L1_error) - #endif - #if PY_MAJOR_VERSION < 3 - __pyx_memoryview_type->tp_print = 0; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_memoryview_type->tp_dictoffset && __pyx_memoryview_type->tp_getattro == PyObject_GenericGetAttr)) { - __pyx_memoryview_type->tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - #endif - if (__Pyx_SetVtable(__pyx_memoryview_type, __pyx_vtabptr_memoryview) < 0) __PYX_ERR(1, 337, __pyx_L1_error) - #if !CYTHON_COMPILING_IN_LIMITED_API - if (__Pyx_MergeVtables(__pyx_memoryview_type) < 0) __PYX_ERR(1, 337, __pyx_L1_error) - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - if (__Pyx_setup_reduce((PyObject *) __pyx_memoryview_type) < 0) __PYX_ERR(1, 337, __pyx_L1_error) - #endif - __pyx_vtabptr__memoryviewslice = &__pyx_vtable__memoryviewslice; - __pyx_vtable__memoryviewslice.__pyx_base = *__pyx_vtabptr_memoryview; - __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_vtable__memoryviewslice.__pyx_base._get_base = (PyObject *(*)(struct __pyx_memoryview_obj *))__pyx_memoryviewslice__get_base; - #if CYTHON_USE_TYPE_SPECS - __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_memoryview_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 952, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_memoryviewslice_type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type___pyx_memoryviewslice_spec, __pyx_t_1); - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_memoryviewslice_type)) __PYX_ERR(1, 952, __pyx_L1_error) - if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type___pyx_memoryviewslice_spec, __pyx_memoryviewslice_type) < 0) __PYX_ERR(1, 952, __pyx_L1_error) - #else - __pyx_memoryviewslice_type = &__pyx_type___pyx_memoryviewslice; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - __pyx_memoryviewslice_type->tp_base = __pyx_memoryview_type; - #endif - #if !CYTHON_USE_TYPE_SPECS - if (__Pyx_PyType_Ready(__pyx_memoryviewslice_type) < 0) __PYX_ERR(1, 952, __pyx_L1_error) - #endif - #if PY_MAJOR_VERSION < 3 - __pyx_memoryviewslice_type->tp_print = 0; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_memoryviewslice_type->tp_dictoffset && __pyx_memoryviewslice_type->tp_getattro == PyObject_GenericGetAttr)) { - __pyx_memoryviewslice_type->tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - #endif - if (__Pyx_SetVtable(__pyx_memoryviewslice_type, __pyx_vtabptr__memoryviewslice) < 0) __PYX_ERR(1, 952, __pyx_L1_error) - #if !CYTHON_COMPILING_IN_LIMITED_API - if (__Pyx_MergeVtables(__pyx_memoryviewslice_type) < 0) __PYX_ERR(1, 952, __pyx_L1_error) - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - if (__Pyx_setup_reduce((PyObject *) __pyx_memoryviewslice_type) < 0) __PYX_ERR(1, 952, __pyx_L1_error) - #endif - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_RefNannyFinishContext(); - return -1; -} - -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) - __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_7cpython_4type_type = __Pyx_ImportType_3_0_10(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", - #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyTypeObject), - #elif CYTHON_COMPILING_IN_LIMITED_API - sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyTypeObject), - #else - sizeof(PyHeapTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyHeapTypeObject), - #endif - __Pyx_ImportType_CheckSize_Warn_3_0_10); 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(2, 202, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_5numpy_dtype = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyArray_Descr),__Pyx_ImportType_CheckSize_Ignore_3_0_10); if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(2, 202, __pyx_L1_error) - __pyx_ptype_5numpy_flatiter = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyArrayIterObject),__Pyx_ImportType_CheckSize_Ignore_3_0_10); if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(2, 225, __pyx_L1_error) - __pyx_ptype_5numpy_broadcast = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyArrayMultiIterObject),__Pyx_ImportType_CheckSize_Ignore_3_0_10); if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(2, 229, __pyx_L1_error) - __pyx_ptype_5numpy_ndarray = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyArrayObject),__Pyx_ImportType_CheckSize_Ignore_3_0_10); if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(2, 238, __pyx_L1_error) - __pyx_ptype_5numpy_generic = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "generic", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_generic) __PYX_ERR(2, 812, __pyx_L1_error) - __pyx_ptype_5numpy_number = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "number", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_number) __PYX_ERR(2, 814, __pyx_L1_error) - __pyx_ptype_5numpy_integer = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "integer", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_integer) __PYX_ERR(2, 816, __pyx_L1_error) - __pyx_ptype_5numpy_signedinteger = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "signedinteger", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_signedinteger) __PYX_ERR(2, 818, __pyx_L1_error) - __pyx_ptype_5numpy_unsignedinteger = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "unsignedinteger", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_unsignedinteger) __PYX_ERR(2, 820, __pyx_L1_error) - __pyx_ptype_5numpy_inexact = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "inexact", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_inexact) __PYX_ERR(2, 822, __pyx_L1_error) - __pyx_ptype_5numpy_floating = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "floating", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_floating) __PYX_ERR(2, 824, __pyx_L1_error) - __pyx_ptype_5numpy_complexfloating = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "complexfloating", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_complexfloating) __PYX_ERR(2, 826, __pyx_L1_error) - __pyx_ptype_5numpy_flexible = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "flexible", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_flexible) __PYX_ERR(2, 828, __pyx_L1_error) - __pyx_ptype_5numpy_character = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "character", sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_5numpy_character) __PYX_ERR(2, 830, __pyx_L1_error) - __pyx_ptype_5numpy_ufunc = __Pyx_ImportType_3_0_10(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyUFuncObject),__Pyx_ImportType_CheckSize_Ignore_3_0_10); if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(2, 868, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_RefNannyFinishContext(); - return -1; -} - -static int __Pyx_modinit_variable_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); - /*--- Variable import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_function_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); - /*--- Function import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - - -#if PY_MAJOR_VERSION >= 3 -#if CYTHON_PEP489_MULTI_PHASE_INIT -static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ -static int __pyx_pymod_exec_core(PyObject* module); /*proto*/ -static PyModuleDef_Slot __pyx_moduledef_slots[] = { - {Py_mod_create, (void*)__pyx_pymod_create}, - {Py_mod_exec, (void*)__pyx_pymod_exec_core}, - {0, NULL} -}; -#endif - -#ifdef __cplusplus -namespace { - struct PyModuleDef __pyx_moduledef = - #else - static struct PyModuleDef __pyx_moduledef = - #endif - { - PyModuleDef_HEAD_INIT, - "core", - 0, /* m_doc */ - #if CYTHON_PEP489_MULTI_PHASE_INIT - 0, /* m_size */ - #elif CYTHON_USE_MODULE_STATE - sizeof(__pyx_mstate), /* m_size */ - #else - -1, /* m_size */ - #endif - __pyx_methods /* m_methods */, - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_moduledef_slots, /* m_slots */ - #else - NULL, /* m_reload */ - #endif - #if CYTHON_USE_MODULE_STATE - __pyx_m_traverse, /* m_traverse */ - __pyx_m_clear, /* m_clear */ - NULL /* m_free */ - #else - NULL, /* m_traverse */ - NULL, /* m_clear */ - NULL /* m_free */ - #endif - }; - #ifdef __cplusplus -} /* anonymous namespace */ -#endif -#endif - -#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 -#define __Pyx_PyMODINIT_FUNC void -#endif -#else -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * -#else -#define __Pyx_PyMODINIT_FUNC PyObject * -#endif -#endif - - -#if PY_MAJOR_VERSION < 3 -__Pyx_PyMODINIT_FUNC initcore(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC initcore(void) -#else -__Pyx_PyMODINIT_FUNC PyInit_core(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC PyInit_core(void) -#if CYTHON_PEP489_MULTI_PHASE_INIT -{ - return PyModuleDef_Init(&__pyx_moduledef); -} -static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { - #if PY_VERSION_HEX >= 0x030700A1 - static PY_INT64_T main_interpreter_id = -1; - PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); - if (main_interpreter_id == -1) { - main_interpreter_id = current_id; - return (unlikely(current_id == -1)) ? -1 : 0; - } else if (unlikely(main_interpreter_id != current_id)) - #else - static PyInterpreterState *main_interpreter = NULL; - PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; - if (!main_interpreter) { - main_interpreter = current_interpreter; - } else if (unlikely(main_interpreter != current_interpreter)) - #endif - { - PyErr_SetString( - PyExc_ImportError, - "Interpreter change detected - this module can only be loaded into one interpreter per process."); - return -1; - } - return 0; -} -#if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) -#else -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) -#endif -{ - PyObject *value = PyObject_GetAttrString(spec, from_name); - int result = 0; - if (likely(value)) { - if (allow_none || value != Py_None) { -#if CYTHON_COMPILING_IN_LIMITED_API - result = PyModule_AddObject(module, to_name, value); -#else - result = PyDict_SetItemString(moddict, to_name, value); -#endif - } - Py_DECREF(value); - } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { - PyErr_Clear(); - } else { - result = -1; - } - return result; -} -static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { - PyObject *module = NULL, *moddict, *modname; - CYTHON_UNUSED_VAR(def); - if (__Pyx_check_single_interpreter()) - return NULL; - if (__pyx_m) - return __Pyx_NewRef(__pyx_m); - modname = PyObject_GetAttrString(spec, "name"); - if (unlikely(!modname)) goto bad; - module = PyModule_NewObject(modname); - Py_DECREF(modname); - if (unlikely(!module)) goto bad; -#if CYTHON_COMPILING_IN_LIMITED_API - moddict = module; -#else - moddict = PyModule_GetDict(module); - if (unlikely(!moddict)) goto bad; -#endif - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; - return module; -bad: - Py_XDECREF(module); - return NULL; -} - - -static CYTHON_SMALL_CODE int __pyx_pymod_exec_core(PyObject *__pyx_pyinit_module) -#endif -#endif -{ - int stringtab_initialized = 0; - #if CYTHON_USE_MODULE_STATE - int pystate_addmodule_run = 0; - #endif - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - int __pyx_t_6; - PyObject *__pyx_t_7 = NULL; - static PyThread_type_lock __pyx_t_8[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) { - if (__pyx_m == __pyx_pyinit_module) return 0; - PyErr_SetString(PyExc_RuntimeError, "Module 'core' has already been imported. Re-initialisation is not supported."); - return -1; - } - #elif PY_MAJOR_VERSION >= 3 - if (__pyx_m) return __Pyx_NewRef(__pyx_m); - #endif - /*--- Module creation code ---*/ - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_m = __pyx_pyinit_module; - Py_INCREF(__pyx_m); - #else - #if PY_MAJOR_VERSION < 3 - __pyx_m = Py_InitModule4("core", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #elif CYTHON_USE_MODULE_STATE - __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) - { - int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef); - __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "core" pseudovariable */ - if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) - pystate_addmodule_run = 1; - } - #else - __pyx_m = PyModule_Create(&__pyx_moduledef); - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #endif - CYTHON_UNUSED_VAR(__pyx_t_1); - __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_d); - __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) - if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #if CYTHON_REFNANNY -__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); -if (!__Pyx_RefNanny) { - PyErr_Clear(); - __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); - if (!__Pyx_RefNanny) - Py_FatalError("failed to import 'refnanny' module"); -} -#endif - __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_core(void)", 0); - if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pxy_PyFrame_Initialize_Offsets - __Pxy_PyFrame_Initialize_Offsets(); - #endif - __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pyx_CyFunction_USED - if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_FusedFunction_USED - if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Coroutine_USED - if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Generator_USED - if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_AsyncGen_USED - if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_StopAsyncIteration_USED - if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - /*--- Library function declarations ---*/ - /*--- Threads initialization code ---*/ - #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS - PyEval_InitThreads(); - #endif - /*--- Initialize various global constants etc. ---*/ - if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - stringtab_initialized = 1; - if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) - if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - if (__pyx_module_is_main_monotonic_align__core) { - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - } - #if PY_MAJOR_VERSION >= 3 - { - PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) - if (!PyDict_GetItemString(modules, "monotonic_align.core")) { - if (unlikely((PyDict_SetItemString(modules, "monotonic_align.core", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) - } - } - #endif - /*--- Builtin init code ---*/ - if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Constants init code ---*/ - if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __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) - (void)__Pyx_modinit_variable_import_code(); - (void)__Pyx_modinit_function_import_code(); - /*--- Execution code ---*/ - #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) - if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - - /* "View.MemoryView":99 - * - * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" - * try: # <<<<<<<<<<<<<< - * if __import__("sys").version_info >= (3, 3): - * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence - */ - { - __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:*/ { - - /* "View.MemoryView":100 - * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" - * try: - * if __import__("sys").version_info >= (3, 3): # <<<<<<<<<<<<<< - * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence - * else: - */ - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 100, __pyx_L2_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_version_info); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 100, __pyx_L2_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyObject_RichCompare(__pyx_t_5, __pyx_tuple__13, Py_GE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 100, __pyx_L2_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(1, 100, __pyx_L2_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - - /* "View.MemoryView":101 - * try: - * if __import__("sys").version_info >= (3, 3): - * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence # <<<<<<<<<<<<<< - * else: - * __pyx_collections_abc_Sequence = __import__("collections").Sequence - */ - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 101, __pyx_L2_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_abc); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 101, __pyx_L2_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_Sequence); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 101, __pyx_L2_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_XGOTREF(__pyx_collections_abc_Sequence); - __Pyx_DECREF_SET(__pyx_collections_abc_Sequence, __pyx_t_4); - __Pyx_GIVEREF(__pyx_t_4); - __pyx_t_4 = 0; - - /* "View.MemoryView":100 - * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" - * try: - * if __import__("sys").version_info >= (3, 3): # <<<<<<<<<<<<<< - * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence - * else: - */ - goto __pyx_L8; - } - - /* "View.MemoryView":103 - * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence - * else: - * __pyx_collections_abc_Sequence = __import__("collections").Sequence # <<<<<<<<<<<<<< - * except: - * - */ - /*else*/ { - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 103, __pyx_L2_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Sequence); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 103, __pyx_L2_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_XGOTREF(__pyx_collections_abc_Sequence); - __Pyx_DECREF_SET(__pyx_collections_abc_Sequence, __pyx_t_5); - __Pyx_GIVEREF(__pyx_t_5); - __pyx_t_5 = 0; - } - __pyx_L8:; - - /* "View.MemoryView":99 - * - * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" - * try: # <<<<<<<<<<<<<< - * if __import__("sys").version_info >= (3, 3): - * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence - */ - } - __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_L7_try_end; - __pyx_L2_error:; - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - - /* "View.MemoryView":104 - * else: - * __pyx_collections_abc_Sequence = __import__("collections").Sequence - * except: # <<<<<<<<<<<<<< - * - * __pyx_collections_abc_Sequence = None - */ - /*except:*/ { - __Pyx_AddTraceback("View.MemoryView", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_7) < 0) __PYX_ERR(1, 104, __pyx_L4_except_error) - __Pyx_XGOTREF(__pyx_t_5); - __Pyx_XGOTREF(__pyx_t_4); - __Pyx_XGOTREF(__pyx_t_7); - - /* "View.MemoryView":106 - * except: - * - * __pyx_collections_abc_Sequence = None # <<<<<<<<<<<<<< - * - * - */ - __Pyx_INCREF(Py_None); - __Pyx_XGOTREF(__pyx_collections_abc_Sequence); - __Pyx_DECREF_SET(__pyx_collections_abc_Sequence, Py_None); - __Pyx_GIVEREF(Py_None); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - goto __pyx_L3_exception_handled; - } - - /* "View.MemoryView":99 - * - * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" - * try: # <<<<<<<<<<<<<< - * if __import__("sys").version_info >= (3, 3): - * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence - */ - __pyx_L4_except_error:; - __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_L3_exception_handled:; - __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); - __pyx_L7_try_end:; - } - - /* "View.MemoryView":241 - * - * - * try: # <<<<<<<<<<<<<< - * count = __pyx_collections_abc_Sequence.count - * index = __pyx_collections_abc_Sequence.index - */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1); - __Pyx_XGOTREF(__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_2); - __Pyx_XGOTREF(__pyx_t_1); - /*try:*/ { - - /* "View.MemoryView":242 - * - * try: - * count = __pyx_collections_abc_Sequence.count # <<<<<<<<<<<<<< - * index = __pyx_collections_abc_Sequence.index - * except: - */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_n_s_count); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 242, __pyx_L11_error) - __Pyx_GOTREF(__pyx_t_7); - if (__Pyx_SetItemOnTypeDict(__pyx_array_type, __pyx_n_s_count, __pyx_t_7) < 0) __PYX_ERR(1, 242, __pyx_L11_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - PyType_Modified(__pyx_array_type); - - /* "View.MemoryView":243 - * try: - * count = __pyx_collections_abc_Sequence.count - * index = __pyx_collections_abc_Sequence.index # <<<<<<<<<<<<<< - * except: - * pass - */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_n_s_index); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 243, __pyx_L11_error) - __Pyx_GOTREF(__pyx_t_7); - if (__Pyx_SetItemOnTypeDict(__pyx_array_type, __pyx_n_s_index, __pyx_t_7) < 0) __PYX_ERR(1, 243, __pyx_L11_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - PyType_Modified(__pyx_array_type); - - /* "View.MemoryView":241 - * - * - * try: # <<<<<<<<<<<<<< - * count = __pyx_collections_abc_Sequence.count - * index = __pyx_collections_abc_Sequence.index - */ - } - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - goto __pyx_L16_try_end; - __pyx_L11_error:; - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "View.MemoryView":244 - * count = __pyx_collections_abc_Sequence.count - * index = __pyx_collections_abc_Sequence.index - * except: # <<<<<<<<<<<<<< - * pass - * - */ - /*except:*/ { - __Pyx_ErrRestore(0,0,0); - goto __pyx_L12_exception_handled; - } - __pyx_L12_exception_handled:; - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_2, __pyx_t_1); - __pyx_L16_try_end:; - } - - /* "View.MemoryView":309 - * return self.name - * - * cdef generic = Enum("") # <<<<<<<<<<<<<< - * cdef strided = Enum("") # default - * cdef indirect = Enum("") - */ - __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 309, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_XGOTREF(generic); - __Pyx_DECREF_SET(generic, __pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - __pyx_t_7 = 0; - - /* "View.MemoryView":310 - * - * cdef generic = Enum("") - * cdef strided = Enum("") # default # <<<<<<<<<<<<<< - * cdef indirect = Enum("") - * - */ - __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 310, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_XGOTREF(strided); - __Pyx_DECREF_SET(strided, __pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - __pyx_t_7 = 0; - - /* "View.MemoryView":311 - * cdef generic = Enum("") - * cdef strided = Enum("") # default - * cdef indirect = Enum("") # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 311, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_XGOTREF(indirect); - __Pyx_DECREF_SET(indirect, __pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - __pyx_t_7 = 0; - - /* "View.MemoryView":314 - * - * - * cdef contiguous = Enum("") # <<<<<<<<<<<<<< - * cdef indirect_contiguous = Enum("") - * - */ - __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__19, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 314, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_XGOTREF(contiguous); - __Pyx_DECREF_SET(contiguous, __pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - __pyx_t_7 = 0; - - /* "View.MemoryView":315 - * - * cdef contiguous = Enum("") - * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__20, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 315, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_XGOTREF(indirect_contiguous); - __Pyx_DECREF_SET(indirect_contiguous, __pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - __pyx_t_7 = 0; - - /* "View.MemoryView":323 - * - * - * cdef int __pyx_memoryview_thread_locks_used = 0 # <<<<<<<<<<<<<< - * cdef PyThread_type_lock[8] __pyx_memoryview_thread_locks = [ - * PyThread_allocate_lock(), - */ - __pyx_memoryview_thread_locks_used = 0; - - /* "View.MemoryView":324 - * - * cdef int __pyx_memoryview_thread_locks_used = 0 - * cdef PyThread_type_lock[8] __pyx_memoryview_thread_locks = [ # <<<<<<<<<<<<<< - * PyThread_allocate_lock(), - * PyThread_allocate_lock(), - */ - __pyx_t_8[0] = PyThread_allocate_lock(); - __pyx_t_8[1] = PyThread_allocate_lock(); - __pyx_t_8[2] = PyThread_allocate_lock(); - __pyx_t_8[3] = PyThread_allocate_lock(); - __pyx_t_8[4] = PyThread_allocate_lock(); - __pyx_t_8[5] = PyThread_allocate_lock(); - __pyx_t_8[6] = PyThread_allocate_lock(); - __pyx_t_8[7] = PyThread_allocate_lock(); - memcpy(&(__pyx_memoryview_thread_locks[0]), __pyx_t_8, sizeof(__pyx_memoryview_thread_locks[0]) * (8)); - - /* "View.MemoryView":982 - * - * - * try: # <<<<<<<<<<<<<< - * count = __pyx_collections_abc_Sequence.count - * index = __pyx_collections_abc_Sequence.index - */ - { - __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:*/ { - - /* "View.MemoryView":983 - * - * try: - * count = __pyx_collections_abc_Sequence.count # <<<<<<<<<<<<<< - * index = __pyx_collections_abc_Sequence.index - * except: - */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_n_s_count); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 983, __pyx_L17_error) - __Pyx_GOTREF(__pyx_t_7); - if (__Pyx_SetItemOnTypeDict(__pyx_memoryviewslice_type, __pyx_n_s_count, __pyx_t_7) < 0) __PYX_ERR(1, 983, __pyx_L17_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - PyType_Modified(__pyx_memoryviewslice_type); - - /* "View.MemoryView":984 - * try: - * count = __pyx_collections_abc_Sequence.count - * index = __pyx_collections_abc_Sequence.index # <<<<<<<<<<<<<< - * except: - * pass - */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_n_s_index); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 984, __pyx_L17_error) - __Pyx_GOTREF(__pyx_t_7); - if (__Pyx_SetItemOnTypeDict(__pyx_memoryviewslice_type, __pyx_n_s_index, __pyx_t_7) < 0) __PYX_ERR(1, 984, __pyx_L17_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - PyType_Modified(__pyx_memoryviewslice_type); - - /* "View.MemoryView":982 - * - * - * try: # <<<<<<<<<<<<<< - * count = __pyx_collections_abc_Sequence.count - * index = __pyx_collections_abc_Sequence.index - */ - } - __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_L22_try_end; - __pyx_L17_error:; - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "View.MemoryView":985 - * count = __pyx_collections_abc_Sequence.count - * index = __pyx_collections_abc_Sequence.index - * except: # <<<<<<<<<<<<<< - * pass - * - */ - /*except:*/ { - __Pyx_ErrRestore(0,0,0); - goto __pyx_L18_exception_handled; - } - __pyx_L18_exception_handled:; - __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); - __pyx_L22_try_end:; - } - - /* "View.MemoryView":988 - * pass - * - * try: # <<<<<<<<<<<<<< - * if __pyx_collections_abc_Sequence: - * - */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1); - __Pyx_XGOTREF(__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_2); - __Pyx_XGOTREF(__pyx_t_1); - /*try:*/ { - - /* "View.MemoryView":989 - * - * try: - * if __pyx_collections_abc_Sequence: # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_collections_abc_Sequence); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(1, 989, __pyx_L23_error) - if (__pyx_t_6) { - - /* "View.MemoryView":993 - * - * - * __pyx_collections_abc_Sequence.register(_memoryviewslice) # <<<<<<<<<<<<<< - * __pyx_collections_abc_Sequence.register(array) - * except: - */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_n_s_register); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 993, __pyx_L23_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_7, ((PyObject *)__pyx_memoryviewslice_type)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 993, __pyx_L23_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - - /* "View.MemoryView":994 - * - * __pyx_collections_abc_Sequence.register(_memoryviewslice) - * __pyx_collections_abc_Sequence.register(array) # <<<<<<<<<<<<<< - * except: - * pass # ignore failure, it's a minor issue - */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_n_s_register); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 994, __pyx_L23_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_4, ((PyObject *)__pyx_array_type)); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 994, __pyx_L23_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "View.MemoryView":989 - * - * try: - * if __pyx_collections_abc_Sequence: # <<<<<<<<<<<<<< - * - * - */ - } - - /* "View.MemoryView":988 - * pass - * - * try: # <<<<<<<<<<<<<< - * if __pyx_collections_abc_Sequence: - * - */ - } - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - goto __pyx_L28_try_end; - __pyx_L23_error:; - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "View.MemoryView":995 - * __pyx_collections_abc_Sequence.register(_memoryviewslice) - * __pyx_collections_abc_Sequence.register(array) - * except: # <<<<<<<<<<<<<< - * pass # ignore failure, it's a minor issue - * - */ - /*except:*/ { - __Pyx_ErrRestore(0,0,0); - goto __pyx_L24_exception_handled; - } - __pyx_L24_exception_handled:; - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_2, __pyx_t_1); - __pyx_L28_try_end:; - } - - /* "(tree fragment)":1 - * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ - __pyx_t_7 = PyCFunction_NewEx(&__pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum, NULL, __pyx_n_s_View_MemoryView); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Enum, __pyx_t_7) < 0) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "monotonic_align/core.pyx":1 - * import numpy as np # <<<<<<<<<<<<<< - * cimport numpy as np - * cimport cython - */ - __pyx_t_7 = __Pyx_ImportDottedModule(__pyx_n_s_numpy, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_7) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "monotonic_align/core.pyx":40 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * cpdef void maximum_path_c(int[:,:,::1] paths, float[:,:,::1] values, int[::1] t_xs, int[::1] t_ys, float max_neg_val=-1e9) nogil: # <<<<<<<<<<<<<< - * cdef int b = values.shape[0] - * - */ - __pyx_k__11 = (-1e9); - __pyx_t_7 = PyFloat_FromDouble((-1e9)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 40, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 40, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_7)) __PYX_ERR(0, 40, __pyx_L1_error); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_15monotonic_align_4core_1maximum_path_c, 0, __pyx_n_s_maximum_path_c, NULL, __pyx_n_s_monotonic_align_core, __pyx_d, ((PyObject *)__pyx_codeobj__24)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 40, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_t_4); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_maximum_path_c, __pyx_t_7) < 0) __PYX_ERR(0, 40, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "monotonic_align/core.pyx":1 - * import numpy as np # <<<<<<<<<<<<<< - * cimport numpy as np - * cimport cython - */ - __pyx_t_7 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_7) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - /*--- Wrapped vars code ---*/ - - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_7); - if (__pyx_m) { - if (__pyx_d && stringtab_initialized) { - __Pyx_AddTraceback("init monotonic_align.core", __pyx_clineno, __pyx_lineno, __pyx_filename); - } - #if !CYTHON_USE_MODULE_STATE - Py_CLEAR(__pyx_m); - #else - Py_DECREF(__pyx_m); - if (pystate_addmodule_run) { - PyObject *tp, *value, *tb; - PyErr_Fetch(&tp, &value, &tb); - PyState_RemoveModule(&__pyx_moduledef); - PyErr_Restore(tp, value, tb); - } - #endif - } else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_ImportError, "init monotonic_align.core"); - } - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - #if CYTHON_PEP489_MULTI_PHASE_INIT - return (__pyx_m != NULL) ? 0 : -1; - #elif PY_MAJOR_VERSION >= 3 - return __pyx_m; - #else - return; - #endif -} -/* #### Code section: cleanup_globals ### */ -/* #### Code section: cleanup_module ### */ -/* #### Code section: main_method ### */ -/* #### Code section: utility_code_pragmas ### */ -#ifdef _MSC_VER -#pragma warning( push ) -/* Warning 4127: conditional expression is constant - * Cython uses constant conditional expressions to allow in inline functions to be optimized at - * compile-time, so this warning is not useful - */ -#pragma warning( disable : 4127 ) -#endif - - - -/* #### Code section: utility_code_def ### */ - -/* --- Runtime support code --- */ -/* Refnanny */ -#if CYTHON_REFNANNY -static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { - PyObject *m = NULL, *p = NULL; - void *r = NULL; - m = PyImport_ImportModule(modname); - if (!m) goto end; - p = PyObject_GetAttrString(m, "RefNannyAPI"); - if (!p) goto end; - r = PyLong_AsVoidPtr(p); -end: - Py_XDECREF(p); - Py_XDECREF(m); - return (__Pyx_RefNannyAPIStruct *)r; -} -#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; i= 0x030C00A6 - PyObject *current_exception = tstate->current_exception; - if (unlikely(!current_exception)) return 0; - exc_type = (PyObject*) Py_TYPE(current_exception); - if (exc_type == err) return 1; -#else - exc_type = tstate->curexc_type; - if (exc_type == err) return 1; - if (unlikely(!exc_type)) return 0; -#endif - #if CYTHON_AVOID_BORROWED_REFS - Py_INCREF(exc_type); - #endif - if (unlikely(PyTuple_Check(err))) { - result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); - } else { - result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); - } - #if CYTHON_AVOID_BORROWED_REFS - Py_DECREF(exc_type); - #endif - return result; -} -#endif - -/* PyErrFetchRestore */ -#if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { -#if PY_VERSION_HEX >= 0x030C00A6 - PyObject *tmp_value; - assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); - if (value) { - #if CYTHON_COMPILING_IN_CPYTHON - if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) - #endif - PyException_SetTraceback(value, tb); - } - tmp_value = tstate->current_exception; - tstate->current_exception = value; - Py_XDECREF(tmp_value); - Py_XDECREF(type); - Py_XDECREF(tb); -#else - PyObject *tmp_type, *tmp_value, *tmp_tb; - tmp_type = tstate->curexc_type; - tmp_value = tstate->curexc_value; - tmp_tb = tstate->curexc_traceback; - tstate->curexc_type = type; - tstate->curexc_value = value; - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); -#endif -} -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { -#if PY_VERSION_HEX >= 0x030C00A6 - PyObject* exc_value; - exc_value = tstate->current_exception; - tstate->current_exception = 0; - *value = exc_value; - *type = NULL; - *tb = NULL; - if (exc_value) { - *type = (PyObject*) Py_TYPE(exc_value); - Py_INCREF(*type); - #if CYTHON_COMPILING_IN_CPYTHON - *tb = ((PyBaseExceptionObject*) exc_value)->traceback; - Py_XINCREF(*tb); - #else - *tb = PyException_GetTraceback(exc_value); - #endif - } -#else - *type = tstate->curexc_type; - *value = tstate->curexc_value; - *tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; -#endif -} -#endif - -/* PyObjectGetAttrStr */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { - PyTypeObject* tp = Py_TYPE(obj); - if (likely(tp->tp_getattro)) - return tp->tp_getattro(obj, attr_name); -#if PY_MAJOR_VERSION < 3 - if (likely(tp->tp_getattr)) - return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); -#endif - return PyObject_GetAttr(obj, attr_name); -} -#endif - -/* PyObjectGetAttrStrNoError */ -#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 -static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) - __Pyx_PyErr_Clear(); -} -#endif -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { - PyObject *result; -#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 - (void) PyObject_GetOptionalAttr(obj, attr_name, &result); - return result; -#else -#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; -#endif -} - -/* GetBuiltinName */ -static PyObject *__Pyx_GetBuiltinName(PyObject *name) { - PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name); - if (unlikely(!result) && !PyErr_Occurred()) { - PyErr_Format(PyExc_NameError, -#if PY_MAJOR_VERSION >= 3 - "name '%U' is not defined", name); -#else - "name '%.200s' is not defined", PyString_AS_STRING(name)); -#endif - } - return result; -} - -/* TupleAndListFromArray */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { - PyObject *v; - Py_ssize_t i; - for (i = 0; i < length; i++) { - v = dest[i] = src[i]; - Py_INCREF(v); - } -} -static CYTHON_INLINE PyObject * -__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) -{ - PyObject *res; - if (n <= 0) { - Py_INCREF(__pyx_empty_tuple); - return __pyx_empty_tuple; - } - res = PyTuple_New(n); - if (unlikely(res == NULL)) return NULL; - __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); - return res; -} -static CYTHON_INLINE PyObject * -__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) -{ - PyObject *res; - if (n <= 0) { - return PyList_New(0); - } - res = PyList_New(n); - if (unlikely(res == NULL)) return NULL; - __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); - return res; -} -#endif - -/* BytesEquals */ -static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { -#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API - 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_VERSION_HEX < 0x030B0000) - 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 || CYTHON_COMPILING_IN_LIMITED_API - 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); - } -#endif - if (s1_is_unicode & s2_is_unicode) { - Py_ssize_t length; - int kind; - void *data1, *data2; - if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) - return -1; - length = __Pyx_PyUnicode_GET_LENGTH(s1); - if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { - goto return_ne; - } -#if CYTHON_USE_UNICODE_INTERNALS - { - Py_hash_t hash1, hash2; - #if CYTHON_PEP393_ENABLED - hash1 = ((PyASCIIObject*)s1)->hash; - hash2 = ((PyASCIIObject*)s2)->hash; - #else - hash1 = ((PyUnicodeObject*)s1)->hash; - hash2 = ((PyUnicodeObject*)s2)->hash; - #endif - if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { - goto return_ne; - } - } -#endif - kind = __Pyx_PyUnicode_KIND(s1); - if (kind != __Pyx_PyUnicode_KIND(s2)) { - goto return_ne; - } - data1 = __Pyx_PyUnicode_DATA(s1); - data2 = __Pyx_PyUnicode_DATA(s2); - if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { - goto return_ne; - } else if (length == 1) { - goto return_eq; - } else { - int result = memcmp(data1, data2, (size_t)(length * kind)); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - return (equals == Py_EQ) ? (result == 0) : (result != 0); - } - } else if ((s1 == Py_None) & s2_is_unicode) { - goto return_ne; - } else if ((s2 == Py_None) & s1_is_unicode) { - goto return_ne; - } else { - int result; - PyObject* py_result = PyObject_RichCompare(s1, s2, equals); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - if (!py_result) - return -1; - result = __Pyx_PyObject_IsTrue(py_result); - Py_DECREF(py_result); - return result; - } -return_eq: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - return (equals == Py_EQ); -return_ne: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - return (equals == Py_NE); -#endif -} - -/* fastcall */ -#if CYTHON_METH_FASTCALL -static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) -{ - Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames); - for (i = 0; i < n; i++) - { - if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i]; - } - for (i = 0; i < n; i++) - { - int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ); - if (unlikely(eq != 0)) { - if (unlikely(eq < 0)) return NULL; - return kwvalues[i]; - } - } - return NULL; -} -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 -CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { - Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames); - PyObject *dict; - dict = PyDict_New(); - if (unlikely(!dict)) - return NULL; - for (i=0; i= 3 - "%s() got multiple values for keyword argument '%U'", func_name, kw_name); - #else - "%s() got multiple values for keyword argument '%s'", func_name, - PyString_AsString(kw_name)); - #endif -} - -/* ParseKeywords */ -static int __Pyx_ParseOptionalKeywords( - PyObject *kwds, - PyObject *const *kwvalues, - PyObject **argnames[], - PyObject *kwds2, - PyObject *values[], - Py_ssize_t num_pos_args, - const char* function_name) -{ - PyObject *key = 0, *value = 0; - Py_ssize_t pos = 0; - PyObject*** name; - PyObject*** first_kw_arg = argnames + num_pos_args; - int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)); - while (1) { - Py_XDECREF(key); key = NULL; - Py_XDECREF(value); value = NULL; - if (kwds_is_tuple) { - Py_ssize_t size; -#if CYTHON_ASSUME_SAFE_MACROS - size = PyTuple_GET_SIZE(kwds); -#else - size = PyTuple_Size(kwds); - if (size < 0) goto bad; -#endif - if (pos >= size) break; -#if CYTHON_AVOID_BORROWED_REFS - key = __Pyx_PySequence_ITEM(kwds, pos); - if (!key) goto bad; -#elif CYTHON_ASSUME_SAFE_MACROS - key = PyTuple_GET_ITEM(kwds, pos); -#else - key = PyTuple_GetItem(kwds, pos); - if (!key) goto bad; -#endif - value = kwvalues[pos]; - pos++; - } - else - { - if (!PyDict_Next(kwds, &pos, &key, &value)) break; -#if CYTHON_AVOID_BORROWED_REFS - Py_INCREF(key); -#endif - } - name = first_kw_arg; - while (*name && (**name != key)) name++; - if (*name) { - values[name-argnames] = value; -#if CYTHON_AVOID_BORROWED_REFS - Py_INCREF(value); - Py_DECREF(key); -#endif - key = NULL; - value = NULL; - continue; - } -#if !CYTHON_AVOID_BORROWED_REFS - Py_INCREF(key); -#endif - Py_INCREF(value); - name = first_kw_arg; - #if PY_MAJOR_VERSION < 3 - if (likely(PyString_Check(key))) { - while (*name) { - if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) - && _PyString_Eq(**name, key)) { - values[name-argnames] = value; -#if CYTHON_AVOID_BORROWED_REFS - value = NULL; -#endif - break; - } - name++; - } - if (*name) continue; - else { - PyObject*** argname = argnames; - while (argname != first_kw_arg) { - if ((**argname == key) || ( - (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) - && _PyString_Eq(**argname, key))) { - goto arg_passed_twice; - } - argname++; - } - } - } else - #endif - if (likely(PyUnicode_Check(key))) { - while (*name) { - int cmp = ( - #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : - #endif - PyUnicode_Compare(**name, key) - ); - if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; - if (cmp == 0) { - values[name-argnames] = value; -#if CYTHON_AVOID_BORROWED_REFS - value = NULL; -#endif - break; - } - name++; - } - if (*name) continue; - else { - PyObject*** argname = argnames; - 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 : - #endif - PyUnicode_Compare(**argname, key); - if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; - if (cmp == 0) goto arg_passed_twice; - argname++; - } - } - } else - goto invalid_keyword_type; - if (kwds2) { - if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; - } else { - goto invalid_keyword; - } - } - Py_XDECREF(key); - Py_XDECREF(value); - return 0; -arg_passed_twice: - __Pyx_RaiseDoubleKeywordsError(function_name, key); - goto bad; -invalid_keyword_type: - PyErr_Format(PyExc_TypeError, - "%.200s() keywords must be strings", function_name); - goto bad; -invalid_keyword: - #if PY_MAJOR_VERSION < 3 - PyErr_Format(PyExc_TypeError, - "%.200s() got an unexpected keyword argument '%.200s'", - function_name, PyString_AsString(key)); - #else - PyErr_Format(PyExc_TypeError, - "%s() got an unexpected keyword argument '%U'", - function_name, key); - #endif -bad: - Py_XDECREF(key); - Py_XDECREF(value); - return -1; -} - -/* ArgTypeTest */ -static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) -{ - __Pyx_TypeName type_name; - __Pyx_TypeName obj_type_name; - 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; - } - type_name = __Pyx_PyType_GetName(type); - obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); - PyErr_Format(PyExc_TypeError, - "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME - ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name); - __Pyx_DECREF_TypeName(type_name); - __Pyx_DECREF_TypeName(obj_type_name); - return 0; -} - -/* RaiseException */ -#if PY_MAJOR_VERSION < 3 -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { - __Pyx_PyThreadState_declare - CYTHON_UNUSED_VAR(cause); - 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 PY_VERSION_HEX >= 0x030C00A6 - PyException_SetTraceback(value, tb); - #elif CYTHON_FAST_THREAD_STATE - 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); - } -#else - 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); -#endif - } -bad: - Py_XDECREF(owned_instance); - return; -} -#endif - -/* PyFunctionFastCall */ -#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL -static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, - PyObject *globals) { - PyFrameObject *f; - PyThreadState *tstate = __Pyx_PyThreadState_Current; - PyObject **fastlocals; - Py_ssize_t i; - PyObject *result; - assert(globals != NULL); - /* XXX Perhaps we should create a specialized - PyFrame_New() that doesn't take locals, but does - take builtins without sanity checking them. - */ - assert(tstate != NULL); - f = PyFrame_New(tstate, co, globals, NULL); - if (f == NULL) { - return NULL; - } - fastlocals = __Pyx_PyFrame_GetLocalsplus(f); - for (i = 0; i < na; i++) { - Py_INCREF(*args); - fastlocals[i] = *args++; - } - result = PyEval_EvalFrameEx(f,0); - ++tstate->recursion_depth; - Py_DECREF(f); - --tstate->recursion_depth; - return result; -} -static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { - PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); - PyObject *globals = PyFunction_GET_GLOBALS(func); - PyObject *argdefs = PyFunction_GET_DEFAULTS(func); - PyObject *closure; -#if PY_MAJOR_VERSION >= 3 - PyObject *kwdefs; -#endif - PyObject *kwtuple, **k; - PyObject **d; - Py_ssize_t nd; - Py_ssize_t nk; - PyObject *result; - assert(kwargs == NULL || PyDict_Check(kwargs)); - nk = kwargs ? PyDict_Size(kwargs) : 0; - #if PY_MAJOR_VERSION < 3 - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) { - return NULL; - } - #else - if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { - return NULL; - } - #endif - if ( -#if PY_MAJOR_VERSION >= 3 - co->co_kwonlyargcount == 0 && -#endif - likely(kwargs == NULL || nk == 0) && - co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { - if (argdefs == NULL && co->co_argcount == nargs) { - result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); - goto done; - } - else if (nargs == 0 && argdefs != NULL - && co->co_argcount == Py_SIZE(argdefs)) { - /* function called with no arguments, but all parameters have - a default value: use default values as arguments .*/ - args = &PyTuple_GET_ITEM(argdefs, 0); - result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); - goto done; - } - } - if (kwargs != NULL) { - Py_ssize_t pos, i; - kwtuple = PyTuple_New(2 * nk); - if (kwtuple == NULL) { - result = NULL; - goto done; - } - k = &PyTuple_GET_ITEM(kwtuple, 0); - pos = i = 0; - while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { - Py_INCREF(k[i]); - Py_INCREF(k[i+1]); - i += 2; - } - nk = i / 2; - } - else { - kwtuple = NULL; - k = NULL; - } - closure = PyFunction_GET_CLOSURE(func); -#if PY_MAJOR_VERSION >= 3 - kwdefs = PyFunction_GET_KW_DEFAULTS(func); -#endif - if (argdefs != NULL) { - d = &PyTuple_GET_ITEM(argdefs, 0); - nd = Py_SIZE(argdefs); - } - else { - d = NULL; - nd = 0; - } -#if PY_MAJOR_VERSION >= 3 - result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, kwdefs, closure); -#else - result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, closure); -#endif - Py_XDECREF(kwtuple); -done: - Py_LeaveRecursiveCall(); - return result; -} -#endif - -/* PyObjectCall */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { - PyObject *result; - ternaryfunc call = Py_TYPE(func)->tp_call; - if (unlikely(!call)) - return PyObject_Call(func, arg, kw); - #if PY_MAJOR_VERSION < 3 - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - #else - if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) - return NULL; - #endif - result = (*call)(func, arg, kw); - Py_LeaveRecursiveCall(); - if (unlikely(!result) && unlikely(!PyErr_Occurred())) { - PyErr_SetString( - PyExc_SystemError, - "NULL result without error in PyObject_Call"); - } - return result; -} -#endif - -/* PyObjectCallMethO */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { - PyObject *self, *result; - PyCFunction cfunc; - cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); - self = __Pyx_CyOrPyCFunction_GET_SELF(func); - #if PY_MAJOR_VERSION < 3 - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - #else - if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) - return NULL; - #endif - result = cfunc(self, arg); - Py_LeaveRecursiveCall(); - if (unlikely(!result) && unlikely(!PyErr_Occurred())) { - PyErr_SetString( - PyExc_SystemError, - "NULL result without error in PyObject_Call"); - } - return result; -} -#endif - -/* PyObjectFastCall */ -#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API -static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) { - PyObject *argstuple; - PyObject *result = 0; - size_t i; - argstuple = PyTuple_New((Py_ssize_t)nargs); - if (unlikely(!argstuple)) return NULL; - for (i = 0; i < nargs; i++) { - Py_INCREF(args[i]); - if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad; - } - result = __Pyx_PyObject_Call(func, argstuple, kwargs); - bad: - Py_DECREF(argstuple); - return result; -} -#endif -static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) { - Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); -#if CYTHON_COMPILING_IN_CPYTHON - if (nargs == 0 && kwargs == NULL) { - if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) - return __Pyx_PyObject_CallMethO(func, NULL); - } - else if (nargs == 1 && kwargs == NULL) { - if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) - return __Pyx_PyObject_CallMethO(func, args[0]); - } -#endif - #if PY_VERSION_HEX < 0x030800B1 - #if CYTHON_FAST_PYCCALL - if (PyCFunction_Check(func)) { - if (kwargs) { - return _PyCFunction_FastCallDict(func, args, nargs, kwargs); - } else { - return _PyCFunction_FastCallKeywords(func, args, nargs, NULL); - } - } - #if PY_VERSION_HEX >= 0x030700A1 - if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { - return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); - } - #endif - #endif - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(func)) { - return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs); - } - #endif - #endif - if (kwargs == NULL) { - #if CYTHON_VECTORCALL - #if PY_VERSION_HEX < 0x03090000 - vectorcallfunc f = _PyVectorcall_Function(func); - #else - vectorcallfunc f = PyVectorcall_Function(func); - #endif - if (f) { - return f(func, args, (size_t)nargs, NULL); - } - #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL - if (__Pyx_CyFunction_CheckExact(func)) { - __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func); - if (f) return f(func, args, (size_t)nargs, NULL); - } - #endif - } - if (nargs == 0) { - return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs); - } - #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API - return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); - #else - return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); - #endif -} - -/* RaiseUnexpectedTypeError */ -static int -__Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj) -{ - __Pyx_TypeName obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); - PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME, - expected, obj_type_name); - __Pyx_DECREF_TypeName(obj_type_name); - return 0; -} - -/* CIntToDigits */ -static const char DIGIT_PAIRS_10[2*10*10+1] = { - "00010203040506070809" - "10111213141516171819" - "20212223242526272829" - "30313233343536373839" - "40414243444546474849" - "50515253545556575859" - "60616263646566676869" - "70717273747576777879" - "80818283848586878889" - "90919293949596979899" -}; -static const char DIGIT_PAIRS_8[2*8*8+1] = { - "0001020304050607" - "1011121314151617" - "2021222324252627" - "3031323334353637" - "4041424344454647" - "5051525354555657" - "6061626364656667" - "7071727374757677" -}; -static const char DIGITS_HEX[2*16+1] = { - "0123456789abcdef" - "0123456789ABCDEF" -}; - -/* BuildPyUnicode */ -static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, char* chars, int clength, - int prepend_sign, char padding_char) { - PyObject *uval; - Py_ssize_t uoffset = ulength - clength; -#if CYTHON_USE_UNICODE_INTERNALS - Py_ssize_t i; -#if CYTHON_PEP393_ENABLED - void *udata; - uval = PyUnicode_New(ulength, 127); - if (unlikely(!uval)) return NULL; - udata = PyUnicode_DATA(uval); -#else - Py_UNICODE *udata; - uval = PyUnicode_FromUnicode(NULL, ulength); - if (unlikely(!uval)) return NULL; - udata = PyUnicode_AS_UNICODE(uval); -#endif - if (uoffset > 0) { - i = 0; - if (prepend_sign) { - __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, 0, '-'); - i++; - } - for (; i < uoffset; i++) { - __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, i, padding_char); - } - } - for (i=0; i < clength; i++) { - __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, uoffset+i, chars[i]); - } -#else - { - PyObject *sign = NULL, *padding = NULL; - uval = NULL; - if (uoffset > 0) { - prepend_sign = !!prepend_sign; - if (uoffset > prepend_sign) { - padding = PyUnicode_FromOrdinal(padding_char); - if (likely(padding) && uoffset > prepend_sign + 1) { - PyObject *tmp; - PyObject *repeat = PyInt_FromSsize_t(uoffset - prepend_sign); - if (unlikely(!repeat)) goto done_or_error; - tmp = PyNumber_Multiply(padding, repeat); - Py_DECREF(repeat); - Py_DECREF(padding); - padding = tmp; - } - if (unlikely(!padding)) goto done_or_error; - } - if (prepend_sign) { - sign = PyUnicode_FromOrdinal('-'); - if (unlikely(!sign)) goto done_or_error; - } - } - uval = PyUnicode_DecodeASCII(chars, clength, NULL); - if (likely(uval) && padding) { - PyObject *tmp = PyNumber_Add(padding, uval); - Py_DECREF(uval); - uval = tmp; - } - if (likely(uval) && sign) { - PyObject *tmp = PyNumber_Add(sign, uval); - Py_DECREF(uval); - uval = tmp; - } -done_or_error: - Py_XDECREF(padding); - Py_XDECREF(sign); - } -#endif - return uval; -} - -/* CIntToPyUnicode */ -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char) { - char digits[sizeof(int)*3+2]; - char *dpos, *end = digits + sizeof(int)*3+2; - const char *hex_digits = DIGITS_HEX; - Py_ssize_t length, ulength; - int prepend_sign, last_one_off; - int remaining; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const int neg_one = (int) -1, const_zero = (int) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; - if (format_char == 'X') { - hex_digits += 16; - format_char = 'x'; - } - remaining = value; - last_one_off = 0; - dpos = end; - do { - int digit_pos; - switch (format_char) { - case 'o': - digit_pos = abs((int)(remaining % (8*8))); - remaining = (int) (remaining / (8*8)); - dpos -= 2; - memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2); - last_one_off = (digit_pos < 8); - break; - case 'd': - digit_pos = abs((int)(remaining % (10*10))); - remaining = (int) (remaining / (10*10)); - dpos -= 2; - memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2); - last_one_off = (digit_pos < 10); - break; - case 'x': - *(--dpos) = hex_digits[abs((int)(remaining % 16))]; - remaining = (int) (remaining / 16); - break; - default: - assert(0); - break; - } - } while (unlikely(remaining != 0)); - assert(!last_one_off || *dpos == '0'); - dpos += last_one_off; - length = end - dpos; - ulength = length; - prepend_sign = 0; - if (!is_unsigned && value <= neg_one) { - if (padding_char == ' ' || width <= length + 1) { - *(--dpos) = '-'; - ++length; - } else { - prepend_sign = 1; - } - ++ulength; - } - if (width > ulength) { - ulength = width; - } - if (ulength == 1) { - return PyUnicode_FromOrdinal(*dpos); - } - return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char); -} - -/* CIntToPyUnicode */ -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char) { - char digits[sizeof(Py_ssize_t)*3+2]; - char *dpos, *end = digits + sizeof(Py_ssize_t)*3+2; - const char *hex_digits = DIGITS_HEX; - Py_ssize_t length, ulength; - int prepend_sign, last_one_off; - Py_ssize_t remaining; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const Py_ssize_t neg_one = (Py_ssize_t) -1, const_zero = (Py_ssize_t) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; - if (format_char == 'X') { - hex_digits += 16; - format_char = 'x'; - } - remaining = value; - last_one_off = 0; - dpos = end; - do { - int digit_pos; - switch (format_char) { - case 'o': - digit_pos = abs((int)(remaining % (8*8))); - remaining = (Py_ssize_t) (remaining / (8*8)); - dpos -= 2; - memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2); - last_one_off = (digit_pos < 8); - break; - case 'd': - digit_pos = abs((int)(remaining % (10*10))); - remaining = (Py_ssize_t) (remaining / (10*10)); - dpos -= 2; - memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2); - last_one_off = (digit_pos < 10); - break; - case 'x': - *(--dpos) = hex_digits[abs((int)(remaining % 16))]; - remaining = (Py_ssize_t) (remaining / 16); - break; - default: - assert(0); - break; - } - } while (unlikely(remaining != 0)); - assert(!last_one_off || *dpos == '0'); - dpos += last_one_off; - length = end - dpos; - ulength = length; - prepend_sign = 0; - if (!is_unsigned && value <= neg_one) { - if (padding_char == ' ' || width <= length + 1) { - *(--dpos) = '-'; - ++length; - } else { - prepend_sign = 1; - } - ++ulength; - } - if (width > ulength) { - ulength = width; - } - if (ulength == 1) { - return PyUnicode_FromOrdinal(*dpos); - } - return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char); -} - -/* JoinPyUnicode */ -static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, - Py_UCS4 max_char) { -#if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - PyObject *result_uval; - int result_ukind, kind_shift; - Py_ssize_t i, char_pos; - void *result_udata; - CYTHON_MAYBE_UNUSED_VAR(max_char); -#if CYTHON_PEP393_ENABLED - result_uval = PyUnicode_New(result_ulength, max_char); - if (unlikely(!result_uval)) return NULL; - result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND; - kind_shift = (result_ukind == PyUnicode_4BYTE_KIND) ? 2 : result_ukind - 1; - result_udata = PyUnicode_DATA(result_uval); -#else - result_uval = PyUnicode_FromUnicode(NULL, result_ulength); - if (unlikely(!result_uval)) return NULL; - result_ukind = sizeof(Py_UNICODE); - kind_shift = (result_ukind == 4) ? 2 : result_ukind - 1; - result_udata = PyUnicode_AS_UNICODE(result_uval); -#endif - assert(kind_shift == 2 || kind_shift == 1 || kind_shift == 0); - char_pos = 0; - for (i=0; i < value_count; i++) { - int ukind; - Py_ssize_t ulength; - void *udata; - PyObject *uval = PyTuple_GET_ITEM(value_tuple, i); - if (unlikely(__Pyx_PyUnicode_READY(uval))) - goto bad; - ulength = __Pyx_PyUnicode_GET_LENGTH(uval); - if (unlikely(!ulength)) - continue; - if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - ulength < char_pos)) - goto overflow; - ukind = __Pyx_PyUnicode_KIND(uval); - udata = __Pyx_PyUnicode_DATA(uval); - if (!CYTHON_PEP393_ENABLED || ukind == result_ukind) { - memcpy((char *)result_udata + (char_pos << kind_shift), udata, (size_t) (ulength << kind_shift)); - } else { - #if PY_VERSION_HEX >= 0x030d0000 - if (unlikely(PyUnicode_CopyCharacters(result_uval, char_pos, uval, 0, ulength) < 0)) goto bad; - #elif CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030300F0 || defined(_PyUnicode_FastCopyCharacters) - _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength); - #else - Py_ssize_t j; - for (j=0; j < ulength; j++) { - Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j); - __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar); - } - #endif - } - char_pos += ulength; - } - return result_uval; -overflow: - PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string"); -bad: - Py_DECREF(result_uval); - return NULL; -#else - CYTHON_UNUSED_VAR(max_char); - CYTHON_UNUSED_VAR(result_ulength); - CYTHON_UNUSED_VAR(value_count); - return PyUnicode_Join(__pyx_empty_unicode, value_tuple); -#endif -} - -/* GetAttr */ -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))) -#else - if (likely(PyString_Check(n))) -#endif - return __Pyx_PyObject_GetAttrStr(o, n); -#endif - return PyObject_GetAttr(o, n); -} - -/* GetItemInt */ -static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { - PyObject *r; - if (unlikely(!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 { - PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; - PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; - if (mm && mm->mp_subscript) { - PyObject *r, *key = PyInt_FromSsize_t(i); - if (unlikely(!key)) return NULL; - r = mm->mp_subscript(o, key); - Py_DECREF(key); - return r; - } - if (likely(sm && sm->sq_item)) { - if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { - Py_ssize_t l = sm->sq_length(o); - if (likely(l >= 0)) { - i += l; - } else { - if (!PyErr_ExceptionMatches(PyExc_OverflowError)) - return NULL; - PyErr_Clear(); - } - } - return sm->sq_item(o, i); - } - } -#else - if (is_list || !PyMapping_Check(o)) { - return PySequence_GetItem(o, i); - } -#endif - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); -} - -/* PyObjectCallOneArg */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *args[2] = {NULL, arg}; - return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); -} - -/* ObjectGetItem */ -#if CYTHON_USE_TYPE_SLOTS -static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject *index) { - PyObject *runerr = NULL; - Py_ssize_t key_value; - key_value = __Pyx_PyIndex_AsSsize_t(index); - if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { - return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); - } - if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { - __Pyx_TypeName index_type_name = __Pyx_PyType_GetName(Py_TYPE(index)); - PyErr_Clear(); - PyErr_Format(PyExc_IndexError, - "cannot fit '" __Pyx_FMT_TYPENAME "' into an index-sized integer", index_type_name); - __Pyx_DECREF_TypeName(index_type_name); - } - return NULL; -} -static PyObject *__Pyx_PyObject_GetItem_Slow(PyObject *obj, PyObject *key) { - __Pyx_TypeName obj_type_name; - if (likely(PyType_Check(obj))) { - PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(obj, __pyx_n_s_class_getitem); - if (!meth) { - PyErr_Clear(); - } else { - PyObject *result = __Pyx_PyObject_CallOneArg(meth, key); - Py_DECREF(meth); - return result; - } - } - obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); - PyErr_Format(PyExc_TypeError, - "'" __Pyx_FMT_TYPENAME "' object is not subscriptable", obj_type_name); - __Pyx_DECREF_TypeName(obj_type_name); - return NULL; -} -static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key) { - PyTypeObject *tp = Py_TYPE(obj); - PyMappingMethods *mm = tp->tp_as_mapping; - PySequenceMethods *sm = tp->tp_as_sequence; - if (likely(mm && mm->mp_subscript)) { - return mm->mp_subscript(obj, key); - } - if (likely(sm && sm->sq_item)) { - return __Pyx_PyObject_GetIndex(obj, key); - } - return __Pyx_PyObject_GetItem_Slow(obj, key); -} -#endif - -/* KeywordStringCheck */ -static int __Pyx_CheckKeywordStrings( - PyObject *kw, - const char* function_name, - int kw_allowed) -{ - PyObject* key = 0; - Py_ssize_t pos = 0; -#if CYTHON_COMPILING_IN_PYPY - if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0)) - goto invalid_keyword; - return 1; -#else - if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) { - Py_ssize_t kwsize; -#if CYTHON_ASSUME_SAFE_MACROS - kwsize = PyTuple_GET_SIZE(kw); -#else - kwsize = PyTuple_Size(kw); - if (kwsize < 0) return 0; -#endif - if (unlikely(kwsize == 0)) - return 1; - if (!kw_allowed) { -#if CYTHON_ASSUME_SAFE_MACROS - key = PyTuple_GET_ITEM(kw, 0); -#else - key = PyTuple_GetItem(kw, pos); - if (!key) return 0; -#endif - goto invalid_keyword; - } -#if PY_VERSION_HEX < 0x03090000 - for (pos = 0; pos < kwsize; pos++) { -#if CYTHON_ASSUME_SAFE_MACROS - key = PyTuple_GET_ITEM(kw, pos); -#else - key = PyTuple_GetItem(kw, pos); - if (!key) return 0; -#endif - if (unlikely(!PyUnicode_Check(key))) - goto invalid_keyword_type; - } -#endif - return 1; - } - while (PyDict_Next(kw, &pos, &key, 0)) { - #if PY_MAJOR_VERSION < 3 - if (unlikely(!PyString_Check(key))) - #endif - if (unlikely(!PyUnicode_Check(key))) - goto invalid_keyword_type; - } - if (!kw_allowed && unlikely(key)) - goto invalid_keyword; - return 1; -invalid_keyword_type: - PyErr_Format(PyExc_TypeError, - "%.200s() keywords must be strings", function_name); - return 0; -#endif -invalid_keyword: - #if PY_MAJOR_VERSION < 3 - PyErr_Format(PyExc_TypeError, - "%.200s() got an unexpected keyword argument '%.200s'", - function_name, PyString_AsString(key)); - #else - PyErr_Format(PyExc_TypeError, - "%s() got an unexpected keyword argument '%U'", - function_name, key); - #endif - return 0; -} - -/* DivInt[Py_ssize_t] */ -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)); - return q; -} - -/* GetAttr3 */ -#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 -static PyObject *__Pyx_GetAttr3Default(PyObject *d) { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) - return NULL; - __Pyx_PyErr_Clear(); - Py_INCREF(d); - return d; -} -#endif -static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { - PyObject *r; -#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 - int res = PyObject_GetOptionalAttr(o, n, &r); - return (res != 0) ? r : __Pyx_NewRef(d); -#else - #if CYTHON_USE_TYPE_SLOTS - if (likely(PyString_Check(n))) { - r = __Pyx_PyObject_GetAttrStrNoError(o, n); - if (unlikely(!r) && likely(!PyErr_Occurred())) { - r = __Pyx_NewRef(d); - } - return r; - } - #endif - r = PyObject_GetAttr(o, n); - return (likely(r)) ? r : __Pyx_GetAttr3Default(d); -#endif -} - -/* PyDictVersioning */ -#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { - PyObject *dict = Py_TYPE(obj)->tp_dict; - return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; -} -static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { - PyObject **dictptr = NULL; - Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; - if (offset) { -#if CYTHON_COMPILING_IN_CPYTHON - dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); -#else - dictptr = _PyObject_GetDictPtr(obj); -#endif - } - return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; -} -static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { - PyObject *dict = Py_TYPE(obj)->tp_dict; - if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) - return 0; - return obj_dict_version == __Pyx_get_object_dict_version(obj); -} -#endif - -/* GetModuleGlobalName */ -#if CYTHON_USE_DICT_VERSIONS -static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) -#else -static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) -#endif -{ - PyObject *result; -#if !CYTHON_AVOID_BORROWED_REFS -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000 - result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } else if (unlikely(PyErr_Occurred())) { - return NULL; - } -#elif CYTHON_COMPILING_IN_LIMITED_API - if (unlikely(!__pyx_m)) { - return NULL; - } - result = PyObject_GetAttr(__pyx_m, name); - if (likely(result)) { - return result; - } -#else - result = PyDict_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } -#endif -#else - result = PyObject_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } - PyErr_Clear(); -#endif - return __Pyx_GetBuiltinName(name); -} - -/* 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 */ -static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { - __Pyx_TypeName obj_type_name; - __Pyx_TypeName type_name; - if (unlikely(!type)) { - PyErr_SetString(PyExc_SystemError, "Missing type object"); - return 0; - } - if (likely(__Pyx_TypeCheck(obj, type))) - return 1; - obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); - type_name = __Pyx_PyType_GetName(type); - PyErr_Format(PyExc_TypeError, - "Cannot convert " __Pyx_FMT_TYPENAME " to " __Pyx_FMT_TYPENAME, - obj_type_name, type_name); - __Pyx_DECREF_TypeName(obj_type_name); - __Pyx_DECREF_TypeName(type_name); - return 0; -} - -/* GetTopmostException */ -#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE -static _PyErr_StackItem * -__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) -{ - _PyErr_StackItem *exc_info = tstate->exc_info; - while ((exc_info->exc_value == NULL || exc_info->exc_value == 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 && PY_VERSION_HEX >= 0x030B00a4 - _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); - PyObject *exc_value = exc_info->exc_value; - if (exc_value == NULL || exc_value == Py_None) { - *value = NULL; - *type = NULL; - *tb = NULL; - } else { - *value = exc_value; - Py_INCREF(*value); - *type = (PyObject*) Py_TYPE(exc_value); - Py_INCREF(*type); - *tb = PyException_GetTraceback(exc_value); - } - #elif 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; - Py_XINCREF(*type); - Py_XINCREF(*value); - Py_XINCREF(*tb); - #else - *type = tstate->exc_type; - *value = tstate->exc_value; - *tb = tstate->exc_traceback; - Py_XINCREF(*type); - Py_XINCREF(*value); - Py_XINCREF(*tb); - #endif -} -static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 - _PyErr_StackItem *exc_info = tstate->exc_info; - PyObject *tmp_value = exc_info->exc_value; - exc_info->exc_value = value; - Py_XDECREF(tmp_value); - Py_XDECREF(type); - Py_XDECREF(tb); - #else - 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 -} -#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 = NULL, *local_value, *local_tb = NULL; -#if CYTHON_FAST_THREAD_STATE - PyObject *tmp_type, *tmp_value, *tmp_tb; - #if PY_VERSION_HEX >= 0x030C00A6 - local_value = tstate->current_exception; - tstate->current_exception = 0; - if (likely(local_value)) { - local_type = (PyObject*) Py_TYPE(local_value); - Py_INCREF(local_type); - local_tb = PyException_GetTraceback(local_value); - } - #else - 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; - #endif -#else - PyErr_Fetch(&local_type, &local_value, &local_tb); -#endif - PyErr_NormalizeException(&local_type, &local_value, &local_tb); -#if CYTHON_FAST_THREAD_STATE && PY_VERSION_HEX >= 0x030C00A6 - if (unlikely(tstate->current_exception)) -#elif 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; - #if PY_VERSION_HEX >= 0x030B00a4 - tmp_value = exc_info->exc_value; - exc_info->exc_value = local_value; - tmp_type = NULL; - tmp_tb = NULL; - Py_XDECREF(local_type); - Py_XDECREF(local_tb); - #else - 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; - #endif - } - #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; -} - -/* SwapException */ -#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 && PY_VERSION_HEX >= 0x030B00a4 - _PyErr_StackItem *exc_info = tstate->exc_info; - tmp_value = exc_info->exc_value; - exc_info->exc_value = *value; - if (tmp_value == NULL || tmp_value == Py_None) { - Py_XDECREF(tmp_value); - tmp_value = NULL; - tmp_type = NULL; - tmp_tb = NULL; - } else { - tmp_type = (PyObject*) Py_TYPE(tmp_value); - Py_INCREF(tmp_type); - #if CYTHON_COMPILING_IN_CPYTHON - tmp_tb = ((PyBaseExceptionObject*) tmp_value)->traceback; - Py_XINCREF(tmp_tb); - #else - tmp_tb = PyException_GetTraceback(tmp_value); - #endif - } - #elif 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 - *type = tmp_type; - *value = tmp_value; - *tb = tmp_tb; -} -#else -static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); - PyErr_SetExcInfo(*type, *value, *tb); - *type = tmp_type; - *value = tmp_value; - *tb = tmp_tb; -} -#endif - -/* Import */ -static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { - PyObject *module = 0; - PyObject *empty_dict = 0; - PyObject *empty_list = 0; - #if PY_MAJOR_VERSION < 3 - PyObject *py_import; - py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); - if (unlikely(!py_import)) - goto bad; - if (!from_list) { - empty_list = PyList_New(0); - if (unlikely(!empty_list)) - goto bad; - from_list = empty_list; - } - #endif - empty_dict = PyDict_New(); - if (unlikely(!empty_dict)) - goto bad; - { - #if PY_MAJOR_VERSION >= 3 - if (level == -1) { - if (strchr(__Pyx_MODULE_NAME, '.') != NULL) { - module = PyImport_ImportModuleLevelObject( - name, __pyx_d, empty_dict, from_list, 1); - if (unlikely(!module)) { - if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) - goto bad; - PyErr_Clear(); - } - } - level = 0; - } - #endif - if (!module) { - #if PY_MAJOR_VERSION < 3 - PyObject *py_level = PyInt_FromLong(level); - if (unlikely(!py_level)) - goto bad; - module = PyObject_CallFunctionObjArgs(py_import, - name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL); - Py_DECREF(py_level); - #else - module = PyImport_ImportModuleLevelObject( - name, __pyx_d, empty_dict, from_list, level); - #endif - } - } -bad: - Py_XDECREF(empty_dict); - Py_XDECREF(empty_list); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(py_import); - #endif - return module; -} - -/* ImportDottedModule */ -#if PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx__ImportDottedModule_Error(PyObject *name, PyObject *parts_tuple, Py_ssize_t count) { - PyObject *partial_name = NULL, *slice = NULL, *sep = NULL; - if (unlikely(PyErr_Occurred())) { - PyErr_Clear(); - } - if (likely(PyTuple_GET_SIZE(parts_tuple) == count)) { - partial_name = name; - } else { - slice = PySequence_GetSlice(parts_tuple, 0, count); - if (unlikely(!slice)) - goto bad; - sep = PyUnicode_FromStringAndSize(".", 1); - if (unlikely(!sep)) - goto bad; - partial_name = PyUnicode_Join(sep, slice); - } - PyErr_Format( -#if PY_MAJOR_VERSION < 3 - PyExc_ImportError, - "No module named '%s'", PyString_AS_STRING(partial_name)); -#else -#if PY_VERSION_HEX >= 0x030600B1 - PyExc_ModuleNotFoundError, -#else - PyExc_ImportError, -#endif - "No module named '%U'", partial_name); -#endif -bad: - Py_XDECREF(sep); - Py_XDECREF(slice); - Py_XDECREF(partial_name); - return NULL; -} -#endif -#if PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx__ImportDottedModule_Lookup(PyObject *name) { - PyObject *imported_module; -#if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) - PyObject *modules = PyImport_GetModuleDict(); - if (unlikely(!modules)) - return NULL; - imported_module = __Pyx_PyDict_GetItemStr(modules, name); - Py_XINCREF(imported_module); -#else - imported_module = PyImport_GetModule(name); -#endif - return imported_module; -} -#endif -#if PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple) { - Py_ssize_t i, nparts; - nparts = PyTuple_GET_SIZE(parts_tuple); - for (i=1; i < nparts && module; i++) { - PyObject *part, *submodule; -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - part = PyTuple_GET_ITEM(parts_tuple, i); -#else - part = PySequence_ITEM(parts_tuple, i); -#endif - submodule = __Pyx_PyObject_GetAttrStrNoError(module, part); -#if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) - Py_DECREF(part); -#endif - Py_DECREF(module); - module = submodule; - } - if (unlikely(!module)) { - return __Pyx__ImportDottedModule_Error(name, parts_tuple, i); - } - return module; -} -#endif -static PyObject *__Pyx__ImportDottedModule(PyObject *name, PyObject *parts_tuple) { -#if PY_MAJOR_VERSION < 3 - PyObject *module, *from_list, *star = __pyx_n_s__3; - CYTHON_UNUSED_VAR(parts_tuple); - from_list = PyList_New(1); - if (unlikely(!from_list)) - return NULL; - Py_INCREF(star); - PyList_SET_ITEM(from_list, 0, star); - module = __Pyx_Import(name, from_list, 0); - Py_DECREF(from_list); - return module; -#else - PyObject *imported_module; - PyObject *module = __Pyx_Import(name, NULL, 0); - if (!parts_tuple || unlikely(!module)) - return module; - imported_module = __Pyx__ImportDottedModule_Lookup(name); - if (likely(imported_module)) { - Py_DECREF(module); - return imported_module; - } - PyErr_Clear(); - return __Pyx_ImportDottedModule_WalkParts(module, name, parts_tuple); -#endif -} -static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple) { -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030400B1 - PyObject *module = __Pyx__ImportDottedModule_Lookup(name); - if (likely(module)) { - PyObject *spec = __Pyx_PyObject_GetAttrStrNoError(module, __pyx_n_s_spec); - if (likely(spec)) { - PyObject *unsafe = __Pyx_PyObject_GetAttrStrNoError(spec, __pyx_n_s_initializing); - if (likely(!unsafe || !__Pyx_PyObject_IsTrue(unsafe))) { - Py_DECREF(spec); - spec = NULL; - } - Py_XDECREF(unsafe); - } - if (likely(!spec)) { - PyErr_Clear(); - return module; - } - Py_DECREF(spec); - Py_DECREF(module); - } else if (PyErr_Occurred()) { - PyErr_Clear(); - } -#endif - return __Pyx__ImportDottedModule(name, parts_tuple); -} - -/* FastTypeChecks */ -#if CYTHON_COMPILING_IN_CPYTHON -static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { - while (a) { - a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); - if (a == b) - return 1; - } - return b == &PyBaseObject_Type; -} -static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { - PyObject *mro; - if (a == b) return 1; - mro = a->tp_mro; - if (likely(mro)) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(mro); - for (i = 0; i < n; i++) { - if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) - return 1; - } - return 0; - } - return __Pyx_InBases(a, b); -} -static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { - PyObject *mro; - if (cls == a || cls == b) return 1; - mro = cls->tp_mro; - if (likely(mro)) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(mro); - for (i = 0; i < n; i++) { - PyObject *base = PyTuple_GET_ITEM(mro, i); - if (base == (PyObject *)a || base == (PyObject *)b) - return 1; - } - return 0; - } - return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); -} -#if PY_MAJOR_VERSION == 2 -static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { - PyObject *exception, *value, *tb; - int res; - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ErrFetch(&exception, &value, &tb); - res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; - if (unlikely(res == -1)) { - PyErr_WriteUnraisable(err); - res = 0; - } - if (!res) { - res = PyObject_IsSubclass(err, exc_type2); - if (unlikely(res == -1)) { - PyErr_WriteUnraisable(err); - res = 0; - } - } - __Pyx_ErrRestore(exception, value, tb); - return res; -} -#else -static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { - if (exc_type1) { - return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); - } else { - return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); - } -} -#endif -static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { - Py_ssize_t i, n; - assert(PyExceptionClass_Check(exc_type)); - n = PyTuple_GET_SIZE(tuple); -#if PY_MAJOR_VERSION >= 3 - for (i=0; itp_as_sequence && type->tp_as_sequence->sq_repeat)) { - return type->tp_as_sequence->sq_repeat(seq, mul); - } else -#endif - { - return __Pyx_PySequence_Multiply_Generic(seq, mul); - } -} - -/* SetItemInt */ -static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { - int r; - if (unlikely(!j)) return -1; - r = PyObject_SetItem(o, j, v); - Py_DECREF(j); - return r; -} -static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, 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) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o)); - if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o)))) { - PyObject* old = PyList_GET_ITEM(o, n); - Py_INCREF(v); - PyList_SET_ITEM(o, n, v); - Py_DECREF(old); - return 1; - } - } else { - PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; - PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; - if (mm && mm->mp_ass_subscript) { - int r; - PyObject *key = PyInt_FromSsize_t(i); - if (unlikely(!key)) return -1; - r = mm->mp_ass_subscript(o, key, v); - Py_DECREF(key); - return r; - } - if (likely(sm && sm->sq_ass_item)) { - if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { - Py_ssize_t l = sm->sq_length(o); - if (likely(l >= 0)) { - i += l; - } else { - if (!PyErr_ExceptionMatches(PyExc_OverflowError)) - return -1; - PyErr_Clear(); - } - } - return sm->sq_ass_item(o, i, v); - } - } -#else - if (is_list || !PyMapping_Check(o)) - { - return PySequence_SetItem(o, i, v); - } -#endif - return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v); -} - -/* RaiseUnboundLocalError */ -static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { - PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); -} - -/* DivInt[long] */ -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)); - return q; -} - -/* ImportFrom */ -static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { - PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); - if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { - const char* module_name_str = 0; - PyObject* module_name = 0; - PyObject* module_dot = 0; - PyObject* full_name = 0; - PyErr_Clear(); - module_name_str = PyModule_GetName(module); - if (unlikely(!module_name_str)) { goto modbad; } - module_name = PyUnicode_FromString(module_name_str); - if (unlikely(!module_name)) { goto modbad; } - module_dot = PyUnicode_Concat(module_name, __pyx_kp_u__2); - if (unlikely(!module_dot)) { goto modbad; } - full_name = PyUnicode_Concat(module_dot, name); - if (unlikely(!full_name)) { goto modbad; } - #if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) - { - PyObject *modules = PyImport_GetModuleDict(); - if (unlikely(!modules)) - goto modbad; - value = PyObject_GetItem(modules, full_name); - } - #else - value = PyImport_GetModule(full_name); - #endif - modbad: - Py_XDECREF(full_name); - Py_XDECREF(module_dot); - Py_XDECREF(module_name); - } - if (unlikely(!value)) { - PyErr_Format(PyExc_ImportError, - #if PY_MAJOR_VERSION < 3 - "cannot import name %.230s", PyString_AS_STRING(name)); - #else - "cannot import name %S", name); - #endif - } - return value; -} - -/* HasAttr */ -#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 -static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { - PyObject *r; - if (unlikely(!__Pyx_PyBaseString_Check(n))) { - PyErr_SetString(PyExc_TypeError, - "hasattr(): attribute name must be string"); - return -1; - } - r = __Pyx_GetAttr(o, n); - if (!r) { - PyErr_Clear(); - return 0; - } else { - Py_DECREF(r); - return 1; - } -} -#endif - -/* ErrOccurredWithGIL */ -static CYTHON_INLINE int __Pyx_ErrOccurredWithGIL(void) { - int err; - #ifdef WITH_THREAD - PyGILState_STATE _save = PyGILState_Ensure(); - #endif - err = !!PyErr_Occurred(); - #ifdef WITH_THREAD - PyGILState_Release(_save); - #endif - return err; -} - -/* PyObject_GenericGetAttrNoDict */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { - __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp); - PyErr_Format(PyExc_AttributeError, -#if PY_MAJOR_VERSION >= 3 - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", - type_name, attr_name); -#else - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", - type_name, PyString_AS_STRING(attr_name)); -#endif - __Pyx_DECREF_TypeName(type_name); - return NULL; -} -static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { - PyObject *descr; - PyTypeObject *tp = Py_TYPE(obj); - if (unlikely(!PyString_Check(attr_name))) { - return PyObject_GenericGetAttr(obj, attr_name); - } - assert(!tp->tp_dictoffset); - descr = _PyType_Lookup(tp, attr_name); - if (unlikely(!descr)) { - return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); - } - Py_INCREF(descr); - #if PY_MAJOR_VERSION < 3 - if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) - #endif - { - descrgetfunc f = Py_TYPE(descr)->tp_descr_get; - if (unlikely(f)) { - PyObject *res = f(descr, obj, (PyObject *)tp); - Py_DECREF(descr); - return res; - } - } - return descr; -} -#endif - -/* PyObject_GenericGetAttr */ -#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); - } - return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); -} -#endif - -/* FixUpExtensionType */ -#if CYTHON_USE_TYPE_SPECS -static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { -#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API - CYTHON_UNUSED_VAR(spec); - CYTHON_UNUSED_VAR(type); -#else - const PyType_Slot *slot = spec->slots; - while (slot && slot->slot && slot->slot != Py_tp_members) - slot++; - if (slot && slot->slot == Py_tp_members) { - int changed = 0; -#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON) - const -#endif - PyMemberDef *memb = (PyMemberDef*) slot->pfunc; - while (memb && memb->name) { - if (memb->name[0] == '_' && memb->name[1] == '_') { -#if PY_VERSION_HEX < 0x030900b1 - if (strcmp(memb->name, "__weaklistoffset__") == 0) { - assert(memb->type == T_PYSSIZET); - assert(memb->flags == READONLY); - type->tp_weaklistoffset = memb->offset; - changed = 1; - } - else if (strcmp(memb->name, "__dictoffset__") == 0) { - assert(memb->type == T_PYSSIZET); - assert(memb->flags == READONLY); - type->tp_dictoffset = memb->offset; - changed = 1; - } -#if CYTHON_METH_FASTCALL - else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { - assert(memb->type == T_PYSSIZET); - assert(memb->flags == READONLY); -#if PY_VERSION_HEX >= 0x030800b4 - type->tp_vectorcall_offset = memb->offset; -#else - type->tp_print = (printfunc) memb->offset; -#endif - changed = 1; - } -#endif -#else - if ((0)); -#endif -#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON - else if (strcmp(memb->name, "__module__") == 0) { - PyObject *descr; - assert(memb->type == T_OBJECT); - assert(memb->flags == 0 || memb->flags == READONLY); - descr = PyDescr_NewMember(type, memb); - if (unlikely(!descr)) - return -1; - if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) { - Py_DECREF(descr); - return -1; - } - Py_DECREF(descr); - changed = 1; - } -#endif - } - memb++; - } - if (changed) - PyType_Modified(type); - } -#endif - return 0; -} -#endif - -/* PyObjectCallNoArg */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { - PyObject *arg[2] = {NULL, NULL}; - return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); -} - -/* PyObjectGetMethod */ -static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { - PyObject *attr; -#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP - __Pyx_TypeName type_name; - PyTypeObject *tp = Py_TYPE(obj); - PyObject *descr; - descrgetfunc f = NULL; - PyObject **dictptr, *dict; - int meth_found = 0; - assert (*method == NULL); - if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { - attr = __Pyx_PyObject_GetAttrStr(obj, name); - goto try_unpack; - } - if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { - return 0; - } - descr = _PyType_Lookup(tp, name); - if (likely(descr != NULL)) { - Py_INCREF(descr); -#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR - if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) -#elif PY_MAJOR_VERSION >= 3 - #ifdef __Pyx_CyFunction_USED - if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) - #else - if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) - #endif -#else - #ifdef __Pyx_CyFunction_USED - if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) - #else - if (likely(PyFunction_Check(descr))) - #endif -#endif - { - meth_found = 1; - } else { - f = Py_TYPE(descr)->tp_descr_get; - if (f != NULL && PyDescr_IsData(descr)) { - attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); - Py_DECREF(descr); - goto try_unpack; - } - } - } - dictptr = _PyObject_GetDictPtr(obj); - if (dictptr != NULL && (dict = *dictptr) != NULL) { - Py_INCREF(dict); - attr = __Pyx_PyDict_GetItemStr(dict, name); - if (attr != NULL) { - Py_INCREF(attr); - Py_DECREF(dict); - Py_XDECREF(descr); - goto try_unpack; - } - Py_DECREF(dict); - } - if (meth_found) { - *method = descr; - return 1; - } - if (f != NULL) { - attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); - Py_DECREF(descr); - goto try_unpack; - } - if (likely(descr != NULL)) { - *method = descr; - return 0; - } - type_name = __Pyx_PyType_GetName(tp); - PyErr_Format(PyExc_AttributeError, -#if PY_MAJOR_VERSION >= 3 - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", - type_name, name); -#else - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", - type_name, PyString_AS_STRING(name)); -#endif - __Pyx_DECREF_TypeName(type_name); - return 0; -#else - attr = __Pyx_PyObject_GetAttrStr(obj, name); - goto try_unpack; -#endif -try_unpack: -#if CYTHON_UNPACK_METHODS - if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { - PyObject *function = PyMethod_GET_FUNCTION(attr); - Py_INCREF(function); - Py_DECREF(attr); - *method = function; - return 1; - } -#endif - *method = attr; - return 0; -} - -/* PyObjectCallMethod0 */ -static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { - PyObject *method = NULL, *result = NULL; - int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); - if (likely(is_method)) { - result = __Pyx_PyObject_CallOneArg(method, obj); - Py_DECREF(method); - return result; - } - if (unlikely(!method)) goto bad; - result = __Pyx_PyObject_CallNoArg(method); - Py_DECREF(method); -bad: - return result; -} - -/* ValidateBasesTuple */ -#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS -static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) { - Py_ssize_t i, n; -#if CYTHON_ASSUME_SAFE_MACROS - n = PyTuple_GET_SIZE(bases); -#else - n = PyTuple_Size(bases); - if (n < 0) return -1; -#endif - for (i = 1; i < n; i++) - { -#if CYTHON_AVOID_BORROWED_REFS - PyObject *b0 = PySequence_GetItem(bases, i); - if (!b0) return -1; -#elif CYTHON_ASSUME_SAFE_MACROS - PyObject *b0 = PyTuple_GET_ITEM(bases, i); -#else - PyObject *b0 = PyTuple_GetItem(bases, i); - if (!b0) return -1; -#endif - PyTypeObject *b; -#if PY_MAJOR_VERSION < 3 - if (PyClass_Check(b0)) - { - PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class", - PyString_AS_STRING(((PyClassObject*)b0)->cl_name)); -#if CYTHON_AVOID_BORROWED_REFS - Py_DECREF(b0); -#endif - return -1; - } -#endif - b = (PyTypeObject*) b0; - if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) - { - __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); - PyErr_Format(PyExc_TypeError, - "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name); - __Pyx_DECREF_TypeName(b_name); -#if CYTHON_AVOID_BORROWED_REFS - Py_DECREF(b0); -#endif - return -1; - } - if (dictoffset == 0) - { - Py_ssize_t b_dictoffset = 0; -#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY - b_dictoffset = b->tp_dictoffset; -#else - PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__"); - if (!py_b_dictoffset) goto dictoffset_return; - b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset); - Py_DECREF(py_b_dictoffset); - if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; -#endif - if (b_dictoffset) { - { - __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); - PyErr_Format(PyExc_TypeError, - "extension type '%.200s' has no __dict__ slot, " - "but base type '" __Pyx_FMT_TYPENAME "' has: " - "either add 'cdef dict __dict__' to the extension type " - "or add '__slots__ = [...]' to the base type", - type_name, b_name); - __Pyx_DECREF_TypeName(b_name); - } -#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY) - dictoffset_return: -#endif -#if CYTHON_AVOID_BORROWED_REFS - Py_DECREF(b0); -#endif - return -1; - } - } -#if CYTHON_AVOID_BORROWED_REFS - Py_DECREF(b0); -#endif - } - return 0; -} -#endif - -/* PyType_Ready */ -static int __Pyx_PyType_Ready(PyTypeObject *t) { -#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION) - (void)__Pyx_PyObject_CallMethod0; -#if CYTHON_USE_TYPE_SPECS - (void)__Pyx_validate_bases_tuple; -#endif - return PyType_Ready(t); -#else - int r; - PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); - if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1)) - return -1; -#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) - { - int gc_was_enabled; - #if PY_VERSION_HEX >= 0x030A00b1 - gc_was_enabled = PyGC_Disable(); - (void)__Pyx_PyObject_CallMethod0; - #else - PyObject *ret, *py_status; - PyObject *gc = NULL; - #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) - gc = PyImport_GetModule(__pyx_kp_u_gc); - #endif - if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc); - if (unlikely(!gc)) return -1; - py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled); - if (unlikely(!py_status)) { - Py_DECREF(gc); - return -1; - } - gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); - Py_DECREF(py_status); - if (gc_was_enabled > 0) { - ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable); - if (unlikely(!ret)) { - Py_DECREF(gc); - return -1; - } - Py_DECREF(ret); - } else if (unlikely(gc_was_enabled == -1)) { - Py_DECREF(gc); - return -1; - } - #endif - t->tp_flags |= Py_TPFLAGS_HEAPTYPE; -#if PY_VERSION_HEX >= 0x030A0000 - t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; -#endif -#else - (void)__Pyx_PyObject_CallMethod0; -#endif - r = PyType_Ready(t); -#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) - t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; - #if PY_VERSION_HEX >= 0x030A00b1 - if (gc_was_enabled) - PyGC_Enable(); - #else - if (gc_was_enabled) { - PyObject *tp, *v, *tb; - PyErr_Fetch(&tp, &v, &tb); - ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable); - if (likely(ret || r == -1)) { - Py_XDECREF(ret); - PyErr_Restore(tp, v, tb); - } else { - Py_XDECREF(tp); - Py_XDECREF(v); - Py_XDECREF(tb); - r = -1; - } - } - Py_DECREF(gc); - #endif - } -#endif - return r; -#endif -} - -/* SetVTable */ -static int __Pyx_SetVtable(PyTypeObject *type, void *vtable) { - PyObject *ob = PyCapsule_New(vtable, 0, 0); - if (unlikely(!ob)) - goto bad; -#if CYTHON_COMPILING_IN_LIMITED_API - if (unlikely(PyObject_SetAttr((PyObject *) type, __pyx_n_s_pyx_vtable, ob) < 0)) -#else - if (unlikely(PyDict_SetItem(type->tp_dict, __pyx_n_s_pyx_vtable, ob) < 0)) -#endif - goto bad; - Py_DECREF(ob); - return 0; -bad: - Py_XDECREF(ob); - return -1; -} - -/* GetVTable */ -static void* __Pyx_GetVtable(PyTypeObject *type) { - void* ptr; -#if CYTHON_COMPILING_IN_LIMITED_API - PyObject *ob = PyObject_GetAttr((PyObject *)type, __pyx_n_s_pyx_vtable); -#else - PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_n_s_pyx_vtable); -#endif - if (!ob) - goto bad; - ptr = PyCapsule_GetPointer(ob, 0); - if (!ptr && !PyErr_Occurred()) - PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); - Py_DECREF(ob); - return ptr; -bad: - Py_XDECREF(ob); - return NULL; -} - -/* MergeVTables */ -#if !CYTHON_COMPILING_IN_LIMITED_API -static int __Pyx_MergeVtables(PyTypeObject *type) { - int i; - void** base_vtables; - __Pyx_TypeName tp_base_name; - __Pyx_TypeName base_name; - void* unknown = (void*)-1; - PyObject* bases = type->tp_bases; - int base_depth = 0; - { - PyTypeObject* base = type->tp_base; - while (base) { - base_depth += 1; - base = base->tp_base; - } - } - base_vtables = (void**) malloc(sizeof(void*) * (size_t)(base_depth + 1)); - base_vtables[0] = unknown; - for (i = 1; i < PyTuple_GET_SIZE(bases); i++) { - void* base_vtable = __Pyx_GetVtable(((PyTypeObject*)PyTuple_GET_ITEM(bases, i))); - if (base_vtable != NULL) { - int j; - PyTypeObject* base = type->tp_base; - for (j = 0; j < base_depth; j++) { - if (base_vtables[j] == unknown) { - base_vtables[j] = __Pyx_GetVtable(base); - base_vtables[j + 1] = unknown; - } - if (base_vtables[j] == base_vtable) { - break; - } else if (base_vtables[j] == NULL) { - goto bad; - } - base = base->tp_base; - } - } - } - PyErr_Clear(); - free(base_vtables); - return 0; -bad: - tp_base_name = __Pyx_PyType_GetName(type->tp_base); - base_name = __Pyx_PyType_GetName((PyTypeObject*)PyTuple_GET_ITEM(bases, i)); - PyErr_Format(PyExc_TypeError, - "multiple bases have vtable conflict: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", tp_base_name, base_name); - __Pyx_DECREF_TypeName(tp_base_name); - __Pyx_DECREF_TypeName(base_name); - free(base_vtables); - return -1; -} -#endif - -/* SetupReduce */ -#if !CYTHON_COMPILING_IN_LIMITED_API -static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { - int ret; - PyObject *name_attr; - name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name_2); - if (likely(name_attr)) { - ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); - } else { - ret = -1; - } - if (unlikely(ret < 0)) { - PyErr_Clear(); - ret = 0; - } - Py_XDECREF(name_attr); - return ret; -} -static int __Pyx_setup_reduce(PyObject* type_obj) { - int ret = 0; - PyObject *object_reduce = NULL; - PyObject *object_getstate = NULL; - PyObject *object_reduce_ex = NULL; - PyObject *reduce = NULL; - PyObject *reduce_ex = NULL; - PyObject *reduce_cython = NULL; - PyObject *setstate = NULL; - PyObject *setstate_cython = NULL; - PyObject *getstate = NULL; -#if CYTHON_USE_PYTYPE_LOOKUP - getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); -#else - getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); - if (!getstate && PyErr_Occurred()) { - goto __PYX_BAD; - } -#endif - if (getstate) { -#if CYTHON_USE_PYTYPE_LOOKUP - object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); -#else - object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); - if (!object_getstate && PyErr_Occurred()) { - goto __PYX_BAD; - } -#endif - if (object_getstate != getstate) { - goto __PYX_GOOD; - } - } -#if CYTHON_USE_PYTYPE_LOOKUP - object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; -#else - object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; -#endif - reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_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; -#else - object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; -#endif - reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_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; - } - setstate = __Pyx_PyObject_GetAttrStrNoError(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; - } - } - PyType_Modified((PyTypeObject*)type_obj); - } - } - goto __PYX_GOOD; -__PYX_BAD: - if (!PyErr_Occurred()) { - __Pyx_TypeName type_obj_name = - __Pyx_PyType_GetName((PyTypeObject*)type_obj); - PyErr_Format(PyExc_RuntimeError, - "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name); - __Pyx_DECREF_TypeName(type_obj_name); - } - ret = -1; -__PYX_GOOD: -#if !CYTHON_USE_PYTYPE_LOOKUP - Py_XDECREF(object_reduce); - Py_XDECREF(object_reduce_ex); - Py_XDECREF(object_getstate); - Py_XDECREF(getstate); -#endif - Py_XDECREF(reduce); - Py_XDECREF(reduce_ex); - Py_XDECREF(reduce_cython); - Py_XDECREF(setstate); - Py_XDECREF(setstate_cython); - return ret; -} -#endif - -/* TypeImport */ -#ifndef __PYX_HAVE_RT_ImportType_3_0_10 -#define __PYX_HAVE_RT_ImportType_3_0_10 -static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject *module, const char *module_name, const char *class_name, - size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size) -{ - PyObject *result = 0; - char warning[200]; - Py_ssize_t basicsize; - Py_ssize_t itemsize; -#if CYTHON_COMPILING_IN_LIMITED_API - PyObject *py_basicsize; - PyObject *py_itemsize; -#endif - result = PyObject_GetAttrString(module, class_name); - if (!result) - goto bad; - if (!PyType_Check(result)) { - PyErr_Format(PyExc_TypeError, - "%.200s.%.200s is not a type object", - module_name, class_name); - goto bad; - } -#if !CYTHON_COMPILING_IN_LIMITED_API - basicsize = ((PyTypeObject *)result)->tp_basicsize; - itemsize = ((PyTypeObject *)result)->tp_itemsize; -#else - py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); - if (!py_basicsize) - goto bad; - basicsize = PyLong_AsSsize_t(py_basicsize); - Py_DECREF(py_basicsize); - py_basicsize = 0; - if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) - goto bad; - py_itemsize = PyObject_GetAttrString(result, "__itemsize__"); - if (!py_itemsize) - goto bad; - itemsize = PyLong_AsSsize_t(py_itemsize); - Py_DECREF(py_itemsize); - py_itemsize = 0; - if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred()) - goto bad; -#endif - if (itemsize) { - if (size % alignment) { - alignment = size % alignment; - } - if (itemsize < (Py_ssize_t)alignment) - itemsize = (Py_ssize_t)alignment; - } - if ((size_t)(basicsize + itemsize) < size) { - PyErr_Format(PyExc_ValueError, - "%.200s.%.200s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize+itemsize); - goto bad; - } - if (check_size == __Pyx_ImportType_CheckSize_Error_3_0_10 && - ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) { - PyErr_Format(PyExc_ValueError, - "%.200s.%.200s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd-%zd from PyObject", - module_name, class_name, size, basicsize, basicsize+itemsize); - goto bad; - } - else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_0_10 && (size_t)basicsize > size) { - PyOS_snprintf(warning, sizeof(warning), - "%s.%s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); - if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; - } - return (PyTypeObject *)result; -bad: - Py_XDECREF(result); - return NULL; -} -#endif - -/* FetchSharedCythonModule */ -static PyObject *__Pyx_FetchSharedCythonABIModule(void) { - return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME); -} - -/* FetchCommonType */ -static int __Pyx_VerifyCachedType(PyObject *cached_type, - const char *name, - Py_ssize_t basicsize, - Py_ssize_t expected_basicsize) { - if (!PyType_Check(cached_type)) { - PyErr_Format(PyExc_TypeError, - "Shared Cython type %.200s is not a type object", name); - return -1; - } - if (basicsize != expected_basicsize) { - PyErr_Format(PyExc_TypeError, - "Shared Cython type %.200s has the wrong size, try recompiling", - name); - return -1; - } - return 0; -} -#if !CYTHON_USE_TYPE_SPECS -static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { - PyObject* abi_module; - const char* object_name; - PyTypeObject *cached_type = NULL; - abi_module = __Pyx_FetchSharedCythonABIModule(); - if (!abi_module) return NULL; - object_name = strrchr(type->tp_name, '.'); - object_name = object_name ? object_name+1 : type->tp_name; - cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name); - if (cached_type) { - if (__Pyx_VerifyCachedType( - (PyObject *)cached_type, - object_name, - cached_type->tp_basicsize, - type->tp_basicsize) < 0) { - goto bad; - } - goto done; - } - if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; - PyErr_Clear(); - if (PyType_Ready(type) < 0) goto bad; - if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) - goto bad; - Py_INCREF(type); - cached_type = type; -done: - Py_DECREF(abi_module); - return cached_type; -bad: - Py_XDECREF(cached_type); - cached_type = NULL; - goto done; -} -#else -static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { - PyObject *abi_module, *cached_type = NULL; - const char* object_name = strrchr(spec->name, '.'); - object_name = object_name ? object_name+1 : spec->name; - abi_module = __Pyx_FetchSharedCythonABIModule(); - if (!abi_module) return NULL; - cached_type = PyObject_GetAttrString(abi_module, object_name); - if (cached_type) { - Py_ssize_t basicsize; -#if CYTHON_COMPILING_IN_LIMITED_API - PyObject *py_basicsize; - py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); - if (unlikely(!py_basicsize)) goto bad; - basicsize = PyLong_AsSsize_t(py_basicsize); - Py_DECREF(py_basicsize); - py_basicsize = 0; - if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; -#else - basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1; -#endif - if (__Pyx_VerifyCachedType( - cached_type, - object_name, - basicsize, - spec->basicsize) < 0) { - goto bad; - } - goto done; - } - if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; - PyErr_Clear(); - CYTHON_UNUSED_VAR(module); - cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases); - if (unlikely(!cached_type)) goto bad; - if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; - if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad; -done: - Py_DECREF(abi_module); - assert(cached_type == NULL || PyType_Check(cached_type)); - return (PyTypeObject *) cached_type; -bad: - Py_XDECREF(cached_type); - cached_type = NULL; - goto done; -} -#endif - -/* PyVectorcallFastCallDict */ -#if CYTHON_METH_FASTCALL -static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) -{ - PyObject *res = NULL; - PyObject *kwnames; - PyObject **newargs; - PyObject **kwvalues; - Py_ssize_t i, pos; - size_t j; - PyObject *key, *value; - unsigned long keys_are_strings; - Py_ssize_t nkw = PyDict_GET_SIZE(kw); - newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); - if (unlikely(newargs == NULL)) { - PyErr_NoMemory(); - return NULL; - } - for (j = 0; j < nargs; j++) newargs[j] = args[j]; - kwnames = PyTuple_New(nkw); - if (unlikely(kwnames == NULL)) { - PyMem_Free(newargs); - return NULL; - } - kwvalues = newargs + nargs; - pos = i = 0; - keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; - while (PyDict_Next(kw, &pos, &key, &value)) { - keys_are_strings &= Py_TYPE(key)->tp_flags; - Py_INCREF(key); - Py_INCREF(value); - PyTuple_SET_ITEM(kwnames, i, key); - kwvalues[i] = value; - i++; - } - if (unlikely(!keys_are_strings)) { - PyErr_SetString(PyExc_TypeError, "keywords must be strings"); - goto cleanup; - } - res = vc(func, newargs, nargs, kwnames); -cleanup: - Py_DECREF(kwnames); - for (i = 0; i < nkw; i++) - Py_DECREF(kwvalues[i]); - PyMem_Free(newargs); - return res; -} -static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) -{ - if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) { - return vc(func, args, nargs, NULL); - } - return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); -} -#endif - -/* CythonFunctionShared */ -#if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { - if (__Pyx_CyFunction_Check(func)) { - return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; - } else if (PyCFunction_Check(func)) { - return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; - } - return 0; -} -#else -static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { - return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; -} -#endif -static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { -#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API - __Pyx_Py_XDECREF_SET( - __Pyx_CyFunction_GetClassObj(f), - ((classobj) ? __Pyx_NewRef(classobj) : NULL)); -#else - __Pyx_Py_XDECREF_SET( - ((PyCMethodObject *) (f))->mm_class, - (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); -#endif -} -static PyObject * -__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) -{ - CYTHON_UNUSED_VAR(closure); - if (unlikely(op->func_doc == NULL)) { -#if CYTHON_COMPILING_IN_LIMITED_API - op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); - if (unlikely(!op->func_doc)) return NULL; -#else - if (((PyCFunctionObject*)op)->m_ml->ml_doc) { -#if PY_MAJOR_VERSION >= 3 - op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); -#else - op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); -#endif - if (unlikely(op->func_doc == NULL)) - return NULL; - } else { - Py_INCREF(Py_None); - return Py_None; - } -#endif - } - Py_INCREF(op->func_doc); - return op->func_doc; -} -static int -__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) -{ - CYTHON_UNUSED_VAR(context); - if (value == NULL) { - value = Py_None; - } - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->func_doc, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(context); - if (unlikely(op->func_name == NULL)) { -#if CYTHON_COMPILING_IN_LIMITED_API - op->func_name = PyObject_GetAttrString(op->func, "__name__"); -#elif PY_MAJOR_VERSION >= 3 - op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); -#else - op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->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, void *context) -{ - CYTHON_UNUSED_VAR(context); -#if PY_MAJOR_VERSION >= 3 - if (unlikely(value == NULL || !PyUnicode_Check(value))) -#else - if (unlikely(value == NULL || !PyString_Check(value))) -#endif - { - PyErr_SetString(PyExc_TypeError, - "__name__ must be set to a string object"); - return -1; - } - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->func_name, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(context); - Py_INCREF(op->func_qualname); - return op->func_qualname; -} -static int -__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) -{ - CYTHON_UNUSED_VAR(context); -#if PY_MAJOR_VERSION >= 3 - if (unlikely(value == NULL || !PyUnicode_Check(value))) -#else - if (unlikely(value == NULL || !PyString_Check(value))) -#endif - { - PyErr_SetString(PyExc_TypeError, - "__qualname__ must be set to a string object"); - return -1; - } - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->func_qualname, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(context); - if (unlikely(op->func_dict == NULL)) { - op->func_dict = PyDict_New(); - if (unlikely(op->func_dict == NULL)) - return NULL; - } - Py_INCREF(op->func_dict); - return op->func_dict; -} -static int -__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context) -{ - CYTHON_UNUSED_VAR(context); - if (unlikely(value == NULL)) { - PyErr_SetString(PyExc_TypeError, - "function's dictionary may not be deleted"); - return -1; - } - if (unlikely(!PyDict_Check(value))) { - PyErr_SetString(PyExc_TypeError, - "setting function's dictionary to a non-dict"); - return -1; - } - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->func_dict, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(context); - Py_INCREF(op->func_globals); - return op->func_globals; -} -static PyObject * -__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(op); - CYTHON_UNUSED_VAR(context); - Py_INCREF(Py_None); - return Py_None; -} -static PyObject * -__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) -{ - PyObject* result = (op->func_code) ? op->func_code : Py_None; - CYTHON_UNUSED_VAR(context); - 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 = __Pyx_PySequence_ITEM(res, 0); - if (unlikely(!op->defaults_tuple)) result = -1; - else { - op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1); - if (unlikely(!op->defaults_kwdict)) result = -1; - } - #endif - Py_DECREF(res); - return result; -} -static int -__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { - CYTHON_UNUSED_VAR(context); - if (!value) { - value = Py_None; - } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { - PyErr_SetString(PyExc_TypeError, - "__defaults__ must be set to a tuple object"); - return -1; - } - PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " - "currently affect the values used in function calls", 1); - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { - PyObject* result = op->defaults_tuple; - CYTHON_UNUSED_VAR(context); - if (unlikely(!result)) { - if (op->defaults_getter) { - if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; - result = op->defaults_tuple; - } else { - result = Py_None; - } - } - Py_INCREF(result); - return result; -} -static int -__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { - CYTHON_UNUSED_VAR(context); - if (!value) { - value = Py_None; - } else if (unlikely(value != Py_None && !PyDict_Check(value))) { - PyErr_SetString(PyExc_TypeError, - "__kwdefaults__ must be set to a dict object"); - return -1; - } - PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " - "currently affect the values used in function calls", 1); - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { - PyObject* result = op->defaults_kwdict; - CYTHON_UNUSED_VAR(context); - if (unlikely(!result)) { - if (op->defaults_getter) { - if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; - result = op->defaults_kwdict; - } else { - result = Py_None; - } - } - Py_INCREF(result); - return result; -} -static int -__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { - CYTHON_UNUSED_VAR(context); - if (!value || value == Py_None) { - value = NULL; - } else if (unlikely(!PyDict_Check(value))) { - PyErr_SetString(PyExc_TypeError, - "__annotations__ must be set to a dict object"); - return -1; - } - Py_XINCREF(value); - __Pyx_Py_XDECREF_SET(op->func_annotations, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { - PyObject* result = op->func_annotations; - CYTHON_UNUSED_VAR(context); - if (unlikely(!result)) { - result = PyDict_New(); - if (unlikely(!result)) return NULL; - op->func_annotations = result; - } - Py_INCREF(result); - return result; -} -static PyObject * -__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { - int is_coroutine; - CYTHON_UNUSED_VAR(context); - if (op->func_is_coroutine) { - return __Pyx_NewRef(op->func_is_coroutine); - } - is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; -#if PY_VERSION_HEX >= 0x03050000 - if (is_coroutine) { - PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine; - fromlist = PyList_New(1); - if (unlikely(!fromlist)) return NULL; - Py_INCREF(marker); -#if CYTHON_ASSUME_SAFE_MACROS - PyList_SET_ITEM(fromlist, 0, marker); -#else - if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { - Py_DECREF(marker); - Py_DECREF(fromlist); - return NULL; - } -#endif - module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0); - Py_DECREF(fromlist); - if (unlikely(!module)) goto ignore; - op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker); - Py_DECREF(module); - if (likely(op->func_is_coroutine)) { - return __Pyx_NewRef(op->func_is_coroutine); - } -ignore: - PyErr_Clear(); - } -#endif - op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine); - return __Pyx_NewRef(op->func_is_coroutine); -} -#if CYTHON_COMPILING_IN_LIMITED_API -static PyObject * -__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { - CYTHON_UNUSED_VAR(context); - return PyObject_GetAttrString(op->func, "__module__"); -} -static int -__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { - CYTHON_UNUSED_VAR(context); - return PyObject_SetAttrString(op->func, "__module__", value); -} -#endif -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 *) "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}, - {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, -#if CYTHON_COMPILING_IN_LIMITED_API - {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, -#endif - {0, 0, 0, 0, 0} -}; -static PyMemberDef __pyx_CyFunction_members[] = { -#if !CYTHON_COMPILING_IN_LIMITED_API - {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, -#endif -#if CYTHON_USE_TYPE_SPECS - {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, -#if CYTHON_METH_FASTCALL -#if CYTHON_BACKPORT_VECTORCALL - {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, -#else -#if !CYTHON_COMPILING_IN_LIMITED_API - {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, -#endif -#endif -#endif -#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API - {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, -#else - {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, -#endif -#endif - {0, 0, 0, 0, 0} -}; -static PyObject * -__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) -{ - CYTHON_UNUSED_VAR(args); -#if PY_MAJOR_VERSION >= 3 - Py_INCREF(m->func_qualname); - return m->func_qualname; -#else - return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name); -#endif -} -static PyMethodDef __pyx_CyFunction_methods[] = { - {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, - {0, 0, 0, 0} -}; -#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API -#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) -#else -#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->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 !CYTHON_COMPILING_IN_LIMITED_API - PyCFunctionObject *cf = (PyCFunctionObject*) op; -#endif - if (unlikely(op == NULL)) - return NULL; -#if CYTHON_COMPILING_IN_LIMITED_API - op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); - if (unlikely(!op->func)) return NULL; -#endif - op->flags = flags; - __Pyx_CyFunction_weakreflist(op) = NULL; -#if !CYTHON_COMPILING_IN_LIMITED_API - cf->m_ml = ml; - cf->m_self = (PyObject *) op; -#endif - Py_XINCREF(closure); - op->func_closure = closure; -#if !CYTHON_COMPILING_IN_LIMITED_API - Py_XINCREF(module); - cf->m_module = module; -#endif - op->func_dict = NULL; - op->func_name = NULL; - Py_INCREF(qualname); - op->func_qualname = qualname; - op->func_doc = NULL; -#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API - op->func_classobj = NULL; -#else - ((PyCMethodObject*)op)->mm_class = NULL; -#endif - op->func_globals = globals; - Py_INCREF(op->func_globals); - 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; - op->func_is_coroutine = NULL; -#if CYTHON_METH_FASTCALL - switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { - case METH_NOARGS: - __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; - break; - case METH_O: - __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; - break; - case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: - __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; - break; - case METH_FASTCALL | METH_KEYWORDS: - __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; - break; - case METH_VARARGS | METH_KEYWORDS: - __Pyx_CyFunction_func_vectorcall(op) = NULL; - break; - default: - PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); - Py_DECREF(op); - return NULL; - } -#endif - return (PyObject *) op; -} -static int -__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) -{ - Py_CLEAR(m->func_closure); -#if CYTHON_COMPILING_IN_LIMITED_API - Py_CLEAR(m->func); -#else - Py_CLEAR(((PyCFunctionObject*)m)->m_module); -#endif - 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); -#if !CYTHON_COMPILING_IN_LIMITED_API -#if PY_VERSION_HEX < 0x030900B1 - Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); -#else - { - PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; - ((PyCMethodObject *) (m))->mm_class = NULL; - Py_XDECREF(cls); - } -#endif -#endif - Py_CLEAR(m->defaults_tuple); - Py_CLEAR(m->defaults_kwdict); - Py_CLEAR(m->func_annotations); - Py_CLEAR(m->func_is_coroutine); - 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; - } - return 0; -} -static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) -{ - if (__Pyx_CyFunction_weakreflist(m) != NULL) - PyObject_ClearWeakRefs((PyObject *) m); - __Pyx_CyFunction_clear(m); - __Pyx_PyHeapTypeObject_GC_Del(m); -} -static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) -{ - PyObject_GC_UnTrack(m); - __Pyx__CyFunction_dealloc(m); -} -static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) -{ - Py_VISIT(m->func_closure); -#if CYTHON_COMPILING_IN_LIMITED_API - Py_VISIT(m->func); -#else - Py_VISIT(((PyCFunctionObject*)m)->m_module); -#endif - 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); -#if !CYTHON_COMPILING_IN_LIMITED_API - Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); -#endif - Py_VISIT(m->defaults_tuple); - Py_VISIT(m->defaults_kwdict); - Py_VISIT(m->func_is_coroutine); - if (m->defaults) { - PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); - int i; - for (i = 0; i < m->defaults_pyobjects; i++) - Py_VISIT(pydefaults[i]); - } - return 0; -} -static PyObject* -__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) -{ -#if PY_MAJOR_VERSION >= 3 - return PyUnicode_FromFormat("", - op->func_qualname, (void *)op); -#else - return PyString_FromFormat("", - PyString_AsString(op->func_qualname), (void *)op); -#endif -} -static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { -#if CYTHON_COMPILING_IN_LIMITED_API - PyObject *f = ((__pyx_CyFunctionObject*)func)->func; - PyObject *py_name = NULL; - PyCFunction meth; - int flags; - meth = PyCFunction_GetFunction(f); - if (unlikely(!meth)) return NULL; - flags = PyCFunction_GetFlags(f); - if (unlikely(flags < 0)) return NULL; -#else - PyCFunctionObject* f = (PyCFunctionObject*)func; - PyCFunction meth = f->m_ml->ml_meth; - int flags = f->m_ml->ml_flags; -#endif - Py_ssize_t size; - switch (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)) { -#if CYTHON_ASSUME_SAFE_MACROS - size = PyTuple_GET_SIZE(arg); -#else - size = PyTuple_Size(arg); - if (unlikely(size < 0)) return NULL; -#endif - if (likely(size == 0)) - return (*meth)(self, NULL); -#if CYTHON_COMPILING_IN_LIMITED_API - py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); - if (!py_name) return NULL; - PyErr_Format(PyExc_TypeError, - "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - py_name, size); - Py_DECREF(py_name); -#else - PyErr_Format(PyExc_TypeError, - "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - f->m_ml->ml_name, size); -#endif - return NULL; - } - break; - case METH_O: - if (likely(kw == NULL || PyDict_Size(kw) == 0)) { -#if CYTHON_ASSUME_SAFE_MACROS - size = PyTuple_GET_SIZE(arg); -#else - size = PyTuple_Size(arg); - if (unlikely(size < 0)) return NULL; -#endif - if (likely(size == 1)) { - PyObject *result, *arg0; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - arg0 = PyTuple_GET_ITEM(arg, 0); - #else - arg0 = __Pyx_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; - } -#if CYTHON_COMPILING_IN_LIMITED_API - py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); - if (!py_name) return NULL; - PyErr_Format(PyExc_TypeError, - "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - py_name, size); - Py_DECREF(py_name); -#else - PyErr_Format(PyExc_TypeError, - "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - f->m_ml->ml_name, size); -#endif - return NULL; - } - break; - default: - PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); - return NULL; - } -#if CYTHON_COMPILING_IN_LIMITED_API - py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); - if (!py_name) return NULL; - PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", - py_name); - Py_DECREF(py_name); -#else - PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", - f->m_ml->ml_name); -#endif - return NULL; -} -static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { - PyObject *self, *result; -#if CYTHON_COMPILING_IN_LIMITED_API - self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); - if (unlikely(!self) && PyErr_Occurred()) return NULL; -#else - self = ((PyCFunctionObject*)func)->m_self; -#endif - result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); - return result; -} -static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { - PyObject *result; - __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; -#if CYTHON_METH_FASTCALL - __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); - if (vc) { -#if CYTHON_ASSUME_SAFE_MACROS - return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); -#else - (void) &__Pyx_PyVectorcall_FastCallDict; - return PyVectorcall_Call(func, args, kw); -#endif - } -#endif - if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { - Py_ssize_t argc; - PyObject *new_args; - PyObject *self; -#if CYTHON_ASSUME_SAFE_MACROS - argc = PyTuple_GET_SIZE(args); -#else - argc = PyTuple_Size(args); - if (unlikely(!argc) < 0) return NULL; -#endif - 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); -#if PY_MAJOR_VERSION > 2 - PyErr_Format(PyExc_TypeError, - "unbound method %.200S() needs an argument", - cyfunc->func_qualname); -#else - PyErr_SetString(PyExc_TypeError, - "unbound method needs an argument"); -#endif - return NULL; - } - result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); - Py_DECREF(new_args); - } else { - result = __Pyx_CyFunction_Call(func, args, kw); - } - return result; -} -#if CYTHON_METH_FASTCALL -static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) -{ - int ret = 0; - if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { - if (unlikely(nargs < 1)) { - PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", - ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); - return -1; - } - ret = 1; - } - if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) { - PyErr_Format(PyExc_TypeError, - "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); - return -1; - } - return ret; -} -static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) -{ - __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else - Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif - PyObject *self; - switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; - } - if (unlikely(nargs != 0)) { - PyErr_Format(PyExc_TypeError, - "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - def->ml_name, nargs); - return NULL; - } - return def->ml_meth(self, NULL); -} -static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) -{ - __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else - Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif - PyObject *self; - switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; - } - if (unlikely(nargs != 1)) { - PyErr_Format(PyExc_TypeError, - "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - def->ml_name, nargs); - return NULL; - } - return def->ml_meth(self, args[0]); -} -static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) -{ - __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else - Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif - PyObject *self; - switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; - } - return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames); -} -static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) -{ - __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; - PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else - Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif - PyObject *self; - switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; - } - return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames); -} -#endif -#if CYTHON_USE_TYPE_SPECS -static PyType_Slot __pyx_CyFunctionType_slots[] = { - {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, - {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, - {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, - {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, - {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, - {Py_tp_methods, (void *)__pyx_CyFunction_methods}, - {Py_tp_members, (void *)__pyx_CyFunction_members}, - {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, - {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, - {0, 0}, -}; -static PyType_Spec __pyx_CyFunctionType_spec = { - __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", - sizeof(__pyx_CyFunctionObject), - 0, -#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR - Py_TPFLAGS_METHOD_DESCRIPTOR | -#endif -#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL) - _Py_TPFLAGS_HAVE_VECTORCALL | -#endif - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, - __pyx_CyFunctionType_slots -}; -#else -static PyTypeObject __pyx_CyFunctionType_type = { - PyVarObject_HEAD_INIT(0, 0) - __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", - sizeof(__pyx_CyFunctionObject), - 0, - (destructor) __Pyx_CyFunction_dealloc, -#if !CYTHON_METH_FASTCALL - 0, -#elif CYTHON_BACKPORT_VECTORCALL - (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall), -#else - offsetof(PyCFunctionObject, vectorcall), -#endif - 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, -#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR - Py_TPFLAGS_METHOD_DESCRIPTOR | -#endif -#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL - _Py_TPFLAGS_HAVE_VECTORCALL | -#endif - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, - 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_PyMethod_New, - 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 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) - 0, -#endif -#if __PYX_NEED_TP_PRINT_SLOT - 0, -#endif -#if PY_VERSION_HEX >= 0x030C0000 - 0, -#endif -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 - 0, -#endif -}; -#endif -static int __pyx_CyFunction_init(PyObject *module) { -#if CYTHON_USE_TYPE_SPECS - __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); -#else - CYTHON_UNUSED_VAR(module); - __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); -#endif - 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; - m->defaults_size = size; - 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); -} - -/* 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; -} - -/* 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 - CYTHON_MAYBE_UNUSED_VAR(tstate); - 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_GetAttrStrNoError(__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; - } - } - if (!use_cline) { - c_line = 0; - (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); - } - 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; -} -#endif - -/* CodeObjectCache */ -#if !CYTHON_COMPILING_IN_LIMITED_API -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 PyCodeObject *__pyx_find_code_object(int code_line) { - PyCodeObject* code_object; - int pos; - if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { - return NULL; - } - 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 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; - } - 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; - } - 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); -} -#endif - -/* AddTraceback */ -#include "compile.h" -#include "frameobject.h" -#include "traceback.h" -#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API - #ifndef Py_BUILD_CORE - #define Py_BUILD_CORE 1 - #endif - #include "internal/pycore_frame.h" -#endif -#if CYTHON_COMPILING_IN_LIMITED_API -static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, - PyObject *firstlineno, PyObject *name) { - PyObject *replace = NULL; - if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; - if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; - replace = PyObject_GetAttrString(code, "replace"); - if (likely(replace)) { - PyObject *result; - result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); - Py_DECREF(replace); - return result; - } - PyErr_Clear(); - #if __PYX_LIMITED_VERSION_HEX < 0x030780000 - { - PyObject *compiled = NULL, *result = NULL; - if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; - if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; - compiled = Py_CompileString( - "out = type(code)(\n" - " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" - " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" - " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" - " code.co_lnotab)\n", "", Py_file_input); - if (!compiled) return NULL; - result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); - Py_DECREF(compiled); - if (!result) PyErr_Print(); - Py_DECREF(result); - result = PyDict_GetItemString(scratch_dict, "out"); - if (result) Py_INCREF(result); - return result; - } - #else - return NULL; - #endif -} -static void __Pyx_AddTraceback(const char *funcname, int c_line, - int py_line, const char *filename) { - PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; - PyObject *replace = NULL, *getframe = NULL, *frame = NULL; - PyObject *exc_type, *exc_value, *exc_traceback; - int success = 0; - if (c_line) { - (void) __pyx_cfilenm; - (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); - } - PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); - code_object = Py_CompileString("_getframe()", filename, Py_eval_input); - if (unlikely(!code_object)) goto bad; - py_py_line = PyLong_FromLong(py_line); - if (unlikely(!py_py_line)) goto bad; - py_funcname = PyUnicode_FromString(funcname); - if (unlikely(!py_funcname)) goto bad; - dict = PyDict_New(); - if (unlikely(!dict)) goto bad; - { - PyObject *old_code_object = code_object; - code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); - Py_DECREF(old_code_object); - } - if (unlikely(!code_object)) goto bad; - getframe = PySys_GetObject("_getframe"); - if (unlikely(!getframe)) goto bad; - if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; - frame = PyEval_EvalCode(code_object, dict, dict); - if (unlikely(!frame) || frame == Py_None) goto bad; - success = 1; - bad: - PyErr_Restore(exc_type, exc_value, exc_traceback); - Py_XDECREF(code_object); - Py_XDECREF(py_py_line); - Py_XDECREF(py_funcname); - Py_XDECREF(dict); - Py_XDECREF(replace); - if (success) { - PyTraceBack_Here( - (struct _frame*)frame); - } - Py_XDECREF(frame); -} -#else -static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( - const char *funcname, int c_line, - int py_line, const char *filename) { - PyCodeObject *py_code = NULL; - PyObject *py_funcname = NULL; - #if PY_MAJOR_VERSION < 3 - PyObject *py_srcfile = NULL; - py_srcfile = PyString_FromString(filename); - if (!py_srcfile) goto bad; - #endif - if (c_line) { - #if PY_MAJOR_VERSION < 3 - py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); - if (!py_funcname) goto bad; - #else - py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); - if (!py_funcname) goto bad; - funcname = PyUnicode_AsUTF8(py_funcname); - if (!funcname) goto bad; - #endif - } - else { - #if PY_MAJOR_VERSION < 3 - py_funcname = PyString_FromString(funcname); - if (!py_funcname) goto bad; - #endif - } - #if PY_MAJOR_VERSION < 3 - py_code = __Pyx_PyCode_New( - 0, - 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); - #else - py_code = PyCode_NewEmpty(filename, funcname, py_line); - #endif - Py_XDECREF(py_funcname); - return py_code; -bad: - Py_XDECREF(py_funcname); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(py_srcfile); - #endif - 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; - PyObject *ptype, *pvalue, *ptraceback; - if (c_line) { - c_line = __Pyx_CLineForTraceback(tstate, c_line); - } - py_code = __pyx_find_code_object(c_line ? -c_line : py_line); - if (!py_code) { - __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); - py_code = __Pyx_CreateCodeObjectForTraceback( - funcname, c_line, py_line, filename); - if (!py_code) { - /* If the code object creation fails, then we should clear the - fetched exception references and propagate the new exception */ - Py_XDECREF(ptype); - Py_XDECREF(pvalue); - Py_XDECREF(ptraceback); - goto bad; - } - __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); - __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); -} -#endif - -#if PY_MAJOR_VERSION < 3 -static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { - __Pyx_TypeName obj_type_name; - if (PyObject_CheckBuffer(obj)) return PyObject_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); - obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); - PyErr_Format(PyExc_TypeError, - "'" __Pyx_FMT_TYPENAME "' does not have the buffer interface", - obj_type_name); - __Pyx_DECREF_TypeName(obj_type_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; - } - if ((0)) {} - view->obj = NULL; - Py_DECREF(obj); -} -#endif - - -/* MemviewSliceIsContig */ -static int -__pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim) -{ - 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; - } - 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; -} - -/* 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); - } - } - *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); -} - -/* 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; -} - -/* 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'; - } - } - *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; -} -static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { - PyErr_Format(PyExc_ValueError, - "Unexpected format string character: '%c'", 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'"; - 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 "unparsable 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; - } - case 'O': case 'P': return sizeof(void*); - default: - __Pyx_BufFmt_RaiseUnexpectedChar(ch); - return 0; - } -} -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 '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; - } - } -} -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, int is_complex) { - CYTHON_UNUSED_VAR(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; - } -} -/* 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, int is_complex) { - CYTHON_UNUSED_VAR(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; - } -} -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 '?': 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; - } - } -} -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 = "'"; - } - 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; - } - } - if (!ctx->is_valid_array) { - PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", - ctx->head->field->type->ndim, ndim); - return -1; - } - for (i = 0; i < ctx->head->field->type->ndim; i++) { - arraysize *= ctx->head->field->type->arraysize[i]; - } - 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); - } - 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 (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; - } - } - 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 int -__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) -{ - const char *ts = *tsp; - int i = 0, number, ndim; - ++ts; - if (ctx->new_count != 1) { - PyErr_SetString(PyExc_ValueError, - "Cannot handle repeated arrays in format string"); - return -1; - } - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return -1; - ndim = ctx->head->field->type->ndim; - 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 -1; - if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) { - PyErr_Format(PyExc_ValueError, - "Expected a dimension of size %zu, got %d", - ctx->head->field->type->arraysize[i], number); - return -1; - } - if (*ts != ',' && *ts != ')') { - PyErr_Format(PyExc_ValueError, - "Expected a comma in format string, got '%c'", *ts); - return -1; - } - if (*ts == ',') ts++; - i++; - } - if (i != ndim) { - PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", - ctx->head->field->type->ndim, i); - return -1; - } - if (!*ts) { - PyErr_SetString(PyExc_ValueError, - "Unexpected end of format string, expected ')'"); - return -1; - } - ctx->is_valid_array = 1; - ctx->new_count = 1; - *tsp = ++ts; - return 0; -} -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 '?': 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)) { - 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) < 0) return NULL; - break; - default: - { - int number = __Pyx_BufFmt_ExpectNumber(&ts); - if (number == -1) return NULL; - ctx->new_count = (size_t)number; - } - } - } -} - -/* TypeInfoCompare */ - static int -__pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b) -{ - int i; - if (!a || !b) - return 0; - if (a == b) - return 1; - if (a->size != b->size || a->typegroup != b->typegroup || - a->is_unsigned != b->is_unsigned || a->ndim != b->ndim) { - if (a->typegroup == 'H' || b->typegroup == 'H') { - return a->size == b->size; - } else { - return 0; - } - } - if (a->ndim) { - for (i = 0; i < a->ndim; i++) - if (a->arraysize[i] != b->arraysize[i]) - return 0; - } - if (a->typegroup == 'S') { - if (a->flags != b->flags) - return 0; - if (a->fields || b->fields) { - if (!(a->fields && b->fields)) - return 0; - for (i = 0; a->fields[i].type && b->fields[i].type; i++) { - __Pyx_StructField *field_a = a->fields + i; - __Pyx_StructField *field_b = b->fields + i; - if (field_a->offset != field_b->offset || - !__pyx_typeinfo_cmp(field_a->type, field_b->type)) - return 0; - } - return !a->fields[i].type && !b->fields[i].type; - } - } - return 1; -} - -/* MemviewSliceValidateAndInit */ - static int -__pyx_check_strides(Py_buffer *buf, int dim, int ndim, int spec) -{ - if (buf->shape[dim] <= 1) - return 1; - if (buf->strides) { - if (spec & __Pyx_MEMVIEW_CONTIG) { - if (spec & (__Pyx_MEMVIEW_PTR|__Pyx_MEMVIEW_FULL)) { - if (unlikely(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)) { - PyErr_SetString(PyExc_ValueError, - "Buffer and memoryview are not contiguous " - "in the same dimension."); - goto fail; - } - } - if (spec & __Pyx_MEMVIEW_FOLLOW) { - Py_ssize_t stride = buf->strides[dim]; - if (stride < 0) - stride = -stride; - if (unlikely(stride < buf->itemsize)) { - PyErr_SetString(PyExc_ValueError, - "Buffer and memoryview are not contiguous " - "in the same dimension."); - goto fail; - } - } - } else { - if (unlikely(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))) { - PyErr_Format(PyExc_ValueError, - "C-contiguous buffer is not indirect in " - "dimension %d", dim); - goto fail; - } else if (unlikely(buf->suboffsets)) { - PyErr_SetString(PyExc_ValueError, - "Buffer exposes suboffsets but no strides"); - goto fail; - } - } - return 1; -fail: - return 0; -} -static int -__pyx_check_suboffsets(Py_buffer *buf, int dim, int ndim, int spec) -{ - CYTHON_UNUSED_VAR(ndim); - if (spec & __Pyx_MEMVIEW_DIRECT) { - if (unlikely(buf->suboffsets && buf->suboffsets[dim] >= 0)) { - PyErr_Format(PyExc_ValueError, - "Buffer not compatible with direct access " - "in dimension %d.", dim); - goto fail; - } - } - if (spec & __Pyx_MEMVIEW_PTR) { - if (unlikely(!buf->suboffsets || (buf->suboffsets[dim] < 0))) { - PyErr_Format(PyExc_ValueError, - "Buffer is not indirectly accessible " - "in dimension %d.", dim); - goto fail; - } - } - return 1; -fail: - return 0; -} -static int -__pyx_verify_contig(Py_buffer *buf, int ndim, int c_or_f_flag) -{ - int i; - 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)) { - PyErr_SetString(PyExc_ValueError, - "Buffer not fortran contiguous."); - goto fail; - } - stride = stride * buf->shape[i]; - } - } 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)) { - PyErr_SetString(PyExc_ValueError, - "Buffer not C contiguous."); - goto fail; - } - stride = stride * buf->shape[i]; - } - } - return 1; -fail: - return 0; -} -static int __Pyx_ValidateAndInit_memviewslice( - int *axes_specs, - int c_or_f_flag, - int buf_flags, - int ndim, - __Pyx_TypeInfo *dtype, - __Pyx_BufFmt_StackElem stack[], - __Pyx_memviewslice *memviewslice, - PyObject *original_obj) -{ - struct __pyx_memoryview_obj *memview, *new_memview; - __Pyx_RefNannyDeclarations - Py_buffer *buf; - int i, spec = 0, retval = -1; - __Pyx_BufFmt_Context ctx; - int from_memoryview = __pyx_memoryview_check(original_obj); - __Pyx_RefNannySetupContext("ValidateAndInit_memviewslice", 0); - if (from_memoryview && __pyx_typeinfo_cmp(dtype, ((struct __pyx_memoryview_obj *) - original_obj)->typeinfo)) { - memview = (struct __pyx_memoryview_obj *) original_obj; - new_memview = NULL; - } else { - memview = (struct __pyx_memoryview_obj *) __pyx_memoryview_new( - original_obj, buf_flags, 0, dtype); - new_memview = memview; - if (unlikely(!memview)) - goto fail; - } - buf = &memview->view; - if (unlikely(buf->ndim != ndim)) { - PyErr_Format(PyExc_ValueError, - "Buffer has wrong number of dimensions (expected %d, got %d)", - ndim, buf->ndim); - goto fail; - } - if (new_memview) { - __Pyx_BufFmt_Init(&ctx, stack, dtype); - if (unlikely(!__Pyx_BufFmt_CheckString(&ctx, buf->format))) goto fail; - } - if (unlikely((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)", - buf->itemsize, - (buf->itemsize > 1) ? "s" : "", - dtype->name, - dtype->size, - (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))) - goto fail; - } - if (unlikely(__Pyx_init_memviewslice(memview, ndim, memviewslice, - new_memview != NULL) == -1)) { - goto fail; - } - retval = 0; - goto no_fail; -fail: - Py_XDECREF(new_memview); - retval = -1; -no_fail: - __Pyx_RefNannyFinishContext(); - return retval; -} - -/* ObjectToMemviewSlice */ - static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_int(PyObject *obj, int writable_flag) { - __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; - __Pyx_BufFmt_StackElem stack[1]; - int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_FOLLOW), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_FOLLOW), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) }; - int retcode; - if (obj == Py_None) { - result.memview = (struct __pyx_memoryview_obj *) Py_None; - return result; - } - retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG, - (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 3, - &__Pyx_TypeInfo_int, stack, - &result, obj); - if (unlikely(retcode == -1)) - goto __pyx_fail; - return result; -__pyx_fail: - result.memview = NULL; - result.data = NULL; - return result; -} - -/* ObjectToMemviewSlice */ - static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_d_dc_float(PyObject *obj, int writable_flag) { - __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; - __Pyx_BufFmt_StackElem stack[1]; - int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_FOLLOW), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_FOLLOW), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) }; - int retcode; - if (obj == Py_None) { - result.memview = (struct __pyx_memoryview_obj *) Py_None; - return result; - } - retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG, - (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 3, - &__Pyx_TypeInfo_float, stack, - &result, obj); - if (unlikely(retcode == -1)) - goto __pyx_fail; - return result; -__pyx_fail: - result.memview = NULL; - result.data = NULL; - return result; -} - -/* ObjectToMemviewSlice */ - static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_int(PyObject *obj, int writable_flag) { - __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; - __Pyx_BufFmt_StackElem stack[1]; - int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) }; - int retcode; - if (obj == Py_None) { - result.memview = (struct __pyx_memoryview_obj *) Py_None; - return result; - } - retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG, - (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 1, - &__Pyx_TypeInfo_int, stack, - &result, obj); - if (unlikely(retcode == -1)) - goto __pyx_fail; - return result; -__pyx_fail: - result.memview = NULL; - result.data = NULL; - return result; -} - -/* CIntFromPyVerify */ - #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ - __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) -#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ - __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) -#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ - {\ - func_type value = func_value;\ - if (sizeof(target_type) < sizeof(func_type)) {\ - if (unlikely(value != (func_type) (target_type) value)) {\ - func_type zero = 0;\ - if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ - return (target_type) -1;\ - if (is_unsigned && unlikely(value < zero))\ - goto raise_neg_overflow;\ - else\ - goto raise_overflow;\ - }\ - }\ - return (target_type) value;\ - } - -/* Declarations */ - #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) - #ifdef __cplusplus - static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { - return ::std::complex< float >(x, y); - } - #else - static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { - return x + y*(__pyx_t_float_complex)_Complex_I; - } - #endif -#else - static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { - __pyx_t_float_complex z; - z.real = x; - z.imag = y; - return z; - } -#endif - -/* Arithmetic */ - #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) -#else - static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { - return (a.real == b.real) && (a.imag == b.imag); - } - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { - __pyx_t_float_complex z; - z.real = a.real + b.real; - z.imag = a.imag + b.imag; - return z; - } - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { - __pyx_t_float_complex z; - z.real = a.real - b.real; - z.imag = a.imag - b.imag; - return z; - } - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { - __pyx_t_float_complex z; - z.real = a.real * b.real - a.imag * b.imag; - z.imag = a.real * b.imag + a.imag * b.real; - return z; - } - #if 1 - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { - if (b.imag == 0) { - return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); - } else if (fabsf(b.real) >= fabsf(b.imag)) { - if (b.real == 0 && b.imag == 0) { - return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag); - } else { - float r = b.imag / b.real; - float s = (float)(1.0) / (b.real + b.imag * r); - return __pyx_t_float_complex_from_parts( - (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); - } - } else { - float r = b.real / b.imag; - float s = (float)(1.0) / (b.imag + b.real * r); - return __pyx_t_float_complex_from_parts( - (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); - } - } - #else - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { - if (b.imag == 0) { - return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); - } else { - float denom = b.real * b.real + b.imag * b.imag; - return __pyx_t_float_complex_from_parts( - (a.real * b.real + a.imag * b.imag) / denom, - (a.imag * b.real - a.real * b.imag) / denom); - } - } - #endif - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) { - __pyx_t_float_complex z; - z.real = -a.real; - z.imag = -a.imag; - return z; - } - static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) { - return (a.real == 0) && (a.imag == 0); - } - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) { - __pyx_t_float_complex z; - z.real = a.real; - z.imag = -a.imag; - return z; - } - #if 1 - static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) { - #if !defined(HAVE_HYPOT) || defined(_MSC_VER) - return sqrtf(z.real*z.real + z.imag*z.imag); - #else - return hypotf(z.real, z.imag); - #endif - } - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { - __pyx_t_float_complex z; - float r, lnr, theta, z_r, z_theta; - if (b.imag == 0 && b.real == (int)b.real) { - if (b.real < 0) { - float denom = a.real * a.real + a.imag * a.imag; - a.real = a.real / denom; - a.imag = -a.imag / denom; - b.real = -b.real; - } - switch ((int)b.real) { - case 0: - z.real = 1; - z.imag = 0; - return z; - case 1: - return a; - case 2: - return __Pyx_c_prod_float(a, a); - case 3: - z = __Pyx_c_prod_float(a, a); - return __Pyx_c_prod_float(z, a); - case 4: - z = __Pyx_c_prod_float(a, a); - return __Pyx_c_prod_float(z, z); - } - } - if (a.imag == 0) { - if (a.real == 0) { - return a; - } else if ((b.imag == 0) && (a.real >= 0)) { - z.real = powf(a.real, b.real); - z.imag = 0; - return z; - } else if (a.real > 0) { - r = a.real; - theta = 0; - } else { - r = -a.real; - theta = atan2f(0.0, -1.0); - } - } else { - r = __Pyx_c_abs_float(a); - theta = atan2f(a.imag, a.real); - } - lnr = logf(r); - z_r = expf(lnr * b.real - theta * b.imag); - z_theta = theta * b.real + lnr * b.imag; - z.real = z_r * cosf(z_theta); - z.imag = z_r * sinf(z_theta); - return z; - } - #endif -#endif - -/* Declarations */ - #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) - #ifdef __cplusplus - static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { - return ::std::complex< double >(x, y); - } - #else - static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { - return x + y*(__pyx_t_double_complex)_Complex_I; - } - #endif -#else - static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { - __pyx_t_double_complex z; - z.real = x; - z.imag = y; - return z; - } -#endif - -/* Arithmetic */ - #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) -#else - static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { - return (a.real == b.real) && (a.imag == b.imag); - } - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { - __pyx_t_double_complex z; - z.real = a.real + b.real; - z.imag = a.imag + b.imag; - return z; - } - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { - __pyx_t_double_complex z; - z.real = a.real - b.real; - z.imag = a.imag - b.imag; - return z; - } - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { - __pyx_t_double_complex z; - z.real = a.real * b.real - a.imag * b.imag; - z.imag = a.real * b.imag + a.imag * b.real; - return z; - } - #if 1 - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { - if (b.imag == 0) { - return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); - } else if (fabs(b.real) >= fabs(b.imag)) { - if (b.real == 0 && b.imag == 0) { - return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag); - } else { - double r = b.imag / b.real; - double s = (double)(1.0) / (b.real + b.imag * r); - return __pyx_t_double_complex_from_parts( - (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); - } - } else { - double r = b.real / b.imag; - double s = (double)(1.0) / (b.imag + b.real * r); - return __pyx_t_double_complex_from_parts( - (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); - } - } - #else - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { - if (b.imag == 0) { - return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); - } else { - double denom = b.real * b.real + b.imag * b.imag; - return __pyx_t_double_complex_from_parts( - (a.real * b.real + a.imag * b.imag) / denom, - (a.imag * b.real - a.real * b.imag) / denom); - } - } - #endif - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) { - __pyx_t_double_complex z; - z.real = -a.real; - z.imag = -a.imag; - return z; - } - static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) { - return (a.real == 0) && (a.imag == 0); - } - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) { - __pyx_t_double_complex z; - z.real = a.real; - z.imag = -a.imag; - return z; - } - #if 1 - static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) { - #if !defined(HAVE_HYPOT) || defined(_MSC_VER) - return sqrt(z.real*z.real + z.imag*z.imag); - #else - return hypot(z.real, z.imag); - #endif - } - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { - __pyx_t_double_complex z; - double r, lnr, theta, z_r, z_theta; - if (b.imag == 0 && b.real == (int)b.real) { - if (b.real < 0) { - double denom = a.real * a.real + a.imag * a.imag; - a.real = a.real / denom; - a.imag = -a.imag / denom; - b.real = -b.real; - } - switch ((int)b.real) { - case 0: - z.real = 1; - z.imag = 0; - return z; - case 1: - return a; - case 2: - return __Pyx_c_prod_double(a, a); - case 3: - z = __Pyx_c_prod_double(a, a); - return __Pyx_c_prod_double(z, a); - case 4: - z = __Pyx_c_prod_double(a, a); - return __Pyx_c_prod_double(z, z); - } - } - if (a.imag == 0) { - if (a.real == 0) { - return a; - } else if ((b.imag == 0) && (a.real >= 0)) { - z.real = pow(a.real, b.real); - z.imag = 0; - return z; - } else if (a.real > 0) { - r = a.real; - theta = 0; - } else { - r = -a.real; - theta = atan2(0.0, -1.0); - } - } else { - r = __Pyx_c_abs_double(a); - theta = atan2(a.imag, a.real); - } - lnr = log(r); - z_r = exp(lnr * b.real - theta * b.imag); - z_theta = theta * b.real + lnr * b.imag; - z.real = z_r * cos(z_theta); - z.imag = z_r * sin(z_theta); - return z; - } - #endif -#endif - -/* MemviewSliceCopyTemplate */ - static __Pyx_memviewslice -__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, - const char *mode, int ndim, - size_t sizeof_dtype, int contig_flag, - int dtype_is_object) -{ - __Pyx_RefNannyDeclarations - int i; - __Pyx_memviewslice new_mvs = { 0, 0, { 0 }, { 0 }, { 0 } }; - struct __pyx_memoryview_obj *from_memview = from_mvs->memview; - Py_buffer *buf = &from_memview->view; - PyObject *shape_tuple = NULL; - PyObject *temp_int = NULL; - struct __pyx_array_obj *array_obj = NULL; - 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)) { - PyErr_Format(PyExc_ValueError, "Cannot copy memoryview slice with " - "indirect dimensions (axis %d)", i); - goto fail; - } - } - shape_tuple = PyTuple_New(ndim); - if (unlikely(!shape_tuple)) { - goto fail; - } - __Pyx_GOTREF(shape_tuple); - for(i = 0; i < ndim; i++) { - temp_int = PyInt_FromSsize_t(from_mvs->shape[i]); - if(unlikely(!temp_int)) { - goto fail; - } else { - PyTuple_SET_ITEM(shape_tuple, i, temp_int); - temp_int = NULL; - } - } - array_obj = __pyx_array_new(shape_tuple, sizeof_dtype, buf->format, (char *) mode, NULL); - if (unlikely(!array_obj)) { - goto fail; - } - __Pyx_GOTREF(array_obj); - memview_obj = (struct __pyx_memoryview_obj *) __pyx_memoryview_new( - (PyObject *) array_obj, contig_flag, - dtype_is_object, - from_mvs->memview->typeinfo); - if (unlikely(!memview_obj)) - goto fail; - if (unlikely(__Pyx_init_memviewslice(memview_obj, ndim, &new_mvs, 1) < 0)) - goto fail; - if (unlikely(__pyx_memoryview_copy_contents(*from_mvs, new_mvs, ndim, ndim, - dtype_is_object) < 0)) - goto fail; - goto no_fail; -fail: - __Pyx_XDECREF(new_mvs.memview); - new_mvs.memview = NULL; - new_mvs.data = NULL; -no_fail: - __Pyx_XDECREF(shape_tuple); - __Pyx_XDECREF(temp_int); - __Pyx_XDECREF(array_obj); - __Pyx_RefNannyFinishContext(); - return new_mvs; -} - -/* MemviewSliceInit */ - static int -__Pyx_init_memviewslice(struct __pyx_memoryview_obj *memview, - int ndim, - __Pyx_memviewslice *memviewslice, - int memview_is_new_reference) -{ - __Pyx_RefNannyDeclarations - int i, retval=-1; - Py_buffer *buf = &memview->view; - __Pyx_RefNannySetupContext("init_memviewslice", 0); - if (unlikely(memviewslice->memview || memviewslice->data)) { - PyErr_SetString(PyExc_ValueError, - "memviewslice is already initialized!"); - goto fail; - } - if (buf->strides) { - for (i = 0; i < ndim; i++) { - memviewslice->strides[i] = buf->strides[i]; - } - } else { - Py_ssize_t stride = buf->itemsize; - for (i = ndim - 1; i >= 0; i--) { - memviewslice->strides[i] = stride; - stride *= buf->shape[i]; - } - } - for (i = 0; i < ndim; i++) { - memviewslice->shape[i] = buf->shape[i]; - if (buf->suboffsets) { - memviewslice->suboffsets[i] = buf->suboffsets[i]; - } else { - memviewslice->suboffsets[i] = -1; - } - } - memviewslice->memview = memview; - memviewslice->data = (char *)buf->buf; - if (__pyx_add_acquisition_count(memview) == 0 && !memview_is_new_reference) { - Py_INCREF(memview); - } - retval = 0; - goto no_fail; -fail: - memviewslice->memview = 0; - memviewslice->data = 0; - retval = -1; -no_fail: - __Pyx_RefNannyFinishContext(); - return retval; -} -#ifndef Py_NO_RETURN -#define Py_NO_RETURN -#endif -static void __pyx_fatalerror(const char *fmt, ...) Py_NO_RETURN { - va_list vargs; - char msg[200]; -#if PY_VERSION_HEX >= 0x030A0000 || defined(HAVE_STDARG_PROTOTYPES) - va_start(vargs, fmt); -#else - va_start(vargs); -#endif - vsnprintf(msg, 200, fmt, vargs); - va_end(vargs); - Py_FatalError(msg); -} -static CYTHON_INLINE int -__pyx_add_acquisition_count_locked(__pyx_atomic_int_type *acquisition_count, - PyThread_type_lock lock) -{ - int result; - PyThread_acquire_lock(lock, 1); - result = (*acquisition_count)++; - PyThread_release_lock(lock); - return result; -} -static CYTHON_INLINE int -__pyx_sub_acquisition_count_locked(__pyx_atomic_int_type *acquisition_count, - PyThread_type_lock lock) -{ - int result; - PyThread_acquire_lock(lock, 1); - result = (*acquisition_count)--; - PyThread_release_lock(lock); - return result; -} -static CYTHON_INLINE void -__Pyx_INC_MEMVIEW(__Pyx_memviewslice *memslice, int have_gil, int lineno) -{ - __pyx_nonatomic_int_type old_acquisition_count; - struct __pyx_memoryview_obj *memview = memslice->memview; - if (unlikely(!memview || (PyObject *) memview == Py_None)) { - return; - } - old_acquisition_count = __pyx_add_acquisition_count(memview); - if (unlikely(old_acquisition_count <= 0)) { - if (likely(old_acquisition_count == 0)) { - if (have_gil) { - Py_INCREF((PyObject *) memview); - } else { - PyGILState_STATE _gilstate = PyGILState_Ensure(); - Py_INCREF((PyObject *) memview); - PyGILState_Release(_gilstate); - } - } else { - __pyx_fatalerror("Acquisition count is %d (line %d)", - old_acquisition_count+1, lineno); - } - } -} -static CYTHON_INLINE void __Pyx_XCLEAR_MEMVIEW(__Pyx_memviewslice *memslice, - int have_gil, int lineno) { - __pyx_nonatomic_int_type old_acquisition_count; - struct __pyx_memoryview_obj *memview = memslice->memview; - if (unlikely(!memview || (PyObject *) memview == Py_None)) { - memslice->memview = NULL; - return; - } - old_acquisition_count = __pyx_sub_acquisition_count(memview); - memslice->data = NULL; - if (likely(old_acquisition_count > 1)) { - memslice->memview = NULL; - } else if (likely(old_acquisition_count == 1)) { - if (have_gil) { - Py_CLEAR(memslice->memview); - } else { - PyGILState_STATE _gilstate = PyGILState_Ensure(); - Py_CLEAR(memslice->memview); - PyGILState_Release(_gilstate); - } - } else { - __pyx_fatalerror("Acquisition count is %d (line %d)", - old_acquisition_count-1, lineno); - } -} - -/* CIntToPy */ - static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const int neg_one = (int) -1, const_zero = (int) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(int) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(int) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(int) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(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; -#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 - return _PyLong_FromByteArray(bytes, sizeof(int), - little, !is_unsigned); -#else - PyObject *from_bytes, *result = NULL; - PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; - from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); - if (!from_bytes) return NULL; - py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); - if (!py_bytes) goto limited_bad; - order_str = PyUnicode_FromString(little ? "little" : "big"); - if (!order_str) goto limited_bad; - arg_tuple = PyTuple_Pack(2, py_bytes, order_str); - if (!arg_tuple) goto limited_bad; - if (!is_unsigned) { - kwds = PyDict_New(); - if (!kwds) goto limited_bad; - if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; - } - result = PyObject_Call(from_bytes, arg_tuple, kwds); - limited_bad: - Py_XDECREF(kwds); - Py_XDECREF(arg_tuple); - Py_XDECREF(order_str); - Py_XDECREF(py_bytes); - Py_XDECREF(from_bytes); - return result; -#endif - } -} - -/* CIntFromPy */ - static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const int neg_one = (int) -1, const_zero = (int) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(int) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (int) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { -#if CYTHON_USE_PYLONG_INTERNALS - if (unlikely(__Pyx_PyLong_IsNeg(x))) { - goto raise_neg_overflow; - } else if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_DigitCount(x)) { - case 2: - if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { - return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); - } - } - break; - case 3: - if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { - return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); - } - } - break; - case 4: - if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(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(int) >= 4 * PyLong_SHIFT)) { - return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); - } - } - break; - } - } -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 - 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 (int) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#endif - if ((sizeof(int) <= sizeof(unsigned long))) { - __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif - } - } else { -#if CYTHON_USE_PYLONG_INTERNALS - if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_SignedDigitCount(x)) { - case -2: - if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { - return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case 2: - if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { - return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case -3: - if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { - return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case 3: - if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { - return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case -4: - if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(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(int) - 1 > 4 * PyLong_SHIFT)) { - return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case 4: - if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(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(int) - 1 > 4 * PyLong_SHIFT)) { - return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - } - } -#endif - if ((sizeof(int) <= sizeof(long))) { - __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif - } - } - { - 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 ret = -1; -#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (int) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (int) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (int) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (int) -1; - } else { - stepval = __Pyx_NewRef(v); - } - val = (int) 0; - mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; - shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; - for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { - PyObject *tmp, *digit; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((int) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - idigit = PyLong_AsLong(stepval); - if (unlikely(idigit < 0)) goto done; - remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); - if (unlikely(idigit >= (1L << remaining_bits))) - goto raise_overflow; - val |= ((int) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - if (!is_unsigned) { - if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) - goto raise_overflow; - if (is_negative) - val = ~val; - } - ret = 0; - done: - Py_XDECREF(shift); - Py_XDECREF(mask); - Py_XDECREF(stepval); -#endif - Py_DECREF(v); - if (likely(!ret)) - return val; - } - return (int) -1; - } - } else { - int val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (int) -1; - val = __Pyx_PyInt_As_int(tmp); - Py_DECREF(tmp); - return val; - } -raise_overflow: - PyErr_SetString(PyExc_OverflowError, - "value too large to convert to int"); - return (int) -1; -raise_neg_overflow: - PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to int"); - return (int) -1; -} - -/* CIntToPy */ - static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const long neg_one = (long) -1, const_zero = (long) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(long) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(long) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(long) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= 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; -#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 - return _PyLong_FromByteArray(bytes, sizeof(long), - little, !is_unsigned); -#else - PyObject *from_bytes, *result = NULL; - PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; - from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); - if (!from_bytes) return NULL; - py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); - if (!py_bytes) goto limited_bad; - order_str = PyUnicode_FromString(little ? "little" : "big"); - if (!order_str) goto limited_bad; - arg_tuple = PyTuple_Pack(2, py_bytes, order_str); - if (!arg_tuple) goto limited_bad; - if (!is_unsigned) { - kwds = PyDict_New(); - if (!kwds) goto limited_bad; - if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; - } - result = PyObject_Call(from_bytes, arg_tuple, kwds); - limited_bad: - Py_XDECREF(kwds); - Py_XDECREF(arg_tuple); - Py_XDECREF(order_str); - Py_XDECREF(py_bytes); - Py_XDECREF(from_bytes); - return result; -#endif - } -} - -/* CIntFromPy */ - static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const long neg_one = (long) -1, const_zero = (long) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(long) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (long) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { -#if CYTHON_USE_PYLONG_INTERNALS - if (unlikely(__Pyx_PyLong_IsNeg(x))) { - goto raise_neg_overflow; - } else if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_DigitCount(x)) { - case 2: - if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { - return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); - } - } - break; - case 3: - if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { - return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); - } - } - break; - case 4: - if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, 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(long) >= 4 * PyLong_SHIFT)) { - return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); - } - } - break; - } - } -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 - 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 (long) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#endif - if ((sizeof(long) <= sizeof(unsigned long))) { - __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif - } - } else { -#if CYTHON_USE_PYLONG_INTERNALS - if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_SignedDigitCount(x)) { - case -2: - if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { - return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case 2: - if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { - return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case -3: - if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { - return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case 3: - if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { - return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case -4: - if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, 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(long) - 1 > 4 * PyLong_SHIFT)) { - return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case 4: - if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, 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(long) - 1 > 4 * PyLong_SHIFT)) { - return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - } - } -#endif - if ((sizeof(long) <= sizeof(long))) { - __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif - } - } - { - long 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 ret = -1; -#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (long) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (long) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (long) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (long) -1; - } else { - stepval = __Pyx_NewRef(v); - } - val = (long) 0; - mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; - shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; - for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { - PyObject *tmp, *digit; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((long) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - idigit = PyLong_AsLong(stepval); - if (unlikely(idigit < 0)) goto done; - remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); - if (unlikely(idigit >= (1L << remaining_bits))) - goto raise_overflow; - val |= ((long) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - if (!is_unsigned) { - if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) - goto raise_overflow; - if (is_negative) - val = ~val; - } - ret = 0; - done: - Py_XDECREF(shift); - Py_XDECREF(mask); - Py_XDECREF(stepval); -#endif - Py_DECREF(v); - if (likely(!ret)) - return val; - } - return (long) -1; - } - } else { - long val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (long) -1; - val = __Pyx_PyInt_As_long(tmp); - Py_DECREF(tmp); - return val; - } -raise_overflow: - PyErr_SetString(PyExc_OverflowError, - "value too large to convert to long"); - return (long) -1; -raise_neg_overflow: - PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to long"); - return (long) -1; -} - -/* CIntFromPy */ - static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const char neg_one = (char) -1, const_zero = (char) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(char) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(char, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (char) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { -#if CYTHON_USE_PYLONG_INTERNALS - if (unlikely(__Pyx_PyLong_IsNeg(x))) { - goto raise_neg_overflow; - } else if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(char, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_DigitCount(x)) { - case 2: - if ((8 * sizeof(char) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(char) >= 2 * PyLong_SHIFT)) { - return (char) (((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); - } - } - break; - case 3: - if ((8 * sizeof(char) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(char) >= 3 * PyLong_SHIFT)) { - return (char) (((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); - } - } - break; - case 4: - if ((8 * sizeof(char) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(char, 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(char) >= 4 * PyLong_SHIFT)) { - return (char) (((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); - } - } - break; - } - } -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 - 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 (char) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#endif - if ((sizeof(char) <= sizeof(unsigned long))) { - __PYX_VERIFY_RETURN_INT_EXC(char, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(char) <= sizeof(unsigned PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(char, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif - } - } else { -#if CYTHON_USE_PYLONG_INTERNALS - if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(char, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_SignedDigitCount(x)) { - case -2: - if ((8 * sizeof(char) - 1 > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(char) - 1 > 2 * PyLong_SHIFT)) { - return (char) (((char)-1)*(((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); - } - } - break; - case 2: - if ((8 * sizeof(char) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(char) - 1 > 2 * PyLong_SHIFT)) { - return (char) ((((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); - } - } - break; - case -3: - if ((8 * sizeof(char) - 1 > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(char) - 1 > 3 * PyLong_SHIFT)) { - return (char) (((char)-1)*(((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); - } - } - break; - case 3: - if ((8 * sizeof(char) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(char) - 1 > 3 * PyLong_SHIFT)) { - return (char) ((((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); - } - } - break; - case -4: - if ((8 * sizeof(char) - 1 > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(char, 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(char) - 1 > 4 * PyLong_SHIFT)) { - return (char) (((char)-1)*(((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); - } - } - break; - case 4: - if ((8 * sizeof(char) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(char, 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(char) - 1 > 4 * PyLong_SHIFT)) { - return (char) ((((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); - } - } - break; - } - } -#endif - if ((sizeof(char) <= sizeof(long))) { - __PYX_VERIFY_RETURN_INT_EXC(char, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(char) <= sizeof(PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(char, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif - } - } - { - char 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 ret = -1; -#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (char) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (char) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (char) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (char) -1; - } else { - stepval = __Pyx_NewRef(v); - } - val = (char) 0; - mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; - shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; - for (bits = 0; bits < (int) sizeof(char) * 8 - chunk_size; bits += chunk_size) { - PyObject *tmp, *digit; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((char) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - idigit = PyLong_AsLong(stepval); - if (unlikely(idigit < 0)) goto done; - remaining_bits = ((int) sizeof(char) * 8) - bits - (is_unsigned ? 0 : 1); - if (unlikely(idigit >= (1L << remaining_bits))) - goto raise_overflow; - val |= ((char) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - if (!is_unsigned) { - if (unlikely(val & (((char) 1) << (sizeof(char) * 8 - 1)))) - goto raise_overflow; - if (is_negative) - val = ~val; - } - ret = 0; - done: - Py_XDECREF(shift); - Py_XDECREF(mask); - Py_XDECREF(stepval); -#endif - Py_DECREF(v); - if (likely(!ret)) - return val; - } - return (char) -1; - } - } else { - char val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (char) -1; - val = __Pyx_PyInt_As_char(tmp); - Py_DECREF(tmp); - return val; - } -raise_overflow: - PyErr_SetString(PyExc_OverflowError, - "value too large to convert to char"); - return (char) -1; -raise_neg_overflow: - PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to char"); - return (char) -1; -} - -/* FormatTypeName */ - #if CYTHON_COMPILING_IN_LIMITED_API -static __Pyx_TypeName -__Pyx_PyType_GetName(PyTypeObject* tp) -{ - PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, - __pyx_n_s_name_2); - if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { - PyErr_Clear(); - Py_XDECREF(name); - name = __Pyx_NewRef(__pyx_n_s__25); - } - return name; -} -#endif - -/* CheckBinaryVersion */ - static unsigned long __Pyx_get_runtime_version(void) { -#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4 - return Py_Version & ~0xFFUL; -#else - const char* rt_version = Py_GetVersion(); - unsigned long version = 0; - unsigned long factor = 0x01000000UL; - unsigned int digit = 0; - int i = 0; - while (factor) { - while ('0' <= rt_version[i] && rt_version[i] <= '9') { - digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); - ++i; - } - version += factor * digit; - if (rt_version[i] != '.') - break; - digit = 0; - factor >>= 8; - ++i; - } - return version; -#endif -} -static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { - const unsigned long MAJOR_MINOR = 0xFFFF0000UL; - if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) - return 0; - if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) - return 1; - { - char message[200]; - PyOS_snprintf(message, sizeof(message), - "compile time Python version %d.%d " - "of module '%.100s' " - "%s " - "runtime version %d.%d", - (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), - __Pyx_MODULE_NAME, - (allow_newer) ? "was newer than" : "does not match", - (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) - ); - return PyErr_WarnEx(NULL, message, 1); - } -} - -/* InitStrings */ - #if PY_MAJOR_VERSION >= 3 -static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { - if (t.is_unicode | t.is_str) { - if (t.intern) { - *str = PyUnicode_InternFromString(t.s); - } else if (t.encoding) { - *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL); - } else { - *str = PyUnicode_FromStringAndSize(t.s, t.n - 1); - } - } else { - *str = PyBytes_FromStringAndSize(t.s, t.n - 1); - } - if (!*str) - return -1; - if (PyObject_Hash(*str) == -1) - return -1; - return 0; -} -#endif -static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { - while (t->p) { - #if PY_MAJOR_VERSION >= 3 - __Pyx_InitString(*t, t->p); - #else - if (t->is_unicode) { - *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); - } else if (t->intern) { - *t->p = PyString_InternFromString(t->s); - } else { - *t->p = PyString_FromStringAndSize(t->s, t->n - 1); - } - if (!*t->p) - return -1; - if (PyObject_Hash(*t->p) == -1) - return -1; - #endif - ++t; - } - return 0; -} - -#include -static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { - size_t len = strlen(s); - if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { - PyErr_SetString(PyExc_OverflowError, "byte string is too long"); - return -1; - } - return (Py_ssize_t) len; -} -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { - Py_ssize_t len = __Pyx_ssize_strlen(c_str); - if (unlikely(len < 0)) return NULL; - return __Pyx_PyUnicode_FromStringAndSize(c_str, len); -} -static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { - Py_ssize_t len = __Pyx_ssize_strlen(c_str); - if (unlikely(len < 0)) return NULL; - return PyByteArray_FromStringAndSize(c_str, len); -} -static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { - Py_ssize_t ignore; - return __Pyx_PyObject_AsStringAndSize(o, &ignore); -} -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT -#if !CYTHON_PEP393_ENABLED -static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { - char* defenc_c; - PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); - if (!defenc) return NULL; - defenc_c = PyBytes_AS_STRING(defenc); -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII - { - char* end = defenc_c + PyBytes_GET_SIZE(defenc); - char* c; - for (c = defenc_c; c < end; c++) { - if ((unsigned char) (*c) >= 128) { - PyUnicode_AsASCIIString(o); - return NULL; - } - } - } -#endif - *length = PyBytes_GET_SIZE(defenc); - return defenc_c; -} -#else -static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { - if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII - if (likely(PyUnicode_IS_ASCII(o))) { - *length = PyUnicode_GET_LENGTH(o); - return PyUnicode_AsUTF8(o); - } else { - PyUnicode_AsASCIIString(o); - return NULL; - } -#else - return PyUnicode_AsUTF8AndSize(o, length); -#endif -} -#endif -#endif -static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT - if ( -#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII - __Pyx_sys_getdefaultencoding_not_ascii && -#endif - PyUnicode_Check(o)) { - return __Pyx_PyUnicode_AsStringAndSize(o, length); - } else -#endif -#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) - if (PyByteArray_Check(o)) { - *length = PyByteArray_GET_SIZE(o); - return PyByteArray_AS_STRING(o); - } else -#endif - { - char* result; - int r = PyBytes_AsStringAndSize(o, &result, length); - if (unlikely(r < 0)) { - return NULL; - } else { - return result; - } - } -} -static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { - int is_true = x == Py_True; - if (is_true | (x == Py_False) | (x == Py_None)) return is_true; - else return PyObject_IsTrue(x); -} -static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { - int retval; - if (unlikely(!x)) return -1; - retval = __Pyx_PyObject_IsTrue(x); - Py_DECREF(x); - return retval; -} -static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { - __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); -#if PY_MAJOR_VERSION >= 3 - if (PyLong_Check(result)) { - if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, - "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " - "The ability to return an instance of a strict subclass of int is deprecated, " - "and may be removed in a future version of Python.", - result_type_name)) { - __Pyx_DECREF_TypeName(result_type_name); - Py_DECREF(result); - return NULL; - } - __Pyx_DECREF_TypeName(result_type_name); - return result; - } -#endif - PyErr_Format(PyExc_TypeError, - "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", - type_name, type_name, result_type_name); - __Pyx_DECREF_TypeName(result_type_name); - Py_DECREF(result); - return NULL; -} -static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { -#if CYTHON_USE_TYPE_SLOTS - PyNumberMethods *m; -#endif - const char *name = NULL; - PyObject *res = NULL; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x) || PyLong_Check(x))) -#else - if (likely(PyLong_Check(x))) -#endif - return __Pyx_NewRef(x); -#if CYTHON_USE_TYPE_SLOTS - m = Py_TYPE(x)->tp_as_number; - #if PY_MAJOR_VERSION < 3 - if (m && m->nb_int) { - name = "int"; - res = m->nb_int(x); - } - else if (m && m->nb_long) { - name = "long"; - res = m->nb_long(x); - } - #else - if (likely(m && m->nb_int)) { - name = "int"; - res = m->nb_int(x); - } - #endif -#else - if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { - res = PyNumber_Int(x); - } -#endif - if (likely(res)) { -#if PY_MAJOR_VERSION < 3 - if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { -#else - if (unlikely(!PyLong_CheckExact(res))) { -#endif - return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); - } - } - else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_TypeError, - "an integer is required"); - } - return res; -} -static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { - Py_ssize_t ival; - PyObject *x; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_CheckExact(b))) { - if (sizeof(Py_ssize_t) >= sizeof(long)) - return PyInt_AS_LONG(b); - else - return PyInt_AsSsize_t(b); - } -#endif - if (likely(PyLong_CheckExact(b))) { - #if CYTHON_USE_PYLONG_INTERNALS - if (likely(__Pyx_PyLong_IsCompact(b))) { - return __Pyx_PyLong_CompactValue(b); - } else { - const digit* digits = __Pyx_PyLong_Digits(b); - const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); - switch (size) { - case 2: - if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { - return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case -2: - if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { - return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case 3: - if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { - return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case -3: - if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { - return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case 4: - if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { - return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case -4: - if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { - return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - } - } - #endif - return PyLong_AsSsize_t(b); - } - x = PyNumber_Index(b); - if (!x) return -1; - ival = PyInt_AsSsize_t(x); - Py_DECREF(x); - return ival; -} -static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { - if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { - return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); -#if PY_MAJOR_VERSION < 3 - } else if (likely(PyInt_CheckExact(o))) { - return PyInt_AS_LONG(o); -#endif - } else { - Py_ssize_t ival; - PyObject *x; - x = PyNumber_Index(o); - if (!x) return -1; - ival = PyInt_AsLong(x); - Py_DECREF(x); - return ival; - } -} -static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { - return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); -} -static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { - return PyInt_FromSize_t(ival); -} - - -/* #### Code section: utility_code_pragmas_end ### */ -#ifdef _MSC_VER -#pragma warning( pop ) -#endif - - - -/* #### Code section: end ### */ -#endif /* Py_PYTHON_H */ diff --git a/monotonic_align/core.pyx b/monotonic_align/core.pyx deleted file mode 100644 index 6aabccc..0000000 --- a/monotonic_align/core.pyx +++ /dev/null @@ -1,45 +0,0 @@ -import numpy as np -cimport numpy as np -cimport cython -from cython.parallel import prange - - -@cython.boundscheck(False) -@cython.wraparound(False) -cdef void maximum_path_each(int[:,::1] path, float[:,::1] value, int t_x, int t_y, float max_neg_val) nogil: - cdef int x - cdef int y - cdef float v_prev - cdef float v_cur - cdef float tmp - cdef int index = t_x - 1 - - for y in range(t_y): - for x in range(max(0, t_x + y - t_y), min(t_x, y + 1)): - if x == y: - v_cur = max_neg_val - else: - v_cur = value[x, y-1] - if x == 0: - if y == 0: - v_prev = 0. - else: - v_prev = max_neg_val - else: - v_prev = value[x-1, y-1] - value[x, y] = max(v_cur, v_prev) + value[x, y] - - for y in range(t_y - 1, -1, -1): - path[index, y] = 1 - if index != 0 and (index == y or value[index, y-1] < value[index-1, y-1]): - index = index - 1 - - -@cython.boundscheck(False) -@cython.wraparound(False) -cpdef void maximum_path_c(int[:,:,::1] paths, float[:,:,::1] values, int[::1] t_xs, int[::1] t_ys, float max_neg_val=-1e9) nogil: - cdef int b = values.shape[0] - - cdef int i - for i in prange(b, nogil=True): - maximum_path_each(paths[i], values[i], t_xs[i], t_ys[i], max_neg_val) diff --git a/monotonic_align/monotonic_align/core.cpython-311-darwin.so b/monotonic_align/monotonic_align/core.cpython-311-darwin.so deleted file mode 100755 index 8b217b2d58db08c7fee3c9ceacac493402a7b430..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 176376 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 W@VDO>|9Da5N3Y&{@e7Y$X8b>%LM1c+ diff --git a/monotonic_align/monotonic_align/core.cpython-39-x86_64-linux-gnu.so b/monotonic_align/monotonic_align/core.cpython-39-x86_64-linux-gnu.so deleted file mode 100755 index 30b056a77fb4f3accd14fa78358617d689a38623..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 202728 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 diff --git a/monotonic_align/setup.py b/monotonic_align/setup.py deleted file mode 100644 index 36c047f..0000000 --- a/monotonic_align/setup.py +++ /dev/null @@ -1,11 +0,0 @@ -from distutils.core import setup -from Cython.Build import cythonize -import numpy - -setup( - name = 'monotonic_align', - ext_modules = cythonize("core.pyx"), - include_dirs=[numpy.get_include()] -) - -# cd monotonic_align; mkdir monotonic_align; python setup.py build_ext --inplace \ No newline at end of file diff --git a/robo_utils/__init__.py b/robo_utils/__init__.py deleted file mode 100644 index dc67ce3..0000000 --- a/robo_utils/__init__.py +++ /dev/null @@ -1,34 +0,0 @@ -import numpy as np -import torch -import torch.nn.functional as F -from .robo_utils.core import float_to_int_duration_batch_c, generate_random_intervals_batch_c - -def float_to_int_duration(dur, T, mask): - """ Cython optimised version of converting float duration to int duration. - - Args: - dur (torch.Tensor): input float duration, shape (B, I) - T (torch.Tensor): input int duration, shape (B,) - mask (torch.Tensor): mask, shape (B, I) - Returns: - torch.LongTensor: output int duration, shape (B, I) - """ - dur = dur * mask - device = dur.device - dur = dur.data.cpu().numpy().astype(np.float32) - T = T.data.cpu().numpy().astype(np.int32) - mask = mask.data.cpu().numpy().astype(np.int32) - - int_dur = np.zeros_like(dur).astype(dtype=np.int32) - float_to_int_duration_batch_c(dur, T, mask, int_dur) - return torch.from_numpy(int_dur).to(device=device, dtype=torch.long) - -def generate_random_intervals(boundaries_batch, num_randoms): - boundaries_batch = F.pad(boundaries_batch, (1, 0, 0, 0)) - - device = boundaries_batch.device - boundaries_batch = boundaries_batch.data.cpu().numpy().astype(np.int32) - - result_batch = np.zeros((boundaries_batch.shape[0], (boundaries_batch.shape[1] - 1) * (num_randoms + 1)), dtype=np.int32) - generate_random_intervals_batch_c(boundaries_batch, result_batch, num_randoms) - return torch.from_numpy(result_batch).to(device=device, dtype=torch.long) diff --git a/robo_utils/build/lib.linux-x86_64-cpython-39/robo_utils/core.cpython-39-x86_64-linux-gnu.so b/robo_utils/build/lib.linux-x86_64-cpython-39/robo_utils/core.cpython-39-x86_64-linux-gnu.so deleted file mode 100755 index 814bbbee2fb8315c493686e138b75061fe9c1311..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 207016 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 diff --git a/robo_utils/build/temp.linux-x86_64-cpython-39/core.o b/robo_utils/build/temp.linux-x86_64-cpython-39/core.o deleted file mode 100644 index 532c533600c404e893047b552f93a06c7ed8f548..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 274960 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 0x03030000 - #define Py_LIMITED_API CYTHON_LIMITED_API - #else - #define Py_LIMITED_API 0x03030000 - #endif - #endif -#endif - -#include "Python.h" -#ifndef Py_PYTHON_H - #error Python headers needed to compile C extensions, please install development version of Python. -#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) - #error Cython requires Python 2.7+ or Python 3.3+. -#else -#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API -#define __PYX_EXTRA_ABI_MODULE_NAME "limited" -#else -#define __PYX_EXTRA_ABI_MODULE_NAME "" -#endif -#define CYTHON_ABI "3_0_10" __PYX_EXTRA_ABI_MODULE_NAME -#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI -#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." -#define CYTHON_HEX_VERSION 0x03000AF0 -#define CYTHON_FUTURE_DIVISION 1 -#include -#ifndef offsetof - #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) -#endif -#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) - #ifndef __stdcall - #define __stdcall - #endif - #ifndef __cdecl - #define __cdecl - #endif - #ifndef __fastcall - #define __fastcall - #endif -#endif -#ifndef DL_IMPORT - #define DL_IMPORT(t) t -#endif -#ifndef DL_EXPORT - #define DL_EXPORT(t) t -#endif -#define __PYX_COMMA , -#ifndef HAVE_LONG_LONG - #define HAVE_LONG_LONG -#endif -#ifndef PY_LONG_LONG - #define PY_LONG_LONG LONG_LONG -#endif -#ifndef Py_HUGE_VAL - #define Py_HUGE_VAL HUGE_VAL -#endif -#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX -#if defined(GRAALVM_PYTHON) - /* For very preliminary testing purposes. Most variables are set the same as PyPy. - The existence of this section does not imply that anything works or is even tested */ - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 1 - #define CYTHON_COMPILING_IN_NOGIL 0 - #undef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 0 - #undef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 0 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #if PY_VERSION_HEX < 0x03050000 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #undef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 0 - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #undef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 1 - #undef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 0 - #undef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 0 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL 0 - #undef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) - #endif - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #undef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 0 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 - #endif - #undef CYTHON_USE_FREELISTS - #define CYTHON_USE_FREELISTS 0 -#elif defined(PYPY_VERSION) - #define CYTHON_COMPILING_IN_PYPY 1 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 0 - #undef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 0 - #ifndef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 0 - #endif - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #if PY_VERSION_HEX < 0x03050000 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #undef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 0 - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #undef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 1 - #undef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 0 - #undef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 0 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL 0 - #undef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) - #endif - #if PY_VERSION_HEX < 0x03090000 - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #endif - #undef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 0 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 - #endif - #undef CYTHON_USE_FREELISTS - #define CYTHON_USE_FREELISTS 0 -#elif defined(CYTHON_LIMITED_API) - #ifdef Py_LIMITED_API - #undef __PYX_LIMITED_VERSION_HEX - #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API - #endif - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 1 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 0 - #undef CYTHON_CLINE_IN_TRACEBACK - #define CYTHON_CLINE_IN_TRACEBACK 0 - #undef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 0 - #undef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 1 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #undef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #endif - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #ifndef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 0 - #endif - #undef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 0 - #undef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 0 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL 0 - #undef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS 1 - #endif - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #undef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 1 - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #endif - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 - #endif - #undef CYTHON_USE_FREELISTS - #define CYTHON_USE_FREELISTS 0 -#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 1 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 - #endif - #ifndef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 0 - #endif - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #ifndef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #ifndef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #endif - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 - #endif - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #ifndef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 0 - #endif - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL 0 - #ifndef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL 1 - #endif - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS 1 - #endif - #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #endif - #ifndef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 0 - #endif - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 1 - #endif - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 - #endif - #ifndef CYTHON_USE_FREELISTS - #define CYTHON_USE_FREELISTS 0 - #endif -#else - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 1 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 0 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 - #endif - #ifndef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 0 - #endif - #ifndef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 1 - #endif - #if PY_MAJOR_VERSION < 3 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #ifndef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 1 - #endif - #ifndef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 1 - #endif - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 - #endif - #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #elif !defined(CYTHON_USE_UNICODE_WRITER) - #define CYTHON_USE_UNICODE_WRITER 1 - #endif - #ifndef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 0 - #endif - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif - #ifndef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 1 - #endif - #ifndef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) - #endif - #ifndef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) - #endif - #ifndef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 1 - #endif - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS 1 - #endif - #if PY_VERSION_HEX < 0x03050000 - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #endif - #ifndef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 0 - #endif - #if PY_VERSION_HEX < 0x030400a1 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #elif !defined(CYTHON_USE_TP_FINALIZE) - #define CYTHON_USE_TP_FINALIZE 1 - #endif - #if PY_VERSION_HEX < 0x030600B1 - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #elif !defined(CYTHON_USE_DICT_VERSIONS) - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5) - #endif - #if PY_VERSION_HEX < 0x030700A3 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #elif !defined(CYTHON_USE_EXC_INFO_STACK) - #define CYTHON_USE_EXC_INFO_STACK 1 - #endif - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 - #endif - #ifndef CYTHON_USE_FREELISTS - #define CYTHON_USE_FREELISTS 1 - #endif -#endif -#if !defined(CYTHON_FAST_PYCCALL) -#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) -#endif -#if !defined(CYTHON_VECTORCALL) -#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) -#endif -#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) -#if CYTHON_USE_PYLONG_INTERNALS - #if PY_MAJOR_VERSION < 3 - #include "longintrepr.h" - #endif - #undef SHIFT - #undef BASE - #undef MASK - #ifdef SIZEOF_VOID_P - enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; - #endif -#endif -#ifndef __has_attribute - #define __has_attribute(x) 0 -#endif -#ifndef __has_cpp_attribute - #define __has_cpp_attribute(x) 0 -#endif -#ifndef CYTHON_RESTRICT - #if defined(__GNUC__) - #define CYTHON_RESTRICT __restrict__ - #elif defined(_MSC_VER) && _MSC_VER >= 1400 - #define CYTHON_RESTRICT __restrict - #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - #define CYTHON_RESTRICT restrict - #else - #define CYTHON_RESTRICT - #endif -#endif -#ifndef CYTHON_UNUSED - #if defined(__cplusplus) - /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 - * but leads to warnings with -pedantic, since it is a C++17 feature */ - #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) - #if __has_cpp_attribute(maybe_unused) - #define CYTHON_UNUSED [[maybe_unused]] - #endif - #endif - #endif -#endif -#ifndef CYTHON_UNUSED -# if defined(__GNUC__) -# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) -# define CYTHON_UNUSED __attribute__ ((__unused__)) -# else -# define CYTHON_UNUSED -# endif -# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) -# define CYTHON_UNUSED __attribute__ ((__unused__)) -# else -# define CYTHON_UNUSED -# endif -#endif -#ifndef CYTHON_UNUSED_VAR -# if defined(__cplusplus) - template void CYTHON_UNUSED_VAR( const T& ) { } -# else -# define CYTHON_UNUSED_VAR(x) (void)(x) -# endif -#endif -#ifndef CYTHON_MAYBE_UNUSED_VAR - #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) -#endif -#ifndef CYTHON_NCP_UNUSED -# if CYTHON_COMPILING_IN_CPYTHON -# define CYTHON_NCP_UNUSED -# else -# define CYTHON_NCP_UNUSED CYTHON_UNUSED -# endif -#endif -#ifndef CYTHON_USE_CPP_STD_MOVE - #if defined(__cplusplus) && (\ - __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) - #define CYTHON_USE_CPP_STD_MOVE 1 - #else - #define CYTHON_USE_CPP_STD_MOVE 0 - #endif -#endif -#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) -#ifdef _MSC_VER - #ifndef _MSC_STDINT_H_ - #if _MSC_VER < 1300 - typedef unsigned char uint8_t; - typedef unsigned short uint16_t; - typedef unsigned int uint32_t; - #else - typedef unsigned __int8 uint8_t; - typedef unsigned __int16 uint16_t; - typedef unsigned __int32 uint32_t; - #endif - #endif - #if _MSC_VER < 1300 - #ifdef _WIN64 - typedef unsigned long long __pyx_uintptr_t; - #else - typedef unsigned int __pyx_uintptr_t; - #endif - #else - #ifdef _WIN64 - typedef unsigned __int64 __pyx_uintptr_t; - #else - typedef unsigned __int32 __pyx_uintptr_t; - #endif - #endif -#else - #include - typedef uintptr_t __pyx_uintptr_t; -#endif -#ifndef CYTHON_FALLTHROUGH - #if defined(__cplusplus) - /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 - * but leads to warnings with -pedantic, since it is a C++17 feature */ - #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) - #if __has_cpp_attribute(fallthrough) - #define CYTHON_FALLTHROUGH [[fallthrough]] - #endif - #endif - #ifndef CYTHON_FALLTHROUGH - #if __has_cpp_attribute(clang::fallthrough) - #define CYTHON_FALLTHROUGH [[clang::fallthrough]] - #elif __has_cpp_attribute(gnu::fallthrough) - #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] - #endif - #endif - #endif - #ifndef CYTHON_FALLTHROUGH - #if __has_attribute(fallthrough) - #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) - #else - #define CYTHON_FALLTHROUGH - #endif - #endif - #if defined(__clang__) && defined(__apple_build_version__) - #if __apple_build_version__ < 7000000 - #undef CYTHON_FALLTHROUGH - #define CYTHON_FALLTHROUGH - #endif - #endif -#endif -#ifdef __cplusplus - template - struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; - #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) -#else - #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) -#endif -#if CYTHON_COMPILING_IN_PYPY == 1 - #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) -#else - #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) -#endif -#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) - -#ifndef CYTHON_INLINE - #if defined(__clang__) - #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) - #elif defined(__GNUC__) - #define CYTHON_INLINE __inline__ - #elif defined(_MSC_VER) - #define CYTHON_INLINE __inline - #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - #define CYTHON_INLINE inline - #else - #define CYTHON_INLINE - #endif -#endif - -#define __PYX_BUILD_PY_SSIZE_T "n" -#define CYTHON_FORMAT_SSIZE_T "z" -#if PY_MAJOR_VERSION < 3 - #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" - #define __Pyx_DefaultClassType PyClass_Type - #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) -#else - #define __Pyx_BUILTIN_MODULE_NAME "builtins" - #define __Pyx_DefaultClassType PyType_Type -#if CYTHON_COMPILING_IN_LIMITED_API - static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, - PyObject *code, PyObject *c, PyObject* n, PyObject *v, - PyObject *fv, PyObject *cell, PyObject* fn, - PyObject *name, int fline, PyObject *lnos) { - PyObject *exception_table = NULL; - PyObject *types_module=NULL, *code_type=NULL, *result=NULL; - #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 - PyObject *version_info; - PyObject *py_minor_version = NULL; - #endif - long minor_version = 0; - PyObject *type, *value, *traceback; - PyErr_Fetch(&type, &value, &traceback); - #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000 - minor_version = 11; - #else - if (!(version_info = PySys_GetObject("version_info"))) goto end; - if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; - minor_version = PyLong_AsLong(py_minor_version); - Py_DECREF(py_minor_version); - if (minor_version == -1 && PyErr_Occurred()) goto end; - #endif - if (!(types_module = PyImport_ImportModule("types"))) goto end; - if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; - if (minor_version <= 7) { - (void)p; - result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code, - c, n, v, fn, name, fline, lnos, fv, cell); - } else if (minor_version <= 10) { - result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, - c, n, v, fn, name, fline, lnos, fv, cell); - } else { - if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; - result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, - c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); - } - end: - Py_XDECREF(code_type); - Py_XDECREF(exception_table); - Py_XDECREF(types_module); - if (type) { - PyErr_Restore(type, value, traceback); - } - return result; - } - #ifndef CO_OPTIMIZED - #define CO_OPTIMIZED 0x0001 - #endif - #ifndef CO_NEWLOCALS - #define CO_NEWLOCALS 0x0002 - #endif - #ifndef CO_VARARGS - #define CO_VARARGS 0x0004 - #endif - #ifndef CO_VARKEYWORDS - #define CO_VARKEYWORDS 0x0008 - #endif - #ifndef CO_ASYNC_GENERATOR - #define CO_ASYNC_GENERATOR 0x0200 - #endif - #ifndef CO_GENERATOR - #define CO_GENERATOR 0x0020 - #endif - #ifndef CO_COROUTINE - #define CO_COROUTINE 0x0080 - #endif -#elif PY_VERSION_HEX >= 0x030B0000 - static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, - PyObject *code, PyObject *c, PyObject* n, PyObject *v, - PyObject *fv, PyObject *cell, PyObject* fn, - PyObject *name, int fline, PyObject *lnos) { - PyCodeObject *result; - PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); - if (!empty_bytes) return NULL; - result = - #if PY_VERSION_HEX >= 0x030C0000 - PyUnstable_Code_NewWithPosOnlyArgs - #else - PyCode_NewWithPosOnlyArgs - #endif - (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes); - Py_DECREF(empty_bytes); - return result; - } -#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY - #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) -#else - #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) -#endif -#endif -#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) - #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) -#else - #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) -#endif -#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) - #define __Pyx_Py_Is(x, y) Py_Is(x, y) -#else - #define __Pyx_Py_Is(x, y) ((x) == (y)) -#endif -#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) - #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) -#else - #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) -#endif -#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) - #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) -#else - #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) -#endif -#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) - #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) -#else - #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) -#endif -#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) -#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY - #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) -#else - #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) -#endif -#ifndef CO_COROUTINE - #define CO_COROUTINE 0x80 -#endif -#ifndef CO_ASYNC_GENERATOR - #define CO_ASYNC_GENERATOR 0x200 -#endif -#ifndef Py_TPFLAGS_CHECKTYPES - #define Py_TPFLAGS_CHECKTYPES 0 -#endif -#ifndef Py_TPFLAGS_HAVE_INDEX - #define Py_TPFLAGS_HAVE_INDEX 0 -#endif -#ifndef Py_TPFLAGS_HAVE_NEWBUFFER - #define Py_TPFLAGS_HAVE_NEWBUFFER 0 -#endif -#ifndef Py_TPFLAGS_HAVE_FINALIZE - #define Py_TPFLAGS_HAVE_FINALIZE 0 -#endif -#ifndef Py_TPFLAGS_SEQUENCE - #define Py_TPFLAGS_SEQUENCE 0 -#endif -#ifndef Py_TPFLAGS_MAPPING - #define Py_TPFLAGS_MAPPING 0 -#endif -#ifndef METH_STACKLESS - #define METH_STACKLESS 0 -#endif -#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) - #ifndef METH_FASTCALL - #define METH_FASTCALL 0x80 - #endif - typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); - typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, - Py_ssize_t nargs, PyObject *kwnames); -#else - #if PY_VERSION_HEX >= 0x030d00A4 - # define __Pyx_PyCFunctionFast PyCFunctionFast - # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords - #else - # define __Pyx_PyCFunctionFast _PyCFunctionFast - # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords - #endif -#endif -#if CYTHON_METH_FASTCALL - #define __Pyx_METH_FASTCALL METH_FASTCALL - #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast - #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords -#else - #define __Pyx_METH_FASTCALL METH_VARARGS - #define __Pyx_PyCFunction_FastCall PyCFunction - #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords -#endif -#if CYTHON_VECTORCALL - #define __pyx_vectorcallfunc vectorcallfunc - #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET - #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) -#elif CYTHON_BACKPORT_VECTORCALL - typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, - size_t nargsf, PyObject *kwnames); - #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) - #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) -#else - #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 - #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) -#endif -#if PY_MAJOR_VERSION >= 0x030900B1 -#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) -#else -#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) -#endif -#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) -#elif !CYTHON_COMPILING_IN_LIMITED_API -#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) -#endif -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) -static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { - return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; -} -#endif -static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { -#if CYTHON_COMPILING_IN_LIMITED_API - return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; -#else - return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; -#endif -} -#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) -#if __PYX_LIMITED_VERSION_HEX < 0x030900B1 - #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) - typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); -#else - #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) - #define __Pyx_PyCMethod PyCMethod -#endif -#ifndef METH_METHOD - #define METH_METHOD 0x200 -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) - #define PyObject_Malloc(s) PyMem_Malloc(s) - #define PyObject_Free(p) PyMem_Free(p) - #define PyObject_Realloc(p) PyMem_Realloc(p) -#endif -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) - #define __Pyx_PyFrame_SetLineNumber(frame, lineno) -#else - #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) - #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) -#endif -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_PyThreadState_Current PyThreadState_Get() -#elif !CYTHON_FAST_THREAD_STATE - #define __Pyx_PyThreadState_Current PyThreadState_GET() -#elif PY_VERSION_HEX >= 0x030d00A1 - #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() -#elif PY_VERSION_HEX >= 0x03060000 - #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() -#elif PY_VERSION_HEX >= 0x03000000 - #define __Pyx_PyThreadState_Current PyThreadState_GET() -#else - #define __Pyx_PyThreadState_Current _PyThreadState_Current -#endif -#if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) -{ - void *result; - result = PyModule_GetState(op); - if (!result) - Py_FatalError("Couldn't find the module state"); - return result; -} -#endif -#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) -#else - #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) -#endif -#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) -#include "pythread.h" -#define Py_tss_NEEDS_INIT 0 -typedef int Py_tss_t; -static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { - *key = PyThread_create_key(); - return 0; -} -static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { - Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); - *key = Py_tss_NEEDS_INIT; - return key; -} -static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { - PyObject_Free(key); -} -static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { - return *key != Py_tss_NEEDS_INIT; -} -static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { - PyThread_delete_key(*key); - *key = Py_tss_NEEDS_INIT; -} -static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { - return PyThread_set_key_value(*key, value); -} -static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { - return PyThread_get_key_value(*key); -} -#endif -#if PY_MAJOR_VERSION < 3 - #if CYTHON_COMPILING_IN_PYPY - #if PYPY_VERSION_NUM < 0x07030600 - #if defined(__cplusplus) && __cplusplus >= 201402L - [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] - #elif defined(__GNUC__) || defined(__clang__) - __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) - #elif defined(_MSC_VER) - __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) - #endif - static CYTHON_INLINE int PyGILState_Check(void) { - return 0; - } - #else // PYPY_VERSION_NUM < 0x07030600 - #endif // PYPY_VERSION_NUM < 0x07030600 - #else - static CYTHON_INLINE int PyGILState_Check(void) { - PyThreadState * tstate = _PyThreadState_Current; - return tstate && (tstate == PyGILState_GetThisThreadState()); - } - #endif -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) -#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) -#else -#define __Pyx_PyDict_NewPresized(n) PyDict_New() -#endif -#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION - #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) - #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) -#else - #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) - #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS -#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) -static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { - PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); - if (res == NULL) PyErr_Clear(); - return res; -} -#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000) -#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError -#define __Pyx_PyDict_GetItemStr PyDict_GetItem -#else -static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { -#if CYTHON_COMPILING_IN_PYPY - return PyDict_GetItem(dict, name); -#else - PyDictEntry *ep; - PyDictObject *mp = (PyDictObject*) dict; - long hash = ((PyStringObject *) name)->ob_shash; - assert(hash != -1); - ep = (mp->ma_lookup)(mp, name, hash); - if (ep == NULL) { - return NULL; - } - return ep->me_value; -#endif -} -#define __Pyx_PyDict_GetItemStr PyDict_GetItem -#endif -#if CYTHON_USE_TYPE_SLOTS - #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) - #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) - #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) -#else - #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) - #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) - #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next -#endif -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) -#else - #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) -#endif -#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 -#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ - PyTypeObject *type = Py_TYPE((PyObject*)obj);\ - assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ - PyObject_GC_Del(obj);\ - Py_DECREF(type);\ -} -#else -#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) -#endif -#if CYTHON_COMPILING_IN_LIMITED_API - #define CYTHON_PEP393_ENABLED 1 - #define __Pyx_PyUnicode_READY(op) (0) - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) - #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) - #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) - #define __Pyx_PyUnicode_DATA(u) ((void*)u) - #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) -#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) - #define CYTHON_PEP393_ENABLED 1 - #if PY_VERSION_HEX >= 0x030C0000 - #define __Pyx_PyUnicode_READY(op) (0) - #else - #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ - 0 : _PyUnicode_Ready((PyObject *)(op))) - #endif - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) - #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) - #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u)) - #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, (Py_UCS4) ch) - #if PY_VERSION_HEX >= 0x030C0000 - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) - #else - #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) - #else - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) - #endif - #endif -#else - #define CYTHON_PEP393_ENABLED 0 - #define PyUnicode_1BYTE_KIND 1 - #define PyUnicode_2BYTE_KIND 2 - #define PyUnicode_4BYTE_KIND 4 - #define __Pyx_PyUnicode_READY(op) (0) - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) - #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) - #define __Pyx_PyUnicode_KIND(u) ((int)sizeof(Py_UNICODE)) - #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) - #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) -#endif -#if CYTHON_COMPILING_IN_PYPY - #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) - #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) -#else - #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) - #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ - PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) -#endif -#if CYTHON_COMPILING_IN_PYPY - #if !defined(PyUnicode_DecodeUnicodeEscape) - #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) - #endif - #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) - #undef PyUnicode_Contains - #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) - #endif - #if !defined(PyByteArray_Check) - #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) - #endif - #if !defined(PyObject_Format) - #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) - #endif -#endif -#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) -#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) -#else - #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) -#endif -#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) - #define PyObject_ASCII(o) PyObject_Repr(o) -#endif -#if PY_MAJOR_VERSION >= 3 - #define PyBaseString_Type PyUnicode_Type - #define PyStringObject PyUnicodeObject - #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) -#else - #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) - #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) -#endif -#if CYTHON_COMPILING_IN_CPYTHON - #define __Pyx_PySequence_ListKeepNew(obj)\ - (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) -#else - #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) -#endif -#ifndef PySet_CheckExact - #define PySet_CheckExact(obj) __Pyx_IS_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_ITEM(o, i) PySequence_ITEM(o, i) - #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) - #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) - #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) - #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) - #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) - #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) - #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) - #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) -#else - #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) - #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) - #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) - #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) - #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) - #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) - #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) - #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) - #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) -#endif -#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 - #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) -#else - static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { - PyObject *module = PyImport_AddModule(name); - Py_XINCREF(module); - return module; - } -#endif -#if PY_MAJOR_VERSION >= 3 - #define PyIntObject PyLongObject - #define PyInt_Type PyLong_Type - #define PyInt_Check(op) PyLong_Check(op) - #define PyInt_CheckExact(op) PyLong_CheckExact(op) - #define __Pyx_Py3Int_Check(op) PyLong_Check(op) - #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) - #define PyInt_FromString PyLong_FromString - #define PyInt_FromUnicode PyLong_FromUnicode - #define PyInt_FromLong PyLong_FromLong - #define PyInt_FromSize_t PyLong_FromSize_t - #define PyInt_FromSsize_t PyLong_FromSsize_t - #define PyInt_AsLong PyLong_AsLong - #define PyInt_AS_LONG PyLong_AS_LONG - #define PyInt_AsSsize_t PyLong_AsSsize_t - #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask - #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask - #define PyNumber_Int PyNumber_Long -#else - #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) - #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) -#endif -#if PY_MAJOR_VERSION >= 3 - #define PyBoolObject PyLongObject -#endif -#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY - #ifndef PyUnicode_InternFromString - #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) - #endif -#endif -#if PY_VERSION_HEX < 0x030200A4 - typedef long Py_hash_t; - #define __Pyx_PyInt_FromHash_t PyInt_FromLong - #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t -#else - #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t - #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t -#endif -#if CYTHON_USE_ASYNC_SLOTS - #if PY_VERSION_HEX >= 0x030500B1 - #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods - #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) - #else - #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) - #endif -#else - #define __Pyx_PyType_AsAsync(obj) NULL -#endif -#ifndef __Pyx_PyAsyncMethodsStruct - typedef struct { - unaryfunc am_await; - unaryfunc am_aiter; - unaryfunc am_anext; - } __Pyx_PyAsyncMethodsStruct; -#endif - -#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) - #if !defined(_USE_MATH_DEFINES) - #define _USE_MATH_DEFINES - #endif -#endif -#include -#ifdef NAN -#define __PYX_NAN() ((float) NAN) -#else -static CYTHON_INLINE float __PYX_NAN() { - float value; - memset(&value, 0xFF, sizeof(value)); - return value; -} -#endif -#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) -#define __Pyx_truncl trunc -#else -#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; } - -#ifdef CYTHON_EXTERN_C - #undef __PYX_EXTERN_C - #define __PYX_EXTERN_C CYTHON_EXTERN_C -#elif defined(__PYX_EXTERN_C) - #ifdef _MSC_VER - #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") - #else - #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. - #endif -#else - #ifdef __cplusplus - #define __PYX_EXTERN_C extern "C" - #else - #define __PYX_EXTERN_C extern - #endif -#endif - -#define __PYX_HAVE__robo_utils__core -#define __PYX_HAVE_API__robo_utils__core -/* Early includes */ -#include -#include -#include -#include "pythread.h" -#ifdef _OPENMP -#include -#endif /* _OPENMP */ - -#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) -#define CYTHON_WITHOUT_ASSERTIONS -#endif - -typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; - const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; - -#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 -#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 -#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) -#define __PYX_DEFAULT_STRING_ENCODING "" -#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString -#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize -#define __Pyx_uchar_cast(c) ((unsigned char)c) -#define __Pyx_long_cast(x) ((long)x) -#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ - (sizeof(type) < sizeof(Py_ssize_t)) ||\ - (sizeof(type) > sizeof(Py_ssize_t) &&\ - likely(v < (type)PY_SSIZE_T_MAX ||\ - v == (type)PY_SSIZE_T_MAX) &&\ - (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ - v == (type)PY_SSIZE_T_MIN))) ||\ - (sizeof(type) == sizeof(Py_ssize_t) &&\ - (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ - v == (type)PY_SSIZE_T_MAX))) ) -static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { - return (size_t) i < (size_t) limit; -} -#if defined (__cplusplus) && __cplusplus >= 201103L - #include - #define __Pyx_sst_abs(value) std::abs(value) -#elif SIZEOF_INT >= SIZEOF_SIZE_T - #define __Pyx_sst_abs(value) abs(value) -#elif SIZEOF_LONG >= SIZEOF_SIZE_T - #define __Pyx_sst_abs(value) labs(value) -#elif defined (_MSC_VER) - #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) -#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - #define __Pyx_sst_abs(value) llabs(value) -#elif defined (__GNUC__) - #define __Pyx_sst_abs(value) __builtin_llabs(value) -#else - #define __Pyx_sst_abs(value) ((value<0) ? -value : value) -#endif -static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); -static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); -static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); -static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); -#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) -#define __Pyx_PyBytes_FromString PyBytes_FromString -#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); -#if PY_MAJOR_VERSION < 3 - #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString - #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize -#else - #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString - #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize -#endif -#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) -#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) -#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) -#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) -#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) -#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) -#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode -#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) -#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) -static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); -static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); -static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); -static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); -#define __Pyx_PySequence_Tuple(obj)\ - (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) -static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); -static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); -static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); -#if CYTHON_ASSUME_SAFE_MACROS -#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) -#else -#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) -#endif -#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) -#if PY_MAJOR_VERSION >= 3 -#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) -#else -#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) -#endif -#if CYTHON_USE_PYLONG_INTERNALS - #if PY_VERSION_HEX >= 0x030C00A7 - #ifndef _PyLong_SIGN_MASK - #define _PyLong_SIGN_MASK 3 - #endif - #ifndef _PyLong_NON_SIZE_BITS - #define _PyLong_NON_SIZE_BITS 3 - #endif - #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) - #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) - #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) - #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) - #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) - #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) - #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) - #define __Pyx_PyLong_SignedDigitCount(x)\ - ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) - #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) - #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) - #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) - #else - #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) - #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) - #endif - typedef Py_ssize_t __Pyx_compact_pylong; - typedef size_t __Pyx_compact_upylong; - #else - #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) - #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) - #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) - #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) - #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) - #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) - #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) - #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) - #define __Pyx_PyLong_CompactValue(x)\ - ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) - typedef sdigit __Pyx_compact_pylong; - typedef digit __Pyx_compact_upylong; - #endif - #if PY_VERSION_HEX >= 0x030C00A5 - #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) - #else - #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) - #endif -#endif -#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII -#include -static int __Pyx_sys_getdefaultencoding_not_ascii; -static int __Pyx_init_sys_getdefaultencoding_params(void) { - PyObject* sys; - PyObject* default_encoding = NULL; - PyObject* ascii_chars_u = NULL; - PyObject* ascii_chars_b = NULL; - const char* default_encoding_c; - sys = PyImport_ImportModule("sys"); - if (!sys) goto bad; - default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); - Py_DECREF(sys); - if (!default_encoding) goto bad; - default_encoding_c = PyBytes_AsString(default_encoding); - if (!default_encoding_c) goto bad; - if (strcmp(default_encoding_c, "ascii") == 0) { - __Pyx_sys_getdefaultencoding_not_ascii = 0; - } else { - char ascii_chars[128]; - int c; - for (c = 0; c < 128; c++) { - ascii_chars[c] = (char) c; - } - __Pyx_sys_getdefaultencoding_not_ascii = 1; - ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); - if (!ascii_chars_u) goto bad; - ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); - if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { - PyErr_Format( - PyExc_ValueError, - "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", - default_encoding_c); - goto bad; - } - Py_DECREF(ascii_chars_u); - Py_DECREF(ascii_chars_b); - } - Py_DECREF(default_encoding); - return 0; -bad: - Py_XDECREF(default_encoding); - Py_XDECREF(ascii_chars_u); - Py_XDECREF(ascii_chars_b); - return -1; -} -#endif -#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 -#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) -#else -#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) -#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT -#include -static char* __PYX_DEFAULT_STRING_ENCODING; -static int __Pyx_init_sys_getdefaultencoding_params(void) { - PyObject* sys; - PyObject* default_encoding = NULL; - char* default_encoding_c; - sys = PyImport_ImportModule("sys"); - if (!sys) goto bad; - default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); - Py_DECREF(sys); - if (!default_encoding) goto bad; - default_encoding_c = PyBytes_AsString(default_encoding); - if (!default_encoding_c) goto bad; - __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); - if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; - strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); - Py_DECREF(default_encoding); - return 0; -bad: - Py_XDECREF(default_encoding); - return -1; -} -#endif -#endif - - -/* Test for GCC > 2.95 */ -#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) - #define likely(x) __builtin_expect(!!(x), 1) - #define unlikely(x) __builtin_expect(!!(x), 0) -#else /* !__GNUC__ or GCC < 2.95 */ - #define likely(x) (x) - #define unlikely(x) (x) -#endif /* __GNUC__ */ -static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } - -#if !CYTHON_USE_MODULE_STATE -static PyObject *__pyx_m = NULL; -#endif -static int __pyx_lineno; -static int __pyx_clineno = 0; -static const char * __pyx_cfilenm = __FILE__; -static const char *__pyx_filename; - -/* #### Code section: filename_table ### */ - -static const char *__pyx_f[] = { - "core.pyx", - "", -}; -/* #### Code section: utility_code_proto_before_types ### */ -/* 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 */ -struct __Pyx_StructField_; -#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) -typedef struct { - const char* name; - struct __Pyx_StructField_* fields; - size_t size; - size_t arraysize[8]; - int ndim; - char typegroup; - char is_unsigned; - int flags; -} __Pyx_TypeInfo; -typedef struct __Pyx_StructField_ { - __Pyx_TypeInfo* type; - const char* name; - size_t offset; -} __Pyx_StructField; -typedef struct { - __Pyx_StructField* field; - size_t parent_offset; -} __Pyx_BufFmt_StackElem; -typedef struct { - __Pyx_StructField root; - __Pyx_BufFmt_StackElem* head; - size_t fmt_offset; - size_t new_count, enc_count; - size_t struct_alignment; - int is_complex; - char enc_type; - char new_packmode; - char enc_packmode; - char is_valid_array; -} __Pyx_BufFmt_Context; - -/* Atomics.proto */ -#include -#ifndef CYTHON_ATOMICS - #define CYTHON_ATOMICS 1 -#endif -#define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS -#define __pyx_atomic_int_type int -#define __pyx_nonatomic_int_type int -#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ - (__STDC_VERSION__ >= 201112L) &&\ - !defined(__STDC_NO_ATOMICS__)) - #include -#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ - (__cplusplus >= 201103L) ||\ - (defined(_MSC_VER) && _MSC_VER >= 1700))) - #include -#endif -#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ - (__STDC_VERSION__ >= 201112L) &&\ - !defined(__STDC_NO_ATOMICS__) &&\ - ATOMIC_INT_LOCK_FREE == 2) - #undef __pyx_atomic_int_type - #define __pyx_atomic_int_type atomic_int - #define __pyx_atomic_incr_aligned(value) atomic_fetch_add_explicit(value, 1, memory_order_relaxed) - #define __pyx_atomic_decr_aligned(value) atomic_fetch_sub_explicit(value, 1, memory_order_acq_rel) - #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) - #pragma message ("Using standard C atomics") - #elif defined(__PYX_DEBUG_ATOMICS) - #warning "Using standard C atomics" - #endif -#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ - (__cplusplus >= 201103L) ||\ -\ - (defined(_MSC_VER) && _MSC_VER >= 1700)) &&\ - ATOMIC_INT_LOCK_FREE == 2) - #undef __pyx_atomic_int_type - #define __pyx_atomic_int_type std::atomic_int - #define __pyx_atomic_incr_aligned(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_relaxed) - #define __pyx_atomic_decr_aligned(value) std::atomic_fetch_sub_explicit(value, 1, std::memory_order_acq_rel) - #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) - #pragma message ("Using standard C++ atomics") - #elif defined(__PYX_DEBUG_ATOMICS) - #warning "Using standard C++ atomics" - #endif -#elif CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\ - (__GNUC_MINOR__ > 1 ||\ - (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2)))) - #define __pyx_atomic_incr_aligned(value) __sync_fetch_and_add(value, 1) - #define __pyx_atomic_decr_aligned(value) __sync_fetch_and_sub(value, 1) - #ifdef __PYX_DEBUG_ATOMICS - #warning "Using GNU atomics" - #endif -#elif CYTHON_ATOMICS && defined(_MSC_VER) - #include - #undef __pyx_atomic_int_type - #define __pyx_atomic_int_type long - #undef __pyx_nonatomic_int_type - #define __pyx_nonatomic_int_type long - #pragma intrinsic (_InterlockedExchangeAdd) - #define __pyx_atomic_incr_aligned(value) _InterlockedExchangeAdd(value, 1) - #define __pyx_atomic_decr_aligned(value) _InterlockedExchangeAdd(value, -1) - #ifdef __PYX_DEBUG_ATOMICS - #pragma message ("Using MSVC atomics") - #endif -#else - #undef CYTHON_ATOMICS - #define CYTHON_ATOMICS 0 - #ifdef __PYX_DEBUG_ATOMICS - #warning "Not using atomics" - #endif -#endif -#if CYTHON_ATOMICS - #define __pyx_add_acquisition_count(memview)\ - __pyx_atomic_incr_aligned(__pyx_get_slice_count_pointer(memview)) - #define __pyx_sub_acquisition_count(memview)\ - __pyx_atomic_decr_aligned(__pyx_get_slice_count_pointer(memview)) -#else - #define __pyx_add_acquisition_count(memview)\ - __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) - #define __pyx_sub_acquisition_count(memview)\ - __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) -#endif - -/* MemviewSliceStruct.proto */ -struct __pyx_memoryview_obj; -typedef struct { - struct __pyx_memoryview_obj *memview; - char *data; - Py_ssize_t shape[8]; - Py_ssize_t strides[8]; - Py_ssize_t suboffsets[8]; -} __Pyx_memviewslice; -#define __Pyx_MemoryView_Len(m) (m.shape[0]) - -/* #### Code section: numeric_typedefs ### */ -/* #### Code section: complex_type_declarations ### */ -/* #### Code section: type_declarations ### */ - -/*--- Type declarations ---*/ -struct __pyx_array_obj; -struct __pyx_MemviewEnum_obj; -struct __pyx_memoryview_obj; -struct __pyx_memoryviewslice_obj; - -/* "View.MemoryView":114 - * @cython.collection_type("sequence") - * @cname("__pyx_array") - * cdef class array: # <<<<<<<<<<<<<< - * - * cdef: - */ -struct __pyx_array_obj { - PyObject_HEAD - struct __pyx_vtabstruct_array *__pyx_vtab; - char *data; - Py_ssize_t len; - char *format; - int ndim; - Py_ssize_t *_shape; - Py_ssize_t *_strides; - Py_ssize_t itemsize; - PyObject *mode; - PyObject *_format; - void (*callback_free_data)(void *); - int free_data; - int dtype_is_object; -}; - - -/* "View.MemoryView":302 - * - * @cname('__pyx_MemviewEnum') - * cdef class Enum(object): # <<<<<<<<<<<<<< - * cdef object name - * def __init__(self, name): - */ -struct __pyx_MemviewEnum_obj { - PyObject_HEAD - PyObject *name; -}; - - -/* "View.MemoryView":337 - * - * @cname('__pyx_memoryview') - * cdef class memoryview: # <<<<<<<<<<<<<< - * - * cdef object obj - */ -struct __pyx_memoryview_obj { - PyObject_HEAD - struct __pyx_vtabstruct_memoryview *__pyx_vtab; - PyObject *obj; - PyObject *_size; - PyObject *_array_interface; - PyThread_type_lock lock; - __pyx_atomic_int_type acquisition_count; - Py_buffer view; - int flags; - int dtype_is_object; - __Pyx_TypeInfo *typeinfo; -}; - - -/* "View.MemoryView":952 - * @cython.collection_type("sequence") - * @cname('__pyx_memoryviewslice') - * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< - * "Internal class for passing memoryview slices to Python" - * - */ -struct __pyx_memoryviewslice_obj { - struct __pyx_memoryview_obj __pyx_base; - __Pyx_memviewslice from_slice; - PyObject *from_object; - PyObject *(*to_object_func)(char *); - int (*to_dtype_func)(char *, PyObject *); -}; - - - -/* "View.MemoryView":114 - * @cython.collection_type("sequence") - * @cname("__pyx_array") - * cdef class array: # <<<<<<<<<<<<<< - * - * cdef: - */ - -struct __pyx_vtabstruct_array { - PyObject *(*get_memview)(struct __pyx_array_obj *); -}; -static struct __pyx_vtabstruct_array *__pyx_vtabptr_array; - - -/* "View.MemoryView":337 - * - * @cname('__pyx_memoryview') - * cdef class memoryview: # <<<<<<<<<<<<<< - * - * cdef object obj - */ - -struct __pyx_vtabstruct_memoryview { - char *(*get_item_pointer)(struct __pyx_memoryview_obj *, PyObject *); - PyObject *(*is_slice)(struct __pyx_memoryview_obj *, PyObject *); - PyObject *(*setitem_slice_assignment)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); - PyObject *(*setitem_slice_assign_scalar)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *); - PyObject *(*setitem_indexed)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); - PyObject *(*convert_item_to_object)(struct __pyx_memoryview_obj *, char *); - PyObject *(*assign_item_from_object)(struct __pyx_memoryview_obj *, char *, PyObject *); - PyObject *(*_get_base)(struct __pyx_memoryview_obj *); -}; -static struct __pyx_vtabstruct_memoryview *__pyx_vtabptr_memoryview; - - -/* "View.MemoryView":952 - * @cython.collection_type("sequence") - * @cname('__pyx_memoryviewslice') - * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< - * "Internal class for passing memoryview slices to Python" - * - */ - -struct __pyx_vtabstruct__memoryviewslice { - struct __pyx_vtabstruct_memoryview __pyx_base; -}; -static struct __pyx_vtabstruct__memoryviewslice *__pyx_vtabptr__memoryviewslice; -/* #### Code section: utility_code_proto ### */ - -/* --- Runtime support code (head) --- */ -/* Refnanny.proto */ -#ifndef CYTHON_REFNANNY - #define CYTHON_REFNANNY 0 -#endif -#if CYTHON_REFNANNY - typedef struct { - void (*INCREF)(void*, PyObject*, Py_ssize_t); - void (*DECREF)(void*, PyObject*, Py_ssize_t); - void (*GOTREF)(void*, PyObject*, Py_ssize_t); - void (*GIVEREF)(void*, PyObject*, Py_ssize_t); - void* (*SetupContext)(const char*, Py_ssize_t, const char*); - void (*FinishContext)(void**); - } __Pyx_RefNannyAPIStruct; - static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; - static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); - #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; -#ifdef WITH_THREAD - #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - if (acquire_gil) {\ - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ - PyGILState_Release(__pyx_gilstate_save);\ - } else {\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ - } - #define __Pyx_RefNannyFinishContextNogil() {\ - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __Pyx_RefNannyFinishContext();\ - PyGILState_Release(__pyx_gilstate_save);\ - } -#else - #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) - #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() -#endif - #define __Pyx_RefNannyFinishContextNogil() {\ - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __Pyx_RefNannyFinishContext();\ - PyGILState_Release(__pyx_gilstate_save);\ - } - #define __Pyx_RefNannyFinishContext()\ - __Pyx_RefNanny->FinishContext(&__pyx_refnanny) - #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) - #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) - #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) - #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) - #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0) - #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) - #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) - #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) -#else - #define __Pyx_RefNannyDeclarations - #define __Pyx_RefNannySetupContext(name, acquire_gil) - #define __Pyx_RefNannyFinishContextNogil() - #define __Pyx_RefNannyFinishContext() - #define __Pyx_INCREF(r) Py_INCREF(r) - #define __Pyx_DECREF(r) Py_DECREF(r) - #define __Pyx_GOTREF(r) - #define __Pyx_GIVEREF(r) - #define __Pyx_XINCREF(r) Py_XINCREF(r) - #define __Pyx_XDECREF(r) Py_XDECREF(r) - #define __Pyx_XGOTREF(r) - #define __Pyx_XGIVEREF(r) -#endif -#define __Pyx_Py_XDECREF_SET(r, v) do {\ - PyObject *tmp = (PyObject *) r;\ - r = v; Py_XDECREF(tmp);\ - } while (0) -#define __Pyx_XDECREF_SET(r, v) do {\ - PyObject *tmp = (PyObject *) r;\ - r = v; __Pyx_XDECREF(tmp);\ - } while (0) -#define __Pyx_DECREF_SET(r, v) do {\ - PyObject *tmp = (PyObject *) r;\ - r = v; __Pyx_DECREF(tmp);\ - } while (0) -#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) -#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) - -/* PyErrExceptionMatches.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) -static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); -#else -#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) -#endif - -/* PyThreadStateGet.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; -#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; -#if PY_VERSION_HEX >= 0x030C00A6 -#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) -#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) -#else -#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) -#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) -#endif -#else -#define __Pyx_PyThreadState_declare -#define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) -#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() -#endif - -/* PyErrFetchRestore.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) -#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 -#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) -#else -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#endif -#else -#define __Pyx_PyErr_Clear() PyErr_Clear() -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) -#endif - -/* PyObjectGetAttrStr.proto */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) -#endif - -/* PyObjectGetAttrStrNoError.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); - -/* GetBuiltinName.proto */ -static PyObject *__Pyx_GetBuiltinName(PyObject *name); - -/* TupleAndListFromArray.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); -static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); -#endif - -/* IncludeStringH.proto */ -#include - -/* BytesEquals.proto */ -static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); - -/* UnicodeEquals.proto */ -static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); - -/* fastcall.proto */ -#if CYTHON_AVOID_BORROWED_REFS - #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i) -#elif CYTHON_ASSUME_SAFE_MACROS - #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) -#else - #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) -#endif -#if CYTHON_AVOID_BORROWED_REFS - #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) - #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) -#else - #define __Pyx_Arg_NewRef_VARARGS(arg) arg - #define __Pyx_Arg_XDECREF_VARARGS(arg) -#endif -#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) -#define __Pyx_KwValues_VARARGS(args, nargs) NULL -#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) -#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) -#if CYTHON_METH_FASTCALL - #define __Pyx_Arg_FASTCALL(args, i) args[i] - #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds) - #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) - static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 - CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); - #else - #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) - #endif - #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs - to have the same reference counting */ - #define __Pyx_Arg_XDECREF_FASTCALL(arg) -#else - #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS - #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS - #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS - #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS - #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS - #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) - #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) -#endif -#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS -#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) -#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) -#else -#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) -#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) -#endif - -/* RaiseArgTupleInvalid.proto */ -static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, - Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); - -/* RaiseDoubleKeywords.proto */ -static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); - -/* ParseKeywords.proto */ -static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, - PyObject **argnames[], - PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, - const char* function_name); - -/* ArgTypeTest.proto */ -#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ - ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\ - __Pyx__ArgTypeTest(obj, type, name, exact)) -static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); - -/* RaiseException.proto */ -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); - -/* PyFunctionFastCall.proto */ -#if CYTHON_FAST_PYCALL -#if !CYTHON_VECTORCALL -#define __Pyx_PyFunction_FastCall(func, args, nargs)\ - __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) -static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); -#endif -#define __Pyx_BUILD_ASSERT_EXPR(cond)\ - (sizeof(char [1 - 2*!(cond)]) - 1) -#ifndef Py_MEMBER_SIZE -#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) -#endif -#if !CYTHON_VECTORCALL -#if PY_VERSION_HEX >= 0x03080000 - #include "frameobject.h" -#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API - #ifndef Py_BUILD_CORE - #define Py_BUILD_CORE 1 - #endif - #include "internal/pycore_frame.h" -#endif - #define __Pxy_PyFrame_Initialize_Offsets() - #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) -#else - static size_t __pyx_pyframe_localsplus_offset = 0; - #include "frameobject.h" - #define __Pxy_PyFrame_Initialize_Offsets()\ - ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ - (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) - #define __Pyx_PyFrame_GetLocalsplus(frame)\ - (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) -#endif -#endif -#endif - -/* PyObjectCall.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); -#else -#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) -#endif - -/* PyObjectCallMethO.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); -#endif - -/* PyObjectFastCall.proto */ -#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) -static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs); - -/* RaiseUnexpectedTypeError.proto */ -static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj); - -/* GCCDiagnostics.proto */ -#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) -#define __Pyx_HAS_GCC_DIAGNOSTIC -#endif - -/* BuildPyUnicode.proto */ -static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, char* chars, int clength, - int prepend_sign, char padding_char); - -/* CIntToPyUnicode.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char); - -/* CIntToPyUnicode.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char); - -/* JoinPyUnicode.proto */ -static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, - Py_UCS4 max_char); - -/* StrEquals.proto */ -#if PY_MAJOR_VERSION >= 3 -#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals -#else -#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals -#endif - -/* PyObjectFormatSimple.proto */ -#if CYTHON_COMPILING_IN_PYPY - #define __Pyx_PyObject_FormatSimple(s, f) (\ - likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ - PyObject_Format(s, f)) -#elif PY_MAJOR_VERSION < 3 - #define __Pyx_PyObject_FormatSimple(s, f) (\ - likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ - likely(PyString_CheckExact(s)) ? PyUnicode_FromEncodedObject(s, NULL, "strict") :\ - PyObject_Format(s, f)) -#elif CYTHON_USE_TYPE_SLOTS - #define __Pyx_PyObject_FormatSimple(s, f) (\ - likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ - likely(PyLong_CheckExact(s)) ? PyLong_Type.tp_repr(s) :\ - likely(PyFloat_CheckExact(s)) ? PyFloat_Type.tp_repr(s) :\ - PyObject_Format(s, f)) -#else - #define __Pyx_PyObject_FormatSimple(s, f) (\ - likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ - PyObject_Format(s, f)) -#endif - -CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ -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); - -/* PyObjectCallOneArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); - -/* ObjectGetItem.proto */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key); -#else -#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) -#endif - -/* KeywordStringCheck.proto */ -static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed); - -/* DivInt[Py_ssize_t].proto */ -static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t, Py_ssize_t); - -/* UnaryNegOverflows.proto */ -#define __Pyx_UNARY_NEG_WOULD_OVERFLOW(x)\ - (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x))) - -/* GetAttr3.proto */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); - -/* PyDictVersioning.proto */ -#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS -#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) -#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) -#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ - (version_var) = __PYX_GET_DICT_VERSION(dict);\ - (cache_var) = (value); -#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ - static PY_UINT64_T __pyx_dict_version = 0;\ - static PyObject *__pyx_dict_cached_value = NULL;\ - if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ - (VAR) = __pyx_dict_cached_value;\ - } else {\ - (VAR) = __pyx_dict_cached_value = (LOOKUP);\ - __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ - }\ -} -static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); -static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); -static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); -#else -#define __PYX_GET_DICT_VERSION(dict) (0) -#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) -#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); -#endif - -/* GetModuleGlobalName.proto */ -#if CYTHON_USE_DICT_VERSIONS -#define __Pyx_GetModuleGlobalName(var, name) do {\ - static PY_UINT64_T __pyx_dict_version = 0;\ - static PyObject *__pyx_dict_cached_value = NULL;\ - (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ - (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ - __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} while(0) -#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ - PY_UINT64_T __pyx_dict_version;\ - PyObject *__pyx_dict_cached_value;\ - (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} while(0) -static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); -#else -#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) -#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) -static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); -#endif - -/* AssertionsEnabled.proto */ -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) - #define __Pyx_init_assertions_enabled() (0) - #define __pyx_assertions_enabled() (1) -#elif CYTHON_COMPILING_IN_LIMITED_API || (CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030C0000) - static int __pyx_assertions_enabled_flag; - #define __pyx_assertions_enabled() (__pyx_assertions_enabled_flag) - static int __Pyx_init_assertions_enabled(void) { - PyObject *builtins, *debug, *debug_str; - int flag; - builtins = PyEval_GetBuiltins(); - if (!builtins) goto bad; - debug_str = PyUnicode_FromStringAndSize("__debug__", 9); - if (!debug_str) goto bad; - debug = PyObject_GetItem(builtins, debug_str); - Py_DECREF(debug_str); - if (!debug) goto bad; - flag = PyObject_IsTrue(debug); - Py_DECREF(debug); - if (flag == -1) goto bad; - __pyx_assertions_enabled_flag = flag; - return 0; - bad: - __pyx_assertions_enabled_flag = 1; - return -1; - } -#else - #define __Pyx_init_assertions_enabled() (0) - #define __pyx_assertions_enabled() (!Py_OptimizeFlag) -#endif - -/* RaiseTooManyValuesToUnpack.proto */ -static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); - -/* RaiseNeedMoreValuesToUnpack.proto */ -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 && CYTHON_FAST_THREAD_STATE -static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); -#endif - -/* SaveResetException.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); -#else -#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) -#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) -#endif - -/* GetException.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) -static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#else -static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); -#endif - -/* SwapException.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#else -static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); -#endif - -/* Import.proto */ -static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); - -/* ImportDottedModule.proto */ -static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple); -#if PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple); -#endif - -/* FastTypeChecks.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) -#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) -static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); -static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b); -static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); -static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); -#else -#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) -#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) -#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) -#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) -#endif -#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) -#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) - -CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ -/* ListCompAppend.proto */ -#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS -static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { - PyListObject* L = (PyListObject*) list; - Py_ssize_t len = Py_SIZE(list); - if (likely(L->allocated > len)) { - Py_INCREF(x); - #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 - L->ob_item[len] = x; - #else - PyList_SET_ITEM(list, len, x); - #endif - __Pyx_SET_SIZE(list, len + 1); - return 0; - } - return PyList_Append(list, x); -} -#else -#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) -#endif - -/* PySequenceMultiply.proto */ -#define __Pyx_PySequence_Multiply_Left(mul, seq) __Pyx_PySequence_Multiply(seq, mul) -static CYTHON_INLINE PyObject* __Pyx_PySequence_Multiply(PyObject *seq, Py_ssize_t mul); - -/* SetItemInt.proto */ -#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\ - (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\ - __Pyx_SetItemInt_Generic(o, to_py_func(i), v))) -static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); -static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, - int is_list, int wraparound, int boundscheck); - -/* RaiseUnboundLocalError.proto */ -static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); - -/* DivInt[long].proto */ -static CYTHON_INLINE long __Pyx_div_long(long, long); - -/* PySequenceContains.proto */ -static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { - int result = PySequence_Contains(seq, item); - return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); -} - -/* ImportFrom.proto */ -static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); - -/* HasAttr.proto */ -#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 -#define __Pyx_HasAttr(o, n) PyObject_HasAttrWithError(o, n) -#else -static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); -#endif - -/* ErrOccurredWithGIL.proto */ -static CYTHON_INLINE int __Pyx_ErrOccurredWithGIL(void); - -/* PyObject_GenericGetAttrNoDict.proto */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr -#endif - -/* PyObject_GenericGetAttr.proto */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr -#endif - -/* IncludeStructmemberH.proto */ -#include - -/* FixUpExtensionType.proto */ -#if CYTHON_USE_TYPE_SPECS -static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); -#endif - -/* PyObjectCallNoArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); - -/* PyObjectGetMethod.proto */ -static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); - -/* PyObjectCallMethod0.proto */ -static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); - -/* ValidateBasesTuple.proto */ -#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS -static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); -#endif - -/* PyType_Ready.proto */ -CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); - -/* SetVTable.proto */ -static int __Pyx_SetVtable(PyTypeObject* typeptr , void* vtable); - -/* GetVTable.proto */ -static void* __Pyx_GetVtable(PyTypeObject *type); - -/* MergeVTables.proto */ -#if !CYTHON_COMPILING_IN_LIMITED_API -static int __Pyx_MergeVtables(PyTypeObject *type); -#endif - -/* SetupReduce.proto */ -#if !CYTHON_COMPILING_IN_LIMITED_API -static int __Pyx_setup_reduce(PyObject* type_obj); -#endif - -/* FetchSharedCythonModule.proto */ -static PyObject *__Pyx_FetchSharedCythonABIModule(void); - -/* FetchCommonType.proto */ -#if !CYTHON_USE_TYPE_SPECS -static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); -#else -static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); -#endif - -/* PyMethodNew.proto */ -#if CYTHON_COMPILING_IN_LIMITED_API -static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { - PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; - CYTHON_UNUSED_VAR(typ); - if (!self) - return __Pyx_NewRef(func); - typesModule = PyImport_ImportModule("types"); - if (!typesModule) return NULL; - methodType = PyObject_GetAttrString(typesModule, "MethodType"); - Py_DECREF(typesModule); - if (!methodType) return NULL; - result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL); - Py_DECREF(methodType); - return result; -} -#elif PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { - CYTHON_UNUSED_VAR(typ); - if (!self) - return __Pyx_NewRef(func); - return PyMethod_New(func, self); -} -#else - #define __Pyx_PyMethod_New PyMethod_New -#endif - -/* PyVectorcallFastCallDict.proto */ -#if CYTHON_METH_FASTCALL -static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); -#endif - -/* CythonFunctionShared.proto */ -#define __Pyx_CyFunction_USED -#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 -#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 -#define __Pyx_CYFUNCTION_CCLASS 0x04 -#define __Pyx_CYFUNCTION_COROUTINE 0x08 -#define __Pyx_CyFunction_GetClosure(f)\ - (((__pyx_CyFunctionObject *) (f))->func_closure) -#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_CyFunction_GetClassObj(f)\ - (((__pyx_CyFunctionObject *) (f))->func_classobj) -#else - #define __Pyx_CyFunction_GetClassObj(f)\ - ((PyObject*) ((PyCMethodObject *) (f))->mm_class) -#endif -#define __Pyx_CyFunction_SetClassObj(f, classobj)\ - __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (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 { -#if CYTHON_COMPILING_IN_LIMITED_API - PyObject_HEAD - PyObject *func; -#elif PY_VERSION_HEX < 0x030900B1 - PyCFunctionObject func; -#else - PyCMethodObject func; -#endif -#if CYTHON_BACKPORT_VECTORCALL - __pyx_vectorcallfunc func_vectorcall; -#endif -#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API - 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; -#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API - PyObject *func_classobj; -#endif - void *defaults; - int defaults_pyobjects; - size_t defaults_size; - int flags; - PyObject *defaults_tuple; - PyObject *defaults_kwdict; - PyObject *(*defaults_getter)(PyObject *); - PyObject *func_annotations; - PyObject *func_is_coroutine; -} __pyx_CyFunctionObject; -#undef __Pyx_CyOrPyCFunction_Check -#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_CyFunctionType) -#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) -#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) -static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); -#undef __Pyx_IsSameCFunction -#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) -static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, - int flags, PyObject* qualname, - PyObject *closure, - PyObject *module, PyObject *globals, - PyObject* code); -static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); -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(PyObject *module); -#if CYTHON_METH_FASTCALL -static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); -static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); -static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); -static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); -#if CYTHON_BACKPORT_VECTORCALL -#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) -#else -#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) -#endif -#endif - -/* CythonFunction.proto */ -static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, - int flags, PyObject* qualname, - PyObject *closure, - PyObject *module, PyObject *globals, - PyObject* code); - -/* CLineInTraceback.proto */ -#ifdef CYTHON_CLINE_IN_TRACEBACK -#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) -#else -static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); -#endif - -/* CodeObjectCache.proto */ -#if !CYTHON_COMPILING_IN_LIMITED_API -typedef struct { - PyCodeObject* code_object; - int code_line; -} __Pyx_CodeObjectCacheEntry; -struct __Pyx_CodeObjectCache { - int count; - int max_count; - __Pyx_CodeObjectCacheEntry* entries; -}; -static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; -static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); -static PyCodeObject *__pyx_find_code_object(int code_line); -static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); -#endif - -/* AddTraceback.proto */ -static void __Pyx_AddTraceback(const char *funcname, int c_line, - int py_line, const char *filename); - -#if PY_MAJOR_VERSION < 3 - static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); - static void __Pyx_ReleaseBuffer(Py_buffer *view); -#else - #define __Pyx_GetBuffer PyObject_GetBuffer - #define __Pyx_ReleaseBuffer PyBuffer_Release -#endif - - -/* BufferStructDeclare.proto */ -typedef struct { - Py_ssize_t shape, strides, suboffsets; -} __Pyx_Buf_DimInfo; -typedef struct { - size_t refcount; - Py_buffer pybuffer; -} __Pyx_Buffer; -typedef struct { - __Pyx_Buffer *rcbuffer; - char *data; - __Pyx_Buf_DimInfo diminfo[8]; -} __Pyx_LocalBuf_ND; - -/* MemviewSliceIsContig.proto */ -static int __pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim); - -/* OverlappingSlices.proto */ -static int __pyx_slices_overlap(__Pyx_memviewslice *slice1, - __Pyx_memviewslice *slice2, - int ndim, size_t itemsize); - -/* 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); - -/* MemviewSliceValidateAndInit.proto */ -static int __Pyx_ValidateAndInit_memviewslice( - int *axes_specs, - int c_or_f_flag, - int buf_flags, - int ndim, - __Pyx_TypeInfo *dtype, - __Pyx_BufFmt_StackElem stack[], - __Pyx_memviewslice *memviewslice, - PyObject *original_obj); - -/* ObjectToMemviewSlice.proto */ -static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dsds_float(PyObject *, int writable_flag); - -/* ObjectToMemviewSlice.proto */ -static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_ds_int(PyObject *, int writable_flag); - -/* ObjectToMemviewSlice.proto */ -static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dsds_int(PyObject *, int writable_flag); - -/* MemviewSliceCopyTemplate.proto */ -static __Pyx_memviewslice -__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, - const char *mode, int ndim, - size_t sizeof_dtype, int contig_flag, - int dtype_is_object); - -/* MemviewSliceInit.proto */ -#define __Pyx_BUF_MAX_NDIMS %(BUF_MAX_NDIMS)d -#define __Pyx_MEMVIEW_DIRECT 1 -#define __Pyx_MEMVIEW_PTR 2 -#define __Pyx_MEMVIEW_FULL 4 -#define __Pyx_MEMVIEW_CONTIG 8 -#define __Pyx_MEMVIEW_STRIDED 16 -#define __Pyx_MEMVIEW_FOLLOW 32 -#define __Pyx_IS_C_CONTIG 1 -#define __Pyx_IS_F_CONTIG 2 -static int __Pyx_init_memviewslice( - struct __pyx_memoryview_obj *memview, - int ndim, - __Pyx_memviewslice *memviewslice, - int memview_is_new_reference); -static CYTHON_INLINE int __pyx_add_acquisition_count_locked( - __pyx_atomic_int_type *acquisition_count, PyThread_type_lock lock); -static CYTHON_INLINE int __pyx_sub_acquisition_count_locked( - __pyx_atomic_int_type *acquisition_count, PyThread_type_lock lock); -#define __pyx_get_slice_count_pointer(memview) (&memview->acquisition_count) -#define __PYX_INC_MEMVIEW(slice, have_gil) __Pyx_INC_MEMVIEW(slice, have_gil, __LINE__) -#define __PYX_XCLEAR_MEMVIEW(slice, have_gil) __Pyx_XCLEAR_MEMVIEW(slice, have_gil, __LINE__) -static CYTHON_INLINE void __Pyx_INC_MEMVIEW(__Pyx_memviewslice *, int, int); -static CYTHON_INLINE void __Pyx_XCLEAR_MEMVIEW(__Pyx_memviewslice *, int, int); - -/* CIntFromPy.proto */ -static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); - -/* CIntFromPy.proto */ -static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); - -/* CIntFromPy.proto */ -static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *); - -/* FormatTypeName.proto */ -#if CYTHON_COMPILING_IN_LIMITED_API -typedef PyObject *__Pyx_TypeName; -#define __Pyx_FMT_TYPENAME "%U" -static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); -#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) -#else -typedef const char *__Pyx_TypeName; -#define __Pyx_FMT_TYPENAME "%.200s" -#define __Pyx_PyType_GetName(tp) ((tp)->tp_name) -#define __Pyx_DECREF_TypeName(obj) -#endif - -/* CheckBinaryVersion.proto */ -static unsigned long __Pyx_get_runtime_version(void); -static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); - -/* InitStrings.proto */ -static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); - -/* #### Code section: module_declarations ### */ -static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self); /* proto*/ -static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto*/ -static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj); /* proto*/ -static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src); /* proto*/ -static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value); /* proto*/ -static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto*/ -static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/ -static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/ -static PyObject *__pyx_memoryview__get_base(struct __pyx_memoryview_obj *__pyx_v_self); /* proto*/ -static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/ -static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/ -static PyObject *__pyx_memoryviewslice__get_base(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto*/ - -/* Module declarations from "cython.view" */ - -/* Module declarations from "cython.dataclasses" */ - -/* Module declarations from "cython" */ - -/* Module declarations from "libc.string" */ - -/* Module declarations from "libc.stdlib" */ - -/* Module declarations from "libc.math" */ - -/* Module declarations from "robo_utils.core" */ -static PyObject *__pyx_collections_abc_Sequence = 0; -static PyObject *generic = 0; -static PyObject *strided = 0; -static PyObject *indirect = 0; -static PyObject *contiguous = 0; -static PyObject *indirect_contiguous = 0; -static int __pyx_memoryview_thread_locks_used; -static PyThread_type_lock __pyx_memoryview_thread_locks[8]; -static int __pyx_f_10robo_utils_4core_round_to_int(float); /*proto*/ -static void __pyx_f_10robo_utils_4core_float_to_int_duration_each(__Pyx_memviewslice, __Pyx_memviewslice, int, __Pyx_memviewslice); /*proto*/ -static void __pyx_f_10robo_utils_4core_float_to_int_duration_batch_c(__Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, __Pyx_memviewslice, int __pyx_skip_dispatch); /*proto*/ -static int __pyx_f_10robo_utils_4core_generate_random(int, int); /*proto*/ -static void __pyx_f_10robo_utils_4core_generate_random_intervals_each(__Pyx_memviewslice, __Pyx_memviewslice, int); /*proto*/ -static void __pyx_f_10robo_utils_4core_generate_random_intervals_batch_c(__Pyx_memviewslice, __Pyx_memviewslice, int, int __pyx_skip_dispatch); /*proto*/ -static int __pyx_array_allocate_buffer(struct __pyx_array_obj *); /*proto*/ -static struct __pyx_array_obj *__pyx_array_new(PyObject *, Py_ssize_t, char *, char *, char *); /*proto*/ -static PyObject *__pyx_memoryview_new(PyObject *, int, int, __Pyx_TypeInfo *); /*proto*/ -static CYTHON_INLINE int __pyx_memoryview_check(PyObject *); /*proto*/ -static PyObject *_unellipsify(PyObject *, int); /*proto*/ -static int assert_direct_dimensions(Py_ssize_t *, int); /*proto*/ -static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *, PyObject *); /*proto*/ -static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int, int); /*proto*/ -static char *__pyx_pybuffer_index(Py_buffer *, char *, Py_ssize_t, Py_ssize_t); /*proto*/ -static int __pyx_memslice_transpose(__Pyx_memviewslice *); /*proto*/ -static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice, int, PyObject *(*)(char *), int (*)(char *, PyObject *), int); /*proto*/ -static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ -static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ -static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *); /*proto*/ -static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ -static Py_ssize_t abs_py_ssize_t(Py_ssize_t); /*proto*/ -static char __pyx_get_best_slice_order(__Pyx_memviewslice *, int); /*proto*/ -static void _copy_strided_to_strided(char *, Py_ssize_t *, char *, Py_ssize_t *, Py_ssize_t *, Py_ssize_t *, int, size_t); /*proto*/ -static void copy_strided_to_strided(__Pyx_memviewslice *, __Pyx_memviewslice *, int, size_t); /*proto*/ -static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *, int); /*proto*/ -static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *, Py_ssize_t *, Py_ssize_t, int, char); /*proto*/ -static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *, __Pyx_memviewslice *, char, int); /*proto*/ -static int __pyx_memoryview_err_extents(int, Py_ssize_t, Py_ssize_t); /*proto*/ -static int __pyx_memoryview_err_dim(PyObject *, PyObject *, int); /*proto*/ -static int __pyx_memoryview_err(PyObject *, PyObject *); /*proto*/ -static int __pyx_memoryview_err_no_memory(void); /*proto*/ -static int __pyx_memoryview_copy_contents(__Pyx_memviewslice, __Pyx_memviewslice, int, int, int); /*proto*/ -static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *, int, int); /*proto*/ -static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *, int, int, int); /*proto*/ -static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/ -static void __pyx_memoryview_refcount_objects_in_slice(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/ -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*/ -/* #### Code section: typeinfo ### */ -static __Pyx_TypeInfo __Pyx_TypeInfo_float = { "float", NULL, sizeof(float), { 0 }, 0, 'R', 0, 0 }; -static __Pyx_TypeInfo __Pyx_TypeInfo_int = { "int", NULL, sizeof(int), { 0 }, 0, __PYX_IS_UNSIGNED(int) ? 'U' : 'I', __PYX_IS_UNSIGNED(int), 0 }; -/* #### Code section: before_global_var ### */ -#define __Pyx_MODULE_NAME "robo_utils.core" -extern int __pyx_module_is_main_robo_utils__core; -int __pyx_module_is_main_robo_utils__core = 0; - -/* Implementation of "robo_utils.core" */ -/* #### Code section: global_var ### */ -static PyObject *__pyx_builtin_range; -static PyObject *__pyx_builtin___import__; -static PyObject *__pyx_builtin_ValueError; -static PyObject *__pyx_builtin_MemoryError; -static PyObject *__pyx_builtin_enumerate; -static PyObject *__pyx_builtin_TypeError; -static PyObject *__pyx_builtin_AssertionError; -static PyObject *__pyx_builtin_Ellipsis; -static PyObject *__pyx_builtin_id; -static PyObject *__pyx_builtin_IndexError; -/* #### Code section: string_decls ### */ -static const char __pyx_k_[] = ": "; -static const char __pyx_k_O[] = "O"; -static const char __pyx_k_T[] = "T"; -static const char __pyx_k_c[] = "c"; -static const char __pyx_k__2[] = "."; -static const char __pyx_k__3[] = "*"; -static const char __pyx_k__6[] = "'"; -static const char __pyx_k__7[] = ")"; -static const char __pyx_k_gc[] = "gc"; -static const char __pyx_k_id[] = "id"; -static const char __pyx_k_np[] = "np"; -static const char __pyx_k__24[] = "?"; -static const char __pyx_k_abc[] = "abc"; -static const char __pyx_k_and[] = " and "; -static const char __pyx_k_dur[] = "dur"; -static const char __pyx_k_got[] = " (got "; -static const char __pyx_k_new[] = "__new__"; -static const char __pyx_k_obj[] = "obj"; -static const char __pyx_k_sys[] = "sys"; -static const char __pyx_k_base[] = "base"; -static const char __pyx_k_dict[] = "__dict__"; -static const char __pyx_k_main[] = "__main__"; -static const char __pyx_k_mask[] = "mask"; -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_size[] = "size"; -static const char __pyx_k_spec[] = "__spec__"; -static const char __pyx_k_step[] = "step"; -static const char __pyx_k_stop[] = "stop"; -static const char __pyx_k_test[] = "__test__"; -static const char __pyx_k_ASCII[] = "ASCII"; -static const char __pyx_k_class[] = "__class__"; -static const char __pyx_k_count[] = "count"; -static const char __pyx_k_error[] = "error"; -static const char __pyx_k_flags[] = "flags"; -static const char __pyx_k_index[] = "index"; -static const char __pyx_k_numpy[] = "numpy"; -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_enable[] = "enable"; -static const char __pyx_k_encode[] = "encode"; -static const char __pyx_k_format[] = "format"; -static const char __pyx_k_import[] = "__import__"; -static const char __pyx_k_name_2[] = "__name__"; -static const char __pyx_k_pickle[] = "pickle"; -static const char __pyx_k_reduce[] = "__reduce__"; -static const char __pyx_k_struct[] = "struct"; -static const char __pyx_k_unpack[] = "unpack"; -static const char __pyx_k_update[] = "update"; -static const char __pyx_k_disable[] = "disable"; -static const char __pyx_k_fortran[] = "fortran"; -static const char __pyx_k_int_dur[] = "int_dur"; -static const char __pyx_k_memview[] = "memview"; -static const char __pyx_k_Ellipsis[] = "Ellipsis"; -static const char __pyx_k_Sequence[] = "Sequence"; -static const char __pyx_k_core_pyx[] = "core.pyx"; -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_register[] = "register"; -static const char __pyx_k_setstate[] = "__setstate__"; -static const char __pyx_k_TypeError[] = "TypeError"; -static const char __pyx_k_enumerate[] = "enumerate"; -static const char __pyx_k_isenabled[] = "isenabled"; -static const char __pyx_k_pyx_state[] = "__pyx_state"; -static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; -static const char __pyx_k_IndexError[] = "IndexError"; -static const char __pyx_k_ValueError[] = "ValueError"; -static const char __pyx_k_pyx_result[] = "__pyx_result"; -static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; -static const char __pyx_k_MemoryError[] = "MemoryError"; -static const char __pyx_k_PickleError[] = "PickleError"; -static const char __pyx_k_collections[] = "collections"; -static const char __pyx_k_num_randoms[] = "num_randoms"; -static const char __pyx_k_initializing[] = "_initializing"; -static const char __pyx_k_is_coroutine[] = "_is_coroutine"; -static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; -static const char __pyx_k_result_batch[] = "result_batch"; -static const char __pyx_k_stringsource[] = ""; -static const char __pyx_k_version_info[] = "version_info"; -static const char __pyx_k_class_getitem[] = "__class_getitem__"; -static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; -static const char __pyx_k_AssertionError[] = "AssertionError"; -static const char __pyx_k_View_MemoryView[] = "View.MemoryView"; -static const char __pyx_k_allocate_buffer[] = "allocate_buffer"; -static const char __pyx_k_collections_abc[] = "collections.abc"; -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_robo_utils_core[] = "robo_utils.core"; -static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; -static const char __pyx_k_boundaries_batch[] = "boundaries_batch"; -static const char __pyx_k_pyx_unpickle_Enum[] = "__pyx_unpickle_Enum"; -static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines"; -static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; -static const char __pyx_k_strided_and_direct[] = ""; -static const char __pyx_k_strided_and_indirect[] = ""; -static const char __pyx_k_Invalid_shape_in_axis[] = "Invalid shape in axis "; -static const char __pyx_k_contiguous_and_direct[] = ""; -static const char __pyx_k_Cannot_index_with_type[] = "Cannot index with type '"; -static const char __pyx_k_MemoryView_of_r_object[] = ""; -static const char __pyx_k_MemoryView_of_r_at_0x_x[] = ""; -static const char __pyx_k_contiguous_and_indirect[] = ""; -static const char __pyx_k_Dimension_d_is_not_direct[] = "Dimension %d is not direct"; -static const char __pyx_k_Index_out_of_bounds_axis_d[] = "Index out of bounds (axis %d)"; -static const char __pyx_k_Step_may_not_be_zero_axis_d[] = "Step may not be zero (axis %d)"; -static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cython.array"; -static const char __pyx_k_float_to_int_duration_batch_c[] = "float_to_int_duration_batch_c"; -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_generate_random_intervals_batch[] = "generate_random_intervals_batch_c"; -static const char __pyx_k_All_dimensions_preceding_dimensi[] = "All dimensions preceding dimension %d must be indexed and not sliced"; -static const char __pyx_k_Buffer_view_does_not_expose_stri[] = "Buffer view does not expose strides"; -static const char __pyx_k_Can_only_create_a_buffer_that_is[] = "Can only create a buffer that is contiguous in memory."; -static const char __pyx_k_Cannot_assign_to_read_only_memor[] = "Cannot assign to read-only memoryview"; -static const char __pyx_k_Cannot_create_writable_memory_vi[] = "Cannot create writable memory view from read-only memoryview"; -static const char __pyx_k_Cannot_transpose_memoryview_with[] = "Cannot transpose memoryview with indirect dimensions"; -static const char __pyx_k_Empty_shape_tuple_for_cython_arr[] = "Empty shape tuple for cython.array"; -static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))"; -static const char __pyx_k_Indirect_dimensions_not_supporte[] = "Indirect dimensions not supported"; -static const char __pyx_k_Invalid_mode_expected_c_or_fortr[] = "Invalid mode, expected 'c' or 'fortran', got "; -static const char __pyx_k_Out_of_bounds_on_buffer_access_a[] = "Out of bounds on buffer access (axis "; -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 "; -static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; -static const char __pyx_k_unable_to_allocate_shape_and_str[] = "unable to allocate shape and strides."; -/* #### Code section: decls ### */ -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 */ -static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self); /* proto */ -static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr); /* proto */ -static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item); /* proto */ -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); /* proto */ -static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self); /* proto */ -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); /* proto */ -static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ -static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ -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); /* proto */ -static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto */ -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); /* proto */ -static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ -static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ -static PyObject *__pyx_pf_10robo_utils_4core_float_to_int_duration_batch_c(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_dur, __Pyx_memviewslice __pyx_v_T, __Pyx_memviewslice __pyx_v_mask, __Pyx_memviewslice __pyx_v_int_dur); /* proto */ -static PyObject *__pyx_pf_10robo_utils_4core_2generate_random_intervals_batch_c(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_boundaries_batch, __Pyx_memviewslice __pyx_v_result_batch, int __pyx_v_num_randoms); /* proto */ -static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -/* #### Code section: late_includes ### */ -/* #### Code section: module_state ### */ -typedef struct { - PyObject *__pyx_d; - PyObject *__pyx_b; - PyObject *__pyx_cython_runtime; - PyObject *__pyx_empty_tuple; - PyObject *__pyx_empty_bytes; - PyObject *__pyx_empty_unicode; - #ifdef __Pyx_CyFunction_USED - PyTypeObject *__pyx_CyFunctionType; - #endif - #ifdef __Pyx_FusedFunction_USED - PyTypeObject *__pyx_FusedFunctionType; - #endif - #ifdef __Pyx_Generator_USED - PyTypeObject *__pyx_GeneratorType; - #endif - #ifdef __Pyx_IterableCoroutine_USED - PyTypeObject *__pyx_IterableCoroutineType; - #endif - #ifdef __Pyx_Coroutine_USED - PyTypeObject *__pyx_CoroutineAwaitType; - #endif - #ifdef __Pyx_Coroutine_USED - PyTypeObject *__pyx_CoroutineType; - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - PyObject *__pyx_type___pyx_array; - PyObject *__pyx_type___pyx_MemviewEnum; - PyObject *__pyx_type___pyx_memoryview; - PyObject *__pyx_type___pyx_memoryviewslice; - #endif - PyTypeObject *__pyx_array_type; - PyTypeObject *__pyx_MemviewEnum_type; - PyTypeObject *__pyx_memoryview_type; - PyTypeObject *__pyx_memoryviewslice_type; - PyObject *__pyx_kp_u_; - PyObject *__pyx_n_s_ASCII; - PyObject *__pyx_kp_s_All_dimensions_preceding_dimensi; - PyObject *__pyx_n_s_AssertionError; - PyObject *__pyx_kp_s_Buffer_view_does_not_expose_stri; - PyObject *__pyx_kp_s_Can_only_create_a_buffer_that_is; - PyObject *__pyx_kp_s_Cannot_assign_to_read_only_memor; - PyObject *__pyx_kp_s_Cannot_create_writable_memory_vi; - PyObject *__pyx_kp_u_Cannot_index_with_type; - PyObject *__pyx_kp_s_Cannot_transpose_memoryview_with; - PyObject *__pyx_kp_s_Dimension_d_is_not_direct; - PyObject *__pyx_n_s_Ellipsis; - PyObject *__pyx_kp_s_Empty_shape_tuple_for_cython_arr; - PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; - PyObject *__pyx_n_s_IndexError; - PyObject *__pyx_kp_s_Index_out_of_bounds_axis_d; - PyObject *__pyx_kp_s_Indirect_dimensions_not_supporte; - PyObject *__pyx_kp_u_Invalid_mode_expected_c_or_fortr; - PyObject *__pyx_kp_u_Invalid_shape_in_axis; - PyObject *__pyx_n_s_MemoryError; - PyObject *__pyx_kp_s_MemoryView_of_r_at_0x_x; - PyObject *__pyx_kp_s_MemoryView_of_r_object; - PyObject *__pyx_n_b_O; - PyObject *__pyx_kp_u_Out_of_bounds_on_buffer_access_a; - PyObject *__pyx_n_s_PickleError; - PyObject *__pyx_n_s_Sequence; - PyObject *__pyx_kp_s_Step_may_not_be_zero_axis_d; - PyObject *__pyx_n_s_T; - PyObject *__pyx_n_s_TypeError; - PyObject *__pyx_kp_s_Unable_to_convert_item_to_object; - PyObject *__pyx_n_s_ValueError; - PyObject *__pyx_n_s_View_MemoryView; - PyObject *__pyx_kp_u__2; - PyObject *__pyx_n_s__24; - PyObject *__pyx_n_s__3; - PyObject *__pyx_kp_u__6; - PyObject *__pyx_kp_u__7; - PyObject *__pyx_n_s_abc; - PyObject *__pyx_n_s_allocate_buffer; - PyObject *__pyx_kp_u_and; - PyObject *__pyx_n_s_asyncio_coroutines; - PyObject *__pyx_n_s_base; - PyObject *__pyx_n_s_boundaries_batch; - PyObject *__pyx_n_s_c; - PyObject *__pyx_n_u_c; - PyObject *__pyx_n_s_class; - PyObject *__pyx_n_s_class_getitem; - PyObject *__pyx_n_s_cline_in_traceback; - PyObject *__pyx_n_s_collections; - PyObject *__pyx_kp_s_collections_abc; - PyObject *__pyx_kp_s_contiguous_and_direct; - PyObject *__pyx_kp_s_contiguous_and_indirect; - PyObject *__pyx_kp_s_core_pyx; - PyObject *__pyx_n_s_count; - PyObject *__pyx_n_s_dict; - PyObject *__pyx_kp_u_disable; - PyObject *__pyx_n_s_dtype_is_object; - PyObject *__pyx_n_s_dur; - PyObject *__pyx_kp_u_enable; - PyObject *__pyx_n_s_encode; - PyObject *__pyx_n_s_enumerate; - PyObject *__pyx_n_s_error; - PyObject *__pyx_n_s_flags; - PyObject *__pyx_n_s_float_to_int_duration_batch_c; - PyObject *__pyx_n_s_format; - PyObject *__pyx_n_s_fortran; - PyObject *__pyx_n_u_fortran; - PyObject *__pyx_kp_u_gc; - PyObject *__pyx_n_s_generate_random_intervals_batch; - PyObject *__pyx_n_s_getstate; - PyObject *__pyx_kp_u_got; - PyObject *__pyx_kp_u_got_differing_extents_in_dimensi; - PyObject *__pyx_n_s_id; - PyObject *__pyx_n_s_import; - PyObject *__pyx_n_s_index; - PyObject *__pyx_n_s_initializing; - PyObject *__pyx_n_s_int_dur; - PyObject *__pyx_n_s_is_coroutine; - PyObject *__pyx_kp_u_isenabled; - PyObject *__pyx_n_s_itemsize; - PyObject *__pyx_kp_s_itemsize_0_for_cython_array; - PyObject *__pyx_n_s_main; - PyObject *__pyx_n_s_mask; - PyObject *__pyx_n_s_memview; - PyObject *__pyx_n_s_mode; - PyObject *__pyx_n_s_name; - PyObject *__pyx_n_s_name_2; - PyObject *__pyx_n_s_ndim; - PyObject *__pyx_n_s_new; - PyObject *__pyx_kp_s_no_default___reduce___due_to_non; - PyObject *__pyx_n_s_np; - PyObject *__pyx_n_s_num_randoms; - PyObject *__pyx_n_s_numpy; - PyObject *__pyx_n_s_obj; - PyObject *__pyx_n_s_pack; - PyObject *__pyx_n_s_pickle; - PyObject *__pyx_n_s_pyx_PickleError; - PyObject *__pyx_n_s_pyx_checksum; - PyObject *__pyx_n_s_pyx_result; - PyObject *__pyx_n_s_pyx_state; - PyObject *__pyx_n_s_pyx_type; - PyObject *__pyx_n_s_pyx_unpickle_Enum; - PyObject *__pyx_n_s_pyx_vtable; - PyObject *__pyx_n_s_range; - PyObject *__pyx_n_s_reduce; - PyObject *__pyx_n_s_reduce_cython; - PyObject *__pyx_n_s_reduce_ex; - PyObject *__pyx_n_s_register; - PyObject *__pyx_n_s_result_batch; - PyObject *__pyx_n_s_robo_utils_core; - PyObject *__pyx_n_s_setstate; - PyObject *__pyx_n_s_setstate_cython; - PyObject *__pyx_n_s_shape; - PyObject *__pyx_n_s_size; - PyObject *__pyx_n_s_spec; - PyObject *__pyx_n_s_start; - PyObject *__pyx_n_s_step; - PyObject *__pyx_n_s_stop; - PyObject *__pyx_kp_s_strided_and_direct; - PyObject *__pyx_kp_s_strided_and_direct_or_indirect; - PyObject *__pyx_kp_s_strided_and_indirect; - PyObject *__pyx_kp_s_stringsource; - PyObject *__pyx_n_s_struct; - PyObject *__pyx_n_s_sys; - PyObject *__pyx_n_s_test; - PyObject *__pyx_kp_s_unable_to_allocate_array_data; - PyObject *__pyx_kp_s_unable_to_allocate_shape_and_str; - PyObject *__pyx_n_s_unpack; - PyObject *__pyx_n_s_update; - PyObject *__pyx_n_s_version_info; - PyObject *__pyx_int_0; - PyObject *__pyx_int_1; - PyObject *__pyx_int_3; - PyObject *__pyx_int_112105877; - PyObject *__pyx_int_136983863; - PyObject *__pyx_int_184977713; - PyObject *__pyx_int_neg_1; - PyObject *__pyx_slice__5; - PyObject *__pyx_tuple__4; - PyObject *__pyx_tuple__8; - PyObject *__pyx_tuple__9; - PyObject *__pyx_tuple__10; - PyObject *__pyx_tuple__11; - PyObject *__pyx_tuple__12; - PyObject *__pyx_tuple__13; - PyObject *__pyx_tuple__14; - PyObject *__pyx_tuple__15; - PyObject *__pyx_tuple__16; - PyObject *__pyx_tuple__17; - PyObject *__pyx_tuple__18; - PyObject *__pyx_tuple__20; - PyObject *__pyx_tuple__22; - PyObject *__pyx_codeobj__19; - PyObject *__pyx_codeobj__21; - PyObject *__pyx_codeobj__23; -} __pyx_mstate; - -#if CYTHON_USE_MODULE_STATE -#ifdef __cplusplus -namespace { - extern struct PyModuleDef __pyx_moduledef; -} /* anonymous namespace */ -#else -static struct PyModuleDef __pyx_moduledef; -#endif - -#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) - -#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) - -#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) -#else -static __pyx_mstate __pyx_mstate_global_static = -#ifdef __cplusplus - {}; -#else - {0}; -#endif -static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; -#endif -/* #### Code section: module_state_clear ### */ -#if CYTHON_USE_MODULE_STATE -static int __pyx_m_clear(PyObject *m) { - __pyx_mstate *clear_module_state = __pyx_mstate(m); - if (!clear_module_state) return 0; - Py_CLEAR(clear_module_state->__pyx_d); - Py_CLEAR(clear_module_state->__pyx_b); - Py_CLEAR(clear_module_state->__pyx_cython_runtime); - Py_CLEAR(clear_module_state->__pyx_empty_tuple); - Py_CLEAR(clear_module_state->__pyx_empty_bytes); - Py_CLEAR(clear_module_state->__pyx_empty_unicode); - #ifdef __Pyx_CyFunction_USED - Py_CLEAR(clear_module_state->__pyx_CyFunctionType); - #endif - #ifdef __Pyx_FusedFunction_USED - Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); - #endif - Py_CLEAR(clear_module_state->__pyx_array_type); - Py_CLEAR(clear_module_state->__pyx_type___pyx_array); - Py_CLEAR(clear_module_state->__pyx_MemviewEnum_type); - Py_CLEAR(clear_module_state->__pyx_type___pyx_MemviewEnum); - Py_CLEAR(clear_module_state->__pyx_memoryview_type); - Py_CLEAR(clear_module_state->__pyx_type___pyx_memoryview); - Py_CLEAR(clear_module_state->__pyx_memoryviewslice_type); - Py_CLEAR(clear_module_state->__pyx_type___pyx_memoryviewslice); - Py_CLEAR(clear_module_state->__pyx_kp_u_); - Py_CLEAR(clear_module_state->__pyx_n_s_ASCII); - Py_CLEAR(clear_module_state->__pyx_kp_s_All_dimensions_preceding_dimensi); - Py_CLEAR(clear_module_state->__pyx_n_s_AssertionError); - Py_CLEAR(clear_module_state->__pyx_kp_s_Buffer_view_does_not_expose_stri); - Py_CLEAR(clear_module_state->__pyx_kp_s_Can_only_create_a_buffer_that_is); - Py_CLEAR(clear_module_state->__pyx_kp_s_Cannot_assign_to_read_only_memor); - Py_CLEAR(clear_module_state->__pyx_kp_s_Cannot_create_writable_memory_vi); - Py_CLEAR(clear_module_state->__pyx_kp_u_Cannot_index_with_type); - Py_CLEAR(clear_module_state->__pyx_kp_s_Cannot_transpose_memoryview_with); - Py_CLEAR(clear_module_state->__pyx_kp_s_Dimension_d_is_not_direct); - Py_CLEAR(clear_module_state->__pyx_n_s_Ellipsis); - Py_CLEAR(clear_module_state->__pyx_kp_s_Empty_shape_tuple_for_cython_arr); - Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); - Py_CLEAR(clear_module_state->__pyx_n_s_IndexError); - Py_CLEAR(clear_module_state->__pyx_kp_s_Index_out_of_bounds_axis_d); - Py_CLEAR(clear_module_state->__pyx_kp_s_Indirect_dimensions_not_supporte); - Py_CLEAR(clear_module_state->__pyx_kp_u_Invalid_mode_expected_c_or_fortr); - Py_CLEAR(clear_module_state->__pyx_kp_u_Invalid_shape_in_axis); - Py_CLEAR(clear_module_state->__pyx_n_s_MemoryError); - Py_CLEAR(clear_module_state->__pyx_kp_s_MemoryView_of_r_at_0x_x); - Py_CLEAR(clear_module_state->__pyx_kp_s_MemoryView_of_r_object); - Py_CLEAR(clear_module_state->__pyx_n_b_O); - Py_CLEAR(clear_module_state->__pyx_kp_u_Out_of_bounds_on_buffer_access_a); - Py_CLEAR(clear_module_state->__pyx_n_s_PickleError); - Py_CLEAR(clear_module_state->__pyx_n_s_Sequence); - Py_CLEAR(clear_module_state->__pyx_kp_s_Step_may_not_be_zero_axis_d); - Py_CLEAR(clear_module_state->__pyx_n_s_T); - Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); - Py_CLEAR(clear_module_state->__pyx_kp_s_Unable_to_convert_item_to_object); - Py_CLEAR(clear_module_state->__pyx_n_s_ValueError); - Py_CLEAR(clear_module_state->__pyx_n_s_View_MemoryView); - Py_CLEAR(clear_module_state->__pyx_kp_u__2); - Py_CLEAR(clear_module_state->__pyx_n_s__24); - Py_CLEAR(clear_module_state->__pyx_n_s__3); - Py_CLEAR(clear_module_state->__pyx_kp_u__6); - Py_CLEAR(clear_module_state->__pyx_kp_u__7); - Py_CLEAR(clear_module_state->__pyx_n_s_abc); - Py_CLEAR(clear_module_state->__pyx_n_s_allocate_buffer); - Py_CLEAR(clear_module_state->__pyx_kp_u_and); - Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); - Py_CLEAR(clear_module_state->__pyx_n_s_base); - Py_CLEAR(clear_module_state->__pyx_n_s_boundaries_batch); - Py_CLEAR(clear_module_state->__pyx_n_s_c); - Py_CLEAR(clear_module_state->__pyx_n_u_c); - Py_CLEAR(clear_module_state->__pyx_n_s_class); - Py_CLEAR(clear_module_state->__pyx_n_s_class_getitem); - Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); - Py_CLEAR(clear_module_state->__pyx_n_s_collections); - Py_CLEAR(clear_module_state->__pyx_kp_s_collections_abc); - Py_CLEAR(clear_module_state->__pyx_kp_s_contiguous_and_direct); - Py_CLEAR(clear_module_state->__pyx_kp_s_contiguous_and_indirect); - Py_CLEAR(clear_module_state->__pyx_kp_s_core_pyx); - Py_CLEAR(clear_module_state->__pyx_n_s_count); - Py_CLEAR(clear_module_state->__pyx_n_s_dict); - Py_CLEAR(clear_module_state->__pyx_kp_u_disable); - Py_CLEAR(clear_module_state->__pyx_n_s_dtype_is_object); - Py_CLEAR(clear_module_state->__pyx_n_s_dur); - Py_CLEAR(clear_module_state->__pyx_kp_u_enable); - Py_CLEAR(clear_module_state->__pyx_n_s_encode); - Py_CLEAR(clear_module_state->__pyx_n_s_enumerate); - Py_CLEAR(clear_module_state->__pyx_n_s_error); - Py_CLEAR(clear_module_state->__pyx_n_s_flags); - Py_CLEAR(clear_module_state->__pyx_n_s_float_to_int_duration_batch_c); - Py_CLEAR(clear_module_state->__pyx_n_s_format); - Py_CLEAR(clear_module_state->__pyx_n_s_fortran); - Py_CLEAR(clear_module_state->__pyx_n_u_fortran); - Py_CLEAR(clear_module_state->__pyx_kp_u_gc); - Py_CLEAR(clear_module_state->__pyx_n_s_generate_random_intervals_batch); - Py_CLEAR(clear_module_state->__pyx_n_s_getstate); - Py_CLEAR(clear_module_state->__pyx_kp_u_got); - Py_CLEAR(clear_module_state->__pyx_kp_u_got_differing_extents_in_dimensi); - Py_CLEAR(clear_module_state->__pyx_n_s_id); - Py_CLEAR(clear_module_state->__pyx_n_s_import); - Py_CLEAR(clear_module_state->__pyx_n_s_index); - Py_CLEAR(clear_module_state->__pyx_n_s_initializing); - Py_CLEAR(clear_module_state->__pyx_n_s_int_dur); - Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); - Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); - Py_CLEAR(clear_module_state->__pyx_n_s_itemsize); - Py_CLEAR(clear_module_state->__pyx_kp_s_itemsize_0_for_cython_array); - Py_CLEAR(clear_module_state->__pyx_n_s_main); - Py_CLEAR(clear_module_state->__pyx_n_s_mask); - Py_CLEAR(clear_module_state->__pyx_n_s_memview); - Py_CLEAR(clear_module_state->__pyx_n_s_mode); - Py_CLEAR(clear_module_state->__pyx_n_s_name); - Py_CLEAR(clear_module_state->__pyx_n_s_name_2); - Py_CLEAR(clear_module_state->__pyx_n_s_ndim); - Py_CLEAR(clear_module_state->__pyx_n_s_new); - Py_CLEAR(clear_module_state->__pyx_kp_s_no_default___reduce___due_to_non); - Py_CLEAR(clear_module_state->__pyx_n_s_np); - Py_CLEAR(clear_module_state->__pyx_n_s_num_randoms); - Py_CLEAR(clear_module_state->__pyx_n_s_numpy); - Py_CLEAR(clear_module_state->__pyx_n_s_obj); - Py_CLEAR(clear_module_state->__pyx_n_s_pack); - Py_CLEAR(clear_module_state->__pyx_n_s_pickle); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_PickleError); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_checksum); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_result); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_type); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Enum); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_vtable); - Py_CLEAR(clear_module_state->__pyx_n_s_range); - Py_CLEAR(clear_module_state->__pyx_n_s_reduce); - Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex); - Py_CLEAR(clear_module_state->__pyx_n_s_register); - Py_CLEAR(clear_module_state->__pyx_n_s_result_batch); - Py_CLEAR(clear_module_state->__pyx_n_s_robo_utils_core); - Py_CLEAR(clear_module_state->__pyx_n_s_setstate); - Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_shape); - Py_CLEAR(clear_module_state->__pyx_n_s_size); - Py_CLEAR(clear_module_state->__pyx_n_s_spec); - Py_CLEAR(clear_module_state->__pyx_n_s_start); - Py_CLEAR(clear_module_state->__pyx_n_s_step); - Py_CLEAR(clear_module_state->__pyx_n_s_stop); - Py_CLEAR(clear_module_state->__pyx_kp_s_strided_and_direct); - Py_CLEAR(clear_module_state->__pyx_kp_s_strided_and_direct_or_indirect); - Py_CLEAR(clear_module_state->__pyx_kp_s_strided_and_indirect); - Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource); - Py_CLEAR(clear_module_state->__pyx_n_s_struct); - Py_CLEAR(clear_module_state->__pyx_n_s_sys); - Py_CLEAR(clear_module_state->__pyx_n_s_test); - Py_CLEAR(clear_module_state->__pyx_kp_s_unable_to_allocate_array_data); - Py_CLEAR(clear_module_state->__pyx_kp_s_unable_to_allocate_shape_and_str); - Py_CLEAR(clear_module_state->__pyx_n_s_unpack); - Py_CLEAR(clear_module_state->__pyx_n_s_update); - Py_CLEAR(clear_module_state->__pyx_n_s_version_info); - Py_CLEAR(clear_module_state->__pyx_int_0); - Py_CLEAR(clear_module_state->__pyx_int_1); - Py_CLEAR(clear_module_state->__pyx_int_3); - Py_CLEAR(clear_module_state->__pyx_int_112105877); - Py_CLEAR(clear_module_state->__pyx_int_136983863); - Py_CLEAR(clear_module_state->__pyx_int_184977713); - Py_CLEAR(clear_module_state->__pyx_int_neg_1); - Py_CLEAR(clear_module_state->__pyx_slice__5); - Py_CLEAR(clear_module_state->__pyx_tuple__4); - Py_CLEAR(clear_module_state->__pyx_tuple__8); - Py_CLEAR(clear_module_state->__pyx_tuple__9); - Py_CLEAR(clear_module_state->__pyx_tuple__10); - Py_CLEAR(clear_module_state->__pyx_tuple__11); - Py_CLEAR(clear_module_state->__pyx_tuple__12); - Py_CLEAR(clear_module_state->__pyx_tuple__13); - Py_CLEAR(clear_module_state->__pyx_tuple__14); - Py_CLEAR(clear_module_state->__pyx_tuple__15); - Py_CLEAR(clear_module_state->__pyx_tuple__16); - Py_CLEAR(clear_module_state->__pyx_tuple__17); - Py_CLEAR(clear_module_state->__pyx_tuple__18); - Py_CLEAR(clear_module_state->__pyx_tuple__20); - Py_CLEAR(clear_module_state->__pyx_tuple__22); - Py_CLEAR(clear_module_state->__pyx_codeobj__19); - Py_CLEAR(clear_module_state->__pyx_codeobj__21); - Py_CLEAR(clear_module_state->__pyx_codeobj__23); - return 0; -} -#endif -/* #### Code section: module_state_traverse ### */ -#if CYTHON_USE_MODULE_STATE -static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { - __pyx_mstate *traverse_module_state = __pyx_mstate(m); - if (!traverse_module_state) return 0; - Py_VISIT(traverse_module_state->__pyx_d); - Py_VISIT(traverse_module_state->__pyx_b); - Py_VISIT(traverse_module_state->__pyx_cython_runtime); - Py_VISIT(traverse_module_state->__pyx_empty_tuple); - Py_VISIT(traverse_module_state->__pyx_empty_bytes); - Py_VISIT(traverse_module_state->__pyx_empty_unicode); - #ifdef __Pyx_CyFunction_USED - Py_VISIT(traverse_module_state->__pyx_CyFunctionType); - #endif - #ifdef __Pyx_FusedFunction_USED - Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); - #endif - Py_VISIT(traverse_module_state->__pyx_array_type); - Py_VISIT(traverse_module_state->__pyx_type___pyx_array); - Py_VISIT(traverse_module_state->__pyx_MemviewEnum_type); - Py_VISIT(traverse_module_state->__pyx_type___pyx_MemviewEnum); - Py_VISIT(traverse_module_state->__pyx_memoryview_type); - Py_VISIT(traverse_module_state->__pyx_type___pyx_memoryview); - Py_VISIT(traverse_module_state->__pyx_memoryviewslice_type); - Py_VISIT(traverse_module_state->__pyx_type___pyx_memoryviewslice); - Py_VISIT(traverse_module_state->__pyx_kp_u_); - Py_VISIT(traverse_module_state->__pyx_n_s_ASCII); - Py_VISIT(traverse_module_state->__pyx_kp_s_All_dimensions_preceding_dimensi); - Py_VISIT(traverse_module_state->__pyx_n_s_AssertionError); - Py_VISIT(traverse_module_state->__pyx_kp_s_Buffer_view_does_not_expose_stri); - Py_VISIT(traverse_module_state->__pyx_kp_s_Can_only_create_a_buffer_that_is); - Py_VISIT(traverse_module_state->__pyx_kp_s_Cannot_assign_to_read_only_memor); - Py_VISIT(traverse_module_state->__pyx_kp_s_Cannot_create_writable_memory_vi); - Py_VISIT(traverse_module_state->__pyx_kp_u_Cannot_index_with_type); - Py_VISIT(traverse_module_state->__pyx_kp_s_Cannot_transpose_memoryview_with); - Py_VISIT(traverse_module_state->__pyx_kp_s_Dimension_d_is_not_direct); - Py_VISIT(traverse_module_state->__pyx_n_s_Ellipsis); - Py_VISIT(traverse_module_state->__pyx_kp_s_Empty_shape_tuple_for_cython_arr); - Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); - Py_VISIT(traverse_module_state->__pyx_n_s_IndexError); - Py_VISIT(traverse_module_state->__pyx_kp_s_Index_out_of_bounds_axis_d); - Py_VISIT(traverse_module_state->__pyx_kp_s_Indirect_dimensions_not_supporte); - Py_VISIT(traverse_module_state->__pyx_kp_u_Invalid_mode_expected_c_or_fortr); - Py_VISIT(traverse_module_state->__pyx_kp_u_Invalid_shape_in_axis); - Py_VISIT(traverse_module_state->__pyx_n_s_MemoryError); - Py_VISIT(traverse_module_state->__pyx_kp_s_MemoryView_of_r_at_0x_x); - Py_VISIT(traverse_module_state->__pyx_kp_s_MemoryView_of_r_object); - Py_VISIT(traverse_module_state->__pyx_n_b_O); - Py_VISIT(traverse_module_state->__pyx_kp_u_Out_of_bounds_on_buffer_access_a); - Py_VISIT(traverse_module_state->__pyx_n_s_PickleError); - Py_VISIT(traverse_module_state->__pyx_n_s_Sequence); - Py_VISIT(traverse_module_state->__pyx_kp_s_Step_may_not_be_zero_axis_d); - Py_VISIT(traverse_module_state->__pyx_n_s_T); - Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); - Py_VISIT(traverse_module_state->__pyx_kp_s_Unable_to_convert_item_to_object); - Py_VISIT(traverse_module_state->__pyx_n_s_ValueError); - Py_VISIT(traverse_module_state->__pyx_n_s_View_MemoryView); - Py_VISIT(traverse_module_state->__pyx_kp_u__2); - Py_VISIT(traverse_module_state->__pyx_n_s__24); - Py_VISIT(traverse_module_state->__pyx_n_s__3); - Py_VISIT(traverse_module_state->__pyx_kp_u__6); - Py_VISIT(traverse_module_state->__pyx_kp_u__7); - Py_VISIT(traverse_module_state->__pyx_n_s_abc); - Py_VISIT(traverse_module_state->__pyx_n_s_allocate_buffer); - Py_VISIT(traverse_module_state->__pyx_kp_u_and); - Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); - Py_VISIT(traverse_module_state->__pyx_n_s_base); - Py_VISIT(traverse_module_state->__pyx_n_s_boundaries_batch); - Py_VISIT(traverse_module_state->__pyx_n_s_c); - Py_VISIT(traverse_module_state->__pyx_n_u_c); - Py_VISIT(traverse_module_state->__pyx_n_s_class); - Py_VISIT(traverse_module_state->__pyx_n_s_class_getitem); - Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); - Py_VISIT(traverse_module_state->__pyx_n_s_collections); - Py_VISIT(traverse_module_state->__pyx_kp_s_collections_abc); - Py_VISIT(traverse_module_state->__pyx_kp_s_contiguous_and_direct); - Py_VISIT(traverse_module_state->__pyx_kp_s_contiguous_and_indirect); - Py_VISIT(traverse_module_state->__pyx_kp_s_core_pyx); - Py_VISIT(traverse_module_state->__pyx_n_s_count); - Py_VISIT(traverse_module_state->__pyx_n_s_dict); - Py_VISIT(traverse_module_state->__pyx_kp_u_disable); - Py_VISIT(traverse_module_state->__pyx_n_s_dtype_is_object); - Py_VISIT(traverse_module_state->__pyx_n_s_dur); - Py_VISIT(traverse_module_state->__pyx_kp_u_enable); - Py_VISIT(traverse_module_state->__pyx_n_s_encode); - Py_VISIT(traverse_module_state->__pyx_n_s_enumerate); - Py_VISIT(traverse_module_state->__pyx_n_s_error); - Py_VISIT(traverse_module_state->__pyx_n_s_flags); - Py_VISIT(traverse_module_state->__pyx_n_s_float_to_int_duration_batch_c); - Py_VISIT(traverse_module_state->__pyx_n_s_format); - Py_VISIT(traverse_module_state->__pyx_n_s_fortran); - Py_VISIT(traverse_module_state->__pyx_n_u_fortran); - Py_VISIT(traverse_module_state->__pyx_kp_u_gc); - Py_VISIT(traverse_module_state->__pyx_n_s_generate_random_intervals_batch); - Py_VISIT(traverse_module_state->__pyx_n_s_getstate); - Py_VISIT(traverse_module_state->__pyx_kp_u_got); - Py_VISIT(traverse_module_state->__pyx_kp_u_got_differing_extents_in_dimensi); - Py_VISIT(traverse_module_state->__pyx_n_s_id); - Py_VISIT(traverse_module_state->__pyx_n_s_import); - Py_VISIT(traverse_module_state->__pyx_n_s_index); - Py_VISIT(traverse_module_state->__pyx_n_s_initializing); - Py_VISIT(traverse_module_state->__pyx_n_s_int_dur); - Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); - Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); - Py_VISIT(traverse_module_state->__pyx_n_s_itemsize); - Py_VISIT(traverse_module_state->__pyx_kp_s_itemsize_0_for_cython_array); - Py_VISIT(traverse_module_state->__pyx_n_s_main); - Py_VISIT(traverse_module_state->__pyx_n_s_mask); - Py_VISIT(traverse_module_state->__pyx_n_s_memview); - Py_VISIT(traverse_module_state->__pyx_n_s_mode); - Py_VISIT(traverse_module_state->__pyx_n_s_name); - Py_VISIT(traverse_module_state->__pyx_n_s_name_2); - Py_VISIT(traverse_module_state->__pyx_n_s_ndim); - Py_VISIT(traverse_module_state->__pyx_n_s_new); - Py_VISIT(traverse_module_state->__pyx_kp_s_no_default___reduce___due_to_non); - Py_VISIT(traverse_module_state->__pyx_n_s_np); - Py_VISIT(traverse_module_state->__pyx_n_s_num_randoms); - Py_VISIT(traverse_module_state->__pyx_n_s_numpy); - Py_VISIT(traverse_module_state->__pyx_n_s_obj); - Py_VISIT(traverse_module_state->__pyx_n_s_pack); - Py_VISIT(traverse_module_state->__pyx_n_s_pickle); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_PickleError); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_checksum); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_result); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_type); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Enum); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_vtable); - Py_VISIT(traverse_module_state->__pyx_n_s_range); - Py_VISIT(traverse_module_state->__pyx_n_s_reduce); - Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex); - Py_VISIT(traverse_module_state->__pyx_n_s_register); - Py_VISIT(traverse_module_state->__pyx_n_s_result_batch); - Py_VISIT(traverse_module_state->__pyx_n_s_robo_utils_core); - Py_VISIT(traverse_module_state->__pyx_n_s_setstate); - Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_shape); - Py_VISIT(traverse_module_state->__pyx_n_s_size); - Py_VISIT(traverse_module_state->__pyx_n_s_spec); - Py_VISIT(traverse_module_state->__pyx_n_s_start); - Py_VISIT(traverse_module_state->__pyx_n_s_step); - Py_VISIT(traverse_module_state->__pyx_n_s_stop); - Py_VISIT(traverse_module_state->__pyx_kp_s_strided_and_direct); - Py_VISIT(traverse_module_state->__pyx_kp_s_strided_and_direct_or_indirect); - Py_VISIT(traverse_module_state->__pyx_kp_s_strided_and_indirect); - Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource); - Py_VISIT(traverse_module_state->__pyx_n_s_struct); - Py_VISIT(traverse_module_state->__pyx_n_s_sys); - Py_VISIT(traverse_module_state->__pyx_n_s_test); - Py_VISIT(traverse_module_state->__pyx_kp_s_unable_to_allocate_array_data); - Py_VISIT(traverse_module_state->__pyx_kp_s_unable_to_allocate_shape_and_str); - Py_VISIT(traverse_module_state->__pyx_n_s_unpack); - Py_VISIT(traverse_module_state->__pyx_n_s_update); - Py_VISIT(traverse_module_state->__pyx_n_s_version_info); - Py_VISIT(traverse_module_state->__pyx_int_0); - Py_VISIT(traverse_module_state->__pyx_int_1); - Py_VISIT(traverse_module_state->__pyx_int_3); - Py_VISIT(traverse_module_state->__pyx_int_112105877); - Py_VISIT(traverse_module_state->__pyx_int_136983863); - Py_VISIT(traverse_module_state->__pyx_int_184977713); - Py_VISIT(traverse_module_state->__pyx_int_neg_1); - Py_VISIT(traverse_module_state->__pyx_slice__5); - Py_VISIT(traverse_module_state->__pyx_tuple__4); - Py_VISIT(traverse_module_state->__pyx_tuple__8); - Py_VISIT(traverse_module_state->__pyx_tuple__9); - Py_VISIT(traverse_module_state->__pyx_tuple__10); - Py_VISIT(traverse_module_state->__pyx_tuple__11); - Py_VISIT(traverse_module_state->__pyx_tuple__12); - Py_VISIT(traverse_module_state->__pyx_tuple__13); - Py_VISIT(traverse_module_state->__pyx_tuple__14); - Py_VISIT(traverse_module_state->__pyx_tuple__15); - Py_VISIT(traverse_module_state->__pyx_tuple__16); - Py_VISIT(traverse_module_state->__pyx_tuple__17); - Py_VISIT(traverse_module_state->__pyx_tuple__18); - Py_VISIT(traverse_module_state->__pyx_tuple__20); - Py_VISIT(traverse_module_state->__pyx_tuple__22); - Py_VISIT(traverse_module_state->__pyx_codeobj__19); - Py_VISIT(traverse_module_state->__pyx_codeobj__21); - Py_VISIT(traverse_module_state->__pyx_codeobj__23); - return 0; -} -#endif -/* #### Code section: module_state_defines ### */ -#define __pyx_d __pyx_mstate_global->__pyx_d -#define __pyx_b __pyx_mstate_global->__pyx_b -#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime -#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple -#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes -#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode -#ifdef __Pyx_CyFunction_USED -#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType -#endif -#ifdef __Pyx_FusedFunction_USED -#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType -#endif -#ifdef __Pyx_Generator_USED -#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType -#endif -#ifdef __Pyx_IterableCoroutine_USED -#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType -#endif -#ifdef __Pyx_Coroutine_USED -#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType -#endif -#ifdef __Pyx_Coroutine_USED -#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#define __pyx_type___pyx_array __pyx_mstate_global->__pyx_type___pyx_array -#define __pyx_type___pyx_MemviewEnum __pyx_mstate_global->__pyx_type___pyx_MemviewEnum -#define __pyx_type___pyx_memoryview __pyx_mstate_global->__pyx_type___pyx_memoryview -#define __pyx_type___pyx_memoryviewslice __pyx_mstate_global->__pyx_type___pyx_memoryviewslice -#endif -#define __pyx_array_type __pyx_mstate_global->__pyx_array_type -#define __pyx_MemviewEnum_type __pyx_mstate_global->__pyx_MemviewEnum_type -#define __pyx_memoryview_type __pyx_mstate_global->__pyx_memoryview_type -#define __pyx_memoryviewslice_type __pyx_mstate_global->__pyx_memoryviewslice_type -#define __pyx_kp_u_ __pyx_mstate_global->__pyx_kp_u_ -#define __pyx_n_s_ASCII __pyx_mstate_global->__pyx_n_s_ASCII -#define __pyx_kp_s_All_dimensions_preceding_dimensi __pyx_mstate_global->__pyx_kp_s_All_dimensions_preceding_dimensi -#define __pyx_n_s_AssertionError __pyx_mstate_global->__pyx_n_s_AssertionError -#define __pyx_kp_s_Buffer_view_does_not_expose_stri __pyx_mstate_global->__pyx_kp_s_Buffer_view_does_not_expose_stri -#define __pyx_kp_s_Can_only_create_a_buffer_that_is __pyx_mstate_global->__pyx_kp_s_Can_only_create_a_buffer_that_is -#define __pyx_kp_s_Cannot_assign_to_read_only_memor __pyx_mstate_global->__pyx_kp_s_Cannot_assign_to_read_only_memor -#define __pyx_kp_s_Cannot_create_writable_memory_vi __pyx_mstate_global->__pyx_kp_s_Cannot_create_writable_memory_vi -#define __pyx_kp_u_Cannot_index_with_type __pyx_mstate_global->__pyx_kp_u_Cannot_index_with_type -#define __pyx_kp_s_Cannot_transpose_memoryview_with __pyx_mstate_global->__pyx_kp_s_Cannot_transpose_memoryview_with -#define __pyx_kp_s_Dimension_d_is_not_direct __pyx_mstate_global->__pyx_kp_s_Dimension_d_is_not_direct -#define __pyx_n_s_Ellipsis __pyx_mstate_global->__pyx_n_s_Ellipsis -#define __pyx_kp_s_Empty_shape_tuple_for_cython_arr __pyx_mstate_global->__pyx_kp_s_Empty_shape_tuple_for_cython_arr -#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0 -#define __pyx_n_s_IndexError __pyx_mstate_global->__pyx_n_s_IndexError -#define __pyx_kp_s_Index_out_of_bounds_axis_d __pyx_mstate_global->__pyx_kp_s_Index_out_of_bounds_axis_d -#define __pyx_kp_s_Indirect_dimensions_not_supporte __pyx_mstate_global->__pyx_kp_s_Indirect_dimensions_not_supporte -#define __pyx_kp_u_Invalid_mode_expected_c_or_fortr __pyx_mstate_global->__pyx_kp_u_Invalid_mode_expected_c_or_fortr -#define __pyx_kp_u_Invalid_shape_in_axis __pyx_mstate_global->__pyx_kp_u_Invalid_shape_in_axis -#define __pyx_n_s_MemoryError __pyx_mstate_global->__pyx_n_s_MemoryError -#define __pyx_kp_s_MemoryView_of_r_at_0x_x __pyx_mstate_global->__pyx_kp_s_MemoryView_of_r_at_0x_x -#define __pyx_kp_s_MemoryView_of_r_object __pyx_mstate_global->__pyx_kp_s_MemoryView_of_r_object -#define __pyx_n_b_O __pyx_mstate_global->__pyx_n_b_O -#define __pyx_kp_u_Out_of_bounds_on_buffer_access_a __pyx_mstate_global->__pyx_kp_u_Out_of_bounds_on_buffer_access_a -#define __pyx_n_s_PickleError __pyx_mstate_global->__pyx_n_s_PickleError -#define __pyx_n_s_Sequence __pyx_mstate_global->__pyx_n_s_Sequence -#define __pyx_kp_s_Step_may_not_be_zero_axis_d __pyx_mstate_global->__pyx_kp_s_Step_may_not_be_zero_axis_d -#define __pyx_n_s_T __pyx_mstate_global->__pyx_n_s_T -#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError -#define __pyx_kp_s_Unable_to_convert_item_to_object __pyx_mstate_global->__pyx_kp_s_Unable_to_convert_item_to_object -#define __pyx_n_s_ValueError __pyx_mstate_global->__pyx_n_s_ValueError -#define __pyx_n_s_View_MemoryView __pyx_mstate_global->__pyx_n_s_View_MemoryView -#define __pyx_kp_u__2 __pyx_mstate_global->__pyx_kp_u__2 -#define __pyx_n_s__24 __pyx_mstate_global->__pyx_n_s__24 -#define __pyx_n_s__3 __pyx_mstate_global->__pyx_n_s__3 -#define __pyx_kp_u__6 __pyx_mstate_global->__pyx_kp_u__6 -#define __pyx_kp_u__7 __pyx_mstate_global->__pyx_kp_u__7 -#define __pyx_n_s_abc __pyx_mstate_global->__pyx_n_s_abc -#define __pyx_n_s_allocate_buffer __pyx_mstate_global->__pyx_n_s_allocate_buffer -#define __pyx_kp_u_and __pyx_mstate_global->__pyx_kp_u_and -#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines -#define __pyx_n_s_base __pyx_mstate_global->__pyx_n_s_base -#define __pyx_n_s_boundaries_batch __pyx_mstate_global->__pyx_n_s_boundaries_batch -#define __pyx_n_s_c __pyx_mstate_global->__pyx_n_s_c -#define __pyx_n_u_c __pyx_mstate_global->__pyx_n_u_c -#define __pyx_n_s_class __pyx_mstate_global->__pyx_n_s_class -#define __pyx_n_s_class_getitem __pyx_mstate_global->__pyx_n_s_class_getitem -#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback -#define __pyx_n_s_collections __pyx_mstate_global->__pyx_n_s_collections -#define __pyx_kp_s_collections_abc __pyx_mstate_global->__pyx_kp_s_collections_abc -#define __pyx_kp_s_contiguous_and_direct __pyx_mstate_global->__pyx_kp_s_contiguous_and_direct -#define __pyx_kp_s_contiguous_and_indirect __pyx_mstate_global->__pyx_kp_s_contiguous_and_indirect -#define __pyx_kp_s_core_pyx __pyx_mstate_global->__pyx_kp_s_core_pyx -#define __pyx_n_s_count __pyx_mstate_global->__pyx_n_s_count -#define __pyx_n_s_dict __pyx_mstate_global->__pyx_n_s_dict -#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable -#define __pyx_n_s_dtype_is_object __pyx_mstate_global->__pyx_n_s_dtype_is_object -#define __pyx_n_s_dur __pyx_mstate_global->__pyx_n_s_dur -#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable -#define __pyx_n_s_encode __pyx_mstate_global->__pyx_n_s_encode -#define __pyx_n_s_enumerate __pyx_mstate_global->__pyx_n_s_enumerate -#define __pyx_n_s_error __pyx_mstate_global->__pyx_n_s_error -#define __pyx_n_s_flags __pyx_mstate_global->__pyx_n_s_flags -#define __pyx_n_s_float_to_int_duration_batch_c __pyx_mstate_global->__pyx_n_s_float_to_int_duration_batch_c -#define __pyx_n_s_format __pyx_mstate_global->__pyx_n_s_format -#define __pyx_n_s_fortran __pyx_mstate_global->__pyx_n_s_fortran -#define __pyx_n_u_fortran __pyx_mstate_global->__pyx_n_u_fortran -#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc -#define __pyx_n_s_generate_random_intervals_batch __pyx_mstate_global->__pyx_n_s_generate_random_intervals_batch -#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate -#define __pyx_kp_u_got __pyx_mstate_global->__pyx_kp_u_got -#define __pyx_kp_u_got_differing_extents_in_dimensi __pyx_mstate_global->__pyx_kp_u_got_differing_extents_in_dimensi -#define __pyx_n_s_id __pyx_mstate_global->__pyx_n_s_id -#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import -#define __pyx_n_s_index __pyx_mstate_global->__pyx_n_s_index -#define __pyx_n_s_initializing __pyx_mstate_global->__pyx_n_s_initializing -#define __pyx_n_s_int_dur __pyx_mstate_global->__pyx_n_s_int_dur -#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine -#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled -#define __pyx_n_s_itemsize __pyx_mstate_global->__pyx_n_s_itemsize -#define __pyx_kp_s_itemsize_0_for_cython_array __pyx_mstate_global->__pyx_kp_s_itemsize_0_for_cython_array -#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main -#define __pyx_n_s_mask __pyx_mstate_global->__pyx_n_s_mask -#define __pyx_n_s_memview __pyx_mstate_global->__pyx_n_s_memview -#define __pyx_n_s_mode __pyx_mstate_global->__pyx_n_s_mode -#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name -#define __pyx_n_s_name_2 __pyx_mstate_global->__pyx_n_s_name_2 -#define __pyx_n_s_ndim __pyx_mstate_global->__pyx_n_s_ndim -#define __pyx_n_s_new __pyx_mstate_global->__pyx_n_s_new -#define __pyx_kp_s_no_default___reduce___due_to_non __pyx_mstate_global->__pyx_kp_s_no_default___reduce___due_to_non -#define __pyx_n_s_np __pyx_mstate_global->__pyx_n_s_np -#define __pyx_n_s_num_randoms __pyx_mstate_global->__pyx_n_s_num_randoms -#define __pyx_n_s_numpy __pyx_mstate_global->__pyx_n_s_numpy -#define __pyx_n_s_obj __pyx_mstate_global->__pyx_n_s_obj -#define __pyx_n_s_pack __pyx_mstate_global->__pyx_n_s_pack -#define __pyx_n_s_pickle __pyx_mstate_global->__pyx_n_s_pickle -#define __pyx_n_s_pyx_PickleError __pyx_mstate_global->__pyx_n_s_pyx_PickleError -#define __pyx_n_s_pyx_checksum __pyx_mstate_global->__pyx_n_s_pyx_checksum -#define __pyx_n_s_pyx_result __pyx_mstate_global->__pyx_n_s_pyx_result -#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state -#define __pyx_n_s_pyx_type __pyx_mstate_global->__pyx_n_s_pyx_type -#define __pyx_n_s_pyx_unpickle_Enum __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Enum -#define __pyx_n_s_pyx_vtable __pyx_mstate_global->__pyx_n_s_pyx_vtable -#define __pyx_n_s_range __pyx_mstate_global->__pyx_n_s_range -#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce -#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython -#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex -#define __pyx_n_s_register __pyx_mstate_global->__pyx_n_s_register -#define __pyx_n_s_result_batch __pyx_mstate_global->__pyx_n_s_result_batch -#define __pyx_n_s_robo_utils_core __pyx_mstate_global->__pyx_n_s_robo_utils_core -#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate -#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython -#define __pyx_n_s_shape __pyx_mstate_global->__pyx_n_s_shape -#define __pyx_n_s_size __pyx_mstate_global->__pyx_n_s_size -#define __pyx_n_s_spec __pyx_mstate_global->__pyx_n_s_spec -#define __pyx_n_s_start __pyx_mstate_global->__pyx_n_s_start -#define __pyx_n_s_step __pyx_mstate_global->__pyx_n_s_step -#define __pyx_n_s_stop __pyx_mstate_global->__pyx_n_s_stop -#define __pyx_kp_s_strided_and_direct __pyx_mstate_global->__pyx_kp_s_strided_and_direct -#define __pyx_kp_s_strided_and_direct_or_indirect __pyx_mstate_global->__pyx_kp_s_strided_and_direct_or_indirect -#define __pyx_kp_s_strided_and_indirect __pyx_mstate_global->__pyx_kp_s_strided_and_indirect -#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource -#define __pyx_n_s_struct __pyx_mstate_global->__pyx_n_s_struct -#define __pyx_n_s_sys __pyx_mstate_global->__pyx_n_s_sys -#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test -#define __pyx_kp_s_unable_to_allocate_array_data __pyx_mstate_global->__pyx_kp_s_unable_to_allocate_array_data -#define __pyx_kp_s_unable_to_allocate_shape_and_str __pyx_mstate_global->__pyx_kp_s_unable_to_allocate_shape_and_str -#define __pyx_n_s_unpack __pyx_mstate_global->__pyx_n_s_unpack -#define __pyx_n_s_update __pyx_mstate_global->__pyx_n_s_update -#define __pyx_n_s_version_info __pyx_mstate_global->__pyx_n_s_version_info -#define __pyx_int_0 __pyx_mstate_global->__pyx_int_0 -#define __pyx_int_1 __pyx_mstate_global->__pyx_int_1 -#define __pyx_int_3 __pyx_mstate_global->__pyx_int_3 -#define __pyx_int_112105877 __pyx_mstate_global->__pyx_int_112105877 -#define __pyx_int_136983863 __pyx_mstate_global->__pyx_int_136983863 -#define __pyx_int_184977713 __pyx_mstate_global->__pyx_int_184977713 -#define __pyx_int_neg_1 __pyx_mstate_global->__pyx_int_neg_1 -#define __pyx_slice__5 __pyx_mstate_global->__pyx_slice__5 -#define __pyx_tuple__4 __pyx_mstate_global->__pyx_tuple__4 -#define __pyx_tuple__8 __pyx_mstate_global->__pyx_tuple__8 -#define __pyx_tuple__9 __pyx_mstate_global->__pyx_tuple__9 -#define __pyx_tuple__10 __pyx_mstate_global->__pyx_tuple__10 -#define __pyx_tuple__11 __pyx_mstate_global->__pyx_tuple__11 -#define __pyx_tuple__12 __pyx_mstate_global->__pyx_tuple__12 -#define __pyx_tuple__13 __pyx_mstate_global->__pyx_tuple__13 -#define __pyx_tuple__14 __pyx_mstate_global->__pyx_tuple__14 -#define __pyx_tuple__15 __pyx_mstate_global->__pyx_tuple__15 -#define __pyx_tuple__16 __pyx_mstate_global->__pyx_tuple__16 -#define __pyx_tuple__17 __pyx_mstate_global->__pyx_tuple__17 -#define __pyx_tuple__18 __pyx_mstate_global->__pyx_tuple__18 -#define __pyx_tuple__20 __pyx_mstate_global->__pyx_tuple__20 -#define __pyx_tuple__22 __pyx_mstate_global->__pyx_tuple__22 -#define __pyx_codeobj__19 __pyx_mstate_global->__pyx_codeobj__19 -#define __pyx_codeobj__21 __pyx_mstate_global->__pyx_codeobj__21 -#define __pyx_codeobj__23 __pyx_mstate_global->__pyx_codeobj__23 -/* #### Code section: module_code ### */ - -/* "View.MemoryView":131 - * cdef bint dtype_is_object - * - * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< - * mode="c", bint allocate_buffer=True): - * - */ - -/* 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; - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[5] = {0,0,0,0,0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; - #endif - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - { - 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}; - values[3] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)__pyx_n_s_c)); - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_VARARGS(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_VARARGS(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_shape)) != 0)) { - (void)__Pyx_Arg_NewRef_VARARGS(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_itemsize)) != 0)) { - (void)__Pyx_Arg_NewRef_VARARGS(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 1); __PYX_ERR(1, 131, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_format)) != 0)) { - (void)__Pyx_Arg_NewRef_VARARGS(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 2); __PYX_ERR(1, 131, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_mode); - if (value) { values[3] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_allocate_buffer); - if (value) { values[4] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(1, 131, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 5: values[4] = __Pyx_Arg_VARARGS(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = __Pyx_Arg_VARARGS(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); - values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); - values[0] = __Pyx_Arg_VARARGS(__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(1, 131, __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(1, 132, __pyx_L3_error) - } else { - - /* "View.MemoryView":132 - * - * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, - * mode="c", bint allocate_buffer=True): # <<<<<<<<<<<<<< - * - * cdef int idx - */ - __pyx_v_allocate_buffer = ((int)1); - } - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, __pyx_nargs); __PYX_ERR(1, 131, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); - } - } - __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(1, 131, __pyx_L1_error) - if (unlikely(((PyObject *)__pyx_v_format) == Py_None)) { - PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "format"); __PYX_ERR(1, 131, __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); - - /* "View.MemoryView":131 - * cdef bint dtype_is_object - * - * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< - * mode="c", bint allocate_buffer=True): - * - */ - - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __pyx_r = -1; - __pyx_L0:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); - } - } - __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_dim; - char __pyx_v_order; - int __pyx_r; - __Pyx_RefNannyDeclarations - Py_ssize_t __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - int __pyx_t_7; - char *__pyx_t_8; - Py_ssize_t __pyx_t_9; - Py_UCS4 __pyx_t_10; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__cinit__", 0); - __Pyx_INCREF(__pyx_v_format); - - /* "View.MemoryView":137 - * cdef Py_ssize_t dim - * - * self.ndim = len(shape) # <<<<<<<<<<<<<< - * self.itemsize = itemsize - * - */ - if (unlikely(__pyx_v_shape == Py_None)) { - PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(1, 137, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 137, __pyx_L1_error) - __pyx_v_self->ndim = ((int)__pyx_t_1); - - /* "View.MemoryView":138 - * - * self.ndim = len(shape) - * self.itemsize = itemsize # <<<<<<<<<<<<<< - * - * if not self.ndim: - */ - __pyx_v_self->itemsize = __pyx_v_itemsize; - - /* "View.MemoryView":140 - * self.itemsize = itemsize - * - * if not self.ndim: # <<<<<<<<<<<<<< - * raise ValueError, "Empty shape tuple for cython.array" - * - */ - __pyx_t_2 = (!(__pyx_v_self->ndim != 0)); - if (unlikely(__pyx_t_2)) { - - /* "View.MemoryView":141 - * - * if not self.ndim: - * raise ValueError, "Empty shape tuple for cython.array" # <<<<<<<<<<<<<< - * - * if itemsize <= 0: - */ - __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Empty_shape_tuple_for_cython_arr, 0, 0); - __PYX_ERR(1, 141, __pyx_L1_error) - - /* "View.MemoryView":140 - * self.itemsize = itemsize - * - * if not self.ndim: # <<<<<<<<<<<<<< - * raise ValueError, "Empty shape tuple for cython.array" - * - */ - } - - /* "View.MemoryView":143 - * raise ValueError, "Empty shape tuple for cython.array" - * - * if itemsize <= 0: # <<<<<<<<<<<<<< - * raise ValueError, "itemsize <= 0 for cython.array" - * - */ - __pyx_t_2 = (__pyx_v_itemsize <= 0); - if (unlikely(__pyx_t_2)) { - - /* "View.MemoryView":144 - * - * if itemsize <= 0: - * raise ValueError, "itemsize <= 0 for cython.array" # <<<<<<<<<<<<<< - * - * if not isinstance(format, bytes): - */ - __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_itemsize_0_for_cython_array, 0, 0); - __PYX_ERR(1, 144, __pyx_L1_error) - - /* "View.MemoryView":143 - * raise ValueError, "Empty shape tuple for cython.array" - * - * if itemsize <= 0: # <<<<<<<<<<<<<< - * raise ValueError, "itemsize <= 0 for cython.array" - * - */ - } - - /* "View.MemoryView":146 - * 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_2 = PyBytes_Check(__pyx_v_format); - __pyx_t_3 = (!__pyx_t_2); - if (__pyx_t_3) { - - /* "View.MemoryView":147 - * - * 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_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = NULL; - __pyx_t_7 = 0; - #if CYTHON_UNPACK_METHODS - if (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_7 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_n_s_ASCII}; - __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } - __Pyx_DECREF_SET(__pyx_v_format, __pyx_t_4); - __pyx_t_4 = 0; - - /* "View.MemoryView":146 - * 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 - */ - } - - /* "View.MemoryView":148 - * if not isinstance(format, bytes): - * format = format.encode('ASCII') - * self._format = format # keep a reference to the byte string # <<<<<<<<<<<<<< - * self.format = self._format - * - */ - if (!(likely(PyBytes_CheckExact(__pyx_v_format))||((__pyx_v_format) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_v_format))) __PYX_ERR(1, 148, __pyx_L1_error) - __pyx_t_4 = __pyx_v_format; - __Pyx_INCREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_4); - __Pyx_GOTREF(__pyx_v_self->_format); - __Pyx_DECREF(__pyx_v_self->_format); - __pyx_v_self->_format = ((PyObject*)__pyx_t_4); - __pyx_t_4 = 0; - - /* "View.MemoryView":149 - * format = format.encode('ASCII') - * self._format = format # keep a reference to the byte string - * self.format = self._format # <<<<<<<<<<<<<< - * - * - */ - if (unlikely(__pyx_v_self->_format == Py_None)) { - PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); - __PYX_ERR(1, 149, __pyx_L1_error) - } - __pyx_t_8 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_8) && PyErr_Occurred())) __PYX_ERR(1, 149, __pyx_L1_error) - __pyx_v_self->format = __pyx_t_8; - - /* "View.MemoryView":152 - * - * - * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) # <<<<<<<<<<<<<< - * self._strides = self._shape + self.ndim - * - */ - __pyx_v_self->_shape = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * __pyx_v_self->ndim) * 2))); - - /* "View.MemoryView":153 - * - * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) - * self._strides = self._shape + self.ndim # <<<<<<<<<<<<<< - * - * if not self._shape: - */ - __pyx_v_self->_strides = (__pyx_v_self->_shape + __pyx_v_self->ndim); - - /* "View.MemoryView":155 - * self._strides = self._shape + self.ndim - * - * if not self._shape: # <<<<<<<<<<<<<< - * raise MemoryError, "unable to allocate shape and strides." - * - */ - __pyx_t_3 = (!(__pyx_v_self->_shape != 0)); - if (unlikely(__pyx_t_3)) { - - /* "View.MemoryView":156 - * - * if not self._shape: - * raise MemoryError, "unable to allocate shape and strides." # <<<<<<<<<<<<<< - * - * - */ - __Pyx_Raise(__pyx_builtin_MemoryError, __pyx_kp_s_unable_to_allocate_shape_and_str, 0, 0); - __PYX_ERR(1, 156, __pyx_L1_error) - - /* "View.MemoryView":155 - * self._strides = self._shape + self.ndim - * - * if not self._shape: # <<<<<<<<<<<<<< - * raise MemoryError, "unable to allocate shape and strides." - * - */ - } - - /* "View.MemoryView":159 - * - * - * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< - * if dim <= 0: - * raise ValueError, f"Invalid shape in axis {idx}: {dim}." - */ - __pyx_t_7 = 0; - __pyx_t_4 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_4); - __pyx_t_1 = 0; - for (;;) { - { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_4); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 159, __pyx_L1_error) - #endif - if (__pyx_t_1 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(1, 159, __pyx_L1_error) - #else - __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 159, __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(1, 159, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_dim = __pyx_t_9; - __pyx_v_idx = __pyx_t_7; - __pyx_t_7 = (__pyx_t_7 + 1); - - /* "View.MemoryView":160 - * - * for idx, dim in enumerate(shape): - * if dim <= 0: # <<<<<<<<<<<<<< - * raise ValueError, f"Invalid shape in axis {idx}: {dim}." - * self._shape[idx] = dim - */ - __pyx_t_3 = (__pyx_v_dim <= 0); - if (unlikely(__pyx_t_3)) { - - /* "View.MemoryView":161 - * for idx, dim in enumerate(shape): - * if dim <= 0: - * raise ValueError, f"Invalid shape in axis {idx}: {dim}." # <<<<<<<<<<<<<< - * self._shape[idx] = dim - * - */ - __pyx_t_5 = PyTuple_New(5); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_9 = 0; - __pyx_t_10 = 127; - __Pyx_INCREF(__pyx_kp_u_Invalid_shape_in_axis); - __pyx_t_9 += 22; - __Pyx_GIVEREF(__pyx_kp_u_Invalid_shape_in_axis); - PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_kp_u_Invalid_shape_in_axis); - __pyx_t_6 = __Pyx_PyUnicode_From_int(__pyx_v_idx, 0, ' ', 'd'); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_6); - __pyx_t_6 = 0; - __Pyx_INCREF(__pyx_kp_u_); - __pyx_t_9 += 2; - __Pyx_GIVEREF(__pyx_kp_u_); - PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_kp_u_); - __pyx_t_6 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_dim, 0, ' ', 'd'); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_6); - __pyx_t_6 = 0; - __Pyx_INCREF(__pyx_kp_u__2); - __pyx_t_9 += 1; - __Pyx_GIVEREF(__pyx_kp_u__2); - PyTuple_SET_ITEM(__pyx_t_5, 4, __pyx_kp_u__2); - __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_5, 5, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_Raise(__pyx_builtin_ValueError, __pyx_t_6, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(1, 161, __pyx_L1_error) - - /* "View.MemoryView":160 - * - * for idx, dim in enumerate(shape): - * if dim <= 0: # <<<<<<<<<<<<<< - * raise ValueError, f"Invalid shape in axis {idx}: {dim}." - * self._shape[idx] = dim - */ - } - - /* "View.MemoryView":162 - * if dim <= 0: - * raise ValueError, f"Invalid shape in axis {idx}: {dim}." - * self._shape[idx] = dim # <<<<<<<<<<<<<< - * - * cdef char order - */ - (__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim; - - /* "View.MemoryView":159 - * - * - * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< - * if dim <= 0: - * raise ValueError, f"Invalid shape in axis {idx}: {dim}." - */ - } - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - - /* "View.MemoryView":165 - * - * cdef char order - * if mode == 'c': # <<<<<<<<<<<<<< - * order = b'C' - * self.mode = u'c' - */ - __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_c, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 165, __pyx_L1_error) - if (__pyx_t_3) { - - /* "View.MemoryView":166 - * cdef char order - * if mode == 'c': - * order = b'C' # <<<<<<<<<<<<<< - * self.mode = u'c' - * elif mode == 'fortran': - */ - __pyx_v_order = 'C'; - - /* "View.MemoryView":167 - * if mode == 'c': - * order = b'C' - * self.mode = u'c' # <<<<<<<<<<<<<< - * elif mode == 'fortran': - * order = b'F' - */ - __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":165 - * - * cdef char order - * if mode == 'c': # <<<<<<<<<<<<<< - * order = b'C' - * self.mode = u'c' - */ - goto __pyx_L11; - } - - /* "View.MemoryView":168 - * order = b'C' - * self.mode = u'c' - * elif mode == 'fortran': # <<<<<<<<<<<<<< - * order = b'F' - * self.mode = u'fortran' - */ - __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_fortran, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 168, __pyx_L1_error) - if (likely(__pyx_t_3)) { - - /* "View.MemoryView":169 - * self.mode = u'c' - * elif mode == 'fortran': - * order = b'F' # <<<<<<<<<<<<<< - * self.mode = u'fortran' - * else: - */ - __pyx_v_order = 'F'; - - /* "View.MemoryView":170 - * elif mode == 'fortran': - * order = b'F' - * self.mode = u'fortran' # <<<<<<<<<<<<<< - * else: - * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}" - */ - __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; - - /* "View.MemoryView":168 - * order = b'C' - * self.mode = u'c' - * elif mode == 'fortran': # <<<<<<<<<<<<<< - * order = b'F' - * self.mode = u'fortran' - */ - goto __pyx_L11; - } - - /* "View.MemoryView":172 - * self.mode = u'fortran' - * else: - * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}" # <<<<<<<<<<<<<< - * - * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order) - */ - /*else*/ { - __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_v_mode, __pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 172, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Invalid_mode_expected_c_or_fortr, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 172, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_Raise(__pyx_builtin_ValueError, __pyx_t_6, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(1, 172, __pyx_L1_error) - } - __pyx_L11:; - - /* "View.MemoryView":174 - * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}" - * - * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order) # <<<<<<<<<<<<<< - * - * self.free_data = allocate_buffer - */ - __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); - - /* "View.MemoryView":176 - * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order) - * - * self.free_data = allocate_buffer # <<<<<<<<<<<<<< - * self.dtype_is_object = format == b'O' - * - */ - __pyx_v_self->free_data = __pyx_v_allocate_buffer; - - /* "View.MemoryView":177 - * - * self.free_data = allocate_buffer - * self.dtype_is_object = format == b'O' # <<<<<<<<<<<<<< - * - * if allocate_buffer: - */ - __pyx_t_6 = PyObject_RichCompare(__pyx_v_format, __pyx_n_b_O, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 177, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 177, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_v_self->dtype_is_object = __pyx_t_3; - - /* "View.MemoryView":179 - * self.dtype_is_object = format == b'O' - * - * if allocate_buffer: # <<<<<<<<<<<<<< - * _allocate_buffer(self) - * - */ - if (__pyx_v_allocate_buffer) { - - /* "View.MemoryView":180 - * - * if allocate_buffer: - * _allocate_buffer(self) # <<<<<<<<<<<<<< - * - * @cname('getbuffer') - */ - __pyx_t_7 = __pyx_array_allocate_buffer(__pyx_v_self); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(1, 180, __pyx_L1_error) - - /* "View.MemoryView":179 - * self.dtype_is_object = format == b'O' - * - * if allocate_buffer: # <<<<<<<<<<<<<< - * _allocate_buffer(self) - * - */ - } - - /* "View.MemoryView":131 - * cdef bint dtype_is_object - * - * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< - * mode="c", bint allocate_buffer=True): - * - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __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; -} - -/* "View.MemoryView":182 - * _allocate_buffer(self) - * - * @cname('getbuffer') # <<<<<<<<<<<<<< - * def __getbuffer__(self, Py_buffer *info, int flags): - * cdef int bufmode = -1 - */ - -/* Python wrapper */ -CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ -CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __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; - char *__pyx_t_2; - Py_ssize_t __pyx_t_3; - int __pyx_t_4; - Py_ssize_t *__pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - if (unlikely(__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); - - /* "View.MemoryView":184 - * @cname('getbuffer') - * def __getbuffer__(self, Py_buffer *info, int flags): - * cdef int bufmode = -1 # <<<<<<<<<<<<<< - * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): - * if self.mode == u"c": - */ - __pyx_v_bufmode = -1; - - /* "View.MemoryView":185 - * def __getbuffer__(self, Py_buffer *info, int flags): - * cdef int bufmode = -1 - * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): # <<<<<<<<<<<<<< - * if self.mode == u"c": - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - */ - __pyx_t_1 = ((__pyx_v_flags & ((PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS) | PyBUF_ANY_CONTIGUOUS)) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":186 - * cdef int bufmode = -1 - * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): - * if self.mode == u"c": # <<<<<<<<<<<<<< - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * elif self.mode == u"fortran": - */ - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_c, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 186, __pyx_L1_error) - if (__pyx_t_1) { - - /* "View.MemoryView":187 - * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): - * 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); - - /* "View.MemoryView":186 - * cdef int bufmode = -1 - * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): - * if self.mode == u"c": # <<<<<<<<<<<<<< - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * elif self.mode == u"fortran": - */ - goto __pyx_L4; - } - - /* "View.MemoryView":188 - * 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_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_fortran, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 188, __pyx_L1_error) - if (__pyx_t_1) { - - /* "View.MemoryView":189 - * 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":188 - * 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_L4:; - - /* "View.MemoryView":190 - * 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)); - if (unlikely(__pyx_t_1)) { - - /* "View.MemoryView":191 - * 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_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Can_only_create_a_buffer_that_is, 0, 0); - __PYX_ERR(1, 191, __pyx_L1_error) - - /* "View.MemoryView":190 - * 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":185 - * def __getbuffer__(self, Py_buffer *info, int flags): - * cdef int bufmode = -1 - * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): # <<<<<<<<<<<<<< - * if self.mode == u"c": - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - */ - } - - /* "View.MemoryView":192 - * 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_2 = __pyx_v_self->data; - __pyx_v_info->buf = __pyx_t_2; - - /* "View.MemoryView":193 - * raise ValueError, "Can only create a buffer that is contiguous in memory." - * info.buf = self.data - * info.len = self.len # <<<<<<<<<<<<<< - * - * if flags & PyBUF_STRIDES: - */ - __pyx_t_3 = __pyx_v_self->len; - __pyx_v_info->len = __pyx_t_3; - - /* "View.MemoryView":195 - * info.len = self.len - * - * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< - * info.ndim = self.ndim - * info.shape = self._shape - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":196 - * - * if flags & PyBUF_STRIDES: - * info.ndim = self.ndim # <<<<<<<<<<<<<< - * info.shape = self._shape - * info.strides = self._strides - */ - __pyx_t_4 = __pyx_v_self->ndim; - __pyx_v_info->ndim = __pyx_t_4; - - /* "View.MemoryView":197 - * if flags & PyBUF_STRIDES: - * info.ndim = self.ndim - * info.shape = self._shape # <<<<<<<<<<<<<< - * info.strides = self._strides - * else: - */ - __pyx_t_5 = __pyx_v_self->_shape; - __pyx_v_info->shape = __pyx_t_5; - - /* "View.MemoryView":198 - * info.ndim = self.ndim - * info.shape = self._shape - * info.strides = self._strides # <<<<<<<<<<<<<< - * else: - * info.ndim = 1 - */ - __pyx_t_5 = __pyx_v_self->_strides; - __pyx_v_info->strides = __pyx_t_5; - - /* "View.MemoryView":195 - * info.len = self.len - * - * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< - * info.ndim = self.ndim - * info.shape = self._shape - */ - goto __pyx_L6; - } - - /* "View.MemoryView":200 - * info.strides = self._strides - * else: - * info.ndim = 1 # <<<<<<<<<<<<<< - * info.shape = &self.len if flags & PyBUF_ND else NULL - * info.strides = NULL - */ - /*else*/ { - __pyx_v_info->ndim = 1; - - /* "View.MemoryView":201 - * else: - * info.ndim = 1 - * info.shape = &self.len if flags & PyBUF_ND else NULL # <<<<<<<<<<<<<< - * info.strides = NULL - * - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0); - if (__pyx_t_1) { - __pyx_t_5 = (&__pyx_v_self->len); - } else { - __pyx_t_5 = NULL; - } - __pyx_v_info->shape = __pyx_t_5; - - /* "View.MemoryView":202 - * info.ndim = 1 - * info.shape = &self.len if flags & PyBUF_ND else NULL - * info.strides = NULL # <<<<<<<<<<<<<< - * - * info.suboffsets = NULL - */ - __pyx_v_info->strides = NULL; - } - __pyx_L6:; - - /* "View.MemoryView":204 - * info.strides = NULL - * - * info.suboffsets = NULL # <<<<<<<<<<<<<< - * info.itemsize = self.itemsize - * info.readonly = 0 - */ - __pyx_v_info->suboffsets = NULL; - - /* "View.MemoryView":205 - * - * info.suboffsets = NULL - * info.itemsize = self.itemsize # <<<<<<<<<<<<<< - * info.readonly = 0 - * info.format = self.format if flags & PyBUF_FORMAT else NULL - */ - __pyx_t_3 = __pyx_v_self->itemsize; - __pyx_v_info->itemsize = __pyx_t_3; - - /* "View.MemoryView":206 - * info.suboffsets = NULL - * info.itemsize = self.itemsize - * info.readonly = 0 # <<<<<<<<<<<<<< - * info.format = self.format if flags & PyBUF_FORMAT else NULL - * info.obj = self - */ - __pyx_v_info->readonly = 0; - - /* "View.MemoryView":207 - * info.itemsize = self.itemsize - * info.readonly = 0 - * info.format = self.format if flags & PyBUF_FORMAT else NULL # <<<<<<<<<<<<<< - * info.obj = self - * - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); - if (__pyx_t_1) { - __pyx_t_2 = __pyx_v_self->format; - } else { - __pyx_t_2 = NULL; - } - __pyx_v_info->format = __pyx_t_2; - - /* "View.MemoryView":208 - * info.readonly = 0 - * info.format = self.format if flags & PyBUF_FORMAT else NULL - * info.obj = self # <<<<<<<<<<<<<< - * - * def __dealloc__(array self): - */ - __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":182 - * _allocate_buffer(self) - * - * @cname('getbuffer') # <<<<<<<<<<<<<< - * def __getbuffer__(self, Py_buffer *info, int flags): - * cdef int bufmode = -1 - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __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":210 - * info.obj = self - * - * def __dealloc__(array self): # <<<<<<<<<<<<<< - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) - */ - -/* Python wrapper */ -static void __pyx_array___dealloc__(PyObject *__pyx_v_self); /*proto*/ -static void __pyx_array___dealloc__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __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) { - int __pyx_t_1; - int __pyx_t_2; - - /* "View.MemoryView":211 - * - * def __dealloc__(array self): - * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< - * self.callback_free_data(self.data) - * elif self.free_data and self.data is not NULL: - */ - __pyx_t_1 = (__pyx_v_self->callback_free_data != NULL); - if (__pyx_t_1) { - - /* "View.MemoryView":212 - * def __dealloc__(array self): - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) # <<<<<<<<<<<<<< - * elif self.free_data and self.data is not NULL: - * if self.dtype_is_object: - */ - __pyx_v_self->callback_free_data(__pyx_v_self->data); - - /* "View.MemoryView":211 - * - * def __dealloc__(array self): - * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< - * self.callback_free_data(self.data) - * elif self.free_data and self.data is not NULL: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":213 - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) - * elif self.free_data and self.data is not NULL: # <<<<<<<<<<<<<< - * if self.dtype_is_object: - * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) - */ - if (__pyx_v_self->free_data) { - } else { - __pyx_t_1 = __pyx_v_self->free_data; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_2 = (__pyx_v_self->data != NULL); - __pyx_t_1 = __pyx_t_2; - __pyx_L4_bool_binop_done:; - if (__pyx_t_1) { - - /* "View.MemoryView":214 - * self.callback_free_data(self.data) - * elif self.free_data and self.data is not NULL: - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) - * free(self.data) - */ - if (__pyx_v_self->dtype_is_object) { - - /* "View.MemoryView":215 - * elif self.free_data and self.data is not NULL: - * if self.dtype_is_object: - * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) # <<<<<<<<<<<<<< - * free(self.data) - * PyObject_Free(self._shape) - */ - __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":214 - * self.callback_free_data(self.data) - * elif self.free_data and self.data is not NULL: - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) - * free(self.data) - */ - } - - /* "View.MemoryView":216 - * if self.dtype_is_object: - * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) - * free(self.data) # <<<<<<<<<<<<<< - * PyObject_Free(self._shape) - * - */ - free(__pyx_v_self->data); - - /* "View.MemoryView":213 - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) - * elif self.free_data and self.data is not NULL: # <<<<<<<<<<<<<< - * if self.dtype_is_object: - * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) - */ - } - __pyx_L3:; - - /* "View.MemoryView":217 - * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) - * free(self.data) - * PyObject_Free(self._shape) # <<<<<<<<<<<<<< - * - * @property - */ - PyObject_Free(__pyx_v_self->_shape); - - /* "View.MemoryView":210 - * info.obj = self - * - * def __dealloc__(array self): # <<<<<<<<<<<<<< - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) - */ - - /* function exit code */ -} - -/* "View.MemoryView":219 - * PyObject_Free(self._shape) - * - * @property # <<<<<<<<<<<<<< - * def memview(self): - * return self.get_memview() - */ - -/* 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) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 1); - - /* "View.MemoryView":221 - * @property - * def memview(self): - * return self.get_memview() # <<<<<<<<<<<<<< - * - * @cname('get_memview') - */ - __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(1, 221, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "View.MemoryView":219 - * PyObject_Free(self._shape) - * - * @property # <<<<<<<<<<<<<< - * def memview(self): - * return self.get_memview() - */ - - /* 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":224 - * - * @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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_memview", 1); - - /* "View.MemoryView":225 - * @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":226 - * 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(1, 226, __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(1, 226, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 226, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF((PyObject *)__pyx_v_self); - __Pyx_GIVEREF((PyObject *)__pyx_v_self); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self))) __PYX_ERR(1, 226, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 226, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2)) __PYX_ERR(1, 226, __pyx_L1_error); - __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(1, 226, __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":224 - * - * @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":228 - * 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) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - Py_ssize_t __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __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; - - /* "View.MemoryView":229 - * - * def __len__(self): - * return self._shape[0] # <<<<<<<<<<<<<< - * - * def __getattr__(self, attr): - */ - __pyx_r = (__pyx_v_self->_shape[0]); - goto __pyx_L0; - - /* "View.MemoryView":228 - * return memoryview(self, flags, self.dtype_is_object) - * - * def __len__(self): # <<<<<<<<<<<<<< - * return self._shape[0] - * - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":231 - * return self._shape[0] - * - * def __getattr__(self, attr): # <<<<<<<<<<<<<< - * return getattr(self.memview, attr) - * - */ - -/* 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) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__getattr__", 1); - - /* "View.MemoryView":232 - * - * def __getattr__(self, attr): - * return getattr(self.memview, attr) # <<<<<<<<<<<<<< - * - * def __getitem__(self, item): - */ - __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(1, 232, __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(1, 232, __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":231 - * return self._shape[0] - * - * def __getattr__(self, attr): # <<<<<<<<<<<<<< - * return getattr(self.memview, attr) - * - */ - - /* 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":234 - * return getattr(self.memview, attr) - * - * def __getitem__(self, item): # <<<<<<<<<<<<<< - * return self.memview[item] - * - */ - -/* 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) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__getitem__", 1); - - /* "View.MemoryView":235 - * - * def __getitem__(self, item): - * return self.memview[item] # <<<<<<<<<<<<<< - * - * def __setitem__(self, item, value): - */ - __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(1, 235, __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(1, 235, __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":234 - * return getattr(self.memview, attr) - * - * def __getitem__(self, item): # <<<<<<<<<<<<<< - * return self.memview[item] - * - */ - - /* 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":237 - * return self.memview[item] - * - * def __setitem__(self, item, value): # <<<<<<<<<<<<<< - * self.memview[item] = value - * - */ - -/* 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) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __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; -} - -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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setitem__", 1); - - /* "View.MemoryView":238 - * - * def __setitem__(self, item, value): - * self.memview[item] = value # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 238, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_v_item, __pyx_v_value) < 0))) __PYX_ERR(1, 238, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "View.MemoryView":237 - * return self.memview[item] - * - * def __setitem__(self, item, value): # <<<<<<<<<<<<<< - * self.memview[item] = value - * - */ - - /* 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; -} - -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" - * def __setstate_cython__(self, __pyx_state): - */ - -/* Python wrapper */ -static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; - __pyx_r = __pyx_pf___pyx_array___reduce_cython__(((struct __pyx_array_obj *)__pyx_v_self)); - - /* 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) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__reduce_cython__", 1); - - /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); - __PYX_ERR(1, 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): - */ - - /* function exit code */ - __pyx_L1_error:; - __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; -} - -/* "(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, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v___pyx_state = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf___pyx_array_2__setstate_cython__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v___pyx_state); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __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 - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setstate_cython__", 1); - - /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); - __PYX_ERR(1, 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_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":248 - * - * @cname("__pyx_array_allocate_buffer") - * cdef int _allocate_buffer(array self) except -1: # <<<<<<<<<<<<<< - * - * - */ - -static int __pyx_array_allocate_buffer(struct __pyx_array_obj *__pyx_v_self) { - Py_ssize_t __pyx_v_i; - PyObject **__pyx_v_p; - int __pyx_r; - int __pyx_t_1; - Py_ssize_t __pyx_t_2; - Py_ssize_t __pyx_t_3; - Py_ssize_t __pyx_t_4; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - - /* "View.MemoryView":254 - * cdef PyObject **p - * - * self.free_data = True # <<<<<<<<<<<<<< - * self.data = malloc(self.len) - * if not self.data: - */ - __pyx_v_self->free_data = 1; - - /* "View.MemoryView":255 - * - * self.free_data = True - * 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":256 - * self.free_data = True - * self.data = malloc(self.len) - * if not self.data: # <<<<<<<<<<<<<< - * raise MemoryError, "unable to allocate array data." - * - */ - __pyx_t_1 = (!(__pyx_v_self->data != 0)); - if (unlikely(__pyx_t_1)) { - - /* "View.MemoryView":257 - * self.data = malloc(self.len) - * if not self.data: - * raise MemoryError, "unable to allocate array data." # <<<<<<<<<<<<<< - * - * if self.dtype_is_object: - */ - __Pyx_Raise(__pyx_builtin_MemoryError, __pyx_kp_s_unable_to_allocate_array_data, 0, 0); - __PYX_ERR(1, 257, __pyx_L1_error) - - /* "View.MemoryView":256 - * self.free_data = True - * self.data = malloc(self.len) - * if not self.data: # <<<<<<<<<<<<<< - * raise MemoryError, "unable to allocate array data." - * - */ - } - - /* "View.MemoryView":259 - * raise MemoryError, "unable to allocate array data." - * - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * p = self.data - * for i in range(self.len // self.itemsize): - */ - if (__pyx_v_self->dtype_is_object) { - - /* "View.MemoryView":260 - * - * if self.dtype_is_object: - * p = self.data # <<<<<<<<<<<<<< - * for i in range(self.len // self.itemsize): - * p[i] = Py_None - */ - __pyx_v_p = ((PyObject **)__pyx_v_self->data); - - /* "View.MemoryView":261 - * if self.dtype_is_object: - * p = self.data - * for i in range(self.len // self.itemsize): # <<<<<<<<<<<<<< - * p[i] = Py_None - * Py_INCREF(Py_None) - */ - if (unlikely(__pyx_v_self->itemsize == 0)) { - PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); - __PYX_ERR(1, 261, __pyx_L1_error) - } - else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_self->itemsize == (Py_ssize_t)-1) && unlikely(__Pyx_UNARY_NEG_WOULD_OVERFLOW(__pyx_v_self->len))) { - PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); - __PYX_ERR(1, 261, __pyx_L1_error) - } - __pyx_t_2 = __Pyx_div_Py_ssize_t(__pyx_v_self->len, __pyx_v_self->itemsize); - __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":262 - * p = self.data - * for i in range(self.len // self.itemsize): - * p[i] = Py_None # <<<<<<<<<<<<<< - * Py_INCREF(Py_None) - * return 0 - */ - (__pyx_v_p[__pyx_v_i]) = Py_None; - - /* "View.MemoryView":263 - * for i in range(self.len // self.itemsize): - * p[i] = Py_None - * Py_INCREF(Py_None) # <<<<<<<<<<<<<< - * return 0 - * - */ - Py_INCREF(Py_None); - } - - /* "View.MemoryView":259 - * raise MemoryError, "unable to allocate array data." - * - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * p = self.data - * for i in range(self.len // self.itemsize): - */ - } - - /* "View.MemoryView":264 - * p[i] = Py_None - * Py_INCREF(Py_None) - * return 0 # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = 0; - goto __pyx_L0; - - /* "View.MemoryView":248 - * - * @cname("__pyx_array_allocate_buffer") - * cdef int _allocate_buffer(array self) except -1: # <<<<<<<<<<<<<< - * - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("View.MemoryView._allocate_buffer", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":268 - * - * @cname("__pyx_array_new") - * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, char *c_mode, char *buf): # <<<<<<<<<<<<<< - * cdef array result - * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. - */ - -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_c_mode, char *__pyx_v_buf) { - struct __pyx_array_obj *__pyx_v_result = 0; - PyObject *__pyx_v_mode = 0; - struct __pyx_array_obj *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - 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("array_cwrapper", 1); - - /* "View.MemoryView":270 - * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, char *c_mode, char *buf): - * cdef array result - * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. # <<<<<<<<<<<<<< - * - * if buf is NULL: - */ - __pyx_t_2 = ((__pyx_v_c_mode[0]) == 'f'); - if (__pyx_t_2) { - __Pyx_INCREF(__pyx_n_s_fortran); - __pyx_t_1 = __pyx_n_s_fortran; - } else { - __Pyx_INCREF(__pyx_n_s_c); - __pyx_t_1 = __pyx_n_s_c; - } - __pyx_v_mode = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - - /* "View.MemoryView":272 - * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. - * - * if buf is NULL: # <<<<<<<<<<<<<< - * result = array.__new__(array, shape, itemsize, format, mode) - * else: - */ - __pyx_t_2 = (__pyx_v_buf == NULL); - if (__pyx_t_2) { - - /* "View.MemoryView":273 - * - * if buf is NULL: - * result = array.__new__(array, shape, itemsize, format, mode) # <<<<<<<<<<<<<< - * else: - * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False) - */ - __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 273, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 273, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 273, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_INCREF(__pyx_v_shape); - __Pyx_GIVEREF(__pyx_v_shape); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_shape)) __PYX_ERR(1, 273, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(1, 273, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3)) __PYX_ERR(1, 273, __pyx_L1_error); - __Pyx_INCREF(__pyx_v_mode); - __Pyx_GIVEREF(__pyx_v_mode); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_v_mode)) __PYX_ERR(1, 273, __pyx_L1_error); - __pyx_t_1 = 0; - __pyx_t_3 = 0; - __pyx_t_3 = ((PyObject *)__pyx_tp_new_array(((PyTypeObject *)__pyx_array_type), __pyx_t_4, NULL)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 273, __pyx_L1_error) - __Pyx_GOTREF((PyObject *)__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_3); - __pyx_t_3 = 0; - - /* "View.MemoryView":272 - * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. - * - * if buf is NULL: # <<<<<<<<<<<<<< - * result = array.__new__(array, shape, itemsize, format, mode) - * else: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":275 - * result = array.__new__(array, shape, itemsize, format, mode) - * else: - * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False) # <<<<<<<<<<<<<< - * result.data = buf - * - */ - /*else*/ { - __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 275, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 275, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 275, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_shape); - __Pyx_GIVEREF(__pyx_v_shape); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_shape)) __PYX_ERR(1, 275, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3)) __PYX_ERR(1, 275, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_t_4)) __PYX_ERR(1, 275, __pyx_L1_error); - __Pyx_INCREF(__pyx_v_mode); - __Pyx_GIVEREF(__pyx_v_mode); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_v_mode)) __PYX_ERR(1, 275, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 275, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_allocate_buffer, Py_False) < 0) __PYX_ERR(1, 275, __pyx_L1_error) - __pyx_t_3 = ((PyObject *)__pyx_tp_new_array(((PyTypeObject *)__pyx_array_type), __pyx_t_1, __pyx_t_4)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 275, __pyx_L1_error) - __Pyx_GOTREF((PyObject *)__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_3); - __pyx_t_3 = 0; - - /* "View.MemoryView":276 - * else: - * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False) - * result.data = buf # <<<<<<<<<<<<<< - * - * return result - */ - __pyx_v_result->data = __pyx_v_buf; - } - __pyx_L3:; - - /* "View.MemoryView":278 - * result.data = buf - * - * return result # <<<<<<<<<<<<<< - * - * - */ - __Pyx_XDECREF((PyObject *)__pyx_r); - __Pyx_INCREF((PyObject *)__pyx_v_result); - __pyx_r = __pyx_v_result; - goto __pyx_L0; - - /* "View.MemoryView":268 - * - * @cname("__pyx_array_new") - * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, char *c_mode, char *buf): # <<<<<<<<<<<<<< - * cdef array result - * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("View.MemoryView.array_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_result); - __Pyx_XDECREF(__pyx_v_mode); - __Pyx_XGIVEREF((PyObject *)__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":304 - * cdef class Enum(object): - * cdef object name - * def __init__(self, name): # <<<<<<<<<<<<<< - * self.name = name - * def __repr__(self): - */ - -/* 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; - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; - #endif - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { - (void)__Pyx_Arg_NewRef_VARARGS(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 304, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(1, 304, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - } - __pyx_v_name = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 304, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); - } - } - __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 */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); - } - } - __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) { - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__", 1); - - /* "View.MemoryView":305 - * cdef object name - * def __init__(self, name): - * self.name = name # <<<<<<<<<<<<<< - * def __repr__(self): - * return self.name - */ - __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":304 - * 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":306 - * def __init__(self, name): - * self.name = name - * def __repr__(self): # <<<<<<<<<<<<<< - * return self.name - * - */ - -/* Python wrapper */ -static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __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_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__", 1); - - /* "View.MemoryView":307 - * self.name = name - * def __repr__(self): - * return self.name # <<<<<<<<<<<<<< - * - * cdef generic = Enum("") - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->name); - __pyx_r = __pyx_v_self->name; - goto __pyx_L0; - - /* "View.MemoryView":306 - * def __init__(self, name): - * self.name = name - * def __repr__(self): # <<<<<<<<<<<<<< - * return self.name - * - */ - - /* function exit code */ - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ - -/* Python wrapper */ -static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; - __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_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; - 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("__reduce_cython__", 1); - - /* "(tree fragment)":5 - * cdef object _dict - * cdef bint use_setstate - * state = (self.name,) # <<<<<<<<<<<<<< - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: - */ - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_self->name); - __Pyx_GIVEREF(__pyx_v_self->name); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->name)) __PYX_ERR(1, 5, __pyx_L1_error); - __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,) - */ - __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v__dict = __pyx_t_1; - __pyx_t_1 = 0; - - /* "(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); - if (__pyx_t_2) { - - /* "(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(1, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v__dict); - __Pyx_GIVEREF(__pyx_v__dict); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(1, 8, __pyx_L1_error); - __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); - __pyx_t_3 = 0; - - /* "(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; - - /* "(tree fragment)":7 - * state = (self.name,) - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True - */ - 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), 0x82a3537, None), state - */ - /*else*/ { - __pyx_t_2 = (__pyx_v_self->name != Py_None); - __pyx_v_use_setstate = __pyx_t_2; - } - __pyx_L3:; - - /* "(tree fragment)":12 - * else: - * use_setstate = self.name is not None - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state - * else: - */ - if (__pyx_v_use_setstate) { - - /* "(tree fragment)":13 - * use_setstate = self.name is not None - * if use_setstate: - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state # <<<<<<<<<<<<<< - * else: - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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)))); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(1, 13, __pyx_L1_error); - __Pyx_INCREF(__pyx_int_136983863); - __Pyx_GIVEREF(__pyx_int_136983863); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_136983863)) __PYX_ERR(1, 13, __pyx_L1_error); - __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(Py_None); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(1, 13, __pyx_L1_error); - __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(1, 13, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_1 = 0; - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; - goto __pyx_L0; - - /* "(tree fragment)":12 - * else: - * use_setstate = self.name is not None - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state - * else: - */ - } - - /* "(tree fragment)":15 - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state - * else: - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_Enum__set_state(self, __pyx_state) - */ - /*else*/ { - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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)))); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(1, 15, __pyx_L1_error); - __Pyx_INCREF(__pyx_int_136983863); - __Pyx_GIVEREF(__pyx_int_136983863); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_136983863)) __PYX_ERR(1, 15, __pyx_L1_error); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(1, 15, __pyx_L1_error); - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error); - __pyx_t_4 = 0; - __pyx_t_1 = 0; - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L0; - } - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __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)":16 - * else: - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_Enum__set_state(self, __pyx_state) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - PyObject *__pyx_v___pyx_state = 0; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 16, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 16, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v___pyx_state = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v___pyx_state); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __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; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setstate_cython__", 1); - - /* "(tree fragment)":17 - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_Enum__set_state(self, __pyx_state) # <<<<<<<<<<<<<< - */ - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 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(1, 17, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "(tree fragment)":16 - * else: - * return __pyx_unpickle_Enum, (type(self), 0x82a3537, 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.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":349 - * 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_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; - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[3] = {0,0,0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; - #endif - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_obj,&__pyx_n_s_flags,&__pyx_n_s_dtype_is_object,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_obj)) != 0)) { - (void)__Pyx_Arg_NewRef_VARARGS(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_flags)) != 0)) { - (void)__Pyx_Arg_NewRef_VARARGS(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, 1); __PYX_ERR(1, 349, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dtype_is_object); - if (value) { values[2] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 349, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__cinit__") < 0)) __PYX_ERR(1, 349, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); - values[0] = __Pyx_Arg_VARARGS(__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(1, 349, __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(1, 349, __pyx_L3_error) - } else { - __pyx_v_dtype_is_object = ((int)0); - } - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, __pyx_nargs); __PYX_ERR(1, 349, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); - } - } - __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); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); - } - } - __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; - Py_intptr_t __pyx_t_4; - size_t __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__cinit__", 1); - - /* "View.MemoryView":350 - * - * 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_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":351 - * 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; - - /* "View.MemoryView":352 - * 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)); - if (!__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_2 = (__pyx_v_obj != Py_None); - __pyx_t_1 = __pyx_t_2; - __pyx_L4_bool_binop_done:; - if (__pyx_t_1) { - - /* "View.MemoryView":353 - * 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_3 = __Pyx_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 353, __pyx_L1_error) - - /* "View.MemoryView":354 - * 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); - if (__pyx_t_1) { - - /* "View.MemoryView":355 - * __Pyx_GetBuffer(obj, &self.view, flags) - * if self.view.obj == NULL: - * (<__pyx_buffer *> &self.view).obj = Py_None # <<<<<<<<<<<<<< - * Py_INCREF(Py_None) - * - */ - ((Py_buffer *)(&__pyx_v_self->view))->obj = Py_None; - - /* "View.MemoryView":356 - * if self.view.obj == NULL: - * (<__pyx_buffer *> &self.view).obj = Py_None - * Py_INCREF(Py_None) # <<<<<<<<<<<<<< - * - * if not __PYX_CYTHON_ATOMICS_ENABLED(): - */ - Py_INCREF(Py_None); - - /* "View.MemoryView":354 - * 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":352 - * 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":358 - * Py_INCREF(Py_None) - * - * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< - * global __pyx_memoryview_thread_locks_used - * if __pyx_memoryview_thread_locks_used < 8: - */ - __pyx_t_1 = (!__PYX_CYTHON_ATOMICS_ENABLED()); - if (__pyx_t_1) { - - /* "View.MemoryView":360 - * if not __PYX_CYTHON_ATOMICS_ENABLED(): - * global __pyx_memoryview_thread_locks_used - * if __pyx_memoryview_thread_locks_used < 8: # <<<<<<<<<<<<<< - * 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); - if (__pyx_t_1) { - - /* "View.MemoryView":361 - * global __pyx_memoryview_thread_locks_used - * if __pyx_memoryview_thread_locks_used < 8: - * 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":362 - * if __pyx_memoryview_thread_locks_used < 8: - * 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":360 - * if not __PYX_CYTHON_ATOMICS_ENABLED(): - * global __pyx_memoryview_thread_locks_used - * if __pyx_memoryview_thread_locks_used < 8: # <<<<<<<<<<<<<< - * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] - * __pyx_memoryview_thread_locks_used += 1 - */ - } - - /* "View.MemoryView":363 - * 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); - if (__pyx_t_1) { - - /* "View.MemoryView":364 - * __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":365 - * 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); - if (unlikely(__pyx_t_1)) { - - /* "View.MemoryView":366 - * self.lock = PyThread_allocate_lock() - * if self.lock is NULL: - * raise MemoryError # <<<<<<<<<<<<<< - * - * if flags & PyBUF_FORMAT: - */ - PyErr_NoMemory(); __PYX_ERR(1, 366, __pyx_L1_error) - - /* "View.MemoryView":365 - * if self.lock is NULL: - * self.lock = PyThread_allocate_lock() - * if self.lock is NULL: # <<<<<<<<<<<<<< - * raise MemoryError - * - */ - } - - /* "View.MemoryView":363 - * 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":358 - * Py_INCREF(Py_None) - * - * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< - * global __pyx_memoryview_thread_locks_used - * if __pyx_memoryview_thread_locks_used < 8: - */ - } - - /* "View.MemoryView":368 - * 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":369 - * - * 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'); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L12_bool_binop_done; - } - __pyx_t_2 = ((__pyx_v_self->view.format[1]) == '\x00'); - __pyx_t_1 = __pyx_t_2; - __pyx_L12_bool_binop_done:; - __pyx_v_self->dtype_is_object = __pyx_t_1; - - /* "View.MemoryView":368 - * 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_L11; - } - - /* "View.MemoryView":371 - * 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 # <<<<<<<<<<<<<< - * - * assert (&self.acquisition_count) % sizeof(__pyx_atomic_int_type) == 0 - */ - /*else*/ { - __pyx_v_self->dtype_is_object = __pyx_v_dtype_is_object; - } - __pyx_L11:; - - /* "View.MemoryView":373 - * self.dtype_is_object = dtype_is_object - * - * assert (&self.acquisition_count) % sizeof(__pyx_atomic_int_type) == 0 # <<<<<<<<<<<<<< - * self.typeinfo = NULL - * - */ - #ifndef CYTHON_WITHOUT_ASSERTIONS - if (unlikely(__pyx_assertions_enabled())) { - __pyx_t_4 = ((Py_intptr_t)((void *)(&__pyx_v_self->acquisition_count))); - __pyx_t_5 = (sizeof(__pyx_atomic_int_type)); - if (unlikely(__pyx_t_5 == 0)) { - PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); - __PYX_ERR(1, 373, __pyx_L1_error) - } - __pyx_t_1 = ((__pyx_t_4 % __pyx_t_5) == 0); - if (unlikely(!__pyx_t_1)) { - __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); - __PYX_ERR(1, 373, __pyx_L1_error) - } - } - #else - if ((1)); else __PYX_ERR(1, 373, __pyx_L1_error) - #endif - - /* "View.MemoryView":374 - * - * assert (&self.acquisition_count) % sizeof(__pyx_atomic_int_type) == 0 - * self.typeinfo = NULL # <<<<<<<<<<<<<< - * - * def __dealloc__(memoryview self): - */ - __pyx_v_self->typeinfo = NULL; - - /* "View.MemoryView":349 - * 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; -} - -/* "View.MemoryView":376 - * self.typeinfo = NULL - * - * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< - * if self.obj is not None: - * __Pyx_ReleaseBuffer(&self.view) - */ - -/* Python wrapper */ -static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self); /*proto*/ -static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self) { - int __pyx_v_i; - int __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - int __pyx_t_4; - PyThread_type_lock __pyx_t_5; - PyThread_type_lock __pyx_t_6; - - /* "View.MemoryView":377 - * - * 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); - if (__pyx_t_1) { - - /* "View.MemoryView":378 - * def __dealloc__(memoryview self): - * if self.obj is not None: - * __Pyx_ReleaseBuffer(&self.view) # <<<<<<<<<<<<<< - * elif (<__pyx_buffer *> &self.view).obj == Py_None: - * - */ - __Pyx_ReleaseBuffer((&__pyx_v_self->view)); - - /* "View.MemoryView":377 - * - * 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":379 - * 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_1 = (((Py_buffer *)(&__pyx_v_self->view))->obj == Py_None); - if (__pyx_t_1) { - - /* "View.MemoryView":381 - * 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":382 - * - * (<__pyx_buffer *> &self.view).obj = NULL - * Py_DECREF(Py_None) # <<<<<<<<<<<<<< - * - * cdef int i - */ - Py_DECREF(Py_None); - - /* "View.MemoryView":379 - * 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":386 - * 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_1 = (__pyx_v_self->lock != NULL); - if (__pyx_t_1) { - - /* "View.MemoryView":387 - * 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_2 = __pyx_memoryview_thread_locks_used; - __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":388 - * 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_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock); - if (__pyx_t_1) { - - /* "View.MemoryView":389 - * 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":390 - * 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_1 = (__pyx_v_i != __pyx_memoryview_thread_locks_used); - if (__pyx_t_1) { - - /* "View.MemoryView":392 - * 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_5 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); - __pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_v_i]); - - /* "View.MemoryView":391 - * __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_5; - (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_6; - - /* "View.MemoryView":390 - * 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":393 - * __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; - - /* "View.MemoryView":388 - * 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: - */ - } - } - /*else*/ { - - /* "View.MemoryView":395 - * 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":386 - * 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":376 - * self.typeinfo = NULL - * - * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< - * if self.obj is not None: - * __Pyx_ReleaseBuffer(&self.view) - */ - - /* function exit code */ -} - -/* "View.MemoryView":397 - * 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 - */ - -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; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_item_pointer", 1); - - /* "View.MemoryView":399 - * 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":401 - * 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(1, 401, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 401, __pyx_L1_error) - } - for (;;) { - if (likely(!__pyx_t_4)) { - if (likely(PyList_CheckExact(__pyx_t_2))) { - { - Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 401, __pyx_L1_error) - #endif - if (__pyx_t_3 >= __pyx_temp) 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(1, 401, __pyx_L1_error) - #else - __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 401, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - #endif - } else { - { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 401, __pyx_L1_error) - #endif - if (__pyx_t_3 >= __pyx_temp) 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(1, 401, __pyx_L1_error) - #else - __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 401, __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(1, 401, __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":402 - * - * 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(1, 402, __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(1, 402, __pyx_L1_error) - __pyx_v_itemp = __pyx_t_7; - - /* "View.MemoryView":401 - * 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":404 - * itemp = pybuffer_index(&self.view, itemp, idx, dim) - * - * return itemp # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = __pyx_v_itemp; - goto __pyx_L0; - - /* "View.MemoryView":397 - * 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":407 - * - * - * 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) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __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 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; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - char *__pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__getitem__", 1); - - /* "View.MemoryView":408 - * - * def __getitem__(memoryview self, object index): - * if index is Ellipsis: # <<<<<<<<<<<<<< - * return self - * - */ - __pyx_t_1 = (__pyx_v_index == __pyx_builtin_Ellipsis); - if (__pyx_t_1) { - - /* "View.MemoryView":409 - * def __getitem__(memoryview self, object index): - * if index is Ellipsis: - * return self # <<<<<<<<<<<<<< - * - * have_slices, indices = _unellipsify(index, self.view.ndim) - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF((PyObject *)__pyx_v_self); - __pyx_r = ((PyObject *)__pyx_v_self); - goto __pyx_L0; - - /* "View.MemoryView":408 - * - * def __getitem__(memoryview self, object index): - * if index is Ellipsis: # <<<<<<<<<<<<<< - * return self - * - */ - } - - /* "View.MemoryView":411 - * return self - * - * have_slices, indices = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< - * - * cdef char *itemp - */ - __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 411, __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(1, 411, __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, 411, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 411, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } else { - __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 411, __pyx_L1_error) - } - __pyx_v_have_slices = __pyx_t_3; - __pyx_t_3 = 0; - __pyx_v_indices = __pyx_t_4; - __pyx_t_4 = 0; - - /* "View.MemoryView":414 - * - * cdef char *itemp - * if have_slices: # <<<<<<<<<<<<<< - * return memview_slice(self, indices) - * else: - */ - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 414, __pyx_L1_error) - if (__pyx_t_1) { - - /* "View.MemoryView":415 - * cdef char *itemp - * if have_slices: - * return memview_slice(self, indices) # <<<<<<<<<<<<<< - * else: - * itemp = self.get_item_pointer(indices) - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 415, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":414 - * - * cdef char *itemp - * if have_slices: # <<<<<<<<<<<<<< - * return memview_slice(self, indices) - * else: - */ - } - - /* "View.MemoryView":417 - * return memview_slice(self, indices) - * else: - * itemp = self.get_item_pointer(indices) # <<<<<<<<<<<<<< - * return self.convert_item_to_object(itemp) - * - */ - /*else*/ { - __pyx_t_5 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_5 == ((char *)NULL))) __PYX_ERR(1, 417, __pyx_L1_error) - __pyx_v_itemp = __pyx_t_5; - - /* "View.MemoryView":418 - * 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_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 418, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - } - - /* "View.MemoryView":407 - * - * - * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< - * if index is Ellipsis: - * return self - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __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":420 - * 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) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __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 - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setitem__", 0); - __Pyx_INCREF(__pyx_v_index); - - /* "View.MemoryView":421 - * - * def __setitem__(memoryview self, object index, object value): - * if self.view.readonly: # <<<<<<<<<<<<<< - * raise TypeError, "Cannot assign to read-only memoryview" - * - */ - if (unlikely(__pyx_v_self->view.readonly)) { - - /* "View.MemoryView":422 - * 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_Cannot_assign_to_read_only_memor, 0, 0); - __PYX_ERR(1, 422, __pyx_L1_error) - - /* "View.MemoryView":421 - * - * def __setitem__(memoryview self, object index, object value): - * if self.view.readonly: # <<<<<<<<<<<<<< - * raise TypeError, "Cannot assign to read-only memoryview" - * - */ - } - - /* "View.MemoryView":424 - * raise TypeError, "Cannot assign to read-only memoryview" - * - * have_slices, index = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< - * - * if have_slices: - */ - __pyx_t_1 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 424, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (likely(__pyx_t_1 != Py_None)) { - PyObject* sequence = __pyx_t_1; - 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, 424, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - #else - __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 424, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 424, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } else { - __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 424, __pyx_L1_error) - } - __pyx_v_have_slices = __pyx_t_2; - __pyx_t_2 = 0; - __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_3); - __pyx_t_3 = 0; - - /* "View.MemoryView":426 - * have_slices, index = _unellipsify(index, self.view.ndim) - * - * if have_slices: # <<<<<<<<<<<<<< - * obj = self.is_slice(value) - * if obj: - */ - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(1, 426, __pyx_L1_error) - if (__pyx_t_4) { - - /* "View.MemoryView":427 - * - * if have_slices: - * obj = self.is_slice(value) # <<<<<<<<<<<<<< - * if obj: - * self.setitem_slice_assignment(self[index], obj) - */ - __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->is_slice(__pyx_v_self, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 427, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_obj = __pyx_t_1; - __pyx_t_1 = 0; - - /* "View.MemoryView":428 - * if have_slices: - * obj = self.is_slice(value) - * if obj: # <<<<<<<<<<<<<< - * self.setitem_slice_assignment(self[index], obj) - * else: - */ - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_obj); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(1, 428, __pyx_L1_error) - if (__pyx_t_4) { - - /* "View.MemoryView":429 - * 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_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 429, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assignment(__pyx_v_self, __pyx_t_1, __pyx_v_obj); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 429, __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; - - /* "View.MemoryView":428 - * if have_slices: - * obj = self.is_slice(value) - * if obj: # <<<<<<<<<<<<<< - * self.setitem_slice_assignment(self[index], obj) - * else: - */ - goto __pyx_L5; - } - - /* "View.MemoryView":431 - * self.setitem_slice_assignment(self[index], obj) - * else: - * self.setitem_slice_assign_scalar(self[index], value) # <<<<<<<<<<<<<< - * else: - * self.setitem_indexed(index, value) - */ - /*else*/ { - __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 431, __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(1, 431, __pyx_L1_error) - __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_3), __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 431, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } - __pyx_L5:; - - /* "View.MemoryView":426 - * have_slices, index = _unellipsify(index, self.view.ndim) - * - * if have_slices: # <<<<<<<<<<<<<< - * obj = self.is_slice(value) - * if obj: - */ - goto __pyx_L4; - } - - /* "View.MemoryView":433 - * self.setitem_slice_assign_scalar(self[index], value) - * else: - * self.setitem_indexed(index, value) # <<<<<<<<<<<<<< - * - * cdef is_slice(self, obj): - */ - /*else*/ { - __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 433, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } - __pyx_L4:; - - /* "View.MemoryView":420 - * 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" - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.memoryview.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_have_slices); - __Pyx_XDECREF(__pyx_v_obj); - __Pyx_XDECREF(__pyx_v_index); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":435 - * self.setitem_indexed(index, value) - * - * cdef is_slice(self, obj): # <<<<<<<<<<<<<< - * if not isinstance(obj, memoryview): - * try: - */ - -static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - 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":436 - * - * cdef is_slice(self, obj): - * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< - * try: - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - */ - __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_obj, __pyx_memoryview_type); - __pyx_t_2 = (!__pyx_t_1); - if (__pyx_t_2) { - - /* "View.MemoryView":437 - * cdef is_slice(self, obj): - * if not isinstance(obj, memoryview): - * try: # <<<<<<<<<<<<<< - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - * self.dtype_is_object) - */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); - __Pyx_XGOTREF(__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_4); - __Pyx_XGOTREF(__pyx_t_5); - /*try:*/ { - - /* "View.MemoryView":438 - * 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(1, 438, __pyx_L4_error) - __Pyx_GOTREF(__pyx_t_6); - - /* "View.MemoryView":439 - * 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(1, 439, __pyx_L4_error) - __Pyx_GOTREF(__pyx_t_7); - - /* "View.MemoryView":438 - * 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(1, 438, __pyx_L4_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_INCREF(__pyx_v_obj); - __Pyx_GIVEREF(__pyx_v_obj); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_obj)) __PYX_ERR(1, 438, __pyx_L4_error); - __Pyx_GIVEREF(__pyx_t_6); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6)) __PYX_ERR(1, 438, __pyx_L4_error); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7)) __PYX_ERR(1, 438, __pyx_L4_error); - __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(1, 438, __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":437 - * cdef is_slice(self, obj): - * if not isinstance(obj, memoryview): - * try: # <<<<<<<<<<<<<< - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - * self.dtype_is_object) - */ - } - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - goto __pyx_L9_try_end; - __pyx_L4_error:; - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - - /* "View.MemoryView":440 - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - * self.dtype_is_object) - * except TypeError: # <<<<<<<<<<<<<< - * return None - * - */ - __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(1, 440, __pyx_L6_except_error) - __Pyx_XGOTREF(__pyx_t_7); - __Pyx_XGOTREF(__pyx_t_8); - __Pyx_XGOTREF(__pyx_t_6); - - /* "View.MemoryView":441 - * self.dtype_is_object) - * except TypeError: - * return None # <<<<<<<<<<<<<< - * - * return obj - */ - __Pyx_XDECREF(__pyx_r); - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - goto __pyx_L7_except_return; - } - goto __pyx_L6_except_error; - - /* "View.MemoryView":437 - * cdef is_slice(self, obj): - * if not isinstance(obj, memoryview): - * try: # <<<<<<<<<<<<<< - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - * self.dtype_is_object) - */ - __pyx_L6_except_error:; - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_XGIVEREF(__pyx_t_4); - __Pyx_XGIVEREF(__pyx_t_5); - __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); - goto __pyx_L1_error; - __pyx_L7_except_return:; - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_XGIVEREF(__pyx_t_4); - __Pyx_XGIVEREF(__pyx_t_5); - __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); - goto __pyx_L0; - __pyx_L9_try_end:; - } - - /* "View.MemoryView":436 - * - * cdef is_slice(self, obj): - * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< - * try: - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - */ - } - - /* "View.MemoryView":443 - * return None - * - * return obj # <<<<<<<<<<<<<< - * - * cdef setitem_slice_assignment(self, dst, src): - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_obj); - __pyx_r = __pyx_v_obj; - goto __pyx_L0; - - /* "View.MemoryView":435 - * self.setitem_indexed(index, value) - * - * cdef is_slice(self, obj): # <<<<<<<<<<<<<< - * if not isinstance(obj, memoryview): - * try: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_obj); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":445 - * return obj - * - * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice dst_slice - * cdef __Pyx_memviewslice src_slice - */ - -static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src) { - __Pyx_memviewslice __pyx_v_dst_slice; - __Pyx_memviewslice __pyx_v_src_slice; - __Pyx_memviewslice __pyx_v_msrc; - __Pyx_memviewslice __pyx_v_mdst; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_memviewslice *__pyx_t_1; - PyObject *__pyx_t_2 = NULL; - int __pyx_t_3; - int __pyx_t_4; - int __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("setitem_slice_assignment", 1); - - /* "View.MemoryView":448 - * cdef __Pyx_memviewslice dst_slice - * cdef __Pyx_memviewslice src_slice - * cdef __Pyx_memviewslice msrc = get_slice_from_memview(src, &src_slice)[0] # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0] - * - */ - if (!(likely(((__pyx_v_src) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_src, __pyx_memoryview_type))))) __PYX_ERR(1, 448, __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(1, 448, __pyx_L1_error) - __pyx_v_msrc = (__pyx_t_1[0]); - - /* "View.MemoryView":449 - * cdef __Pyx_memviewslice src_slice - * cdef __Pyx_memviewslice msrc = get_slice_from_memview(src, &src_slice)[0] - * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0] # <<<<<<<<<<<<<< - * - * memoryview_copy_contents(msrc, mdst, 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(1, 449, __pyx_L1_error) - __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 449, __pyx_L1_error) - __pyx_v_mdst = (__pyx_t_1[0]); - - /* "View.MemoryView":451 - * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0] - * - * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) # <<<<<<<<<<<<<< - * - * cdef setitem_slice_assign_scalar(self, memoryview dst, value): - */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_n_s_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 451, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 451, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_dst, __pyx_n_s_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 451, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 451, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_5 = __pyx_memoryview_copy_contents(__pyx_v_msrc, __pyx_v_mdst, __pyx_t_3, __pyx_t_4, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 451, __pyx_L1_error) - - /* "View.MemoryView":445 - * return obj - * - * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice dst_slice - * cdef __Pyx_memviewslice src_slice - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assignment", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":453 - * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) - * - * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< - * cdef int array[128] - * cdef void *tmp = NULL - */ - -static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value) { - int __pyx_v_array[0x80]; - void *__pyx_v_tmp; - void *__pyx_v_item; - __Pyx_memviewslice *__pyx_v_dst_slice; - __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_4; - int __pyx_t_5; - char const *__pyx_t_6; - 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", 1); - - /* "View.MemoryView":455 - * cdef setitem_slice_assign_scalar(self, memoryview dst, value): - * cdef int array[128] - * cdef void *tmp = NULL # <<<<<<<<<<<<<< - * cdef void *item - * - */ - __pyx_v_tmp = NULL; - - /* "View.MemoryView":460 - * 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(1, 460, __pyx_L1_error) - __pyx_v_dst_slice = __pyx_t_1; - - /* "View.MemoryView":462 - * 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))); - if (__pyx_t_2) { - - /* "View.MemoryView":463 - * - * if self.view.itemsize > sizeof(array): - * tmp = PyMem_Malloc(self.view.itemsize) # <<<<<<<<<<<<<< - * if tmp == NULL: - * raise MemoryError - */ - __pyx_v_tmp = PyMem_Malloc(__pyx_v_self->view.itemsize); - - /* "View.MemoryView":464 - * 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); - if (unlikely(__pyx_t_2)) { - - /* "View.MemoryView":465 - * tmp = PyMem_Malloc(self.view.itemsize) - * if tmp == NULL: - * raise MemoryError # <<<<<<<<<<<<<< - * item = tmp - * else: - */ - PyErr_NoMemory(); __PYX_ERR(1, 465, __pyx_L1_error) - - /* "View.MemoryView":464 - * if self.view.itemsize > sizeof(array): - * tmp = PyMem_Malloc(self.view.itemsize) - * if tmp == NULL: # <<<<<<<<<<<<<< - * raise MemoryError - * item = tmp - */ - } - - /* "View.MemoryView":466 - * if tmp == NULL: - * raise MemoryError - * item = tmp # <<<<<<<<<<<<<< - * else: - * item = array - */ - __pyx_v_item = __pyx_v_tmp; - - /* "View.MemoryView":462 - * dst_slice = get_slice_from_memview(dst, &tmp_slice) - * - * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< - * tmp = PyMem_Malloc(self.view.itemsize) - * if tmp == NULL: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":468 - * item = tmp - * else: - * item = array # <<<<<<<<<<<<<< - * - * try: - */ - /*else*/ { - __pyx_v_item = ((void *)__pyx_v_array); - } - __pyx_L3:; - - /* "View.MemoryView":470 - * item = array - * - * try: # <<<<<<<<<<<<<< - * if self.dtype_is_object: - * ( item)[0] = value - */ - /*try:*/ { - - /* "View.MemoryView":471 - * - * try: - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * ( item)[0] = value - * else: - */ - if (__pyx_v_self->dtype_is_object) { - - /* "View.MemoryView":472 - * try: - * if self.dtype_is_object: - * ( item)[0] = value # <<<<<<<<<<<<<< - * else: - * self.assign_item_from_object( item, value) - */ - (((PyObject **)__pyx_v_item)[0]) = ((PyObject *)__pyx_v_value); - - /* "View.MemoryView":471 - * - * try: - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * ( item)[0] = value - * else: - */ - goto __pyx_L8; - } - - /* "View.MemoryView":474 - * ( item)[0] = value - * else: - * self.assign_item_from_object( item, value) # <<<<<<<<<<<<<< - * - * - */ - /*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(1, 474, __pyx_L6_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } - __pyx_L8:; - - /* "View.MemoryView":478 - * - * - * 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); - if (__pyx_t_2) { - - /* "View.MemoryView":479 - * - * 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_4 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 479, __pyx_L6_error) - - /* "View.MemoryView":478 - * - * - * 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, - */ - } - - /* "View.MemoryView":480 - * 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) - * finally: - */ - __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":483 - * item, self.dtype_is_object) - * finally: - * PyMem_Free(tmp) # <<<<<<<<<<<<<< - * - * cdef setitem_indexed(self, index, value): - */ - /*finally:*/ { - /*normal exit:*/{ - PyMem_Free(__pyx_v_tmp); - goto __pyx_L7; - } - __pyx_L6_error:; - /*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_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; - { - PyMem_Free(__pyx_v_tmp); - } - if (PY_MAJOR_VERSION >= 3) { - __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_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; - goto __pyx_L1_error; - } - __pyx_L7:; - } - - /* "View.MemoryView":453 - * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) - * - * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< - * cdef int array[128] - * cdef void *tmp = NULL - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assign_scalar", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":485 - * PyMem_Free(tmp) - * - * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< - * cdef char *itemp = self.get_item_pointer(index) - * self.assign_item_from_object(itemp, value) - */ - -static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { - char *__pyx_v_itemp; - PyObject *__pyx_r = NULL; - __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", 1); - - /* "View.MemoryView":486 - * - * 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(1, 486, __pyx_L1_error) - __pyx_v_itemp = __pyx_t_1; - - /* "View.MemoryView":487 - * 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(1, 487, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "View.MemoryView":485 - * PyMem_Free(tmp) - * - * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< - * cdef char *itemp = self.get_item_pointer(index) - * self.assign_item_from_object(itemp, value) - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_indexed", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":489 - * self.assign_item_from_object(itemp, value) - * - * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< - * """Only used if instantiated manually by the user, or if Cython doesn't - * know how to convert the type""" - */ - -static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp) { - PyObject *__pyx_v_struct = NULL; - PyObject *__pyx_v_bytesitem = 0; - PyObject *__pyx_v_result = NULL; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - int __pyx_t_8; - Py_ssize_t __pyx_t_9; - int __pyx_t_10; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("convert_item_to_object", 1); - - /* "View.MemoryView":492 - * """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_ImportDottedModule(__pyx_n_s_struct, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 492, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_struct = __pyx_t_1; - __pyx_t_1 = 0; - - /* "View.MemoryView":495 - * 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(1, 495, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_bytesitem = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - - /* "View.MemoryView":496 - * - * bytesitem = itemp[:self.view.itemsize] - * try: # <<<<<<<<<<<<<< - * result = struct.unpack(self.view.format, bytesitem) - * except struct.error: - */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); - __Pyx_XGOTREF(__pyx_t_2); - __Pyx_XGOTREF(__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_4); - /*try:*/ { - - /* "View.MemoryView":497 - * 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(1, 497, __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(1, 497, __pyx_L3_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = NULL; - __pyx_t_8 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - __pyx_t_8 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_8, 2+__pyx_t_8); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 497, __pyx_L3_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } - __pyx_v_result = __pyx_t_1; - __pyx_t_1 = 0; - - /* "View.MemoryView":496 - * - * bytesitem = itemp[:self.view.itemsize] - * try: # <<<<<<<<<<<<<< - * result = struct.unpack(self.view.format, bytesitem) - * except struct.error: - */ - } - - /* "View.MemoryView":501 - * raise ValueError, "Unable to convert item to object" - * else: - * if len(self.view.format) == 1: # <<<<<<<<<<<<<< - * return result[0] - * return result - */ - /*else:*/ { - __pyx_t_9 = __Pyx_ssize_strlen(__pyx_v_self->view.format); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(1, 501, __pyx_L5_except_error) - __pyx_t_10 = (__pyx_t_9 == 1); - if (__pyx_t_10) { - - /* "View.MemoryView":502 - * else: - * if len(self.view.format) == 1: - * return result[0] # <<<<<<<<<<<<<< - * return result - * - */ - __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(1, 502, __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":501 - * raise ValueError, "Unable to convert item to object" - * else: - * if len(self.view.format) == 1: # <<<<<<<<<<<<<< - * return result[0] - * return result - */ - } - - /* "View.MemoryView":503 - * if len(self.view.format) == 1: - * return result[0] - * return result # <<<<<<<<<<<<<< - * - * cdef assign_item_from_object(self, char *itemp, object value): - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_result); - __pyx_r = __pyx_v_result; - goto __pyx_L6_except_return; - } - __pyx_L3_error:; - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "View.MemoryView":498 - * try: - * result = struct.unpack(self.view.format, bytesitem) - * except struct.error: # <<<<<<<<<<<<<< - * raise ValueError, "Unable to convert item to object" - * else: - */ - __Pyx_ErrFetch(&__pyx_t_1, &__pyx_t_5, &__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_error); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 498, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_7); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_ErrRestore(__pyx_t_1, __pyx_t_5, __pyx_t_6); - __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_6 = 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_6, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(1, 498, __pyx_L5_except_error) - __Pyx_XGOTREF(__pyx_t_6); - __Pyx_XGOTREF(__pyx_t_5); - __Pyx_XGOTREF(__pyx_t_1); - - /* "View.MemoryView":499 - * 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_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Unable_to_convert_item_to_object, 0, 0); - __PYX_ERR(1, 499, __pyx_L5_except_error) - } - goto __pyx_L5_except_error; - - /* "View.MemoryView":496 - * - * bytesitem = itemp[:self.view.itemsize] - * try: # <<<<<<<<<<<<<< - * result = struct.unpack(self.view.format, bytesitem) - * except struct.error: - */ - __pyx_L5_except_error:; - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_XGIVEREF(__pyx_t_4); - __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); - goto __pyx_L1_error; - __pyx_L6_except_return:; - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_XGIVEREF(__pyx_t_4); - __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); - goto __pyx_L0; - } - - /* "View.MemoryView":489 - * self.assign_item_from_object(itemp, value) - * - * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< - * """Only used if instantiated manually by the user, or if Cython doesn't - * know how to convert the type""" - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_struct); - __Pyx_XDECREF(__pyx_v_bytesitem); - __Pyx_XDECREF(__pyx_v_result); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":505 - * return result - * - * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< - * """Only used if instantiated manually by the user, or if Cython doesn't - * know how to convert the type""" - */ - -static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) { - PyObject *__pyx_v_struct = NULL; - char __pyx_v_c; - PyObject *__pyx_v_bytesvalue = 0; - Py_ssize_t __pyx_v_i; - 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; - int __pyx_t_6; - Py_ssize_t __pyx_t_7; - PyObject *__pyx_t_8 = NULL; - char *__pyx_t_9; - char *__pyx_t_10; - char *__pyx_t_11; - char *__pyx_t_12; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("assign_item_from_object", 1); - - /* "View.MemoryView":508 - * """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_ImportDottedModule(__pyx_n_s_struct, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 508, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_struct = __pyx_t_1; - __pyx_t_1 = 0; - - /* "View.MemoryView":513 - * cdef Py_ssize_t i - * - * if isinstance(value, tuple): # <<<<<<<<<<<<<< - * bytesvalue = struct.pack(self.view.format, *value) - * else: - */ - __pyx_t_2 = PyTuple_Check(__pyx_v_value); - if (__pyx_t_2) { - - /* "View.MemoryView":514 - * - * 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(1, 514, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_3); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = PyNumber_Add(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 514, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 514, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (!(likely(PyBytes_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_3))) __PYX_ERR(1, 514, __pyx_L1_error) - __pyx_v_bytesvalue = ((PyObject*)__pyx_t_3); - __pyx_t_3 = 0; - - /* "View.MemoryView":513 - * cdef Py_ssize_t i - * - * if isinstance(value, tuple): # <<<<<<<<<<<<<< - * bytesvalue = struct.pack(self.view.format, *value) - * else: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":516 - * bytesvalue = struct.pack(self.view.format, *value) - * else: - * bytesvalue = struct.pack(self.view.format, value) # <<<<<<<<<<<<<< - * - * for i, c in enumerate(bytesvalue): - */ - /*else*/ { - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 516, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 516, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = NULL; - __pyx_t_6 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - __pyx_t_6 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_1, __pyx_v_value}; - __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 516, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } - if (!(likely(PyBytes_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_3))) __PYX_ERR(1, 516, __pyx_L1_error) - __pyx_v_bytesvalue = ((PyObject*)__pyx_t_3); - __pyx_t_3 = 0; - } - __pyx_L3:; - - /* "View.MemoryView":518 - * bytesvalue = struct.pack(self.view.format, value) - * - * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< - * itemp[i] = c - * - */ - __pyx_t_7 = 0; - if (unlikely(__pyx_v_bytesvalue == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable"); - __PYX_ERR(1, 518, __pyx_L1_error) - } - __Pyx_INCREF(__pyx_v_bytesvalue); - __pyx_t_8 = __pyx_v_bytesvalue; - __pyx_t_10 = PyBytes_AS_STRING(__pyx_t_8); - __pyx_t_11 = (__pyx_t_10 + PyBytes_GET_SIZE(__pyx_t_8)); - for (__pyx_t_12 = __pyx_t_10; __pyx_t_12 < __pyx_t_11; __pyx_t_12++) { - __pyx_t_9 = __pyx_t_12; - __pyx_v_c = (__pyx_t_9[0]); - - /* "View.MemoryView":519 - * - * for i, c in enumerate(bytesvalue): - * itemp[i] = c # <<<<<<<<<<<<<< - * - * @cname('getbuffer') - */ - __pyx_v_i = __pyx_t_7; - - /* "View.MemoryView":518 - * bytesvalue = struct.pack(self.view.format, value) - * - * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< - * itemp[i] = c - * - */ - __pyx_t_7 = (__pyx_t_7 + 1); - - /* "View.MemoryView":519 - * - * for i, c in enumerate(bytesvalue): - * itemp[i] = c # <<<<<<<<<<<<<< - * - * @cname('getbuffer') - */ - (__pyx_v_itemp[__pyx_v_i]) = __pyx_v_c; - } - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - - /* "View.MemoryView":505 - * return result - * - * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< - * """Only used if instantiated manually by the user, or if Cython doesn't - * know how to convert the type""" - */ - - /* 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_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("View.MemoryView.memoryview.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_struct); - __Pyx_XDECREF(__pyx_v_bytesvalue); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":521 - * itemp[i] = c - * - * @cname('getbuffer') # <<<<<<<<<<<<<< - * def __getbuffer__(self, Py_buffer *info, int flags): - * if flags & PyBUF_WRITABLE and self.view.readonly: - */ - -/* Python wrapper */ -CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ -CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { - int __pyx_r; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - Py_ssize_t *__pyx_t_3; - char *__pyx_t_4; - void *__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 (unlikely(__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); - - /* "View.MemoryView":523 - * @cname('getbuffer') - * 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" - * - */ - __pyx_t_2 = ((__pyx_v_flags & PyBUF_WRITABLE) != 0); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_1 = __pyx_v_self->view.readonly; - __pyx_L4_bool_binop_done:; - if (unlikely(__pyx_t_1)) { - - /* "View.MemoryView":524 - * 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_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Cannot_create_writable_memory_vi, 0, 0); - __PYX_ERR(1, 524, __pyx_L1_error) - - /* "View.MemoryView":523 - * @cname('getbuffer') - * 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" - * - */ - } - - /* "View.MemoryView":526 - * raise ValueError, "Cannot create writable memory view from read-only memoryview" - * - * if flags & PyBUF_ND: # <<<<<<<<<<<<<< - * info.shape = self.view.shape - * else: - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":527 - * - * if flags & PyBUF_ND: - * info.shape = self.view.shape # <<<<<<<<<<<<<< - * else: - * info.shape = NULL - */ - __pyx_t_3 = __pyx_v_self->view.shape; - __pyx_v_info->shape = __pyx_t_3; - - /* "View.MemoryView":526 - * raise ValueError, "Cannot create writable memory view from read-only memoryview" - * - * if flags & PyBUF_ND: # <<<<<<<<<<<<<< - * info.shape = self.view.shape - * else: - */ - goto __pyx_L6; - } - - /* "View.MemoryView":529 - * info.shape = self.view.shape - * else: - * info.shape = NULL # <<<<<<<<<<<<<< - * - * if flags & PyBUF_STRIDES: - */ - /*else*/ { - __pyx_v_info->shape = NULL; - } - __pyx_L6:; - - /* "View.MemoryView":531 - * info.shape = NULL - * - * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< - * info.strides = self.view.strides - * else: - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":532 - * - * if flags & PyBUF_STRIDES: - * info.strides = self.view.strides # <<<<<<<<<<<<<< - * else: - * info.strides = NULL - */ - __pyx_t_3 = __pyx_v_self->view.strides; - __pyx_v_info->strides = __pyx_t_3; - - /* "View.MemoryView":531 - * info.shape = NULL - * - * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< - * info.strides = self.view.strides - * else: - */ - goto __pyx_L7; - } - - /* "View.MemoryView":534 - * info.strides = self.view.strides - * else: - * info.strides = NULL # <<<<<<<<<<<<<< - * - * if flags & PyBUF_INDIRECT: - */ - /*else*/ { - __pyx_v_info->strides = NULL; - } - __pyx_L7:; - - /* "View.MemoryView":536 - * info.strides = NULL - * - * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< - * info.suboffsets = self.view.suboffsets - * else: - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_INDIRECT) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":537 - * - * if flags & PyBUF_INDIRECT: - * info.suboffsets = self.view.suboffsets # <<<<<<<<<<<<<< - * else: - * info.suboffsets = NULL - */ - __pyx_t_3 = __pyx_v_self->view.suboffsets; - __pyx_v_info->suboffsets = __pyx_t_3; - - /* "View.MemoryView":536 - * info.strides = NULL - * - * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< - * info.suboffsets = self.view.suboffsets - * else: - */ - goto __pyx_L8; - } - - /* "View.MemoryView":539 - * info.suboffsets = self.view.suboffsets - * else: - * info.suboffsets = NULL # <<<<<<<<<<<<<< - * - * if flags & PyBUF_FORMAT: - */ - /*else*/ { - __pyx_v_info->suboffsets = NULL; - } - __pyx_L8:; - - /* "View.MemoryView":541 - * info.suboffsets = NULL - * - * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< - * info.format = self.view.format - * else: - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":542 - * - * if flags & PyBUF_FORMAT: - * info.format = self.view.format # <<<<<<<<<<<<<< - * else: - * info.format = NULL - */ - __pyx_t_4 = __pyx_v_self->view.format; - __pyx_v_info->format = __pyx_t_4; - - /* "View.MemoryView":541 - * info.suboffsets = NULL - * - * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< - * info.format = self.view.format - * else: - */ - goto __pyx_L9; - } - - /* "View.MemoryView":544 - * info.format = self.view.format - * else: - * info.format = NULL # <<<<<<<<<<<<<< - * - * info.buf = self.view.buf - */ - /*else*/ { - __pyx_v_info->format = NULL; - } - __pyx_L9:; - - /* "View.MemoryView":546 - * info.format = NULL - * - * info.buf = self.view.buf # <<<<<<<<<<<<<< - * info.ndim = self.view.ndim - * info.itemsize = self.view.itemsize - */ - __pyx_t_5 = __pyx_v_self->view.buf; - __pyx_v_info->buf = __pyx_t_5; - - /* "View.MemoryView":547 - * - * info.buf = self.view.buf - * info.ndim = self.view.ndim # <<<<<<<<<<<<<< - * info.itemsize = self.view.itemsize - * info.len = self.view.len - */ - __pyx_t_6 = __pyx_v_self->view.ndim; - __pyx_v_info->ndim = __pyx_t_6; - - /* "View.MemoryView":548 - * info.buf = self.view.buf - * info.ndim = self.view.ndim - * info.itemsize = self.view.itemsize # <<<<<<<<<<<<<< - * info.len = self.view.len - * info.readonly = self.view.readonly - */ - __pyx_t_7 = __pyx_v_self->view.itemsize; - __pyx_v_info->itemsize = __pyx_t_7; - - /* "View.MemoryView":549 - * info.ndim = self.view.ndim - * info.itemsize = self.view.itemsize - * info.len = self.view.len # <<<<<<<<<<<<<< - * info.readonly = self.view.readonly - * info.obj = self - */ - __pyx_t_7 = __pyx_v_self->view.len; - __pyx_v_info->len = __pyx_t_7; - - /* "View.MemoryView":550 - * info.itemsize = self.view.itemsize - * info.len = self.view.len - * info.readonly = self.view.readonly # <<<<<<<<<<<<<< - * info.obj = self - * - */ - __pyx_t_1 = __pyx_v_self->view.readonly; - __pyx_v_info->readonly = __pyx_t_1; - - /* "View.MemoryView":551 - * info.len = self.view.len - * info.readonly = self.view.readonly - * info.obj = self # <<<<<<<<<<<<<< - * - * - */ - __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":521 - * itemp[i] = c - * - * @cname('getbuffer') # <<<<<<<<<<<<<< - * def __getbuffer__(self, Py_buffer *info, int flags): - * if flags & PyBUF_WRITABLE and self.view.readonly: - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_AddTraceback("View.MemoryView.memoryview.__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":554 - * - * - * @property # <<<<<<<<<<<<<< - * def T(self): - * cdef _memoryviewslice result = memoryview_copy(self) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - struct __pyx_memoryviewslice_obj *__pyx_v_result = 0; - PyObject *__pyx_r = NULL; - __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__", 1); - - /* "View.MemoryView":556 - * @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(1, 556, __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(1, 556, __pyx_L1_error) - __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_1); - __pyx_t_1 = 0; - - /* "View.MemoryView":557 - * 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)-1))) __PYX_ERR(1, 557, __pyx_L1_error) - - /* "View.MemoryView":558 - * cdef _memoryviewslice result = memoryview_copy(self) - * transpose_memslice(&result.from_slice) - * return result # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF((PyObject *)__pyx_v_result); - __pyx_r = ((PyObject *)__pyx_v_result); - goto __pyx_L0; - - /* "View.MemoryView":554 - * - * - * @property # <<<<<<<<<<<<<< - * def T(self): - * cdef _memoryviewslice result = memoryview_copy(self) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.memoryview.T.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_result); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":560 - * return result - * - * @property # <<<<<<<<<<<<<< - * def base(self): - * return self._get_base() - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - 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__", 1); - - /* "View.MemoryView":562 - * @property - * def base(self): - * return self._get_base() # <<<<<<<<<<<<<< - * - * cdef _get_base(self): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->_get_base(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 562, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "View.MemoryView":560 - * return result - * - * @property # <<<<<<<<<<<<<< - * def base(self): - * return self._get_base() - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.memoryview.base.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":564 - * return self._get_base() - * - * cdef _get_base(self): # <<<<<<<<<<<<<< - * return self.obj - * - */ - -static PyObject *__pyx_memoryview__get_base(struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("_get_base", 1); - - /* "View.MemoryView":565 - * - * cdef _get_base(self): - * return self.obj # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->obj); - __pyx_r = __pyx_v_self->obj; - goto __pyx_L0; - - /* "View.MemoryView":564 - * return self._get_base() - * - * cdef _get_base(self): # <<<<<<<<<<<<<< - * return self.obj - * - */ - - /* function exit code */ - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":567 - * return self.obj - * - * @property # <<<<<<<<<<<<<< - * def shape(self): - * return tuple([length for length in self.view.shape[:self.view.ndim]]) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - Py_ssize_t __pyx_7genexpr__pyx_v_length; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - Py_ssize_t *__pyx_t_2; - 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__", 1); - - /* "View.MemoryView":569 - * @property - * def shape(self): - * return tuple([length for length in self.view.shape[:self.view.ndim]]) # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - { /* enter inner scope */ - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 569, __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_7genexpr__pyx_v_length = (__pyx_t_2[0]); - __pyx_t_5 = PyInt_FromSsize_t(__pyx_7genexpr__pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 569, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(1, 569, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } - } /* exit inner scope */ - __pyx_t_5 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 569, __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":567 - * return self.obj - * - * @property # <<<<<<<<<<<<<< - * def shape(self): - * return tuple([length for length in self.view.shape[:self.view.ndim]]) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("View.MemoryView.memoryview.shape.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":571 - * return tuple([length for length in self.view.shape[:self.view.ndim]]) - * - * @property # <<<<<<<<<<<<<< - * def strides(self): - * if self.view.strides == NULL: - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - Py_ssize_t __pyx_8genexpr1__pyx_v_stride; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - Py_ssize_t *__pyx_t_3; - 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__", 1); - - /* "View.MemoryView":573 - * @property - * def strides(self): - * if self.view.strides == NULL: # <<<<<<<<<<<<<< - * - * raise ValueError, "Buffer view does not expose strides" - */ - __pyx_t_1 = (__pyx_v_self->view.strides == NULL); - if (unlikely(__pyx_t_1)) { - - /* "View.MemoryView":575 - * 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_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Buffer_view_does_not_expose_stri, 0, 0); - __PYX_ERR(1, 575, __pyx_L1_error) - - /* "View.MemoryView":573 - * @property - * def strides(self): - * if self.view.strides == NULL: # <<<<<<<<<<<<<< - * - * raise ValueError, "Buffer view does not expose strides" - */ - } - - /* "View.MemoryView":577 - * raise ValueError, "Buffer view does not expose strides" - * - * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - { /* enter inner scope */ - __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 577, __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_8genexpr1__pyx_v_stride = (__pyx_t_3[0]); - __pyx_t_6 = PyInt_FromSsize_t(__pyx_8genexpr1__pyx_v_stride); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 577, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 577, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - } - } /* exit inner scope */ - __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 577, __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":571 - * return tuple([length for length in self.view.shape[:self.view.ndim]]) - * - * @property # <<<<<<<<<<<<<< - * def strides(self): - * if self.view.strides == NULL: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_AddTraceback("View.MemoryView.memoryview.strides.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":579 - * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) - * - * @property # <<<<<<<<<<<<<< - * def suboffsets(self): - * if self.view.suboffsets == NULL: - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - Py_ssize_t __pyx_8genexpr2__pyx_v_suboffset; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - Py_ssize_t *__pyx_t_3; - 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__", 1); - - /* "View.MemoryView":581 - * @property - * def suboffsets(self): - * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< - * return (-1,) * self.view.ndim - * - */ - __pyx_t_1 = (__pyx_v_self->view.suboffsets == NULL); - if (__pyx_t_1) { - - /* "View.MemoryView":582 - * 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_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PySequence_Multiply(__pyx_tuple__4, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 582, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":581 - * @property - * def suboffsets(self): - * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< - * return (-1,) * self.view.ndim - * - */ - } - - /* "View.MemoryView":584 - * return (-1,) * self.view.ndim - * - * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - { /* enter inner scope */ - __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 584, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = (__pyx_v_self->view.suboffsets + __pyx_v_self->view.ndim); - for (__pyx_t_5 = __pyx_v_self->view.suboffsets; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { - __pyx_t_3 = __pyx_t_5; - __pyx_8genexpr2__pyx_v_suboffset = (__pyx_t_3[0]); - __pyx_t_6 = PyInt_FromSsize_t(__pyx_8genexpr2__pyx_v_suboffset); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 584, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 584, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - } - } /* exit inner scope */ - __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 584, __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":579 - * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) - * - * @property # <<<<<<<<<<<<<< - * def suboffsets(self): - * if self.view.suboffsets == NULL: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_AddTraceback("View.MemoryView.memoryview.suboffsets.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":586 - * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) - * - * @property # <<<<<<<<<<<<<< - * def ndim(self): - * return self.view.ndim - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - 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__", 1); - - /* "View.MemoryView":588 - * @property - * def ndim(self): - * return self.view.ndim # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 588, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "View.MemoryView":586 - * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) - * - * @property # <<<<<<<<<<<<<< - * def ndim(self): - * return self.view.ndim - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.memoryview.ndim.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":590 - * return self.view.ndim - * - * @property # <<<<<<<<<<<<<< - * def itemsize(self): - * return self.view.itemsize - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - 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__", 1); - - /* "View.MemoryView":592 - * @property - * def itemsize(self): - * return self.view.itemsize # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 592, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "View.MemoryView":590 - * return self.view.ndim - * - * @property # <<<<<<<<<<<<<< - * def itemsize(self): - * return self.view.itemsize - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.memoryview.itemsize.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":594 - * return self.view.itemsize - * - * @property # <<<<<<<<<<<<<< - * def nbytes(self): - * return self.size * self.view.itemsize - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - 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__", 1); - - /* "View.MemoryView":596 - * @property - * def nbytes(self): - * return self.size * self.view.itemsize # <<<<<<<<<<<<<< - * - * @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(1, 596, __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(1, 596, __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(1, 596, __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; - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L0; - - /* "View.MemoryView":594 - * return self.view.itemsize - * - * @property # <<<<<<<<<<<<<< - * def nbytes(self): - * return self.size * self.view.itemsize - */ - - /* 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.memoryview.nbytes.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":598 - * return self.size * self.view.itemsize - * - * @property # <<<<<<<<<<<<<< - * def size(self): - * if self._size is None: - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_v_result = NULL; - PyObject *__pyx_v_length = NULL; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - Py_ssize_t *__pyx_t_2; - 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__", 1); - - /* "View.MemoryView":600 - * @property - * def size(self): - * if self._size is None: # <<<<<<<<<<<<<< - * result = 1 - * - */ - __pyx_t_1 = (__pyx_v_self->_size == Py_None); - if (__pyx_t_1) { - - /* "View.MemoryView":601 - * def size(self): - * if self._size is None: - * result = 1 # <<<<<<<<<<<<<< - * - * for length in self.view.shape[:self.view.ndim]: - */ - __Pyx_INCREF(__pyx_int_1); - __pyx_v_result = __pyx_int_1; - - /* "View.MemoryView":603 - * result = 1 - * - * for length in self.view.shape[:self.view.ndim]: # <<<<<<<<<<<<<< - * result *= length - * - */ - __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_t_5 = PyInt_FromSsize_t((__pyx_t_2[0])); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 603, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_5); - __pyx_t_5 = 0; - - /* "View.MemoryView":604 - * - * for length in self.view.shape[:self.view.ndim]: - * result *= length # <<<<<<<<<<<<<< - * - * self._size = result - */ - __pyx_t_5 = PyNumber_InPlaceMultiply(__pyx_v_result, __pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 604, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_5); - __pyx_t_5 = 0; - } - - /* "View.MemoryView":606 - * result *= length - * - * self._size = result # <<<<<<<<<<<<<< - * - * return self._size - */ - __Pyx_INCREF(__pyx_v_result); - __Pyx_GIVEREF(__pyx_v_result); - __Pyx_GOTREF(__pyx_v_self->_size); - __Pyx_DECREF(__pyx_v_self->_size); - __pyx_v_self->_size = __pyx_v_result; - - /* "View.MemoryView":600 - * @property - * def size(self): - * if self._size is None: # <<<<<<<<<<<<<< - * result = 1 - * - */ - } - - /* "View.MemoryView":608 - * self._size = result - * - * return self._size # <<<<<<<<<<<<<< - * - * def __len__(self): - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->_size); - __pyx_r = __pyx_v_self->_size; - goto __pyx_L0; - - /* "View.MemoryView":598 - * return self.size * self.view.itemsize - * - * @property # <<<<<<<<<<<<<< - * def size(self): - * if self._size is None: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("View.MemoryView.memoryview.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_result); - __Pyx_XDECREF(__pyx_v_length); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":610 - * return self._size - * - * def __len__(self): # <<<<<<<<<<<<<< - * if self.view.ndim >= 1: - * return self.view.shape[0] - */ - -/* Python wrapper */ -static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self); /*proto*/ -static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - Py_ssize_t __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self) { - Py_ssize_t __pyx_r; - int __pyx_t_1; - - /* "View.MemoryView":611 - * - * def __len__(self): - * if self.view.ndim >= 1: # <<<<<<<<<<<<<< - * return self.view.shape[0] - * - */ - __pyx_t_1 = (__pyx_v_self->view.ndim >= 1); - if (__pyx_t_1) { - - /* "View.MemoryView":612 - * def __len__(self): - * if self.view.ndim >= 1: - * return self.view.shape[0] # <<<<<<<<<<<<<< - * - * return 0 - */ - __pyx_r = (__pyx_v_self->view.shape[0]); - goto __pyx_L0; - - /* "View.MemoryView":611 - * - * def __len__(self): - * if self.view.ndim >= 1: # <<<<<<<<<<<<<< - * return self.view.shape[0] - * - */ - } - - /* "View.MemoryView":614 - * return self.view.shape[0] - * - * return 0 # <<<<<<<<<<<<<< - * - * def __repr__(self): - */ - __pyx_r = 0; - goto __pyx_L0; - - /* "View.MemoryView":610 - * return self._size - * - * def __len__(self): # <<<<<<<<<<<<<< - * if self.view.ndim >= 1: - * return self.view.shape[0] - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":616 - * return 0 - * - * def __repr__(self): # <<<<<<<<<<<<<< - * return "" % (self.base.__class__.__name__, - * id(self)) - */ - -/* Python wrapper */ -static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - 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__", 1); - - /* "View.MemoryView":617 - * - * def __repr__(self): - * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< - * id(self)) - * - */ - __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(1, 617, __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(1, 617, __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(1, 617, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "View.MemoryView":618 - * 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(1, 618, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - - /* "View.MemoryView":617 - * - * def __repr__(self): - * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< - * id(self)) - * - */ - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 617, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1)) __PYX_ERR(1, 617, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2)) __PYX_ERR(1, 617, __pyx_L1_error); - __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(1, 617, __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":616 - * return 0 - * - * def __repr__(self): # <<<<<<<<<<<<<< - * return "" % (self.base.__class__.__name__, - * id(self)) - */ - - /* 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.memoryview.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":620 - * id(self)) - * - * def __str__(self): # <<<<<<<<<<<<<< - * return "" % (self.base.__class__.__name__,) - * - */ - -/* Python wrapper */ -static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __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__", 1); - - /* "View.MemoryView":621 - * - * def __str__(self): - * return "" % (self.base.__class__.__name__,) # <<<<<<<<<<<<<< - * - * - */ - __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(1, 621, __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(1, 621, __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(1, 621, __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(1, 621, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1)) __PYX_ERR(1, 621, __pyx_L1_error); - __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(1, 621, __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":620 - * id(self)) - * - * def __str__(self): # <<<<<<<<<<<<<< - * return "" % (self.base.__class__.__name__,) - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.memoryview.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":624 - * - * - * def is_c_contig(self): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice *mslice - * cdef __Pyx_memviewslice tmp - */ - -/* Python wrapper */ -static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("is_c_contig (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("is_c_contig", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "is_c_contig", 0))) return NULL; - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self) { - __Pyx_memviewslice *__pyx_v_mslice; - __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; - __Pyx_RefNannySetupContext("is_c_contig", 1); - - /* "View.MemoryView":627 - * 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(1, 627, __pyx_L1_error) - __pyx_v_mslice = __pyx_t_1; - - /* "View.MemoryView":628 - * cdef __Pyx_memviewslice tmp - * mslice = get_slice_from_memview(self, &tmp) - * return slice_is_contig(mslice[0], 'C', self.view.ndim) # <<<<<<<<<<<<<< - * - * 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(1, 628, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":624 - * - * - * def is_c_contig(self): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice *mslice - * cdef __Pyx_memviewslice tmp - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.memoryview.is_c_contig", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":630 - * return slice_is_contig(mslice[0], 'C', self.view.ndim) - * - * def is_f_contig(self): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice *mslice - * cdef __Pyx_memviewslice tmp - */ - -/* Python wrapper */ -static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("is_f_contig (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("is_f_contig", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "is_f_contig", 0))) return NULL; - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self) { - __Pyx_memviewslice *__pyx_v_mslice; - __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; - __Pyx_RefNannySetupContext("is_f_contig", 1); - - /* "View.MemoryView":633 - * 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(1, 633, __pyx_L1_error) - __pyx_v_mslice = __pyx_t_1; - - /* "View.MemoryView":634 - * cdef __Pyx_memviewslice tmp - * mslice = get_slice_from_memview(self, &tmp) - * return slice_is_contig(mslice[0], 'F', self.view.ndim) # <<<<<<<<<<<<<< - * - * 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(1, 634, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":630 - * return slice_is_contig(mslice[0], 'C', self.view.ndim) - * - * def is_f_contig(self): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice *mslice - * cdef __Pyx_memviewslice tmp - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.memoryview.is_f_contig", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":636 - * return slice_is_contig(mslice[0], 'F', self.view.ndim) - * - * def copy(self): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice mslice - * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS - */ - -/* Python wrapper */ -static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("copy (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("copy", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "copy", 0))) return NULL; - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self) { - __Pyx_memviewslice __pyx_v_mslice; - int __pyx_v_flags; - 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; - __Pyx_RefNannySetupContext("copy", 1); - - /* "View.MemoryView":638 - * def copy(self): - * cdef __Pyx_memviewslice mslice - * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS # <<<<<<<<<<<<<< - * - * slice_copy(self, &mslice) - */ - __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_F_CONTIGUOUS)); - - /* "View.MemoryView":640 - * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS - * - * slice_copy(self, &mslice) # <<<<<<<<<<<<<< - * mslice = slice_copy_contig(&mslice, "c", self.view.ndim, - * self.view.itemsize, - */ - __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_mslice)); - - /* "View.MemoryView":641 - * - * 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(1, 641, __pyx_L1_error) - __pyx_v_mslice = __pyx_t_1; - - /* "View.MemoryView":646 - * self.dtype_is_object) - * - * return memoryview_copy_from_slice(self, &mslice) # <<<<<<<<<<<<<< - * - * 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(1, 646, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":636 - * return slice_is_contig(mslice[0], 'F', self.view.ndim) - * - * def copy(self): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice mslice - * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.memoryview.copy", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":648 - * return memoryview_copy_from_slice(self, &mslice) - * - * def copy_fortran(self): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice src, dst - * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS - */ - -/* Python wrapper */ -static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("copy_fortran (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("copy_fortran", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "copy_fortran", 0))) return NULL; - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self) { - __Pyx_memviewslice __pyx_v_src; - __Pyx_memviewslice __pyx_v_dst; - int __pyx_v_flags; - 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; - __Pyx_RefNannySetupContext("copy_fortran", 1); - - /* "View.MemoryView":650 - * def copy_fortran(self): - * cdef __Pyx_memviewslice src, dst - * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS # <<<<<<<<<<<<<< - * - * slice_copy(self, &src) - */ - __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_C_CONTIGUOUS)); - - /* "View.MemoryView":652 - * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS - * - * slice_copy(self, &src) # <<<<<<<<<<<<<< - * dst = slice_copy_contig(&src, "fortran", self.view.ndim, - * self.view.itemsize, - */ - __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_src)); - - /* "View.MemoryView":653 - * - * 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(1, 653, __pyx_L1_error) - __pyx_v_dst = __pyx_t_1; - - /* "View.MemoryView":658 - * self.dtype_is_object) - * - * return memoryview_copy_from_slice(self, &dst) # <<<<<<<<<<<<<< - * - * - */ - __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(1, 658, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":648 - * return memoryview_copy_from_slice(self, &mslice) - * - * def copy_fortran(self): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice src, dst - * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.memoryview.copy_fortran", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __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): - */ - -/* Python wrapper */ -static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; - __pyx_r = __pyx_pf___pyx_memoryview___reduce_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__reduce_cython__", 1); - - /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); - __PYX_ERR(1, 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): - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("View.MemoryView.memoryview.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __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_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v___pyx_state = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("View.MemoryView.memoryview.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf___pyx_memoryview_2__setstate_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v___pyx_state); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setstate_cython__", 1); - - /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); - __PYX_ERR(1, 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_AddTraceback("View.MemoryView.memoryview.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":662 - * - * @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 - */ - -static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, int __pyx_v_dtype_is_object, __Pyx_TypeInfo *__pyx_v_typeinfo) { - struct __pyx_memoryview_obj *__pyx_v_result = 0; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - 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", 1); - - /* "View.MemoryView":663 - * @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(1, 663, __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(1, 663, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 663, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_v_o); - __Pyx_GIVEREF(__pyx_v_o); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_o)) __PYX_ERR(1, 663, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 663, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2)) __PYX_ERR(1, 663, __pyx_L1_error); - __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(1, 663, __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":664 - * 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_v_result->typeinfo = __pyx_v_typeinfo; - - /* "View.MemoryView":665 - * cdef memoryview result = memoryview(o, flags, dtype_is_object) - * result.typeinfo = typeinfo - * return result # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_check') - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF((PyObject *)__pyx_v_result); - __pyx_r = ((PyObject *)__pyx_v_result); - goto __pyx_L0; - - /* "View.MemoryView":662 - * - * @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 - */ - - /* 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.memoryview_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_result); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":668 - * - * @cname('__pyx_memoryview_check') - * cdef inline bint memoryview_check(object o) noexcept: # <<<<<<<<<<<<<< - * return isinstance(o, memoryview) - * - */ - -static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) { - int __pyx_r; - int __pyx_t_1; - - /* "View.MemoryView":669 - * @cname('__pyx_memoryview_check') - * cdef inline bint memoryview_check(object o) noexcept: - * return isinstance(o, memoryview) # <<<<<<<<<<<<<< - * - * cdef tuple _unellipsify(object index, int ndim): - */ - __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_o, __pyx_memoryview_type); - __pyx_r = __pyx_t_1; - goto __pyx_L0; - - /* "View.MemoryView":668 - * - * @cname('__pyx_memoryview_check') - * cdef inline bint memoryview_check(object o) noexcept: # <<<<<<<<<<<<<< - * return isinstance(o, memoryview) - * - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":671 - * return isinstance(o, memoryview) - * - * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< - * """ - * Replace all ellipses with full slices and fill incomplete indices with - */ - -static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { - Py_ssize_t __pyx_v_idx; - PyObject *__pyx_v_tup = NULL; - PyObject *__pyx_v_result = NULL; - int __pyx_v_have_slices; - int __pyx_v_seen_ellipsis; - PyObject *__pyx_v_item = NULL; - Py_ssize_t __pyx_v_nslices; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - Py_ssize_t __pyx_t_4; - Py_ssize_t __pyx_t_5; - Py_UCS4 __pyx_t_6; - PyObject *__pyx_t_7 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_unellipsify", 1); - - /* "View.MemoryView":677 - * """ - * cdef Py_ssize_t idx - * tup = index if isinstance(index, tuple) else (index,) # <<<<<<<<<<<<<< - * - * result = [slice(None)] * ndim - */ - __pyx_t_2 = PyTuple_Check(__pyx_v_index); - if (__pyx_t_2) { - __Pyx_INCREF(((PyObject*)__pyx_v_index)); - __pyx_t_1 = __pyx_v_index; - } else { - __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 677, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_v_index); - __Pyx_GIVEREF(__pyx_v_index); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_index)) __PYX_ERR(1, 677, __pyx_L1_error); - __pyx_t_1 = __pyx_t_3; - __pyx_t_3 = 0; - } - __pyx_v_tup = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - - /* "View.MemoryView":679 - * tup = index if isinstance(index, tuple) else (index,) - * - * result = [slice(None)] * ndim # <<<<<<<<<<<<<< - * have_slices = False - * seen_ellipsis = False - */ - __pyx_t_1 = PyList_New(1 * ((__pyx_v_ndim<0) ? 0:__pyx_v_ndim)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 679, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - { Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < __pyx_v_ndim; __pyx_temp++) { - __Pyx_INCREF(__pyx_slice__5); - __Pyx_GIVEREF(__pyx_slice__5); - if (__Pyx_PyList_SET_ITEM(__pyx_t_1, __pyx_temp, __pyx_slice__5)) __PYX_ERR(1, 679, __pyx_L1_error); - } - } - __pyx_v_result = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - - /* "View.MemoryView":680 - * - * result = [slice(None)] * ndim - * have_slices = False # <<<<<<<<<<<<<< - * seen_ellipsis = False - * idx = 0 - */ - __pyx_v_have_slices = 0; - - /* "View.MemoryView":681 - * result = [slice(None)] * ndim - * have_slices = False - * seen_ellipsis = False # <<<<<<<<<<<<<< - * idx = 0 - * for item in tup: - */ - __pyx_v_seen_ellipsis = 0; - - /* "View.MemoryView":682 - * have_slices = False - * seen_ellipsis = False - * idx = 0 # <<<<<<<<<<<<<< - * for item in tup: - * if item is Ellipsis: - */ - __pyx_v_idx = 0; - - /* "View.MemoryView":683 - * seen_ellipsis = False - * idx = 0 - * for item in tup: # <<<<<<<<<<<<<< - * if item is Ellipsis: - * if not seen_ellipsis: - */ - if (unlikely(__pyx_v_tup == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(1, 683, __pyx_L1_error) - } - __pyx_t_1 = __pyx_v_tup; __Pyx_INCREF(__pyx_t_1); - __pyx_t_4 = 0; - for (;;) { - { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 683, __pyx_L1_error) - #endif - if (__pyx_t_4 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_3); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(1, 683, __pyx_L1_error) - #else - __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 683, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_3); - __pyx_t_3 = 0; - - /* "View.MemoryView":684 - * idx = 0 - * for item in tup: - * if item is Ellipsis: # <<<<<<<<<<<<<< - * if not seen_ellipsis: - * idx += ndim - len(tup) - */ - __pyx_t_2 = (__pyx_v_item == __pyx_builtin_Ellipsis); - if (__pyx_t_2) { - - /* "View.MemoryView":685 - * for item in tup: - * if item is Ellipsis: - * if not seen_ellipsis: # <<<<<<<<<<<<<< - * idx += ndim - len(tup) - * seen_ellipsis = True - */ - __pyx_t_2 = (!__pyx_v_seen_ellipsis); - if (__pyx_t_2) { - - /* "View.MemoryView":686 - * if item is Ellipsis: - * if not seen_ellipsis: - * idx += ndim - len(tup) # <<<<<<<<<<<<<< - * seen_ellipsis = True - * have_slices = True - */ - if (unlikely(__pyx_v_tup == Py_None)) { - PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(1, 686, __pyx_L1_error) - } - __pyx_t_5 = __Pyx_PyTuple_GET_SIZE(__pyx_v_tup); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 686, __pyx_L1_error) - __pyx_v_idx = (__pyx_v_idx + (__pyx_v_ndim - __pyx_t_5)); - - /* "View.MemoryView":687 - * if not seen_ellipsis: - * idx += ndim - len(tup) - * seen_ellipsis = True # <<<<<<<<<<<<<< - * have_slices = True - * else: - */ - __pyx_v_seen_ellipsis = 1; - - /* "View.MemoryView":685 - * for item in tup: - * if item is Ellipsis: - * if not seen_ellipsis: # <<<<<<<<<<<<<< - * idx += ndim - len(tup) - * seen_ellipsis = True - */ - } - - /* "View.MemoryView":688 - * idx += ndim - len(tup) - * seen_ellipsis = True - * have_slices = True # <<<<<<<<<<<<<< - * else: - * if isinstance(item, slice): - */ - __pyx_v_have_slices = 1; - - /* "View.MemoryView":684 - * idx = 0 - * for item in tup: - * if item is Ellipsis: # <<<<<<<<<<<<<< - * if not seen_ellipsis: - * idx += ndim - len(tup) - */ - goto __pyx_L5; - } - - /* "View.MemoryView":690 - * have_slices = True - * else: - * if isinstance(item, slice): # <<<<<<<<<<<<<< - * have_slices = True - * elif not PyIndex_Check(item): - */ - /*else*/ { - __pyx_t_2 = PySlice_Check(__pyx_v_item); - if (__pyx_t_2) { - - /* "View.MemoryView":691 - * else: - * if isinstance(item, slice): - * have_slices = True # <<<<<<<<<<<<<< - * elif not PyIndex_Check(item): - * raise TypeError, f"Cannot index with type '{type(item)}'" - */ - __pyx_v_have_slices = 1; - - /* "View.MemoryView":690 - * have_slices = True - * else: - * if isinstance(item, slice): # <<<<<<<<<<<<<< - * have_slices = True - * elif not PyIndex_Check(item): - */ - goto __pyx_L7; - } - - /* "View.MemoryView":692 - * if isinstance(item, slice): - * have_slices = True - * elif not PyIndex_Check(item): # <<<<<<<<<<<<<< - * raise TypeError, f"Cannot index with type '{type(item)}'" - * result[idx] = item - */ - __pyx_t_2 = (!(PyIndex_Check(__pyx_v_item) != 0)); - if (unlikely(__pyx_t_2)) { - - /* "View.MemoryView":693 - * have_slices = True - * elif not PyIndex_Check(item): - * raise TypeError, f"Cannot index with type '{type(item)}'" # <<<<<<<<<<<<<< - * result[idx] = item - * idx += 1 - */ - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 693, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = 0; - __pyx_t_6 = 127; - __Pyx_INCREF(__pyx_kp_u_Cannot_index_with_type); - __pyx_t_5 += 24; - __Pyx_GIVEREF(__pyx_kp_u_Cannot_index_with_type); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_Cannot_index_with_type); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(((PyObject *)Py_TYPE(__pyx_v_item)), __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 693, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_6; - __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7); - __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_kp_u__6); - __pyx_t_5 += 1; - __Pyx_GIVEREF(__pyx_kp_u__6); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__6); - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 693, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_builtin_TypeError, __pyx_t_7, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(1, 693, __pyx_L1_error) - - /* "View.MemoryView":692 - * if isinstance(item, slice): - * have_slices = True - * elif not PyIndex_Check(item): # <<<<<<<<<<<<<< - * raise TypeError, f"Cannot index with type '{type(item)}'" - * result[idx] = item - */ - } - __pyx_L7:; - - /* "View.MemoryView":694 - * elif not PyIndex_Check(item): - * raise TypeError, f"Cannot index with type '{type(item)}'" - * result[idx] = item # <<<<<<<<<<<<<< - * idx += 1 - * - */ - if (unlikely((__Pyx_SetItemInt(__pyx_v_result, __pyx_v_idx, __pyx_v_item, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1) < 0))) __PYX_ERR(1, 694, __pyx_L1_error) - } - __pyx_L5:; - - /* "View.MemoryView":695 - * raise TypeError, f"Cannot index with type '{type(item)}'" - * result[idx] = item - * idx += 1 # <<<<<<<<<<<<<< - * - * nslices = ndim - idx - */ - __pyx_v_idx = (__pyx_v_idx + 1); - - /* "View.MemoryView":683 - * seen_ellipsis = False - * idx = 0 - * for item in tup: # <<<<<<<<<<<<<< - * if item is Ellipsis: - * if not seen_ellipsis: - */ - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "View.MemoryView":697 - * idx += 1 - * - * nslices = ndim - idx # <<<<<<<<<<<<<< - * return have_slices or nslices, tuple(result) - * - */ - __pyx_v_nslices = (__pyx_v_ndim - __pyx_v_idx); - - /* "View.MemoryView":698 - * - * nslices = ndim - idx - * return have_slices or nslices, tuple(result) # <<<<<<<<<<<<<< - * - * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: - */ - __Pyx_XDECREF(__pyx_r); - if (!__pyx_v_have_slices) { - } else { - __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_have_slices); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 698, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_1 = __pyx_t_7; - __pyx_t_7 = 0; - goto __pyx_L9_bool_binop_done; - } - __pyx_t_7 = PyInt_FromSsize_t(__pyx_v_nslices); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 698, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_1 = __pyx_t_7; - __pyx_t_7 = 0; - __pyx_L9_bool_binop_done:; - __pyx_t_7 = PyList_AsTuple(__pyx_v_result); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 698, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 698, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1)) __PYX_ERR(1, 698, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_7); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7)) __PYX_ERR(1, 698, __pyx_L1_error); - __pyx_t_1 = 0; - __pyx_t_7 = 0; - __pyx_r = ((PyObject*)__pyx_t_3); - __pyx_t_3 = 0; - goto __pyx_L0; - - /* "View.MemoryView":671 - * return isinstance(o, memoryview) - * - * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< - * """ - * Replace all ellipses with full slices and fill incomplete indices with - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_AddTraceback("View.MemoryView._unellipsify", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_tup); - __Pyx_XDECREF(__pyx_v_result); - __Pyx_XDECREF(__pyx_v_item); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":700 - * return have_slices or nslices, tuple(result) - * - * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: # <<<<<<<<<<<<<< - * for suboffset in suboffsets[:ndim]: - * if suboffset >= 0: - */ - -static int assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __pyx_v_ndim) { - Py_ssize_t __pyx_v_suboffset; - int __pyx_r; - Py_ssize_t *__pyx_t_1; - Py_ssize_t *__pyx_t_2; - Py_ssize_t *__pyx_t_3; - int __pyx_t_4; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - - /* "View.MemoryView":701 - * - * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: - * for suboffset in suboffsets[:ndim]: # <<<<<<<<<<<<<< - * if suboffset >= 0: - * raise ValueError, "Indirect dimensions not supported" - */ - __pyx_t_2 = (__pyx_v_suboffsets + __pyx_v_ndim); - for (__pyx_t_3 = __pyx_v_suboffsets; __pyx_t_3 < __pyx_t_2; __pyx_t_3++) { - __pyx_t_1 = __pyx_t_3; - __pyx_v_suboffset = (__pyx_t_1[0]); - - /* "View.MemoryView":702 - * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: - * for suboffset in suboffsets[:ndim]: - * if suboffset >= 0: # <<<<<<<<<<<<<< - * raise ValueError, "Indirect dimensions not supported" - * return 0 # return type just used as an error flag - */ - __pyx_t_4 = (__pyx_v_suboffset >= 0); - if (unlikely(__pyx_t_4)) { - - /* "View.MemoryView":703 - * for suboffset in suboffsets[:ndim]: - * if suboffset >= 0: - * raise ValueError, "Indirect dimensions not supported" # <<<<<<<<<<<<<< - * return 0 # return type just used as an error flag - * - */ - __Pyx_Raise(__pyx_builtin_ValueError, __pyx_kp_s_Indirect_dimensions_not_supporte, 0, 0); - __PYX_ERR(1, 703, __pyx_L1_error) - - /* "View.MemoryView":702 - * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: - * for suboffset in suboffsets[:ndim]: - * if suboffset >= 0: # <<<<<<<<<<<<<< - * raise ValueError, "Indirect dimensions not supported" - * return 0 # return type just used as an error flag - */ - } - } - - /* "View.MemoryView":704 - * if suboffset >= 0: - * raise ValueError, "Indirect dimensions not supported" - * return 0 # return type just used as an error flag # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = 0; - goto __pyx_L0; - - /* "View.MemoryView":700 - * return have_slices or nslices, tuple(result) - * - * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: # <<<<<<<<<<<<<< - * for suboffset in suboffsets[:ndim]: - * if suboffset >= 0: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("View.MemoryView.assert_direct_dimensions", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":711 - * - * @cname('__pyx_memview_slice') - * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< - * cdef int new_ndim = 0, suboffset_dim = -1, dim - * cdef bint negative_step - */ - -static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *__pyx_v_memview, PyObject *__pyx_v_indices) { - int __pyx_v_new_ndim; - int __pyx_v_suboffset_dim; - int __pyx_v_dim; - __Pyx_memviewslice __pyx_v_src; - __Pyx_memviewslice __pyx_v_dst; - __Pyx_memviewslice *__pyx_v_p_src; - struct __pyx_memoryviewslice_obj *__pyx_v_memviewsliceobj = 0; - __Pyx_memviewslice *__pyx_v_p_dst; - int *__pyx_v_p_suboffset_dim; - Py_ssize_t __pyx_v_start; - Py_ssize_t __pyx_v_stop; - Py_ssize_t __pyx_v_step; - Py_ssize_t __pyx_v_cindex; - int __pyx_v_have_start; - int __pyx_v_have_stop; - int __pyx_v_have_step; - PyObject *__pyx_v_index = NULL; - struct __pyx_memoryview_obj *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - struct __pyx_memoryview_obj *__pyx_t_3; - char *__pyx_t_4; - int __pyx_t_5; - Py_ssize_t __pyx_t_6; - PyObject *(*__pyx_t_7)(PyObject *); - PyObject *__pyx_t_8 = NULL; - Py_ssize_t __pyx_t_9; - int __pyx_t_10; - Py_ssize_t __pyx_t_11; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("memview_slice", 1); - - /* "View.MemoryView":712 - * @cname('__pyx_memview_slice') - * cdef memoryview memview_slice(memoryview memview, object indices): - * cdef int new_ndim = 0, suboffset_dim = -1, dim # <<<<<<<<<<<<<< - * cdef bint negative_step - * cdef __Pyx_memviewslice src, dst - */ - __pyx_v_new_ndim = 0; - __pyx_v_suboffset_dim = -1; - - /* "View.MemoryView":719 - * - * - * memset(&dst, 0, sizeof(dst)) # <<<<<<<<<<<<<< - * - * cdef _memoryviewslice memviewsliceobj - */ - (void)(memset((&__pyx_v_dst), 0, (sizeof(__pyx_v_dst)))); - - /* "View.MemoryView":723 - * cdef _memoryviewslice memviewsliceobj - * - * assert memview.view.ndim > 0 # <<<<<<<<<<<<<< - * - * if isinstance(memview, _memoryviewslice): - */ - #ifndef CYTHON_WITHOUT_ASSERTIONS - if (unlikely(__pyx_assertions_enabled())) { - __pyx_t_1 = (__pyx_v_memview->view.ndim > 0); - if (unlikely(!__pyx_t_1)) { - __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); - __PYX_ERR(1, 723, __pyx_L1_error) - } - } - #else - if ((1)); else __PYX_ERR(1, 723, __pyx_L1_error) - #endif - - /* "View.MemoryView":725 - * assert memview.view.ndim > 0 - * - * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< - * memviewsliceobj = memview - * p_src = &memviewsliceobj.from_slice - */ - __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); - if (__pyx_t_1) { - - /* "View.MemoryView":726 - * - * 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(1, 726, __pyx_L1_error) - __pyx_t_2 = ((PyObject *)__pyx_v_memview); - __Pyx_INCREF(__pyx_t_2); - __pyx_v_memviewsliceobj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); - __pyx_t_2 = 0; - - /* "View.MemoryView":727 - * if isinstance(memview, _memoryviewslice): - * memviewsliceobj = memview - * p_src = &memviewsliceobj.from_slice # <<<<<<<<<<<<<< - * else: - * slice_copy(memview, &src) - */ - __pyx_v_p_src = (&__pyx_v_memviewsliceobj->from_slice); - - /* "View.MemoryView":725 - * assert memview.view.ndim > 0 - * - * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< - * memviewsliceobj = memview - * p_src = &memviewsliceobj.from_slice - */ - goto __pyx_L3; - } - - /* "View.MemoryView":729 - * p_src = &memviewsliceobj.from_slice - * else: - * slice_copy(memview, &src) # <<<<<<<<<<<<<< - * p_src = &src - * - */ - /*else*/ { - __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_src)); - - /* "View.MemoryView":730 - * else: - * slice_copy(memview, &src) - * p_src = &src # <<<<<<<<<<<<<< - * - * - */ - __pyx_v_p_src = (&__pyx_v_src); - } - __pyx_L3:; - - /* "View.MemoryView":736 - * - * - * dst.memview = p_src.memview # <<<<<<<<<<<<<< - * dst.data = p_src.data - * - */ - __pyx_t_3 = __pyx_v_p_src->memview; - __pyx_v_dst.memview = __pyx_t_3; - - /* "View.MemoryView":737 - * - * dst.memview = p_src.memview - * dst.data = p_src.data # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_4 = __pyx_v_p_src->data; - __pyx_v_dst.data = __pyx_t_4; - - /* "View.MemoryView":742 - * - * - * cdef __Pyx_memviewslice *p_dst = &dst # <<<<<<<<<<<<<< - * cdef int *p_suboffset_dim = &suboffset_dim - * cdef Py_ssize_t start, stop, step, cindex - */ - __pyx_v_p_dst = (&__pyx_v_dst); - - /* "View.MemoryView":743 - * - * cdef __Pyx_memviewslice *p_dst = &dst - * cdef int *p_suboffset_dim = &suboffset_dim # <<<<<<<<<<<<<< - * cdef Py_ssize_t start, stop, step, cindex - * cdef bint have_start, have_stop, have_step - */ - __pyx_v_p_suboffset_dim = (&__pyx_v_suboffset_dim); - - /* "View.MemoryView":747 - * cdef bint have_start, have_stop, have_step - * - * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< - * if PyIndex_Check(index): - * cindex = index - */ - __pyx_t_5 = 0; - if (likely(PyList_CheckExact(__pyx_v_indices)) || PyTuple_CheckExact(__pyx_v_indices)) { - __pyx_t_2 = __pyx_v_indices; __Pyx_INCREF(__pyx_t_2); - __pyx_t_6 = 0; - __pyx_t_7 = NULL; - } else { - __pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_indices); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 747, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 747, __pyx_L1_error) - } - for (;;) { - if (likely(!__pyx_t_7)) { - if (likely(PyList_CheckExact(__pyx_t_2))) { - { - Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 747, __pyx_L1_error) - #endif - if (__pyx_t_6 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_8 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_8); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(1, 747, __pyx_L1_error) - #else - __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 747, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - #endif - } else { - { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 747, __pyx_L1_error) - #endif - if (__pyx_t_6 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_8); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(1, 747, __pyx_L1_error) - #else - __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 747, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - #endif - } - } else { - __pyx_t_8 = __pyx_t_7(__pyx_t_2); - if (unlikely(!__pyx_t_8)) { - PyObject* exc_type = PyErr_Occurred(); - if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 747, __pyx_L1_error) - } - break; - } - __Pyx_GOTREF(__pyx_t_8); - } - __Pyx_XDECREF_SET(__pyx_v_index, __pyx_t_8); - __pyx_t_8 = 0; - __pyx_v_dim = __pyx_t_5; - __pyx_t_5 = (__pyx_t_5 + 1); - - /* "View.MemoryView":748 - * - * for dim, index in enumerate(indices): - * if PyIndex_Check(index): # <<<<<<<<<<<<<< - * cindex = index - * slice_memviewslice( - */ - __pyx_t_1 = (PyIndex_Check(__pyx_v_index) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":749 - * for dim, index in enumerate(indices): - * if PyIndex_Check(index): - * cindex = index # <<<<<<<<<<<<<< - * slice_memviewslice( - * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], - */ - __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_v_index); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 749, __pyx_L1_error) - __pyx_v_cindex = __pyx_t_9; - - /* "View.MemoryView":750 - * if PyIndex_Check(index): - * cindex = 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_10 = __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_cindex, 0, 0, 0, 0, 0, 0); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(1, 750, __pyx_L1_error) - - /* "View.MemoryView":748 - * - * for dim, index in enumerate(indices): - * if PyIndex_Check(index): # <<<<<<<<<<<<<< - * cindex = index - * slice_memviewslice( - */ - goto __pyx_L6; - } - - /* "View.MemoryView":756 - * 0, 0, 0, # have_{start,stop,step} - * False) - * elif index is None: # <<<<<<<<<<<<<< - * p_dst.shape[new_ndim] = 1 - * p_dst.strides[new_ndim] = 0 - */ - __pyx_t_1 = (__pyx_v_index == Py_None); - if (__pyx_t_1) { - - /* "View.MemoryView":757 - * False) - * elif index is None: - * p_dst.shape[new_ndim] = 1 # <<<<<<<<<<<<<< - * p_dst.strides[new_ndim] = 0 - * p_dst.suboffsets[new_ndim] = -1 - */ - (__pyx_v_p_dst->shape[__pyx_v_new_ndim]) = 1; - - /* "View.MemoryView":758 - * elif index is None: - * p_dst.shape[new_ndim] = 1 - * p_dst.strides[new_ndim] = 0 # <<<<<<<<<<<<<< - * p_dst.suboffsets[new_ndim] = -1 - * new_ndim += 1 - */ - (__pyx_v_p_dst->strides[__pyx_v_new_ndim]) = 0; - - /* "View.MemoryView":759 - * p_dst.shape[new_ndim] = 1 - * p_dst.strides[new_ndim] = 0 - * p_dst.suboffsets[new_ndim] = -1 # <<<<<<<<<<<<<< - * new_ndim += 1 - * else: - */ - (__pyx_v_p_dst->suboffsets[__pyx_v_new_ndim]) = -1L; - - /* "View.MemoryView":760 - * p_dst.strides[new_ndim] = 0 - * p_dst.suboffsets[new_ndim] = -1 - * new_ndim += 1 # <<<<<<<<<<<<<< - * else: - * start = index.start or 0 - */ - __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); - - /* "View.MemoryView":756 - * 0, 0, 0, # have_{start,stop,step} - * False) - * elif index is None: # <<<<<<<<<<<<<< - * p_dst.shape[new_ndim] = 1 - * p_dst.strides[new_ndim] = 0 - */ - goto __pyx_L6; - } - - /* "View.MemoryView":762 - * new_ndim += 1 - * else: - * start = index.start or 0 # <<<<<<<<<<<<<< - * stop = index.stop or 0 - * step = index.step or 0 - */ - /*else*/ { - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 762, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 762, __pyx_L1_error) - if (!__pyx_t_1) { - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - } else { - __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_t_8); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 762, __pyx_L1_error) - __pyx_t_9 = __pyx_t_11; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - goto __pyx_L7_bool_binop_done; - } - __pyx_t_9 = 0; - __pyx_L7_bool_binop_done:; - __pyx_v_start = __pyx_t_9; - - /* "View.MemoryView":763 - * else: - * start = index.start or 0 - * stop = index.stop or 0 # <<<<<<<<<<<<<< - * step = index.step or 0 - * - */ - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 763, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 763, __pyx_L1_error) - if (!__pyx_t_1) { - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - } else { - __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_t_8); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 763, __pyx_L1_error) - __pyx_t_9 = __pyx_t_11; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - goto __pyx_L9_bool_binop_done; - } - __pyx_t_9 = 0; - __pyx_L9_bool_binop_done:; - __pyx_v_stop = __pyx_t_9; - - /* "View.MemoryView":764 - * start = index.start or 0 - * stop = index.stop or 0 - * step = index.step or 0 # <<<<<<<<<<<<<< - * - * have_start = index.start is not None - */ - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 764, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 764, __pyx_L1_error) - if (!__pyx_t_1) { - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - } else { - __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_t_8); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 764, __pyx_L1_error) - __pyx_t_9 = __pyx_t_11; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - goto __pyx_L11_bool_binop_done; - } - __pyx_t_9 = 0; - __pyx_L11_bool_binop_done:; - __pyx_v_step = __pyx_t_9; - - /* "View.MemoryView":766 - * 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_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 766, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_1 = (__pyx_t_8 != Py_None); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_v_have_start = __pyx_t_1; - - /* "View.MemoryView":767 - * - * have_start = index.start is not None - * have_stop = index.stop is not None # <<<<<<<<<<<<<< - * have_step = index.step is not None - * - */ - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 767, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_1 = (__pyx_t_8 != Py_None); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_v_have_stop = __pyx_t_1; - - /* "View.MemoryView":768 - * 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_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 768, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_1 = (__pyx_t_8 != Py_None); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_v_have_step = __pyx_t_1; - - /* "View.MemoryView":770 - * 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_10 = __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_10 == ((int)-1))) __PYX_ERR(1, 770, __pyx_L1_error) - - /* "View.MemoryView":776 - * have_start, have_stop, have_step, - * True) - * new_ndim += 1 # <<<<<<<<<<<<<< - * - * if isinstance(memview, _memoryviewslice): - */ - __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); - } - __pyx_L6:; - - /* "View.MemoryView":747 - * cdef bint have_start, have_stop, have_step - * - * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< - * if PyIndex_Check(index): - * cindex = index - */ - } - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "View.MemoryView":778 - * new_ndim += 1 - * - * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< - * return memoryview_fromslice(dst, new_ndim, - * memviewsliceobj.to_object_func, - */ - __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); - if (__pyx_t_1) { - - /* "View.MemoryView":779 - * - * if isinstance(memview, _memoryviewslice): - * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< - * memviewsliceobj.to_object_func, - * memviewsliceobj.to_dtype_func, - */ - __Pyx_XDECREF((PyObject *)__pyx_r); - - /* "View.MemoryView":780 - * 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(1, 780, __pyx_L1_error) } - - /* "View.MemoryView":781 - * 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(1, 781, __pyx_L1_error) } - - /* "View.MemoryView":779 - * - * if isinstance(memview, _memoryviewslice): - * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< - * memviewsliceobj.to_object_func, - * memviewsliceobj.to_dtype_func, - */ - __pyx_t_2 = __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_2)) __PYX_ERR(1, 779, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_memoryview_type))))) __PYX_ERR(1, 779, __pyx_L1_error) - __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_2); - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":778 - * new_ndim += 1 - * - * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< - * return memoryview_fromslice(dst, new_ndim, - * memviewsliceobj.to_object_func, - */ - } - - /* "View.MemoryView":784 - * memview.dtype_is_object) - * else: - * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< - * memview.dtype_is_object) - * - */ - /*else*/ { - __Pyx_XDECREF((PyObject *)__pyx_r); - - /* "View.MemoryView":785 - * else: - * return memoryview_fromslice(dst, new_ndim, NULL, NULL, - * memview.dtype_is_object) # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_2 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, NULL, NULL, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 784, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - - /* "View.MemoryView":784 - * memview.dtype_is_object) - * else: - * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< - * memview.dtype_is_object) - * - */ - if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_memoryview_type))))) __PYX_ERR(1, 784, __pyx_L1_error) - __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_2); - __pyx_t_2 = 0; - goto __pyx_L0; - } - - /* "View.MemoryView":711 - * - * @cname('__pyx_memview_slice') - * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< - * cdef int new_ndim = 0, suboffset_dim = -1, dim - * cdef bint negative_step - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("View.MemoryView.memview_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_memviewsliceobj); - __Pyx_XDECREF(__pyx_v_index); - __Pyx_XGIVEREF((PyObject *)__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":793 - * - * @cname('__pyx_memoryview_slice_memviewslice') - * cdef int slice_memviewslice( # <<<<<<<<<<<<<< - * __Pyx_memviewslice *dst, - * Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, - */ - -static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, Py_ssize_t __pyx_v_shape, Py_ssize_t __pyx_v_stride, Py_ssize_t __pyx_v_suboffset, int __pyx_v_dim, int __pyx_v_new_ndim, int *__pyx_v_suboffset_dim, Py_ssize_t __pyx_v_start, Py_ssize_t __pyx_v_stop, Py_ssize_t __pyx_v_step, int __pyx_v_have_start, int __pyx_v_have_stop, int __pyx_v_have_step, int __pyx_v_is_slice) { - Py_ssize_t __pyx_v_new_shape; - int __pyx_v_negative_step; - int __pyx_r; - 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; - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save; - #endif - - /* "View.MemoryView":813 - * cdef bint negative_step - * - * if not is_slice: # <<<<<<<<<<<<<< - * - * if start < 0: - */ - __pyx_t_1 = (!__pyx_v_is_slice); - if (__pyx_t_1) { - - /* "View.MemoryView":815 - * if not is_slice: - * - * if start < 0: # <<<<<<<<<<<<<< - * start += shape - * if not 0 <= start < shape: - */ - __pyx_t_1 = (__pyx_v_start < 0); - if (__pyx_t_1) { - - /* "View.MemoryView":816 - * - * if start < 0: - * start += shape # <<<<<<<<<<<<<< - * if not 0 <= start < shape: - * _err_dim(PyExc_IndexError, "Index out of bounds (axis %d)", dim) - */ - __pyx_v_start = (__pyx_v_start + __pyx_v_shape); - - /* "View.MemoryView":815 - * if not is_slice: - * - * if start < 0: # <<<<<<<<<<<<<< - * start += shape - * if not 0 <= start < shape: - */ - } - - /* "View.MemoryView":817 - * if start < 0: - * start += shape - * if not 0 <= start < shape: # <<<<<<<<<<<<<< - * _err_dim(PyExc_IndexError, "Index out of bounds (axis %d)", dim) - * else: - */ - __pyx_t_1 = (0 <= __pyx_v_start); - if (__pyx_t_1) { - __pyx_t_1 = (__pyx_v_start < __pyx_v_shape); - } - __pyx_t_2 = (!__pyx_t_1); - if (__pyx_t_2) { - - /* "View.MemoryView":818 - * start += shape - * if not 0 <= start < shape: - * _err_dim(PyExc_IndexError, "Index out of bounds (axis %d)", dim) # <<<<<<<<<<<<<< - * else: - * - */ - __pyx_t_3 = __pyx_memoryview_err_dim(PyExc_IndexError, __pyx_kp_s_Index_out_of_bounds_axis_d, __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 818, __pyx_L1_error) - - /* "View.MemoryView":817 - * if start < 0: - * start += shape - * if not 0 <= start < shape: # <<<<<<<<<<<<<< - * _err_dim(PyExc_IndexError, "Index out of bounds (axis %d)", dim) - * else: - */ - } - - /* "View.MemoryView":813 - * cdef bint negative_step - * - * if not is_slice: # <<<<<<<<<<<<<< - * - * if start < 0: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":821 - * else: - * - * if have_step: # <<<<<<<<<<<<<< - * negative_step = step < 0 - * if step == 0: - */ - /*else*/ { - __pyx_t_2 = (__pyx_v_have_step != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":822 - * - * if have_step: - * negative_step = step < 0 # <<<<<<<<<<<<<< - * if step == 0: - * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) - */ - __pyx_v_negative_step = (__pyx_v_step < 0); - - /* "View.MemoryView":823 - * if have_step: - * negative_step = step < 0 - * if step == 0: # <<<<<<<<<<<<<< - * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) - * else: - */ - __pyx_t_2 = (__pyx_v_step == 0); - if (__pyx_t_2) { - - /* "View.MemoryView":824 - * negative_step = step < 0 - * if step == 0: - * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) # <<<<<<<<<<<<<< - * else: - * negative_step = False - */ - __pyx_t_3 = __pyx_memoryview_err_dim(PyExc_ValueError, __pyx_kp_s_Step_may_not_be_zero_axis_d, __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 824, __pyx_L1_error) - - /* "View.MemoryView":823 - * if have_step: - * negative_step = step < 0 - * if step == 0: # <<<<<<<<<<<<<< - * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) - * else: - */ - } - - /* "View.MemoryView":821 - * else: - * - * if have_step: # <<<<<<<<<<<<<< - * negative_step = step < 0 - * if step == 0: - */ - goto __pyx_L6; - } - - /* "View.MemoryView":826 - * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) - * else: - * negative_step = False # <<<<<<<<<<<<<< - * step = 1 - * - */ - /*else*/ { - __pyx_v_negative_step = 0; - - /* "View.MemoryView":827 - * else: - * negative_step = False - * step = 1 # <<<<<<<<<<<<<< - * - * - */ - __pyx_v_step = 1; - } - __pyx_L6:; - - /* "View.MemoryView":830 - * - * - * if have_start: # <<<<<<<<<<<<<< - * if start < 0: - * start += shape - */ - __pyx_t_2 = (__pyx_v_have_start != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":831 - * - * if have_start: - * if start < 0: # <<<<<<<<<<<<<< - * start += shape - * if start < 0: - */ - __pyx_t_2 = (__pyx_v_start < 0); - if (__pyx_t_2) { - - /* "View.MemoryView":832 - * if have_start: - * if start < 0: - * start += shape # <<<<<<<<<<<<<< - * if start < 0: - * start = 0 - */ - __pyx_v_start = (__pyx_v_start + __pyx_v_shape); - - /* "View.MemoryView":833 - * if start < 0: - * start += shape - * if start < 0: # <<<<<<<<<<<<<< - * start = 0 - * elif start >= shape: - */ - __pyx_t_2 = (__pyx_v_start < 0); - if (__pyx_t_2) { - - /* "View.MemoryView":834 - * start += shape - * if start < 0: - * start = 0 # <<<<<<<<<<<<<< - * elif start >= shape: - * if negative_step: - */ - __pyx_v_start = 0; - - /* "View.MemoryView":833 - * if start < 0: - * start += shape - * if start < 0: # <<<<<<<<<<<<<< - * start = 0 - * elif start >= shape: - */ - } - - /* "View.MemoryView":831 - * - * if have_start: - * if start < 0: # <<<<<<<<<<<<<< - * start += shape - * if start < 0: - */ - goto __pyx_L9; - } - - /* "View.MemoryView":835 - * if start < 0: - * start = 0 - * elif start >= shape: # <<<<<<<<<<<<<< - * if negative_step: - * start = shape - 1 - */ - __pyx_t_2 = (__pyx_v_start >= __pyx_v_shape); - if (__pyx_t_2) { - - /* "View.MemoryView":836 - * start = 0 - * elif start >= shape: - * if negative_step: # <<<<<<<<<<<<<< - * start = shape - 1 - * else: - */ - if (__pyx_v_negative_step) { - - /* "View.MemoryView":837 - * elif start >= shape: - * if negative_step: - * start = shape - 1 # <<<<<<<<<<<<<< - * else: - * start = shape - */ - __pyx_v_start = (__pyx_v_shape - 1); - - /* "View.MemoryView":836 - * start = 0 - * elif start >= shape: - * if negative_step: # <<<<<<<<<<<<<< - * start = shape - 1 - * else: - */ - goto __pyx_L11; - } - - /* "View.MemoryView":839 - * start = shape - 1 - * else: - * start = shape # <<<<<<<<<<<<<< - * else: - * if negative_step: - */ - /*else*/ { - __pyx_v_start = __pyx_v_shape; - } - __pyx_L11:; - - /* "View.MemoryView":835 - * if start < 0: - * start = 0 - * elif start >= shape: # <<<<<<<<<<<<<< - * if negative_step: - * start = shape - 1 - */ - } - __pyx_L9:; - - /* "View.MemoryView":830 - * - * - * if have_start: # <<<<<<<<<<<<<< - * if start < 0: - * start += shape - */ - goto __pyx_L8; - } - - /* "View.MemoryView":841 - * start = shape - * else: - * if negative_step: # <<<<<<<<<<<<<< - * start = shape - 1 - * else: - */ - /*else*/ { - if (__pyx_v_negative_step) { - - /* "View.MemoryView":842 - * else: - * if negative_step: - * start = shape - 1 # <<<<<<<<<<<<<< - * else: - * start = 0 - */ - __pyx_v_start = (__pyx_v_shape - 1); - - /* "View.MemoryView":841 - * start = shape - * else: - * if negative_step: # <<<<<<<<<<<<<< - * start = shape - 1 - * else: - */ - goto __pyx_L12; - } - - /* "View.MemoryView":844 - * start = shape - 1 - * else: - * start = 0 # <<<<<<<<<<<<<< - * - * if have_stop: - */ - /*else*/ { - __pyx_v_start = 0; - } - __pyx_L12:; - } - __pyx_L8:; - - /* "View.MemoryView":846 - * start = 0 - * - * if have_stop: # <<<<<<<<<<<<<< - * if stop < 0: - * stop += shape - */ - __pyx_t_2 = (__pyx_v_have_stop != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":847 - * - * if have_stop: - * if stop < 0: # <<<<<<<<<<<<<< - * stop += shape - * if stop < 0: - */ - __pyx_t_2 = (__pyx_v_stop < 0); - if (__pyx_t_2) { - - /* "View.MemoryView":848 - * if have_stop: - * if stop < 0: - * stop += shape # <<<<<<<<<<<<<< - * if stop < 0: - * stop = 0 - */ - __pyx_v_stop = (__pyx_v_stop + __pyx_v_shape); - - /* "View.MemoryView":849 - * if stop < 0: - * stop += shape - * if stop < 0: # <<<<<<<<<<<<<< - * stop = 0 - * elif stop > shape: - */ - __pyx_t_2 = (__pyx_v_stop < 0); - if (__pyx_t_2) { - - /* "View.MemoryView":850 - * stop += shape - * if stop < 0: - * stop = 0 # <<<<<<<<<<<<<< - * elif stop > shape: - * stop = shape - */ - __pyx_v_stop = 0; - - /* "View.MemoryView":849 - * if stop < 0: - * stop += shape - * if stop < 0: # <<<<<<<<<<<<<< - * stop = 0 - * elif stop > shape: - */ - } - - /* "View.MemoryView":847 - * - * if have_stop: - * if stop < 0: # <<<<<<<<<<<<<< - * stop += shape - * if stop < 0: - */ - goto __pyx_L14; - } - - /* "View.MemoryView":851 - * if stop < 0: - * stop = 0 - * elif stop > shape: # <<<<<<<<<<<<<< - * stop = shape - * else: - */ - __pyx_t_2 = (__pyx_v_stop > __pyx_v_shape); - if (__pyx_t_2) { - - /* "View.MemoryView":852 - * stop = 0 - * elif stop > shape: - * stop = shape # <<<<<<<<<<<<<< - * else: - * if negative_step: - */ - __pyx_v_stop = __pyx_v_shape; - - /* "View.MemoryView":851 - * if stop < 0: - * stop = 0 - * elif stop > shape: # <<<<<<<<<<<<<< - * stop = shape - * else: - */ - } - __pyx_L14:; - - /* "View.MemoryView":846 - * start = 0 - * - * if have_stop: # <<<<<<<<<<<<<< - * if stop < 0: - * stop += shape - */ - goto __pyx_L13; - } - - /* "View.MemoryView":854 - * stop = shape - * else: - * if negative_step: # <<<<<<<<<<<<<< - * stop = -1 - * else: - */ - /*else*/ { - if (__pyx_v_negative_step) { - - /* "View.MemoryView":855 - * else: - * if negative_step: - * stop = -1 # <<<<<<<<<<<<<< - * else: - * stop = shape - */ - __pyx_v_stop = -1L; - - /* "View.MemoryView":854 - * stop = shape - * else: - * if negative_step: # <<<<<<<<<<<<<< - * stop = -1 - * else: - */ - goto __pyx_L16; - } - - /* "View.MemoryView":857 - * stop = -1 - * else: - * stop = shape # <<<<<<<<<<<<<< - * - * - */ - /*else*/ { - __pyx_v_stop = __pyx_v_shape; - } - __pyx_L16:; - } - __pyx_L13:; - - /* "View.MemoryView":861 - * - * with cython.cdivision(True): - * new_shape = (stop - start) // step # <<<<<<<<<<<<<< - * - * if (stop - start) - step * new_shape: - */ - __pyx_v_new_shape = ((__pyx_v_stop - __pyx_v_start) / __pyx_v_step); - - /* "View.MemoryView":863 - * new_shape = (stop - start) // step - * - * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< - * new_shape += 1 - * - */ - __pyx_t_2 = (((__pyx_v_stop - __pyx_v_start) - (__pyx_v_step * __pyx_v_new_shape)) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":864 - * - * if (stop - start) - step * new_shape: - * new_shape += 1 # <<<<<<<<<<<<<< - * - * if new_shape < 0: - */ - __pyx_v_new_shape = (__pyx_v_new_shape + 1); - - /* "View.MemoryView":863 - * new_shape = (stop - start) // step - * - * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< - * new_shape += 1 - * - */ - } - - /* "View.MemoryView":866 - * new_shape += 1 - * - * if new_shape < 0: # <<<<<<<<<<<<<< - * new_shape = 0 - * - */ - __pyx_t_2 = (__pyx_v_new_shape < 0); - if (__pyx_t_2) { - - /* "View.MemoryView":867 - * - * if new_shape < 0: - * new_shape = 0 # <<<<<<<<<<<<<< - * - * - */ - __pyx_v_new_shape = 0; - - /* "View.MemoryView":866 - * new_shape += 1 - * - * if new_shape < 0: # <<<<<<<<<<<<<< - * new_shape = 0 - * - */ - } - - /* "View.MemoryView":870 - * - * - * dst.strides[new_ndim] = stride * step # <<<<<<<<<<<<<< - * dst.shape[new_ndim] = new_shape - * dst.suboffsets[new_ndim] = suboffset - */ - (__pyx_v_dst->strides[__pyx_v_new_ndim]) = (__pyx_v_stride * __pyx_v_step); - - /* "View.MemoryView":871 - * - * dst.strides[new_ndim] = stride * step - * dst.shape[new_ndim] = new_shape # <<<<<<<<<<<<<< - * dst.suboffsets[new_ndim] = suboffset - * - */ - (__pyx_v_dst->shape[__pyx_v_new_ndim]) = __pyx_v_new_shape; - - /* "View.MemoryView":872 - * dst.strides[new_ndim] = stride * step - * dst.shape[new_ndim] = new_shape - * dst.suboffsets[new_ndim] = suboffset # <<<<<<<<<<<<<< - * - * - */ - (__pyx_v_dst->suboffsets[__pyx_v_new_ndim]) = __pyx_v_suboffset; - } - __pyx_L3:; - - /* "View.MemoryView":875 - * - * - * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< - * dst.data += start * stride - * else: - */ - __pyx_t_2 = ((__pyx_v_suboffset_dim[0]) < 0); - if (__pyx_t_2) { - - /* "View.MemoryView":876 - * - * if suboffset_dim[0] < 0: - * dst.data += start * stride # <<<<<<<<<<<<<< - * else: - * dst.suboffsets[suboffset_dim[0]] += start * stride - */ - __pyx_v_dst->data = (__pyx_v_dst->data + (__pyx_v_start * __pyx_v_stride)); - - /* "View.MemoryView":875 - * - * - * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< - * dst.data += start * stride - * else: - */ - goto __pyx_L19; - } - - /* "View.MemoryView":878 - * dst.data += start * stride - * else: - * dst.suboffsets[suboffset_dim[0]] += start * stride # <<<<<<<<<<<<<< - * - * if suboffset >= 0: - */ - /*else*/ { - __pyx_t_3 = (__pyx_v_suboffset_dim[0]); - (__pyx_v_dst->suboffsets[__pyx_t_3]) = ((__pyx_v_dst->suboffsets[__pyx_t_3]) + (__pyx_v_start * __pyx_v_stride)); - } - __pyx_L19:; - - /* "View.MemoryView":880 - * dst.suboffsets[suboffset_dim[0]] += start * stride - * - * if suboffset >= 0: # <<<<<<<<<<<<<< - * if not is_slice: - * if new_ndim == 0: - */ - __pyx_t_2 = (__pyx_v_suboffset >= 0); - if (__pyx_t_2) { - - /* "View.MemoryView":881 - * - * if suboffset >= 0: - * if not is_slice: # <<<<<<<<<<<<<< - * if new_ndim == 0: - * dst.data = ( dst.data)[0] + suboffset - */ - __pyx_t_2 = (!__pyx_v_is_slice); - if (__pyx_t_2) { - - /* "View.MemoryView":882 - * if suboffset >= 0: - * if not is_slice: - * if new_ndim == 0: # <<<<<<<<<<<<<< - * dst.data = ( dst.data)[0] + suboffset - * else: - */ - __pyx_t_2 = (__pyx_v_new_ndim == 0); - if (__pyx_t_2) { - - /* "View.MemoryView":883 - * if not is_slice: - * if new_ndim == 0: - * dst.data = ( dst.data)[0] + suboffset # <<<<<<<<<<<<<< - * else: - * _err_dim(PyExc_IndexError, "All dimensions preceding dimension %d " - */ - __pyx_v_dst->data = ((((char **)__pyx_v_dst->data)[0]) + __pyx_v_suboffset); - - /* "View.MemoryView":882 - * if suboffset >= 0: - * if not is_slice: - * if new_ndim == 0: # <<<<<<<<<<<<<< - * dst.data = ( dst.data)[0] + suboffset - * else: - */ - goto __pyx_L22; - } - - /* "View.MemoryView":885 - * dst.data = ( dst.data)[0] + suboffset - * else: - * _err_dim(PyExc_IndexError, "All dimensions preceding dimension %d " # <<<<<<<<<<<<<< - * "must be indexed and not sliced", dim) - * else: - */ - /*else*/ { - - /* "View.MemoryView":886 - * else: - * _err_dim(PyExc_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(PyExc_IndexError, __pyx_kp_s_All_dimensions_preceding_dimensi, __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 885, __pyx_L1_error) - } - __pyx_L22:; - - /* "View.MemoryView":881 - * - * if suboffset >= 0: - * if not is_slice: # <<<<<<<<<<<<<< - * if new_ndim == 0: - * dst.data = ( dst.data)[0] + suboffset - */ - goto __pyx_L21; - } - - /* "View.MemoryView":888 - * "must be indexed and not sliced", dim) - * else: - * suboffset_dim[0] = new_ndim # <<<<<<<<<<<<<< - * - * return 0 - */ - /*else*/ { - (__pyx_v_suboffset_dim[0]) = __pyx_v_new_ndim; - } - __pyx_L21:; - - /* "View.MemoryView":880 - * dst.suboffsets[suboffset_dim[0]] += start * stride - * - * if suboffset >= 0: # <<<<<<<<<<<<<< - * if not is_slice: - * if new_ndim == 0: - */ - } - - /* "View.MemoryView":890 - * suboffset_dim[0] = new_ndim - * - * return 0 # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = 0; - goto __pyx_L0; - - /* "View.MemoryView":793 - * - * @cname('__pyx_memoryview_slice_memviewslice') - * cdef int slice_memviewslice( # <<<<<<<<<<<<<< - * __Pyx_memviewslice *dst, - * Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, - */ - - /* function exit code */ - __pyx_L1_error:; - #ifdef WITH_THREAD - __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_AddTraceback("View.MemoryView.slice_memviewslice", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":896 - * - * @cname('__pyx_pybuffer_index') - * 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 - */ - -static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, Py_ssize_t __pyx_v_index, Py_ssize_t __pyx_v_dim) { - Py_ssize_t __pyx_v_shape; - Py_ssize_t __pyx_v_stride; - Py_ssize_t __pyx_v_suboffset; - Py_ssize_t __pyx_v_itemsize; - char *__pyx_v_resultp; - char *__pyx_r; - __Pyx_RefNannyDeclarations - Py_ssize_t __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - Py_UCS4 __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("pybuffer_index", 1); - - /* "View.MemoryView":898 - * 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 # <<<<<<<<<<<<<< - * cdef Py_ssize_t itemsize = view.itemsize - * cdef char *resultp - */ - __pyx_v_suboffset = -1L; - - /* "View.MemoryView":899 - * Py_ssize_t dim) except NULL: - * cdef Py_ssize_t shape, stride, suboffset = -1 - * cdef Py_ssize_t itemsize = view.itemsize # <<<<<<<<<<<<<< - * cdef char *resultp - * - */ - __pyx_t_1 = __pyx_v_view->itemsize; - __pyx_v_itemsize = __pyx_t_1; - - /* "View.MemoryView":902 - * cdef char *resultp - * - * if view.ndim == 0: # <<<<<<<<<<<<<< - * shape = view.len // itemsize - * stride = itemsize - */ - __pyx_t_2 = (__pyx_v_view->ndim == 0); - if (__pyx_t_2) { - - /* "View.MemoryView":903 - * - * if view.ndim == 0: - * shape = view.len // itemsize # <<<<<<<<<<<<<< - * stride = itemsize - * else: - */ - if (unlikely(__pyx_v_itemsize == 0)) { - PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); - __PYX_ERR(1, 903, __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(__Pyx_UNARY_NEG_WOULD_OVERFLOW(__pyx_v_view->len))) { - PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); - __PYX_ERR(1, 903, __pyx_L1_error) - } - __pyx_v_shape = __Pyx_div_Py_ssize_t(__pyx_v_view->len, __pyx_v_itemsize); - - /* "View.MemoryView":904 - * if view.ndim == 0: - * shape = view.len // itemsize - * stride = itemsize # <<<<<<<<<<<<<< - * else: - * shape = view.shape[dim] - */ - __pyx_v_stride = __pyx_v_itemsize; - - /* "View.MemoryView":902 - * cdef char *resultp - * - * if view.ndim == 0: # <<<<<<<<<<<<<< - * shape = view.len // itemsize - * stride = itemsize - */ - goto __pyx_L3; - } - - /* "View.MemoryView":906 - * stride = itemsize - * else: - * shape = view.shape[dim] # <<<<<<<<<<<<<< - * stride = view.strides[dim] - * if view.suboffsets != NULL: - */ - /*else*/ { - __pyx_v_shape = (__pyx_v_view->shape[__pyx_v_dim]); - - /* "View.MemoryView":907 - * else: - * shape = view.shape[dim] - * stride = view.strides[dim] # <<<<<<<<<<<<<< - * if view.suboffsets != NULL: - * suboffset = view.suboffsets[dim] - */ - __pyx_v_stride = (__pyx_v_view->strides[__pyx_v_dim]); - - /* "View.MemoryView":908 - * shape = view.shape[dim] - * stride = view.strides[dim] - * if view.suboffsets != NULL: # <<<<<<<<<<<<<< - * suboffset = view.suboffsets[dim] - * - */ - __pyx_t_2 = (__pyx_v_view->suboffsets != NULL); - if (__pyx_t_2) { - - /* "View.MemoryView":909 - * stride = view.strides[dim] - * if view.suboffsets != NULL: - * suboffset = view.suboffsets[dim] # <<<<<<<<<<<<<< - * - * if index < 0: - */ - __pyx_v_suboffset = (__pyx_v_view->suboffsets[__pyx_v_dim]); - - /* "View.MemoryView":908 - * shape = view.shape[dim] - * stride = view.strides[dim] - * if view.suboffsets != NULL: # <<<<<<<<<<<<<< - * suboffset = view.suboffsets[dim] - * - */ - } - } - __pyx_L3:; - - /* "View.MemoryView":911 - * suboffset = view.suboffsets[dim] - * - * if index < 0: # <<<<<<<<<<<<<< - * index += view.shape[dim] - * if index < 0: - */ - __pyx_t_2 = (__pyx_v_index < 0); - if (__pyx_t_2) { - - /* "View.MemoryView":912 - * - * if index < 0: - * index += view.shape[dim] # <<<<<<<<<<<<<< - * if index < 0: - * raise IndexError, f"Out of bounds on buffer access (axis {dim})" - */ - __pyx_v_index = (__pyx_v_index + (__pyx_v_view->shape[__pyx_v_dim])); - - /* "View.MemoryView":913 - * if index < 0: - * index += view.shape[dim] - * if index < 0: # <<<<<<<<<<<<<< - * raise IndexError, f"Out of bounds on buffer access (axis {dim})" - * - */ - __pyx_t_2 = (__pyx_v_index < 0); - if (unlikely(__pyx_t_2)) { - - /* "View.MemoryView":914 - * index += view.shape[dim] - * if index < 0: - * raise IndexError, f"Out of bounds on buffer access (axis {dim})" # <<<<<<<<<<<<<< - * - * if index >= shape: - */ - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 914, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = 0; - __pyx_t_4 = 127; - __Pyx_INCREF(__pyx_kp_u_Out_of_bounds_on_buffer_access_a); - __pyx_t_1 += 37; - __Pyx_GIVEREF(__pyx_kp_u_Out_of_bounds_on_buffer_access_a); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_Out_of_bounds_on_buffer_access_a); - __pyx_t_5 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_dim, 0, ' ', 'd'); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 914, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_5); - __pyx_t_5 = 0; - __Pyx_INCREF(__pyx_kp_u__7); - __pyx_t_1 += 1; - __Pyx_GIVEREF(__pyx_kp_u__7); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__7); - __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 914, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_builtin_IndexError, __pyx_t_5, 0, 0); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __PYX_ERR(1, 914, __pyx_L1_error) - - /* "View.MemoryView":913 - * if index < 0: - * index += view.shape[dim] - * if index < 0: # <<<<<<<<<<<<<< - * raise IndexError, f"Out of bounds on buffer access (axis {dim})" - * - */ - } - - /* "View.MemoryView":911 - * suboffset = view.suboffsets[dim] - * - * if index < 0: # <<<<<<<<<<<<<< - * index += view.shape[dim] - * if index < 0: - */ - } - - /* "View.MemoryView":916 - * raise IndexError, f"Out of bounds on buffer access (axis {dim})" - * - * if index >= shape: # <<<<<<<<<<<<<< - * raise IndexError, f"Out of bounds on buffer access (axis {dim})" - * - */ - __pyx_t_2 = (__pyx_v_index >= __pyx_v_shape); - if (unlikely(__pyx_t_2)) { - - /* "View.MemoryView":917 - * - * if index >= shape: - * raise IndexError, f"Out of bounds on buffer access (axis {dim})" # <<<<<<<<<<<<<< - * - * resultp = bufp + index * stride - */ - __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 917, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = 0; - __pyx_t_4 = 127; - __Pyx_INCREF(__pyx_kp_u_Out_of_bounds_on_buffer_access_a); - __pyx_t_1 += 37; - __Pyx_GIVEREF(__pyx_kp_u_Out_of_bounds_on_buffer_access_a); - PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_kp_u_Out_of_bounds_on_buffer_access_a); - __pyx_t_3 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_dim, 0, ' ', 'd'); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 917, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3); - __pyx_t_3 = 0; - __Pyx_INCREF(__pyx_kp_u__7); - __pyx_t_1 += 1; - __Pyx_GIVEREF(__pyx_kp_u__7); - PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_kp_u__7); - __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_5, 3, __pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 917, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_Raise(__pyx_builtin_IndexError, __pyx_t_3, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 917, __pyx_L1_error) - - /* "View.MemoryView":916 - * raise IndexError, f"Out of bounds on buffer access (axis {dim})" - * - * if index >= shape: # <<<<<<<<<<<<<< - * raise IndexError, f"Out of bounds on buffer access (axis {dim})" - * - */ - } - - /* "View.MemoryView":919 - * raise IndexError, f"Out of bounds on buffer access (axis {dim})" - * - * resultp = bufp + index * stride # <<<<<<<<<<<<<< - * if suboffset >= 0: - * resultp = ( resultp)[0] + suboffset - */ - __pyx_v_resultp = (__pyx_v_bufp + (__pyx_v_index * __pyx_v_stride)); - - /* "View.MemoryView":920 - * - * resultp = bufp + index * stride - * if suboffset >= 0: # <<<<<<<<<<<<<< - * resultp = ( resultp)[0] + suboffset - * - */ - __pyx_t_2 = (__pyx_v_suboffset >= 0); - if (__pyx_t_2) { - - /* "View.MemoryView":921 - * resultp = bufp + index * stride - * if suboffset >= 0: - * resultp = ( resultp)[0] + suboffset # <<<<<<<<<<<<<< - * - * return resultp - */ - __pyx_v_resultp = ((((char **)__pyx_v_resultp)[0]) + __pyx_v_suboffset); - - /* "View.MemoryView":920 - * - * resultp = bufp + index * stride - * if suboffset >= 0: # <<<<<<<<<<<<<< - * resultp = ( resultp)[0] + suboffset - * - */ - } - - /* "View.MemoryView":923 - * resultp = ( resultp)[0] + suboffset - * - * return resultp # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = __pyx_v_resultp; - goto __pyx_L0; - - /* "View.MemoryView":896 - * - * @cname('__pyx_pybuffer_index') - * 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 - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("View.MemoryView.pybuffer_index", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":929 - * - * @cname('__pyx_memslice_transpose') - * cdef int transpose_memslice(__Pyx_memviewslice *memslice) except -1 nogil: # <<<<<<<<<<<<<< - * cdef int ndim = memslice.memview.view.ndim - * - */ - -static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { - int __pyx_v_ndim; - Py_ssize_t *__pyx_v_shape; - Py_ssize_t *__pyx_v_strides; - int __pyx_v_i; - int __pyx_v_j; - int __pyx_r; - int __pyx_t_1; - Py_ssize_t *__pyx_t_2; - long __pyx_t_3; - long __pyx_t_4; - Py_ssize_t __pyx_t_5; - Py_ssize_t __pyx_t_6; - 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; - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save; - #endif - - /* "View.MemoryView":930 - * @cname('__pyx_memslice_transpose') - * cdef int transpose_memslice(__Pyx_memviewslice *memslice) except -1 nogil: - * cdef int ndim = memslice.memview.view.ndim # <<<<<<<<<<<<<< - * - * cdef Py_ssize_t *shape = memslice.shape - */ - __pyx_t_1 = __pyx_v_memslice->memview->view.ndim; - __pyx_v_ndim = __pyx_t_1; - - /* "View.MemoryView":932 - * cdef int ndim = memslice.memview.view.ndim - * - * cdef Py_ssize_t *shape = memslice.shape # <<<<<<<<<<<<<< - * cdef Py_ssize_t *strides = memslice.strides - * - */ - __pyx_t_2 = __pyx_v_memslice->shape; - __pyx_v_shape = __pyx_t_2; - - /* "View.MemoryView":933 - * - * cdef Py_ssize_t *shape = memslice.shape - * cdef Py_ssize_t *strides = memslice.strides # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_2 = __pyx_v_memslice->strides; - __pyx_v_strides = __pyx_t_2; - - /* "View.MemoryView":937 - * - * cdef int i, j - * for i in range(ndim // 2): # <<<<<<<<<<<<<< - * j = ndim - 1 - i - * strides[i], strides[j] = strides[j], strides[i] - */ - __pyx_t_3 = __Pyx_div_long(__pyx_v_ndim, 2); - __pyx_t_4 = __pyx_t_3; - for (__pyx_t_1 = 0; __pyx_t_1 < __pyx_t_4; __pyx_t_1+=1) { - __pyx_v_i = __pyx_t_1; - - /* "View.MemoryView":938 - * cdef int i, j - * for i in range(ndim // 2): - * j = ndim - 1 - i # <<<<<<<<<<<<<< - * strides[i], strides[j] = strides[j], strides[i] - * shape[i], shape[j] = shape[j], shape[i] - */ - __pyx_v_j = ((__pyx_v_ndim - 1) - __pyx_v_i); - - /* "View.MemoryView":939 - * for i in range(ndim // 2): - * j = ndim - 1 - i - * strides[i], strides[j] = strides[j], strides[i] # <<<<<<<<<<<<<< - * shape[i], shape[j] = shape[j], shape[i] - * - */ - __pyx_t_5 = (__pyx_v_strides[__pyx_v_j]); - __pyx_t_6 = (__pyx_v_strides[__pyx_v_i]); - (__pyx_v_strides[__pyx_v_i]) = __pyx_t_5; - (__pyx_v_strides[__pyx_v_j]) = __pyx_t_6; - - /* "View.MemoryView":940 - * j = ndim - 1 - i - * strides[i], strides[j] = strides[j], strides[i] - * shape[i], shape[j] = shape[j], shape[i] # <<<<<<<<<<<<<< - * - * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: - */ - __pyx_t_6 = (__pyx_v_shape[__pyx_v_j]); - __pyx_t_5 = (__pyx_v_shape[__pyx_v_i]); - (__pyx_v_shape[__pyx_v_i]) = __pyx_t_6; - (__pyx_v_shape[__pyx_v_j]) = __pyx_t_5; - - /* "View.MemoryView":942 - * shape[i], shape[j] = shape[j], shape[i] - * - * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< - * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") - * - */ - __pyx_t_8 = ((__pyx_v_memslice->suboffsets[__pyx_v_i]) >= 0); - if (!__pyx_t_8) { - } else { - __pyx_t_7 = __pyx_t_8; - goto __pyx_L6_bool_binop_done; - } - __pyx_t_8 = ((__pyx_v_memslice->suboffsets[__pyx_v_j]) >= 0); - __pyx_t_7 = __pyx_t_8; - __pyx_L6_bool_binop_done:; - if (__pyx_t_7) { - - /* "View.MemoryView":943 - * - * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: - * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") # <<<<<<<<<<<<<< - * - * return 0 - */ - __pyx_t_9 = __pyx_memoryview_err(PyExc_ValueError, __pyx_kp_s_Cannot_transpose_memoryview_with); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 943, __pyx_L1_error) - - /* "View.MemoryView":942 - * shape[i], shape[j] = shape[j], shape[i] - * - * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< - * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") - * - */ - } - } - - /* "View.MemoryView":945 - * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") - * - * return 0 # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = 0; - goto __pyx_L0; - - /* "View.MemoryView":929 - * - * @cname('__pyx_memslice_transpose') - * cdef int transpose_memslice(__Pyx_memviewslice *memslice) except -1 nogil: # <<<<<<<<<<<<<< - * cdef int ndim = memslice.memview.view.ndim - * - */ - - /* function exit code */ - __pyx_L1_error:; - #ifdef WITH_THREAD - __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_AddTraceback("View.MemoryView.transpose_memslice", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":963 - * cdef int (*to_dtype_func)(char *, object) except 0 - * - * def __dealloc__(self): # <<<<<<<<<<<<<< - * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) - * - */ - -/* Python wrapper */ -static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self); /*proto*/ -static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self) { - - /* "View.MemoryView":964 - * - * def __dealloc__(self): - * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) # <<<<<<<<<<<<<< - * - * cdef convert_item_to_object(self, char *itemp): - */ - __PYX_XCLEAR_MEMVIEW((&__pyx_v_self->from_slice), 1); - - /* "View.MemoryView":963 - * cdef int (*to_dtype_func)(char *, object) except 0 - * - * def __dealloc__(self): # <<<<<<<<<<<<<< - * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) - * - */ - - /* function exit code */ -} - -/* "View.MemoryView":966 - * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) - * - * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< - * if self.to_object_func != NULL: - * return self.to_object_func(itemp) - */ - -static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp) { - PyObject *__pyx_r = NULL; - __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", 1); - - /* "View.MemoryView":967 - * - * cdef convert_item_to_object(self, char *itemp): - * if self.to_object_func != NULL: # <<<<<<<<<<<<<< - * return self.to_object_func(itemp) - * else: - */ - __pyx_t_1 = (__pyx_v_self->to_object_func != NULL); - if (__pyx_t_1) { - - /* "View.MemoryView":968 - * cdef convert_item_to_object(self, char *itemp): - * if self.to_object_func != NULL: - * return self.to_object_func(itemp) # <<<<<<<<<<<<<< - * else: - * 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(1, 968, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":967 - * - * cdef convert_item_to_object(self, char *itemp): - * if self.to_object_func != NULL: # <<<<<<<<<<<<<< - * return self.to_object_func(itemp) - * else: - */ - } - - /* "View.MemoryView":970 - * return self.to_object_func(itemp) - * else: - * return memoryview.convert_item_to_object(self, itemp) # <<<<<<<<<<<<<< - * - * cdef assign_item_from_object(self, char *itemp, object value): - */ - /*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(1, 970, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - } - - /* "View.MemoryView":966 - * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) - * - * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< - * if self.to_object_func != NULL: - * return self.to_object_func(itemp) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView._memoryviewslice.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":972 - * return memoryview.convert_item_to_object(self, itemp) - * - * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< - * if self.to_dtype_func != NULL: - * self.to_dtype_func(itemp, value) - */ - -static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - 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", 1); - - /* "View.MemoryView":973 - * - * cdef assign_item_from_object(self, char *itemp, object value): - * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< - * self.to_dtype_func(itemp, value) - * else: - */ - __pyx_t_1 = (__pyx_v_self->to_dtype_func != NULL); - if (__pyx_t_1) { - - /* "View.MemoryView":974 - * 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(1, 974, __pyx_L1_error) - - /* "View.MemoryView":973 - * - * cdef assign_item_from_object(self, char *itemp, object value): - * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< - * self.to_dtype_func(itemp, value) - * else: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":976 - * self.to_dtype_func(itemp, value) - * else: - * memoryview.assign_item_from_object(self, itemp, value) # <<<<<<<<<<<<<< - * - * cdef _get_base(self): - */ - /*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(1, 976, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } - __pyx_L3:; - - /* "View.MemoryView":972 - * return memoryview.convert_item_to_object(self, itemp) - * - * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< - * if self.to_dtype_func != NULL: - * self.to_dtype_func(itemp, value) - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView._memoryviewslice.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":978 - * memoryview.assign_item_from_object(self, itemp, value) - * - * cdef _get_base(self): # <<<<<<<<<<<<<< - * return self.from_object - * - */ - -static PyObject *__pyx_memoryviewslice__get_base(struct __pyx_memoryviewslice_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("_get_base", 1); - - /* "View.MemoryView":979 - * - * cdef _get_base(self): - * return self.from_object # <<<<<<<<<<<<<< - * - * - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->from_object); - __pyx_r = __pyx_v_self->from_object; - goto __pyx_L0; - - /* "View.MemoryView":978 - * memoryview.assign_item_from_object(self, itemp, value) - * - * cdef _get_base(self): # <<<<<<<<<<<<<< - * return self.from_object - * - */ - - /* function exit code */ - __pyx_L0:; - __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): - */ - -/* Python wrapper */ -static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; - __pyx_r = __pyx_pf___pyx_memoryviewslice___reduce_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__reduce_cython__", 1); - - /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); - __PYX_ERR(1, 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): - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __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_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v___pyx_state = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf___pyx_memoryviewslice_2__setstate_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self), __pyx_v___pyx_state); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setstate_cython__", 1); - - /* "(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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_no_default___reduce___due_to_non, 0, 0); - __PYX_ERR(1, 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_AddTraceback("View.MemoryView._memoryviewslice.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":999 - * - * @cname('__pyx_memoryview_fromslice') - * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< - * int ndim, - * object (*to_object_func)(char *), - */ - -static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewslice, int __pyx_v_ndim, PyObject *(*__pyx_v_to_object_func)(char *), int (*__pyx_v_to_dtype_func)(char *, PyObject *), int __pyx_v_dtype_is_object) { - struct __pyx_memoryviewslice_obj *__pyx_v_result = 0; - Py_ssize_t __pyx_v_suboffset; - PyObject *__pyx_v_length = NULL; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - __Pyx_TypeInfo *__pyx_t_4; - Py_buffer __pyx_t_5; - Py_ssize_t *__pyx_t_6; - 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", 1); - - /* "View.MemoryView":1007 - * cdef _memoryviewslice result - * - * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< - * return None - * - */ - __pyx_t_1 = (((PyObject *)__pyx_v_memviewslice.memview) == Py_None); - if (__pyx_t_1) { - - /* "View.MemoryView":1008 - * - * if memviewslice.memview == Py_None: - * return None # <<<<<<<<<<<<<< - * - * - */ - __Pyx_XDECREF(__pyx_r); - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - - /* "View.MemoryView":1007 - * cdef _memoryviewslice result - * - * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< - * return None - * - */ - } - - /* "View.MemoryView":1013 - * - * - * result = _memoryviewslice.__new__(_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(1, 1013, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1013, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(Py_None); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, Py_None)) __PYX_ERR(1, 1013, __pyx_L1_error); - __Pyx_INCREF(__pyx_int_0); - __Pyx_GIVEREF(__pyx_int_0); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_0)) __PYX_ERR(1, 1013, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2)) __PYX_ERR(1, 1013, __pyx_L1_error); - __pyx_t_2 = 0; - __pyx_t_2 = ((PyObject *)__pyx_tp_new__memoryviewslice(((PyTypeObject *)__pyx_memoryviewslice_type), __pyx_t_3, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1013, __pyx_L1_error) - __Pyx_GOTREF((PyObject *)__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 - * result = _memoryviewslice.__new__(_memoryviewslice, None, 0, dtype_is_object) - * - * result.from_slice = memviewslice # <<<<<<<<<<<<<< - * __PYX_INC_MEMVIEW(&memviewslice, 1) - * - */ - __pyx_v_result->from_slice = __pyx_v_memviewslice; - - /* "View.MemoryView":1016 - * - * result.from_slice = memviewslice - * __PYX_INC_MEMVIEW(&memviewslice, 1) # <<<<<<<<<<<<<< - * - * result.from_object = ( memviewslice.memview)._get_base() - */ - __PYX_INC_MEMVIEW((&__pyx_v_memviewslice), 1); - - /* "View.MemoryView":1018 - * __PYX_INC_MEMVIEW(&memviewslice, 1) - * - * result.from_object = ( memviewslice.memview)._get_base() # <<<<<<<<<<<<<< - * result.typeinfo = memviewslice.memview.typeinfo - * - */ - __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->__pyx_vtab)->_get_base(((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1018, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_result->from_object); - __Pyx_DECREF(__pyx_v_result->from_object); - __pyx_v_result->from_object = __pyx_t_2; - __pyx_t_2 = 0; - - /* "View.MemoryView":1019 - * - * result.from_object = ( memviewslice.memview)._get_base() - * result.typeinfo = memviewslice.memview.typeinfo # <<<<<<<<<<<<<< - * - * result.view = memviewslice.memview.view - */ - __pyx_t_4 = __pyx_v_memviewslice.memview->typeinfo; - __pyx_v_result->__pyx_base.typeinfo = __pyx_t_4; - - /* "View.MemoryView":1021 - * result.typeinfo = memviewslice.memview.typeinfo - * - * result.view = memviewslice.memview.view # <<<<<<<<<<<<<< - * result.view.buf = memviewslice.data - * result.view.ndim = ndim - */ - __pyx_t_5 = __pyx_v_memviewslice.memview->view; - __pyx_v_result->__pyx_base.view = __pyx_t_5; - - /* "View.MemoryView":1022 - * - * result.view = memviewslice.memview.view - * result.view.buf = memviewslice.data # <<<<<<<<<<<<<< - * result.view.ndim = ndim - * (<__pyx_buffer *> &result.view).obj = Py_None - */ - __pyx_v_result->__pyx_base.view.buf = ((void *)__pyx_v_memviewslice.data); - - /* "View.MemoryView":1023 - * result.view = memviewslice.memview.view - * result.view.buf = memviewslice.data - * result.view.ndim = ndim # <<<<<<<<<<<<<< - * (<__pyx_buffer *> &result.view).obj = Py_None - * Py_INCREF(Py_None) - */ - __pyx_v_result->__pyx_base.view.ndim = __pyx_v_ndim; - - /* "View.MemoryView":1024 - * result.view.buf = memviewslice.data - * result.view.ndim = ndim - * (<__pyx_buffer *> &result.view).obj = Py_None # <<<<<<<<<<<<<< - * Py_INCREF(Py_None) - * - */ - ((Py_buffer *)(&__pyx_v_result->__pyx_base.view))->obj = Py_None; - - /* "View.MemoryView":1025 - * result.view.ndim = ndim - * (<__pyx_buffer *> &result.view).obj = Py_None - * Py_INCREF(Py_None) # <<<<<<<<<<<<<< - * - * if (memviewslice.memview).flags & PyBUF_WRITABLE: - */ - Py_INCREF(Py_None); - - /* "View.MemoryView":1027 - * Py_INCREF(Py_None) - * - * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< - * result.flags = PyBUF_RECORDS - * else: - */ - __pyx_t_1 = ((((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->flags & PyBUF_WRITABLE) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":1028 - * - * if (memviewslice.memview).flags & PyBUF_WRITABLE: - * result.flags = PyBUF_RECORDS # <<<<<<<<<<<<<< - * else: - * result.flags = PyBUF_RECORDS_RO - */ - __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS; - - /* "View.MemoryView":1027 - * Py_INCREF(Py_None) - * - * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< - * result.flags = PyBUF_RECORDS - * else: - */ - goto __pyx_L4; - } - - /* "View.MemoryView":1030 - * result.flags = PyBUF_RECORDS - * else: - * result.flags = PyBUF_RECORDS_RO # <<<<<<<<<<<<<< - * - * result.view.shape = result.from_slice.shape - */ - /*else*/ { - __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS_RO; - } - __pyx_L4:; - - /* "View.MemoryView":1032 - * result.flags = PyBUF_RECORDS_RO - * - * result.view.shape = result.from_slice.shape # <<<<<<<<<<<<<< - * result.view.strides = result.from_slice.strides - * - */ - __pyx_v_result->__pyx_base.view.shape = ((Py_ssize_t *)__pyx_v_result->from_slice.shape); - - /* "View.MemoryView":1033 - * - * result.view.shape = result.from_slice.shape - * result.view.strides = result.from_slice.strides # <<<<<<<<<<<<<< - * - * - */ - __pyx_v_result->__pyx_base.view.strides = ((Py_ssize_t *)__pyx_v_result->from_slice.strides); - - /* "View.MemoryView":1036 - * - * - * result.view.suboffsets = NULL # <<<<<<<<<<<<<< - * for suboffset in result.from_slice.suboffsets[:ndim]: - * if suboffset >= 0: - */ - __pyx_v_result->__pyx_base.view.suboffsets = NULL; - - /* "View.MemoryView":1037 - * - * result.view.suboffsets = NULL - * for suboffset in result.from_slice.suboffsets[:ndim]: # <<<<<<<<<<<<<< - * if suboffset >= 0: - * result.view.suboffsets = result.from_slice.suboffsets - */ - __pyx_t_7 = (__pyx_v_result->from_slice.suboffsets + __pyx_v_ndim); - for (__pyx_t_8 = __pyx_v_result->from_slice.suboffsets; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) { - __pyx_t_6 = __pyx_t_8; - __pyx_v_suboffset = (__pyx_t_6[0]); - - /* "View.MemoryView":1038 - * result.view.suboffsets = NULL - * for suboffset in result.from_slice.suboffsets[:ndim]: - * if suboffset >= 0: # <<<<<<<<<<<<<< - * result.view.suboffsets = result.from_slice.suboffsets - * break - */ - __pyx_t_1 = (__pyx_v_suboffset >= 0); - if (__pyx_t_1) { - - /* "View.MemoryView":1039 - * for suboffset in result.from_slice.suboffsets[:ndim]: - * if suboffset >= 0: - * result.view.suboffsets = result.from_slice.suboffsets # <<<<<<<<<<<<<< - * break - * - */ - __pyx_v_result->__pyx_base.view.suboffsets = ((Py_ssize_t *)__pyx_v_result->from_slice.suboffsets); - - /* "View.MemoryView":1040 - * if suboffset >= 0: - * result.view.suboffsets = result.from_slice.suboffsets - * break # <<<<<<<<<<<<<< - * - * result.view.len = result.view.itemsize - */ - goto __pyx_L6_break; - - /* "View.MemoryView":1038 - * result.view.suboffsets = NULL - * for suboffset in result.from_slice.suboffsets[:ndim]: - * if suboffset >= 0: # <<<<<<<<<<<<<< - * result.view.suboffsets = result.from_slice.suboffsets - * break - */ - } - } - __pyx_L6_break:; - - /* "View.MemoryView":1042 - * break - * - * result.view.len = result.view.itemsize # <<<<<<<<<<<<<< - * for length in result.view.shape[:ndim]: - * result.view.len *= length - */ - __pyx_t_9 = __pyx_v_result->__pyx_base.view.itemsize; - __pyx_v_result->__pyx_base.view.len = __pyx_t_9; - - /* "View.MemoryView":1043 - * - * result.view.len = result.view.itemsize - * for length in result.view.shape[:ndim]: # <<<<<<<<<<<<<< - * result.view.len *= length - * - */ - __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(1, 1043, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_2); - __pyx_t_2 = 0; - - /* "View.MemoryView":1044 - * 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(1, 1044, __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(1, 1044, __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(1, 1044, __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 - * result.view.len *= length - * - * result.to_object_func = to_object_func # <<<<<<<<<<<<<< - * result.to_dtype_func = to_dtype_func - * - */ - __pyx_v_result->to_object_func = __pyx_v_to_object_func; - - /* "View.MemoryView":1047 - * - * result.to_object_func = to_object_func - * result.to_dtype_func = to_dtype_func # <<<<<<<<<<<<<< - * - * return result - */ - __pyx_v_result->to_dtype_func = __pyx_v_to_dtype_func; - - /* "View.MemoryView":1049 - * result.to_dtype_func = to_dtype_func - * - * return result # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_get_slice_from_memoryview') - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF((PyObject *)__pyx_v_result); - __pyx_r = ((PyObject *)__pyx_v_result); - goto __pyx_L0; - - /* "View.MemoryView":999 - * - * @cname('__pyx_memoryview_fromslice') - * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< - * int ndim, - * object (*to_object_func)(char *), - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.memoryview_fromslice", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_result); - __Pyx_XDECREF(__pyx_v_length); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":1052 - * - * @cname('__pyx_memoryview_get_slice_from_memoryview') - * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< - * __Pyx_memviewslice *mslice) except NULL: - * cdef _memoryviewslice obj - */ - -static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_mslice) { - struct __pyx_memoryviewslice_obj *__pyx_v_obj = 0; - __Pyx_memviewslice *__pyx_r; - __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("get_slice_from_memview", 1); - - /* "View.MemoryView":1055 - * __Pyx_memviewslice *mslice) except NULL: - * cdef _memoryviewslice obj - * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< - * obj = memview - * return &obj.from_slice - */ - __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); - if (__pyx_t_1) { - - /* "View.MemoryView":1056 - * 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(1, 1056, __pyx_L1_error) - __pyx_t_2 = ((PyObject *)__pyx_v_memview); - __Pyx_INCREF(__pyx_t_2); - __pyx_v_obj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); - __pyx_t_2 = 0; - - /* "View.MemoryView":1057 - * if isinstance(memview, _memoryviewslice): - * obj = memview - * return &obj.from_slice # <<<<<<<<<<<<<< - * else: - * slice_copy(memview, mslice) - */ - __pyx_r = (&__pyx_v_obj->from_slice); - goto __pyx_L0; - - /* "View.MemoryView":1055 - * __Pyx_memviewslice *mslice) except NULL: - * cdef _memoryviewslice obj - * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< - * obj = memview - * return &obj.from_slice - */ - } - - /* "View.MemoryView":1059 - * return &obj.from_slice - * else: - * slice_copy(memview, mslice) # <<<<<<<<<<<<<< - * return mslice - * - */ - /*else*/ { - __pyx_memoryview_slice_copy(__pyx_v_memview, __pyx_v_mslice); - - /* "View.MemoryView":1060 - * else: - * slice_copy(memview, mslice) - * return mslice # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_slice_copy') - */ - __pyx_r = __pyx_v_mslice; - goto __pyx_L0; - } - - /* "View.MemoryView":1052 - * - * @cname('__pyx_memoryview_get_slice_from_memoryview') - * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< - * __Pyx_memviewslice *mslice) except NULL: - * cdef _memoryviewslice obj - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.get_slice_from_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_obj); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":1063 - * - * @cname('__pyx_memoryview_slice_copy') - * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst) noexcept: # <<<<<<<<<<<<<< - * cdef int dim - * cdef (Py_ssize_t*) shape, strides, suboffsets - */ - -static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_dst) { - int __pyx_v_dim; - Py_ssize_t *__pyx_v_shape; - Py_ssize_t *__pyx_v_strides; - Py_ssize_t *__pyx_v_suboffsets; - Py_ssize_t *__pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - int __pyx_t_4; - Py_ssize_t __pyx_t_5; - int __pyx_t_6; - - /* "View.MemoryView":1067 - * cdef (Py_ssize_t*) shape, strides, suboffsets - * - * shape = memview.view.shape # <<<<<<<<<<<<<< - * strides = memview.view.strides - * suboffsets = memview.view.suboffsets - */ - __pyx_t_1 = __pyx_v_memview->view.shape; - __pyx_v_shape = __pyx_t_1; - - /* "View.MemoryView":1068 - * - * shape = memview.view.shape - * strides = memview.view.strides # <<<<<<<<<<<<<< - * suboffsets = memview.view.suboffsets - * - */ - __pyx_t_1 = __pyx_v_memview->view.strides; - __pyx_v_strides = __pyx_t_1; - - /* "View.MemoryView":1069 - * shape = memview.view.shape - * strides = memview.view.strides - * suboffsets = memview.view.suboffsets # <<<<<<<<<<<<<< - * - * dst.memview = <__pyx_memoryview *> memview - */ - __pyx_t_1 = __pyx_v_memview->view.suboffsets; - __pyx_v_suboffsets = __pyx_t_1; - - /* "View.MemoryView":1071 - * suboffsets = memview.view.suboffsets - * - * dst.memview = <__pyx_memoryview *> memview # <<<<<<<<<<<<<< - * dst.data = memview.view.buf - * - */ - __pyx_v_dst->memview = ((struct __pyx_memoryview_obj *)__pyx_v_memview); - - /* "View.MemoryView":1072 - * - * dst.memview = <__pyx_memoryview *> memview - * dst.data = memview.view.buf # <<<<<<<<<<<<<< - * - * for dim in range(memview.view.ndim): - */ - __pyx_v_dst->data = ((char *)__pyx_v_memview->view.buf); - - /* "View.MemoryView":1074 - * dst.data = memview.view.buf - * - * for dim in range(memview.view.ndim): # <<<<<<<<<<<<<< - * dst.shape[dim] = shape[dim] - * dst.strides[dim] = strides[dim] - */ - __pyx_t_2 = __pyx_v_memview->view.ndim; - __pyx_t_3 = __pyx_t_2; - for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { - __pyx_v_dim = __pyx_t_4; - - /* "View.MemoryView":1075 - * - * for dim in range(memview.view.ndim): - * dst.shape[dim] = shape[dim] # <<<<<<<<<<<<<< - * dst.strides[dim] = strides[dim] - * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 - */ - (__pyx_v_dst->shape[__pyx_v_dim]) = (__pyx_v_shape[__pyx_v_dim]); - - /* "View.MemoryView":1076 - * for dim in range(memview.view.ndim): - * dst.shape[dim] = shape[dim] - * dst.strides[dim] = strides[dim] # <<<<<<<<<<<<<< - * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 - * - */ - (__pyx_v_dst->strides[__pyx_v_dim]) = (__pyx_v_strides[__pyx_v_dim]); - - /* "View.MemoryView":1077 - * dst.shape[dim] = shape[dim] - * dst.strides[dim] = strides[dim] - * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_copy_object') - */ - __pyx_t_6 = (__pyx_v_suboffsets != 0); - if (__pyx_t_6) { - __pyx_t_5 = (__pyx_v_suboffsets[__pyx_v_dim]); - } else { - __pyx_t_5 = -1L; - } - (__pyx_v_dst->suboffsets[__pyx_v_dim]) = __pyx_t_5; - } - - /* "View.MemoryView":1063 - * - * @cname('__pyx_memoryview_slice_copy') - * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst) noexcept: # <<<<<<<<<<<<<< - * cdef int dim - * cdef (Py_ssize_t*) shape, strides, suboffsets - */ - - /* function exit code */ -} - -/* "View.MemoryView":1080 - * - * @cname('__pyx_memoryview_copy_object') - * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< - * "Create a new memoryview object" - * cdef __Pyx_memviewslice memviewslice - */ - -static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx_v_memview) { - __Pyx_memviewslice __pyx_v_memviewslice; - 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", 1); - - /* "View.MemoryView":1083 - * "Create a new memoryview object" - * cdef __Pyx_memviewslice memviewslice - * slice_copy(memview, &memviewslice) # <<<<<<<<<<<<<< - * return memoryview_copy_from_slice(memview, &memviewslice) - * - */ - __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_memviewslice)); - - /* "View.MemoryView":1084 - * cdef __Pyx_memviewslice memviewslice - * slice_copy(memview, &memviewslice) - * return memoryview_copy_from_slice(memview, &memviewslice) # <<<<<<<<<<<<<< - * - * @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(1, 1084, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "View.MemoryView":1080 - * - * @cname('__pyx_memoryview_copy_object') - * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< - * "Create a new memoryview object" - * cdef __Pyx_memviewslice memviewslice - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.memoryview_copy", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":1087 - * - * @cname('__pyx_memoryview_copy_object_from_slice') - * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< - * """ - * Create a new memoryview object from a given memoryview object and slice. - */ - -static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_memviewslice) { - PyObject *(*__pyx_v_to_object_func)(char *); - int (*__pyx_v_to_dtype_func)(char *, PyObject *); - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *(*__pyx_t_2)(char *); - int (*__pyx_t_3)(char *, PyObject *); - PyObject *__pyx_t_4 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("memoryview_copy_from_slice", 1); - - /* "View.MemoryView":1094 - * cdef int (*to_dtype_func)(char *, object) except 0 - * - * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< - * to_object_func = (<_memoryviewslice> memview).to_object_func - * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func - */ - __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); - if (__pyx_t_1) { - - /* "View.MemoryView":1095 - * - * if isinstance(memview, _memoryviewslice): - * to_object_func = (<_memoryviewslice> memview).to_object_func # <<<<<<<<<<<<<< - * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func - * else: - */ - __pyx_t_2 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_object_func; - __pyx_v_to_object_func = __pyx_t_2; - - /* "View.MemoryView":1096 - * if isinstance(memview, _memoryviewslice): - * to_object_func = (<_memoryviewslice> memview).to_object_func - * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func # <<<<<<<<<<<<<< - * else: - * to_object_func = NULL - */ - __pyx_t_3 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_dtype_func; - __pyx_v_to_dtype_func = __pyx_t_3; - - /* "View.MemoryView":1094 - * cdef int (*to_dtype_func)(char *, object) except 0 - * - * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< - * to_object_func = (<_memoryviewslice> memview).to_object_func - * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func - */ - goto __pyx_L3; - } - - /* "View.MemoryView":1098 - * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func - * else: - * to_object_func = NULL # <<<<<<<<<<<<<< - * to_dtype_func = NULL - * - */ - /*else*/ { - __pyx_v_to_object_func = NULL; - - /* "View.MemoryView":1099 - * else: - * to_object_func = NULL - * to_dtype_func = NULL # <<<<<<<<<<<<<< - * - * return memoryview_fromslice(memviewslice[0], memview.view.ndim, - */ - __pyx_v_to_dtype_func = NULL; - } - __pyx_L3:; - - /* "View.MemoryView":1101 - * to_dtype_func = NULL - * - * return memoryview_fromslice(memviewslice[0], memview.view.ndim, # <<<<<<<<<<<<<< - * to_object_func, to_dtype_func, - * memview.dtype_is_object) - */ - __Pyx_XDECREF(__pyx_r); - - /* "View.MemoryView":1103 - * return memoryview_fromslice(memviewslice[0], memview.view.ndim, - * to_object_func, to_dtype_func, - * memview.dtype_is_object) # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_4 = __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_4)) __PYX_ERR(1, 1101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; - goto __pyx_L0; - - /* "View.MemoryView":1087 - * - * @cname('__pyx_memoryview_copy_object_from_slice') - * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< - * """ - * Create a new memoryview object from a given memoryview object and slice. - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("View.MemoryView.memoryview_copy_from_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":1109 - * - * - * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) noexcept nogil: # <<<<<<<<<<<<<< - * return -arg if arg < 0 else arg - * - */ - -static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { - Py_ssize_t __pyx_r; - Py_ssize_t __pyx_t_1; - int __pyx_t_2; - - /* "View.MemoryView":1110 - * - * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) noexcept nogil: - * return -arg if arg < 0 else arg # <<<<<<<<<<<<<< - * - * @cname('__pyx_get_best_slice_order') - */ - __pyx_t_2 = (__pyx_v_arg < 0); - if (__pyx_t_2) { - __pyx_t_1 = (-__pyx_v_arg); - } else { - __pyx_t_1 = __pyx_v_arg; - } - __pyx_r = __pyx_t_1; - goto __pyx_L0; - - /* "View.MemoryView":1109 - * - * - * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) noexcept nogil: # <<<<<<<<<<<<<< - * return -arg if arg < 0 else arg - * - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":1113 - * - * @cname('__pyx_get_best_slice_order') - * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) noexcept nogil: # <<<<<<<<<<<<<< - * """ - * Figure out the best memory access order for a given slice. - */ - -static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim) { - int __pyx_v_i; - Py_ssize_t __pyx_v_c_stride; - Py_ssize_t __pyx_v_f_stride; - char __pyx_r; - int __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - int __pyx_t_4; - - /* "View.MemoryView":1118 - * """ - * cdef int i - * cdef Py_ssize_t c_stride = 0 # <<<<<<<<<<<<<< - * cdef Py_ssize_t f_stride = 0 - * - */ - __pyx_v_c_stride = 0; - - /* "View.MemoryView":1119 - * cdef int i - * cdef Py_ssize_t c_stride = 0 - * cdef Py_ssize_t f_stride = 0 # <<<<<<<<<<<<<< - * - * for i in range(ndim - 1, -1, -1): - */ - __pyx_v_f_stride = 0; - - /* "View.MemoryView":1121 - * cdef Py_ssize_t f_stride = 0 - * - * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< - * if mslice.shape[i] > 1: - * c_stride = mslice.strides[i] - */ - for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { - __pyx_v_i = __pyx_t_1; - - /* "View.MemoryView":1122 - * - * for i in range(ndim - 1, -1, -1): - * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< - * c_stride = mslice.strides[i] - * break - */ - __pyx_t_2 = ((__pyx_v_mslice->shape[__pyx_v_i]) > 1); - if (__pyx_t_2) { - - /* "View.MemoryView":1123 - * for i in range(ndim - 1, -1, -1): - * if mslice.shape[i] > 1: - * c_stride = mslice.strides[i] # <<<<<<<<<<<<<< - * break - * - */ - __pyx_v_c_stride = (__pyx_v_mslice->strides[__pyx_v_i]); - - /* "View.MemoryView":1124 - * if mslice.shape[i] > 1: - * c_stride = mslice.strides[i] - * break # <<<<<<<<<<<<<< - * - * for i in range(ndim): - */ - goto __pyx_L4_break; - - /* "View.MemoryView":1122 - * - * for i in range(ndim - 1, -1, -1): - * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< - * c_stride = mslice.strides[i] - * break - */ - } - } - __pyx_L4_break:; - - /* "View.MemoryView":1126 - * break - * - * for i in range(ndim): # <<<<<<<<<<<<<< - * if mslice.shape[i] > 1: - * f_stride = mslice.strides[i] - */ - __pyx_t_1 = __pyx_v_ndim; - __pyx_t_3 = __pyx_t_1; - for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { - __pyx_v_i = __pyx_t_4; - - /* "View.MemoryView":1127 - * - * for i in range(ndim): - * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< - * f_stride = mslice.strides[i] - * break - */ - __pyx_t_2 = ((__pyx_v_mslice->shape[__pyx_v_i]) > 1); - if (__pyx_t_2) { - - /* "View.MemoryView":1128 - * for i in range(ndim): - * if mslice.shape[i] > 1: - * f_stride = mslice.strides[i] # <<<<<<<<<<<<<< - * break - * - */ - __pyx_v_f_stride = (__pyx_v_mslice->strides[__pyx_v_i]); - - /* "View.MemoryView":1129 - * if mslice.shape[i] > 1: - * f_stride = mslice.strides[i] - * break # <<<<<<<<<<<<<< - * - * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): - */ - goto __pyx_L7_break; - - /* "View.MemoryView":1127 - * - * for i in range(ndim): - * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< - * f_stride = mslice.strides[i] - * break - */ - } - } - __pyx_L7_break:; - - /* "View.MemoryView":1131 - * break - * - * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< - * return 'C' - * else: - */ - __pyx_t_2 = (abs_py_ssize_t(__pyx_v_c_stride) <= abs_py_ssize_t(__pyx_v_f_stride)); - if (__pyx_t_2) { - - /* "View.MemoryView":1132 - * - * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): - * return 'C' # <<<<<<<<<<<<<< - * else: - * return 'F' - */ - __pyx_r = 'C'; - goto __pyx_L0; - - /* "View.MemoryView":1131 - * break - * - * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< - * return 'C' - * else: - */ - } - - /* "View.MemoryView":1134 - * return 'C' - * else: - * return 'F' # <<<<<<<<<<<<<< - * - * @cython.cdivision(True) - */ - /*else*/ { - __pyx_r = 'F'; - goto __pyx_L0; - } - - /* "View.MemoryView":1113 - * - * @cname('__pyx_get_best_slice_order') - * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) noexcept nogil: # <<<<<<<<<<<<<< - * """ - * Figure out the best memory access order for a given slice. - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":1137 - * - * @cython.cdivision(True) - * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< - * char *dst_data, Py_ssize_t *dst_strides, - * Py_ssize_t *src_shape, Py_ssize_t *dst_shape, - */ - -static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v_src_strides, char *__pyx_v_dst_data, Py_ssize_t *__pyx_v_dst_strides, Py_ssize_t *__pyx_v_src_shape, Py_ssize_t *__pyx_v_dst_shape, int __pyx_v_ndim, size_t __pyx_v_itemsize) { - CYTHON_UNUSED Py_ssize_t __pyx_v_i; - CYTHON_UNUSED Py_ssize_t __pyx_v_src_extent; - Py_ssize_t __pyx_v_dst_extent; - Py_ssize_t __pyx_v_src_stride; - Py_ssize_t __pyx_v_dst_stride; - int __pyx_t_1; - int __pyx_t_2; - Py_ssize_t __pyx_t_3; - Py_ssize_t __pyx_t_4; - Py_ssize_t __pyx_t_5; - - /* "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] - * cdef Py_ssize_t src_stride = src_strides[0] - */ - __pyx_v_src_extent = (__pyx_v_src_shape[0]); - - /* "View.MemoryView":1145 - * cdef Py_ssize_t i - * 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] - * cdef Py_ssize_t dst_stride = dst_strides[0] - */ - __pyx_v_dst_extent = (__pyx_v_dst_shape[0]); - - /* "View.MemoryView":1146 - * 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] # <<<<<<<<<<<<<< - * cdef Py_ssize_t dst_stride = dst_strides[0] - * - */ - __pyx_v_src_stride = (__pyx_v_src_strides[0]); - - /* "View.MemoryView":1147 - * 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] # <<<<<<<<<<<<<< - * - * if ndim == 1: - */ - __pyx_v_dst_stride = (__pyx_v_dst_strides[0]); - - /* "View.MemoryView":1149 - * cdef Py_ssize_t dst_stride = dst_strides[0] - * - * if ndim == 1: # <<<<<<<<<<<<<< - * if (src_stride > 0 and dst_stride > 0 and - * src_stride == itemsize == dst_stride): - */ - __pyx_t_1 = (__pyx_v_ndim == 1); - if (__pyx_t_1) { - - /* "View.MemoryView":1150 - * - * if ndim == 1: - * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< - * src_stride == itemsize == dst_stride): - * memcpy(dst_data, src_data, itemsize * dst_extent) - */ - __pyx_t_2 = (__pyx_v_src_stride > 0); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L5_bool_binop_done; - } - __pyx_t_2 = (__pyx_v_dst_stride > 0); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L5_bool_binop_done; - } - - /* "View.MemoryView":1151 - * if ndim == 1: - * if (src_stride > 0 and dst_stride > 0 and - * src_stride == itemsize == dst_stride): # <<<<<<<<<<<<<< - * memcpy(dst_data, src_data, itemsize * dst_extent) - * else: - */ - __pyx_t_2 = (((size_t)__pyx_v_src_stride) == __pyx_v_itemsize); - if (__pyx_t_2) { - __pyx_t_2 = (__pyx_v_itemsize == ((size_t)__pyx_v_dst_stride)); - } - __pyx_t_1 = __pyx_t_2; - __pyx_L5_bool_binop_done:; - - /* "View.MemoryView":1150 - * - * if ndim == 1: - * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< - * src_stride == itemsize == dst_stride): - * memcpy(dst_data, src_data, itemsize * dst_extent) - */ - if (__pyx_t_1) { - - /* "View.MemoryView":1152 - * if (src_stride > 0 and dst_stride > 0 and - * src_stride == itemsize == dst_stride): - * memcpy(dst_data, src_data, itemsize * dst_extent) # <<<<<<<<<<<<<< - * else: - * for i in range(dst_extent): - */ - (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, (__pyx_v_itemsize * __pyx_v_dst_extent))); - - /* "View.MemoryView":1150 - * - * if ndim == 1: - * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< - * src_stride == itemsize == dst_stride): - * memcpy(dst_data, src_data, itemsize * dst_extent) - */ - goto __pyx_L4; - } - - /* "View.MemoryView":1154 - * memcpy(dst_data, src_data, itemsize * dst_extent) - * else: - * for i in range(dst_extent): # <<<<<<<<<<<<<< - * memcpy(dst_data, src_data, itemsize) - * src_data += src_stride - */ - /*else*/ { - __pyx_t_3 = __pyx_v_dst_extent; - __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":1155 - * else: - * for i in range(dst_extent): - * memcpy(dst_data, src_data, itemsize) # <<<<<<<<<<<<<< - * src_data += src_stride - * dst_data += dst_stride - */ - (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, __pyx_v_itemsize)); - - /* "View.MemoryView":1156 - * for i in range(dst_extent): - * memcpy(dst_data, src_data, itemsize) - * src_data += src_stride # <<<<<<<<<<<<<< - * dst_data += dst_stride - * else: - */ - __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); - - /* "View.MemoryView":1157 - * memcpy(dst_data, src_data, itemsize) - * src_data += src_stride - * dst_data += dst_stride # <<<<<<<<<<<<<< - * else: - * for i in range(dst_extent): - */ - __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride); - } - } - __pyx_L4:; - - /* "View.MemoryView":1149 - * cdef Py_ssize_t dst_stride = dst_strides[0] - * - * if ndim == 1: # <<<<<<<<<<<<<< - * if (src_stride > 0 and dst_stride > 0 and - * src_stride == itemsize == dst_stride): - */ - goto __pyx_L3; - } - - /* "View.MemoryView":1159 - * dst_data += dst_stride - * else: - * for i in range(dst_extent): # <<<<<<<<<<<<<< - * _copy_strided_to_strided(src_data, src_strides + 1, - * dst_data, dst_strides + 1, - */ - /*else*/ { - __pyx_t_3 = __pyx_v_dst_extent; - __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":1160 - * else: - * for i in range(dst_extent): - * _copy_strided_to_strided(src_data, src_strides + 1, # <<<<<<<<<<<<<< - * dst_data, dst_strides + 1, - * src_shape + 1, dst_shape + 1, - */ - _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":1164 - * src_shape + 1, dst_shape + 1, - * ndim - 1, itemsize) - * src_data += src_stride # <<<<<<<<<<<<<< - * dst_data += dst_stride - * - */ - __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); - - /* "View.MemoryView":1165 - * ndim - 1, itemsize) - * src_data += src_stride - * dst_data += dst_stride # <<<<<<<<<<<<<< - * - * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, - */ - __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride); - } - } - __pyx_L3:; - - /* "View.MemoryView":1137 - * - * @cython.cdivision(True) - * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< - * char *dst_data, Py_ssize_t *dst_strides, - * Py_ssize_t *src_shape, Py_ssize_t *dst_shape, - */ - - /* function exit code */ -} - -/* "View.MemoryView":1167 - * dst_data += dst_stride - * - * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< - * __Pyx_memviewslice *dst, - * int ndim, size_t itemsize) noexcept nogil: - */ - -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":1170 - * __Pyx_memviewslice *dst, - * int ndim, size_t itemsize) noexcept nogil: - * _copy_strided_to_strided(src.data, src.strides, dst.data, dst.strides, # <<<<<<<<<<<<<< - * src.shape, dst.shape, ndim, itemsize) - * - */ - _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":1167 - * dst_data += dst_stride - * - * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< - * __Pyx_memviewslice *dst, - * int ndim, size_t itemsize) noexcept nogil: - */ - - /* function exit code */ -} - -/* "View.MemoryView":1174 - * - * @cname('__pyx_memoryview_slice_get_size') - * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) noexcept 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 - */ - -static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_src, int __pyx_v_ndim) { - Py_ssize_t __pyx_v_shape; - 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; - - /* "View.MemoryView":1176 - * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) noexcept 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 # <<<<<<<<<<<<<< - * - * for shape in src.shape[:ndim]: - */ - __pyx_t_1 = __pyx_v_src->memview->view.itemsize; - __pyx_v_size = __pyx_t_1; - - /* "View.MemoryView":1178 - * cdef Py_ssize_t shape, size = src.memview.view.itemsize - * - * for shape in src.shape[:ndim]: # <<<<<<<<<<<<<< - * size *= shape - * - */ - __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]); - - /* "View.MemoryView":1179 - * - * for shape in src.shape[:ndim]: - * size *= shape # <<<<<<<<<<<<<< - * - * return size - */ - __pyx_v_size = (__pyx_v_size * __pyx_v_shape); - } - - /* "View.MemoryView":1181 - * size *= shape - * - * return size # <<<<<<<<<<<<<< - * - * @cname('__pyx_fill_contig_strides_array') - */ - __pyx_r = __pyx_v_size; - goto __pyx_L0; - - /* "View.MemoryView":1174 - * - * @cname('__pyx_memoryview_slice_get_size') - * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) noexcept 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 - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":1184 - * - * @cname('__pyx_fill_contig_strides_array') - * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< - * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, - * int ndim, char order) noexcept nogil: - */ - -static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, Py_ssize_t __pyx_v_stride, int __pyx_v_ndim, char __pyx_v_order) { - int __pyx_v_idx; - Py_ssize_t __pyx_r; - int __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - int __pyx_t_4; - - /* "View.MemoryView":1193 - * cdef int idx - * - * if order == 'F': # <<<<<<<<<<<<<< - * for idx in range(ndim): - * strides[idx] = stride - */ - __pyx_t_1 = (__pyx_v_order == 'F'); - if (__pyx_t_1) { - - /* "View.MemoryView":1194 - * - * if order == 'F': - * for idx in range(ndim): # <<<<<<<<<<<<<< - * strides[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":1195 - * if order == 'F': - * for idx in range(ndim): - * strides[idx] = stride # <<<<<<<<<<<<<< - * stride *= shape[idx] - * else: - */ - (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; - - /* "View.MemoryView":1196 - * for idx in range(ndim): - * strides[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":1193 - * cdef int idx - * - * if order == 'F': # <<<<<<<<<<<<<< - * for idx in range(ndim): - * strides[idx] = stride - */ - goto __pyx_L3; - } - - /* "View.MemoryView":1198 - * stride *= shape[idx] - * else: - * for idx in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< - * strides[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":1199 - * else: - * for idx in range(ndim - 1, -1, -1): - * strides[idx] = stride # <<<<<<<<<<<<<< - * stride *= shape[idx] - * - */ - (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; - - /* "View.MemoryView":1200 - * for idx in range(ndim - 1, -1, -1): - * strides[idx] = stride - * stride *= shape[idx] # <<<<<<<<<<<<<< - * - * return stride - */ - __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx])); - } - } - __pyx_L3:; - - /* "View.MemoryView":1202 - * stride *= shape[idx] - * - * return stride # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_copy_data_to_temp') - */ - __pyx_r = __pyx_v_stride; - goto __pyx_L0; - - /* "View.MemoryView":1184 - * - * @cname('__pyx_fill_contig_strides_array') - * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< - * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, - * int ndim, char order) noexcept nogil: - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":1205 - * - * @cname('__pyx_memoryview_copy_data_to_temp') - * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< - * __Pyx_memviewslice *tmpslice, - * char order, - */ - -static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_tmpslice, char __pyx_v_order, int __pyx_v_ndim) { - int __pyx_v_i; - void *__pyx_v_result; - size_t __pyx_v_itemsize; - size_t __pyx_v_size; - void *__pyx_r; - Py_ssize_t __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - 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; - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save; - #endif - - /* "View.MemoryView":1216 - * cdef void *result - * - * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< - * cdef size_t size = slice_get_size(src, ndim) - * - */ - __pyx_t_1 = __pyx_v_src->memview->view.itemsize; - __pyx_v_itemsize = __pyx_t_1; - - /* "View.MemoryView":1217 - * - * cdef size_t itemsize = src.memview.view.itemsize - * cdef size_t size = slice_get_size(src, ndim) # <<<<<<<<<<<<<< - * - * result = malloc(size) - */ - __pyx_v_size = __pyx_memoryview_slice_get_size(__pyx_v_src, __pyx_v_ndim); - - /* "View.MemoryView":1219 - * cdef size_t size = slice_get_size(src, ndim) - * - * result = malloc(size) # <<<<<<<<<<<<<< - * if not result: - * _err_no_memory() - */ - __pyx_v_result = malloc(__pyx_v_size); - - /* "View.MemoryView":1220 - * - * result = malloc(size) - * if not result: # <<<<<<<<<<<<<< - * _err_no_memory() - * - */ - __pyx_t_2 = (!(__pyx_v_result != 0)); - if (__pyx_t_2) { - - /* "View.MemoryView":1221 - * result = malloc(size) - * if not result: - * _err_no_memory() # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_3 = __pyx_memoryview_err_no_memory(); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 1221, __pyx_L1_error) - - /* "View.MemoryView":1220 - * - * result = malloc(size) - * if not result: # <<<<<<<<<<<<<< - * _err_no_memory() - * - */ - } - - /* "View.MemoryView":1224 - * - * - * tmpslice.data = result # <<<<<<<<<<<<<< - * tmpslice.memview = src.memview - * for i in range(ndim): - */ - __pyx_v_tmpslice->data = ((char *)__pyx_v_result); - - /* "View.MemoryView":1225 - * - * tmpslice.data = result - * tmpslice.memview = src.memview # <<<<<<<<<<<<<< - * for i in range(ndim): - * tmpslice.shape[i] = src.shape[i] - */ - __pyx_t_4 = __pyx_v_src->memview; - __pyx_v_tmpslice->memview = __pyx_t_4; - - /* "View.MemoryView":1226 - * tmpslice.data = result - * tmpslice.memview = src.memview - * for i in range(ndim): # <<<<<<<<<<<<<< - * tmpslice.shape[i] = src.shape[i] - * tmpslice.suboffsets[i] = -1 - */ - __pyx_t_3 = __pyx_v_ndim; - __pyx_t_5 = __pyx_t_3; - for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { - __pyx_v_i = __pyx_t_6; - - /* "View.MemoryView":1227 - * tmpslice.memview = src.memview - * for i in range(ndim): - * tmpslice.shape[i] = src.shape[i] # <<<<<<<<<<<<<< - * tmpslice.suboffsets[i] = -1 - * - */ - (__pyx_v_tmpslice->shape[__pyx_v_i]) = (__pyx_v_src->shape[__pyx_v_i]); - - /* "View.MemoryView":1228 - * for i in range(ndim): - * tmpslice.shape[i] = src.shape[i] - * tmpslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< - * - * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, ndim, order) - */ - (__pyx_v_tmpslice->suboffsets[__pyx_v_i]) = -1L; - } - - /* "View.MemoryView":1230 - * tmpslice.suboffsets[i] = -1 - * - * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, ndim, order) # <<<<<<<<<<<<<< - * - * - */ - (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":1233 - * - * - * for i in range(ndim): # <<<<<<<<<<<<<< - * if tmpslice.shape[i] == 1: - * tmpslice.strides[i] = 0 - */ - __pyx_t_3 = __pyx_v_ndim; - __pyx_t_5 = __pyx_t_3; - for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { - __pyx_v_i = __pyx_t_6; - - /* "View.MemoryView":1234 - * - * for i in range(ndim): - * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< - * tmpslice.strides[i] = 0 - * - */ - __pyx_t_2 = ((__pyx_v_tmpslice->shape[__pyx_v_i]) == 1); - if (__pyx_t_2) { - - /* "View.MemoryView":1235 - * for i in range(ndim): - * if tmpslice.shape[i] == 1: - * tmpslice.strides[i] = 0 # <<<<<<<<<<<<<< - * - * if slice_is_contig(src[0], order, ndim): - */ - (__pyx_v_tmpslice->strides[__pyx_v_i]) = 0; - - /* "View.MemoryView":1234 - * - * for i in range(ndim): - * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< - * tmpslice.strides[i] = 0 - * - */ - } - } - - /* "View.MemoryView":1237 - * tmpslice.strides[i] = 0 - * - * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< - * memcpy(result, src.data, size) - * else: - */ - __pyx_t_2 = __pyx_memviewslice_is_contig((__pyx_v_src[0]), __pyx_v_order, __pyx_v_ndim); - if (__pyx_t_2) { - - /* "View.MemoryView":1238 - * - * if slice_is_contig(src[0], order, ndim): - * memcpy(result, src.data, size) # <<<<<<<<<<<<<< - * else: - * copy_strided_to_strided(src, tmpslice, ndim, itemsize) - */ - (void)(memcpy(__pyx_v_result, __pyx_v_src->data, __pyx_v_size)); - - /* "View.MemoryView":1237 - * tmpslice.strides[i] = 0 - * - * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< - * memcpy(result, src.data, size) - * else: - */ - goto __pyx_L9; - } - - /* "View.MemoryView":1240 - * memcpy(result, src.data, size) - * else: - * copy_strided_to_strided(src, tmpslice, ndim, itemsize) # <<<<<<<<<<<<<< - * - * return result - */ - /*else*/ { - copy_strided_to_strided(__pyx_v_src, __pyx_v_tmpslice, __pyx_v_ndim, __pyx_v_itemsize); - } - __pyx_L9:; - - /* "View.MemoryView":1242 - * copy_strided_to_strided(src, tmpslice, ndim, itemsize) - * - * return result # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = __pyx_v_result; - goto __pyx_L0; - - /* "View.MemoryView":1205 - * - * @cname('__pyx_memoryview_copy_data_to_temp') - * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< - * __Pyx_memviewslice *tmpslice, - * char order, - */ - - /* function exit code */ - __pyx_L1_error:; - #ifdef WITH_THREAD - __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_AddTraceback("View.MemoryView.copy_data_to_temp", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":1247 - * - * @cname('__pyx_memoryview_err_extents') - * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< - * Py_ssize_t extent2) except -1 with gil: - * raise ValueError, f"got differing extents in dimension {i} (got {extent1} and {extent2})" - */ - -static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent1, Py_ssize_t __pyx_v_extent2) { - int __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - Py_ssize_t __pyx_t_2; - Py_UCS4 __pyx_t_3; - 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":1249 - * cdef int _err_extents(int i, Py_ssize_t extent1, - * Py_ssize_t extent2) except -1 with gil: - * raise ValueError, f"got differing extents in dimension {i} (got {extent1} and {extent2})" # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_err_dim') - */ - __pyx_t_1 = PyTuple_New(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = 0; - __pyx_t_3 = 127; - __Pyx_INCREF(__pyx_kp_u_got_differing_extents_in_dimensi); - __pyx_t_2 += 35; - __Pyx_GIVEREF(__pyx_kp_u_got_differing_extents_in_dimensi); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_got_differing_extents_in_dimensi); - __pyx_t_4 = __Pyx_PyUnicode_From_int(__pyx_v_i, 0, ' ', 'd'); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_4); - __pyx_t_4 = 0; - __Pyx_INCREF(__pyx_kp_u_got); - __pyx_t_2 += 6; - __Pyx_GIVEREF(__pyx_kp_u_got); - PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_got); - __pyx_t_4 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_extent1, 0, ' ', 'd'); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_4); - __pyx_t_4 = 0; - __Pyx_INCREF(__pyx_kp_u_and); - __pyx_t_2 += 5; - __Pyx_GIVEREF(__pyx_kp_u_and); - PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_kp_u_and); - __pyx_t_4 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_extent2, 0, ' ', 'd'); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_1, 5, __pyx_t_4); - __pyx_t_4 = 0; - __Pyx_INCREF(__pyx_kp_u__7); - __pyx_t_2 += 1; - __Pyx_GIVEREF(__pyx_kp_u__7); - PyTuple_SET_ITEM(__pyx_t_1, 6, __pyx_kp_u__7); - __pyx_t_4 = __Pyx_PyUnicode_Join(__pyx_t_1, 7, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_Raise(__pyx_builtin_ValueError, __pyx_t_4, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(1, 1249, __pyx_L1_error) - - /* "View.MemoryView":1247 - * - * @cname('__pyx_memoryview_err_extents') - * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< - * Py_ssize_t extent2) except -1 with gil: - * raise ValueError, f"got differing extents in dimension {i} (got {extent1} and {extent2})" - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("View.MemoryView._err_extents", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __Pyx_RefNannyFinishContext(); - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - return __pyx_r; -} - -/* "View.MemoryView":1252 - * - * @cname('__pyx_memoryview_err_dim') - * cdef int _err_dim(PyObject *error, str msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< - * raise error, msg % dim - * - */ - -static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, PyObject *__pyx_v_msg, int __pyx_v_dim) { - int __pyx_r; - __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; - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_RefNannySetupContext("_err_dim", 0); - __Pyx_INCREF(__pyx_v_msg); - - /* "View.MemoryView":1253 - * @cname('__pyx_memoryview_err_dim') - * cdef int _err_dim(PyObject *error, str msg, int dim) except -1 with gil: - * raise error, msg % dim # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_err') - */ - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1253, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyString_FormatSafe(__pyx_v_msg, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1253, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_Raise(((PyObject *)__pyx_v_error), __pyx_t_2, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(1, 1253, __pyx_L1_error) - - /* "View.MemoryView":1252 - * - * @cname('__pyx_memoryview_err_dim') - * cdef int _err_dim(PyObject *error, str msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< - * raise error, msg % dim - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView._err_dim", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __Pyx_XDECREF(__pyx_v_msg); - __Pyx_RefNannyFinishContext(); - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - return __pyx_r; -} - -/* "View.MemoryView":1256 - * - * @cname('__pyx_memoryview_err') - * cdef int _err(PyObject *error, str msg) except -1 with gil: # <<<<<<<<<<<<<< - * raise error, msg - * - */ - -static int __pyx_memoryview_err(PyObject *__pyx_v_error, PyObject *__pyx_v_msg) { - int __pyx_r; - __Pyx_RefNannyDeclarations - 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_msg); - - /* "View.MemoryView":1257 - * @cname('__pyx_memoryview_err') - * cdef int _err(PyObject *error, str msg) except -1 with gil: - * raise error, msg # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_err_no_memory') - */ - __Pyx_Raise(((PyObject *)__pyx_v_error), __pyx_v_msg, 0, 0); - __PYX_ERR(1, 1257, __pyx_L1_error) - - /* "View.MemoryView":1256 - * - * @cname('__pyx_memoryview_err') - * cdef int _err(PyObject *error, str msg) except -1 with gil: # <<<<<<<<<<<<<< - * raise error, msg - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("View.MemoryView._err", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __Pyx_XDECREF(__pyx_v_msg); - __Pyx_RefNannyFinishContext(); - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - return __pyx_r; -} - -/* "View.MemoryView":1260 - * - * @cname('__pyx_memoryview_err_no_memory') - * cdef int _err_no_memory() except -1 with gil: # <<<<<<<<<<<<<< - * raise MemoryError - * - */ - -static int __pyx_memoryview_err_no_memory(void) { - int __pyx_r; - 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 - - /* "View.MemoryView":1261 - * @cname('__pyx_memoryview_err_no_memory') - * cdef int _err_no_memory() except -1 with gil: - * raise MemoryError # <<<<<<<<<<<<<< - * - * - */ - PyErr_NoMemory(); __PYX_ERR(1, 1261, __pyx_L1_error) - - /* "View.MemoryView":1260 - * - * @cname('__pyx_memoryview_err_no_memory') - * cdef int _err_no_memory() except -1 with gil: # <<<<<<<<<<<<<< - * raise MemoryError - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("View.MemoryView._err_no_memory", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - return __pyx_r; -} - -/* "View.MemoryView":1265 - * - * @cname('__pyx_memoryview_copy_contents') - * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< - * __Pyx_memviewslice dst, - * int src_ndim, int dst_ndim, - */ - -static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_memviewslice __pyx_v_dst, int __pyx_v_src_ndim, int __pyx_v_dst_ndim, int __pyx_v_dtype_is_object) { - void *__pyx_v_tmpdata; - size_t __pyx_v_itemsize; - int __pyx_v_i; - char __pyx_v_order; - int __pyx_v_broadcasting; - int __pyx_v_direct_copy; - __Pyx_memviewslice __pyx_v_tmp; - int __pyx_v_ndim; - int __pyx_r; - Py_ssize_t __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - int __pyx_t_4; - int __pyx_t_5; - int __pyx_t_6; - void *__pyx_t_7; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save; - #endif - - /* "View.MemoryView":1273 - * Check for overlapping memory and verify the shapes. - * """ - * cdef void *tmpdata = NULL # <<<<<<<<<<<<<< - * cdef size_t itemsize = src.memview.view.itemsize - * cdef int i - */ - __pyx_v_tmpdata = NULL; - - /* "View.MemoryView":1274 - * """ - * cdef void *tmpdata = NULL - * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< - * cdef int i - * cdef char order = get_best_order(&src, src_ndim) - */ - __pyx_t_1 = __pyx_v_src.memview->view.itemsize; - __pyx_v_itemsize = __pyx_t_1; - - /* "View.MemoryView":1276 - * cdef size_t itemsize = src.memview.view.itemsize - * cdef int i - * cdef char order = get_best_order(&src, src_ndim) # <<<<<<<<<<<<<< - * cdef bint broadcasting = False - * cdef bint direct_copy = False - */ - __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_src), __pyx_v_src_ndim); - - /* "View.MemoryView":1277 - * cdef int i - * cdef char order = get_best_order(&src, src_ndim) - * cdef bint broadcasting = False # <<<<<<<<<<<<<< - * cdef bint direct_copy = False - * cdef __Pyx_memviewslice tmp - */ - __pyx_v_broadcasting = 0; - - /* "View.MemoryView":1278 - * cdef char order = get_best_order(&src, src_ndim) - * cdef bint broadcasting = False - * cdef bint direct_copy = False # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice tmp - * - */ - __pyx_v_direct_copy = 0; - - /* "View.MemoryView":1281 - * cdef __Pyx_memviewslice tmp - * - * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< - * broadcast_leading(&src, src_ndim, dst_ndim) - * elif dst_ndim < src_ndim: - */ - __pyx_t_2 = (__pyx_v_src_ndim < __pyx_v_dst_ndim); - if (__pyx_t_2) { - - /* "View.MemoryView":1282 - * - * if src_ndim < dst_ndim: - * broadcast_leading(&src, src_ndim, dst_ndim) # <<<<<<<<<<<<<< - * elif dst_ndim < src_ndim: - * broadcast_leading(&dst, dst_ndim, src_ndim) - */ - __pyx_memoryview_broadcast_leading((&__pyx_v_src), __pyx_v_src_ndim, __pyx_v_dst_ndim); - - /* "View.MemoryView":1281 - * cdef __Pyx_memviewslice tmp - * - * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< - * broadcast_leading(&src, src_ndim, dst_ndim) - * elif dst_ndim < src_ndim: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":1283 - * if src_ndim < dst_ndim: - * broadcast_leading(&src, src_ndim, dst_ndim) - * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< - * broadcast_leading(&dst, dst_ndim, src_ndim) - * - */ - __pyx_t_2 = (__pyx_v_dst_ndim < __pyx_v_src_ndim); - if (__pyx_t_2) { - - /* "View.MemoryView":1284 - * broadcast_leading(&src, src_ndim, dst_ndim) - * elif dst_ndim < src_ndim: - * broadcast_leading(&dst, dst_ndim, src_ndim) # <<<<<<<<<<<<<< - * - * cdef int ndim = max(src_ndim, dst_ndim) - */ - __pyx_memoryview_broadcast_leading((&__pyx_v_dst), __pyx_v_dst_ndim, __pyx_v_src_ndim); - - /* "View.MemoryView":1283 - * if src_ndim < dst_ndim: - * broadcast_leading(&src, src_ndim, dst_ndim) - * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< - * broadcast_leading(&dst, dst_ndim, src_ndim) - * - */ - } - __pyx_L3:; - - /* "View.MemoryView":1286 - * broadcast_leading(&dst, dst_ndim, src_ndim) - * - * cdef int ndim = max(src_ndim, dst_ndim) # <<<<<<<<<<<<<< - * - * for i in range(ndim): - */ - __pyx_t_3 = __pyx_v_dst_ndim; - __pyx_t_4 = __pyx_v_src_ndim; - __pyx_t_2 = (__pyx_t_3 > __pyx_t_4); - if (__pyx_t_2) { - __pyx_t_5 = __pyx_t_3; - } else { - __pyx_t_5 = __pyx_t_4; - } - __pyx_v_ndim = __pyx_t_5; - - /* "View.MemoryView":1288 - * cdef int ndim = max(src_ndim, dst_ndim) - * - * for i in range(ndim): # <<<<<<<<<<<<<< - * if src.shape[i] != dst.shape[i]: - * if src.shape[i] == 1: - */ - __pyx_t_5 = __pyx_v_ndim; - __pyx_t_3 = __pyx_t_5; - for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { - __pyx_v_i = __pyx_t_4; - - /* "View.MemoryView":1289 - * - * for i in range(ndim): - * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< - * if src.shape[i] == 1: - * broadcasting = True - */ - __pyx_t_2 = ((__pyx_v_src.shape[__pyx_v_i]) != (__pyx_v_dst.shape[__pyx_v_i])); - if (__pyx_t_2) { - - /* "View.MemoryView":1290 - * for i in range(ndim): - * if src.shape[i] != dst.shape[i]: - * if src.shape[i] == 1: # <<<<<<<<<<<<<< - * broadcasting = True - * src.strides[i] = 0 - */ - __pyx_t_2 = ((__pyx_v_src.shape[__pyx_v_i]) == 1); - if (__pyx_t_2) { - - /* "View.MemoryView":1291 - * if src.shape[i] != dst.shape[i]: - * if src.shape[i] == 1: - * broadcasting = True # <<<<<<<<<<<<<< - * src.strides[i] = 0 - * else: - */ - __pyx_v_broadcasting = 1; - - /* "View.MemoryView":1292 - * if src.shape[i] == 1: - * broadcasting = True - * src.strides[i] = 0 # <<<<<<<<<<<<<< - * else: - * _err_extents(i, dst.shape[i], src.shape[i]) - */ - (__pyx_v_src.strides[__pyx_v_i]) = 0; - - /* "View.MemoryView":1290 - * for i in range(ndim): - * if src.shape[i] != dst.shape[i]: - * if src.shape[i] == 1: # <<<<<<<<<<<<<< - * broadcasting = True - * src.strides[i] = 0 - */ - goto __pyx_L7; - } - - /* "View.MemoryView":1294 - * src.strides[i] = 0 - * else: - * _err_extents(i, dst.shape[i], src.shape[i]) # <<<<<<<<<<<<<< - * - * 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(1, 1294, __pyx_L1_error) - } - __pyx_L7:; - - /* "View.MemoryView":1289 - * - * for i in range(ndim): - * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< - * if src.shape[i] == 1: - * broadcasting = True - */ - } - - /* "View.MemoryView":1296 - * _err_extents(i, dst.shape[i], src.shape[i]) - * - * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< - * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) - * - */ - __pyx_t_2 = ((__pyx_v_src.suboffsets[__pyx_v_i]) >= 0); - if (__pyx_t_2) { - - /* "View.MemoryView":1297 - * - * if src.suboffsets[i] >= 0: - * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) # <<<<<<<<<<<<<< - * - * if slices_overlap(&src, &dst, ndim, itemsize): - */ - __pyx_t_6 = __pyx_memoryview_err_dim(PyExc_ValueError, __pyx_kp_s_Dimension_d_is_not_direct, __pyx_v_i); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1297, __pyx_L1_error) - - /* "View.MemoryView":1296 - * _err_extents(i, dst.shape[i], src.shape[i]) - * - * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< - * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) - * - */ - } - } - - /* "View.MemoryView":1299 - * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) - * - * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< - * - * if not slice_is_contig(src, order, ndim): - */ - __pyx_t_2 = __pyx_slices_overlap((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize); - if (__pyx_t_2) { - - /* "View.MemoryView":1301 - * if slices_overlap(&src, &dst, ndim, itemsize): - * - * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< - * order = get_best_order(&dst, ndim) - * - */ - __pyx_t_2 = (!__pyx_memviewslice_is_contig(__pyx_v_src, __pyx_v_order, __pyx_v_ndim)); - if (__pyx_t_2) { - - /* "View.MemoryView":1302 - * - * if not slice_is_contig(src, order, ndim): - * order = get_best_order(&dst, ndim) # <<<<<<<<<<<<<< - * - * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) - */ - __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim); - - /* "View.MemoryView":1301 - * if slices_overlap(&src, &dst, ndim, itemsize): - * - * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< - * order = get_best_order(&dst, ndim) - * - */ - } - - /* "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(1, 1304, __pyx_L1_error) - __pyx_v_tmpdata = __pyx_t_7; - - /* "View.MemoryView":1305 - * - * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) - * src = tmp # <<<<<<<<<<<<<< - * - * if not broadcasting: - */ - __pyx_v_src = __pyx_v_tmp; - - /* "View.MemoryView":1299 - * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) - * - * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< - * - * if not slice_is_contig(src, order, ndim): - */ - } - - /* "View.MemoryView":1307 - * src = tmp - * - * if not broadcasting: # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_2 = (!__pyx_v_broadcasting); - if (__pyx_t_2) { - - /* "View.MemoryView":1310 - * - * - * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< - * direct_copy = slice_is_contig(dst, 'C', ndim) - * elif slice_is_contig(src, 'F', ndim): - */ - __pyx_t_2 = __pyx_memviewslice_is_contig(__pyx_v_src, 'C', __pyx_v_ndim); - if (__pyx_t_2) { - - /* "View.MemoryView":1311 - * - * if slice_is_contig(src, 'C', ndim): - * direct_copy = slice_is_contig(dst, 'C', ndim) # <<<<<<<<<<<<<< - * elif slice_is_contig(src, 'F', ndim): - * direct_copy = slice_is_contig(dst, 'F', ndim) - */ - __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'C', __pyx_v_ndim); - - /* "View.MemoryView":1310 - * - * - * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< - * direct_copy = slice_is_contig(dst, 'C', ndim) - * elif slice_is_contig(src, 'F', ndim): - */ - goto __pyx_L12; - } - - /* "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): # <<<<<<<<<<<<<< - * direct_copy = slice_is_contig(dst, 'F', ndim) - * - */ - __pyx_t_2 = __pyx_memviewslice_is_contig(__pyx_v_src, 'F', __pyx_v_ndim); - if (__pyx_t_2) { - - /* "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) # <<<<<<<<<<<<<< - * - * if direct_copy: - */ - __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'F', __pyx_v_ndim); - - /* "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): # <<<<<<<<<<<<<< - * direct_copy = slice_is_contig(dst, 'F', ndim) - * - */ - } - __pyx_L12:; - - /* "View.MemoryView":1315 - * direct_copy = slice_is_contig(dst, 'F', ndim) - * - * if direct_copy: # <<<<<<<<<<<<<< - * - * refcount_copying(&dst, dtype_is_object, ndim, inc=False) - */ - if (__pyx_v_direct_copy) { - - /* "View.MemoryView":1317 - * if direct_copy: - * - * refcount_copying(&dst, dtype_is_object, ndim, inc=False) # <<<<<<<<<<<<<< - * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) - * refcount_copying(&dst, dtype_is_object, ndim, inc=True) - */ - __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); - - /* "View.MemoryView":1318 - * - * refcount_copying(&dst, dtype_is_object, ndim, inc=False) - * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) # <<<<<<<<<<<<<< - * refcount_copying(&dst, dtype_is_object, ndim, inc=True) - * free(tmpdata) - */ - (void)(memcpy(__pyx_v_dst.data, __pyx_v_src.data, __pyx_memoryview_slice_get_size((&__pyx_v_src), __pyx_v_ndim))); - - /* "View.MemoryView":1319 - * refcount_copying(&dst, dtype_is_object, ndim, inc=False) - * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) - * refcount_copying(&dst, dtype_is_object, ndim, inc=True) # <<<<<<<<<<<<<< - * free(tmpdata) - * return 0 - */ - __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); - - /* "View.MemoryView":1320 - * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) - * refcount_copying(&dst, dtype_is_object, ndim, inc=True) - * free(tmpdata) # <<<<<<<<<<<<<< - * return 0 - * - */ - free(__pyx_v_tmpdata); - - /* "View.MemoryView":1321 - * refcount_copying(&dst, dtype_is_object, ndim, inc=True) - * free(tmpdata) - * return 0 # <<<<<<<<<<<<<< - * - * if order == 'F' == get_best_order(&dst, ndim): - */ - __pyx_r = 0; - goto __pyx_L0; - - /* "View.MemoryView":1315 - * direct_copy = slice_is_contig(dst, 'F', ndim) - * - * if direct_copy: # <<<<<<<<<<<<<< - * - * refcount_copying(&dst, dtype_is_object, ndim, inc=False) - */ - } - - /* "View.MemoryView":1307 - * src = tmp - * - * if not broadcasting: # <<<<<<<<<<<<<< - * - * - */ - } - - /* "View.MemoryView":1323 - * return 0 - * - * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_2 = (__pyx_v_order == 'F'); - if (__pyx_t_2) { - __pyx_t_2 = ('F' == __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim)); - } - if (__pyx_t_2) { - - /* "View.MemoryView":1326 - * - * - * transpose_memslice(&src) # <<<<<<<<<<<<<< - * transpose_memslice(&dst) - * - */ - __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_src)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 1326, __pyx_L1_error) - - /* "View.MemoryView":1327 - * - * transpose_memslice(&src) - * transpose_memslice(&dst) # <<<<<<<<<<<<<< - * - * refcount_copying(&dst, dtype_is_object, ndim, inc=False) - */ - __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_dst)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 1327, __pyx_L1_error) - - /* "View.MemoryView":1323 - * return 0 - * - * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< - * - * - */ - } - - /* "View.MemoryView":1329 - * transpose_memslice(&dst) - * - * refcount_copying(&dst, dtype_is_object, ndim, inc=False) # <<<<<<<<<<<<<< - * copy_strided_to_strided(&src, &dst, ndim, itemsize) - * refcount_copying(&dst, dtype_is_object, ndim, inc=True) - */ - __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); - - /* "View.MemoryView":1330 - * - * refcount_copying(&dst, dtype_is_object, ndim, inc=False) - * copy_strided_to_strided(&src, &dst, ndim, itemsize) # <<<<<<<<<<<<<< - * refcount_copying(&dst, dtype_is_object, ndim, inc=True) - * - */ - copy_strided_to_strided((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize); - - /* "View.MemoryView":1331 - * refcount_copying(&dst, dtype_is_object, ndim, inc=False) - * copy_strided_to_strided(&src, &dst, ndim, itemsize) - * refcount_copying(&dst, dtype_is_object, ndim, inc=True) # <<<<<<<<<<<<<< - * - * free(tmpdata) - */ - __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); - - /* "View.MemoryView":1333 - * refcount_copying(&dst, dtype_is_object, ndim, inc=True) - * - * free(tmpdata) # <<<<<<<<<<<<<< - * return 0 - * - */ - free(__pyx_v_tmpdata); - - /* "View.MemoryView":1334 - * - * free(tmpdata) - * return 0 # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_broadcast_leading') - */ - __pyx_r = 0; - goto __pyx_L0; - - /* "View.MemoryView":1265 - * - * @cname('__pyx_memoryview_copy_contents') - * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< - * __Pyx_memviewslice dst, - * int src_ndim, int dst_ndim, - */ - - /* function exit code */ - __pyx_L1_error:; - #ifdef WITH_THREAD - __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_AddTraceback("View.MemoryView.memoryview_copy_contents", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":1337 - * - * @cname('__pyx_memoryview_broadcast_leading') - * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< - * int ndim, - * int ndim_other) noexcept nogil: - */ - -static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim, int __pyx_v_ndim_other) { - int __pyx_v_i; - int __pyx_v_offset; - int __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - - /* "View.MemoryView":1341 - * int ndim_other) noexcept nogil: - * cdef int i - * cdef int offset = ndim_other - ndim # <<<<<<<<<<<<<< - * - * for i in range(ndim - 1, -1, -1): - */ - __pyx_v_offset = (__pyx_v_ndim_other - __pyx_v_ndim); - - /* "View.MemoryView":1343 - * cdef int offset = ndim_other - ndim - * - * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< - * mslice.shape[i + offset] = mslice.shape[i] - * mslice.strides[i + offset] = mslice.strides[i] - */ - for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { - __pyx_v_i = __pyx_t_1; - - /* "View.MemoryView":1344 - * - * for i in range(ndim - 1, -1, -1): - * mslice.shape[i + offset] = mslice.shape[i] # <<<<<<<<<<<<<< - * mslice.strides[i + offset] = mslice.strides[i] - * mslice.suboffsets[i + offset] = mslice.suboffsets[i] - */ - (__pyx_v_mslice->shape[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->shape[__pyx_v_i]); - - /* "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] # <<<<<<<<<<<<<< - * mslice.suboffsets[i + offset] = mslice.suboffsets[i] - * - */ - (__pyx_v_mslice->strides[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->strides[__pyx_v_i]); - - /* "View.MemoryView":1346 - * mslice.shape[i + offset] = mslice.shape[i] - * mslice.strides[i + offset] = mslice.strides[i] - * mslice.suboffsets[i + offset] = mslice.suboffsets[i] # <<<<<<<<<<<<<< - * - * for i in range(offset): - */ - (__pyx_v_mslice->suboffsets[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->suboffsets[__pyx_v_i]); - } - - /* "View.MemoryView":1348 - * mslice.suboffsets[i + offset] = mslice.suboffsets[i] - * - * for i in range(offset): # <<<<<<<<<<<<<< - * mslice.shape[i] = 1 - * mslice.strides[i] = mslice.strides[0] - */ - __pyx_t_1 = __pyx_v_offset; - __pyx_t_2 = __pyx_t_1; - for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { - __pyx_v_i = __pyx_t_3; - - /* "View.MemoryView":1349 - * - * for i in range(offset): - * mslice.shape[i] = 1 # <<<<<<<<<<<<<< - * mslice.strides[i] = mslice.strides[0] - * mslice.suboffsets[i] = -1 - */ - (__pyx_v_mslice->shape[__pyx_v_i]) = 1; - - /* "View.MemoryView":1350 - * for i in range(offset): - * mslice.shape[i] = 1 - * mslice.strides[i] = mslice.strides[0] # <<<<<<<<<<<<<< - * mslice.suboffsets[i] = -1 - * - */ - (__pyx_v_mslice->strides[__pyx_v_i]) = (__pyx_v_mslice->strides[0]); - - /* "View.MemoryView":1351 - * mslice.shape[i] = 1 - * mslice.strides[i] = mslice.strides[0] - * mslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< - * - * - */ - (__pyx_v_mslice->suboffsets[__pyx_v_i]) = -1L; - } - - /* "View.MemoryView":1337 - * - * @cname('__pyx_memoryview_broadcast_leading') - * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< - * int ndim, - * int ndim_other) noexcept nogil: - */ - - /* function exit code */ -} - -/* "View.MemoryView":1359 - * - * @cname('__pyx_memoryview_refcount_copying') - * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil: # <<<<<<<<<<<<<< - * - * if dtype_is_object: - */ - -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) { - - /* "View.MemoryView":1361 - * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil: - * - * if dtype_is_object: # <<<<<<<<<<<<<< - * refcount_objects_in_slice_with_gil(dst.data, dst.shape, dst.strides, ndim, inc) - * - */ - if (__pyx_v_dtype_is_object) { - - /* "View.MemoryView":1362 - * - * if dtype_is_object: - * refcount_objects_in_slice_with_gil(dst.data, dst.shape, dst.strides, ndim, inc) # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') - */ - __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":1361 - * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil: - * - * if dtype_is_object: # <<<<<<<<<<<<<< - * refcount_objects_in_slice_with_gil(dst.data, dst.shape, dst.strides, ndim, inc) - * - */ - } - - /* "View.MemoryView":1359 - * - * @cname('__pyx_memoryview_refcount_copying') - * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil: # <<<<<<<<<<<<<< - * - * if dtype_is_object: - */ - - /* function exit code */ -} - -/* "View.MemoryView":1365 - * - * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') - * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< - * Py_ssize_t *strides, int ndim, - * bint inc) noexcept with gil: - */ - -static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) { - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - - /* "View.MemoryView":1368 - * Py_ssize_t *strides, int ndim, - * bint inc) noexcept with gil: - * refcount_objects_in_slice(data, shape, strides, ndim, inc) # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_refcount_objects_in_slice') - */ - __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, __pyx_v_shape, __pyx_v_strides, __pyx_v_ndim, __pyx_v_inc); - - /* "View.MemoryView":1365 - * - * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') - * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< - * Py_ssize_t *strides, int ndim, - * bint inc) noexcept with gil: - */ - - /* function exit code */ - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif -} - -/* "View.MemoryView":1371 - * - * @cname('__pyx_memoryview_refcount_objects_in_slice') - * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< - * Py_ssize_t *strides, int ndim, bint inc) noexcept: - * cdef Py_ssize_t i - */ - -static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) { - CYTHON_UNUSED Py_ssize_t __pyx_v_i; - Py_ssize_t __pyx_v_stride; - Py_ssize_t __pyx_t_1; - Py_ssize_t __pyx_t_2; - Py_ssize_t __pyx_t_3; - int __pyx_t_4; - - /* "View.MemoryView":1374 - * Py_ssize_t *strides, int ndim, bint inc) noexcept: - * cdef Py_ssize_t i - * cdef Py_ssize_t stride = strides[0] # <<<<<<<<<<<<<< - * - * for i in range(shape[0]): - */ - __pyx_v_stride = (__pyx_v_strides[0]); - - /* "View.MemoryView":1376 - * cdef Py_ssize_t stride = strides[0] - * - * for i in range(shape[0]): # <<<<<<<<<<<<<< - * if ndim == 1: - * if inc: - */ - __pyx_t_1 = (__pyx_v_shape[0]); - __pyx_t_2 = __pyx_t_1; - for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { - __pyx_v_i = __pyx_t_3; - - /* "View.MemoryView":1377 - * - * for i in range(shape[0]): - * if ndim == 1: # <<<<<<<<<<<<<< - * if inc: - * Py_INCREF(( data)[0]) - */ - __pyx_t_4 = (__pyx_v_ndim == 1); - if (__pyx_t_4) { - - /* "View.MemoryView":1378 - * for i in range(shape[0]): - * if ndim == 1: - * if inc: # <<<<<<<<<<<<<< - * Py_INCREF(( data)[0]) - * else: - */ - if (__pyx_v_inc) { - - /* "View.MemoryView":1379 - * if ndim == 1: - * if inc: - * Py_INCREF(( data)[0]) # <<<<<<<<<<<<<< - * else: - * Py_DECREF(( data)[0]) - */ - Py_INCREF((((PyObject **)__pyx_v_data)[0])); - - /* "View.MemoryView":1378 - * for i in range(shape[0]): - * if ndim == 1: - * if inc: # <<<<<<<<<<<<<< - * Py_INCREF(( data)[0]) - * else: - */ - goto __pyx_L6; - } - - /* "View.MemoryView":1381 - * Py_INCREF(( data)[0]) - * else: - * Py_DECREF(( data)[0]) # <<<<<<<<<<<<<< - * else: - * refcount_objects_in_slice(data, shape + 1, strides + 1, ndim - 1, inc) - */ - /*else*/ { - Py_DECREF((((PyObject **)__pyx_v_data)[0])); - } - __pyx_L6:; - - /* "View.MemoryView":1377 - * - * for i in range(shape[0]): - * if ndim == 1: # <<<<<<<<<<<<<< - * if inc: - * Py_INCREF(( data)[0]) - */ - goto __pyx_L5; - } - - /* "View.MemoryView":1383 - * Py_DECREF(( data)[0]) - * else: - * refcount_objects_in_slice(data, shape + 1, strides + 1, ndim - 1, inc) # <<<<<<<<<<<<<< - * - * data += stride - */ - /*else*/ { - __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_inc); - } - __pyx_L5:; - - /* "View.MemoryView":1385 - * refcount_objects_in_slice(data, shape + 1, strides + 1, ndim - 1, inc) - * - * data += stride # <<<<<<<<<<<<<< - * - * - */ - __pyx_v_data = (__pyx_v_data + __pyx_v_stride); - } - - /* "View.MemoryView":1371 - * - * @cname('__pyx_memoryview_refcount_objects_in_slice') - * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< - * Py_ssize_t *strides, int ndim, bint inc) noexcept: - * cdef Py_ssize_t i - */ - - /* function exit code */ -} - -/* "View.MemoryView":1391 - * - * @cname('__pyx_memoryview_slice_assign_scalar') - * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< - * size_t itemsize, void *item, - * bint dtype_is_object) noexcept nogil: - */ - -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":1394 - * size_t itemsize, void *item, - * bint dtype_is_object) noexcept nogil: - * refcount_copying(dst, dtype_is_object, ndim, inc=False) # <<<<<<<<<<<<<< - * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, itemsize, item) - * refcount_copying(dst, dtype_is_object, ndim, inc=True) - */ - __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 0); - - /* "View.MemoryView":1395 - * bint dtype_is_object) noexcept nogil: - * refcount_copying(dst, dtype_is_object, ndim, inc=False) - * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, itemsize, item) # <<<<<<<<<<<<<< - * refcount_copying(dst, dtype_is_object, ndim, inc=True) - * - */ - __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":1396 - * refcount_copying(dst, dtype_is_object, ndim, inc=False) - * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, itemsize, item) - * refcount_copying(dst, dtype_is_object, ndim, inc=True) # <<<<<<<<<<<<<< - * - * - */ - __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 1); - - /* "View.MemoryView":1391 - * - * @cname('__pyx_memoryview_slice_assign_scalar') - * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< - * size_t itemsize, void *item, - * bint dtype_is_object) noexcept nogil: - */ - - /* function exit code */ -} - -/* "View.MemoryView":1400 - * - * @cname('__pyx_memoryview__slice_assign_scalar') - * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< - * Py_ssize_t *strides, int ndim, - * size_t itemsize, void *item) noexcept nogil: - */ - -static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item) { - CYTHON_UNUSED Py_ssize_t __pyx_v_i; - Py_ssize_t __pyx_v_stride; - Py_ssize_t __pyx_v_extent; - int __pyx_t_1; - Py_ssize_t __pyx_t_2; - Py_ssize_t __pyx_t_3; - Py_ssize_t __pyx_t_4; - - /* "View.MemoryView":1404 - * size_t itemsize, void *item) noexcept nogil: - * cdef Py_ssize_t i - * cdef Py_ssize_t stride = strides[0] # <<<<<<<<<<<<<< - * cdef Py_ssize_t extent = shape[0] - * - */ - __pyx_v_stride = (__pyx_v_strides[0]); - - /* "View.MemoryView":1405 - * cdef Py_ssize_t i - * cdef Py_ssize_t stride = strides[0] - * cdef Py_ssize_t extent = shape[0] # <<<<<<<<<<<<<< - * - * if ndim == 1: - */ - __pyx_v_extent = (__pyx_v_shape[0]); - - /* "View.MemoryView":1407 - * cdef Py_ssize_t extent = shape[0] - * - * if ndim == 1: # <<<<<<<<<<<<<< - * for i in range(extent): - * memcpy(data, item, itemsize) - */ - __pyx_t_1 = (__pyx_v_ndim == 1); - if (__pyx_t_1) { - - /* "View.MemoryView":1408 - * - * if ndim == 1: - * for i in range(extent): # <<<<<<<<<<<<<< - * memcpy(data, item, itemsize) - * data += stride - */ - __pyx_t_2 = __pyx_v_extent; - __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":1409 - * if ndim == 1: - * for i in range(extent): - * memcpy(data, item, itemsize) # <<<<<<<<<<<<<< - * data += stride - * else: - */ - (void)(memcpy(__pyx_v_data, __pyx_v_item, __pyx_v_itemsize)); - - /* "View.MemoryView":1410 - * for i in range(extent): - * memcpy(data, item, itemsize) - * data += stride # <<<<<<<<<<<<<< - * else: - * for i in range(extent): - */ - __pyx_v_data = (__pyx_v_data + __pyx_v_stride); - } - - /* "View.MemoryView":1407 - * cdef Py_ssize_t extent = shape[0] - * - * if ndim == 1: # <<<<<<<<<<<<<< - * for i in range(extent): - * memcpy(data, item, itemsize) - */ - goto __pyx_L3; - } - - /* "View.MemoryView":1412 - * data += stride - * else: - * for i in range(extent): # <<<<<<<<<<<<<< - * _slice_assign_scalar(data, shape + 1, strides + 1, ndim - 1, itemsize, item) - * data += stride - */ - /*else*/ { - __pyx_t_2 = __pyx_v_extent; - __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":1413 - * else: - * for i in range(extent): - * _slice_assign_scalar(data, shape + 1, strides + 1, ndim - 1, itemsize, item) # <<<<<<<<<<<<<< - * data += stride - * - */ - __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":1414 - * for i in range(extent): - * _slice_assign_scalar(data, shape + 1, strides + 1, ndim - 1, itemsize, item) - * data += stride # <<<<<<<<<<<<<< - * - * - */ - __pyx_v_data = (__pyx_v_data + __pyx_v_stride); - } - } - __pyx_L3:; - - /* "View.MemoryView":1400 - * - * @cname('__pyx_memoryview__slice_assign_scalar') - * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< - * Py_ssize_t *strides, int ndim, - * size_t itemsize, void *item) noexcept nogil: - */ - - /* function exit code */ -} - -/* "(tree fragment)":1 - * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyMethodDef __pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum = {"__pyx_unpickle_Enum", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - PyObject *__pyx_v___pyx_type = 0; - long __pyx_v___pyx_checksum; - PyObject *__pyx_v___pyx_state = 0; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[3] = {0,0,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); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Enum") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 3)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - } - __pyx_v___pyx_type = values[0]; - __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) - __pyx_v___pyx_state = values[2]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 1, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_v___pyx_PickleError = 0; - PyObject *__pyx_v___pyx_result = 0; - 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; - int __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_unpickle_Enum", 1); - - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * if __pyx_checksum not in (0x82a3537, 0x6ae9995, 0xb068931): # <<<<<<<<<<<<<< - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum - */ - __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__8, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (__pyx_t_2) { - - /* "(tree fragment)":5 - * cdef object __pyx_result - * if __pyx_checksum not in (0x82a3537, 0x6ae9995, 0xb068931): - * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< - * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum - * __pyx_result = Enum.__new__(__pyx_type) - */ - __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_n_s_PickleError); - __Pyx_GIVEREF(__pyx_n_s_PickleError); - if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(1, 5, __pyx_L1_error); - __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_t_1); - __pyx_v___pyx_PickleError = __pyx_t_1; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "(tree fragment)":6 - * if __pyx_checksum not in (0x82a3537, 0x6ae9995, 0xb068931): - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum # <<<<<<<<<<<<<< - * __pyx_result = Enum.__new__(__pyx_type) - * if __pyx_state is not None: - */ - __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(1, 6, __pyx_L1_error) - - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * if __pyx_checksum not in (0x82a3537, 0x6ae9995, 0xb068931): # <<<<<<<<<<<<<< - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum - */ - } - - /* "(tree fragment)":7 - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum - * __pyx_result = Enum.__new__(__pyx_type) # <<<<<<<<<<<<<< - * if __pyx_state is not None: - * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) - */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_MemviewEnum_type), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = NULL; - __pyx_t_5 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_5 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } - __pyx_v___pyx_result = __pyx_t_1; - __pyx_t_1 = 0; - - /* "(tree fragment)":8 - * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum - * __pyx_result = Enum.__new__(__pyx_type) - * if __pyx_state is not None: # <<<<<<<<<<<<<< - * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) - * return __pyx_result - */ - __pyx_t_2 = (__pyx_v___pyx_state != Py_None); - if (__pyx_t_2) { - - /* "(tree fragment)":9 - * __pyx_result = Enum.__new__(__pyx_type) - * if __pyx_state is not None: - * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< - * return __pyx_result - * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): - */ - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 9, __pyx_L1_error) - __pyx_t_1 = __pyx_unpickle_Enum__set_state(((struct __pyx_MemviewEnum_obj *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "(tree fragment)":8 - * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum - * __pyx_result = Enum.__new__(__pyx_type) - * if __pyx_state is not None: # <<<<<<<<<<<<<< - * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) - * return __pyx_result - */ - } - - /* "(tree fragment)":10 - * if __pyx_state is not None: - * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) - * return __pyx_result # <<<<<<<<<<<<<< - * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): - * __pyx_result.name = __pyx_state[0] - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v___pyx_result); - __pyx_r = __pyx_v___pyx_result; - goto __pyx_L0; - - /* "(tree fragment)":1 - * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v___pyx_PickleError); - __Pyx_XDECREF(__pyx_v___pyx_result); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":11 - * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result.name = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - */ - -static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - Py_ssize_t __pyx_t_3; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - int __pyx_t_8; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_unpickle_Enum__set_state", 1); - - /* "(tree fragment)":12 - * return __pyx_result - * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): - * __pyx_result.name = __pyx_state[0] # <<<<<<<<<<<<<< - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - * __pyx_result.__dict__.update(__pyx_state[1]) - */ - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->name); - __Pyx_DECREF(__pyx_v___pyx_result->name); - __pyx_v___pyx_result->name = __pyx_t_1; - __pyx_t_1 = 0; - - /* "(tree fragment)":13 - * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): - * __pyx_result.name = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< - * __pyx_result.__dict__.update(__pyx_state[1]) - */ - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(1, 13, __pyx_L1_error) - } - __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) - __pyx_t_4 = (__pyx_t_3 > 1); - if (__pyx_t_4) { - } else { - __pyx_t_2 = __pyx_t_4; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) - __pyx_t_2 = __pyx_t_4; - __pyx_L4_bool_binop_done:; - if (__pyx_t_2) { - - /* "(tree fragment)":14 - * __pyx_result.name = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< - */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 14, __pyx_L1_error) - } - __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_7 = NULL; - __pyx_t_8 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_6))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_6, function); - __pyx_t_8 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "(tree fragment)":13 - * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): - * __pyx_result.name = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< - * __pyx_result.__dict__.update(__pyx_state[1]) - */ - } - - /* "(tree fragment)":11 - * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result.name = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - */ - - /* 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_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "robo_utils/core.pyx":10 - * from libc.math cimport floor - * - * cdef int round_to_int(float x) nogil: # <<<<<<<<<<<<<< - * return (x + 0.5) - * - */ - -static int __pyx_f_10robo_utils_4core_round_to_int(float __pyx_v_x) { - int __pyx_r; - - /* "robo_utils/core.pyx":11 - * - * cdef int round_to_int(float x) nogil: - * return (x + 0.5) # <<<<<<<<<<<<<< - * - * @cython.cdivision(True) - */ - __pyx_r = ((int)(__pyx_v_x + 0.5)); - goto __pyx_L0; - - /* "robo_utils/core.pyx":10 - * from libc.math cimport floor - * - * cdef int round_to_int(float x) nogil: # <<<<<<<<<<<<<< - * return (x + 0.5) - * - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "robo_utils/core.pyx":16 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * cdef void float_to_int_duration_each(float[:] dur, int[:] int_dur, int T, int[:] mask) nogil: # <<<<<<<<<<<<<< - * """ - * Convert float duration to int duration - */ - -static void __pyx_f_10robo_utils_4core_float_to_int_duration_each(__Pyx_memviewslice __pyx_v_dur, __Pyx_memviewslice __pyx_v_int_dur, int __pyx_v_T, __Pyx_memviewslice __pyx_v_mask) { - int __pyx_v_I; - float __pyx_v_float_sum; - int __pyx_v_int_sum; - int __pyx_v_i; - int __pyx_v_rounded_dur; - int __pyx_v_valid_count; - int __pyx_v_remaining_time; - int __pyx_v_j; - int __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - 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; - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save; - #endif - - /* "robo_utils/core.pyx":26 - * mask (int[:]): mask, shape (I,) - * """ - * cdef int I = dur.shape[0] # <<<<<<<<<<<<<< - * cdef float float_sum = 0 - * cdef int int_sum = 0, i, rounded_dur, valid_count - */ - __pyx_v_I = (__pyx_v_dur.shape[0]); - - /* "robo_utils/core.pyx":27 - * """ - * cdef int I = dur.shape[0] - * cdef float float_sum = 0 # <<<<<<<<<<<<<< - * cdef int int_sum = 0, i, rounded_dur, valid_count - * valid_count = 0 - */ - __pyx_v_float_sum = 0.0; - - /* "robo_utils/core.pyx":28 - * cdef int I = dur.shape[0] - * cdef float float_sum = 0 - * cdef int int_sum = 0, i, rounded_dur, valid_count # <<<<<<<<<<<<<< - * valid_count = 0 - * - */ - __pyx_v_int_sum = 0; - - /* "robo_utils/core.pyx":29 - * cdef float float_sum = 0 - * cdef int int_sum = 0, i, rounded_dur, valid_count - * valid_count = 0 # <<<<<<<<<<<<<< - * - * for i in range(I): - */ - __pyx_v_valid_count = 0; - - /* "robo_utils/core.pyx":31 - * valid_count = 0 - * - * for i in range(I): # <<<<<<<<<<<<<< - * if mask[i] == 1: - * valid_count += 1 - */ - __pyx_t_1 = __pyx_v_I; - __pyx_t_2 = __pyx_t_1; - for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { - __pyx_v_i = __pyx_t_3; - - /* "robo_utils/core.pyx":32 - * - * for i in range(I): - * if mask[i] == 1: # <<<<<<<<<<<<<< - * valid_count += 1 - * float_sum += dur[i] - */ - __pyx_t_4 = __pyx_v_i; - __pyx_t_5 = ((*((int *) ( /* dim=0 */ (__pyx_v_mask.data + __pyx_t_4 * __pyx_v_mask.strides[0]) ))) == 1); - if (__pyx_t_5) { - - /* "robo_utils/core.pyx":33 - * for i in range(I): - * if mask[i] == 1: - * valid_count += 1 # <<<<<<<<<<<<<< - * float_sum += dur[i] - * rounded_dur = round_to_int(float_sum - int_sum) - */ - __pyx_v_valid_count = (__pyx_v_valid_count + 1); - - /* "robo_utils/core.pyx":34 - * if mask[i] == 1: - * valid_count += 1 - * float_sum += dur[i] # <<<<<<<<<<<<<< - * rounded_dur = round_to_int(float_sum - int_sum) - * if rounded_dur <= 0: - */ - __pyx_t_4 = __pyx_v_i; - __pyx_v_float_sum = (__pyx_v_float_sum + (*((float *) ( /* dim=0 */ (__pyx_v_dur.data + __pyx_t_4 * __pyx_v_dur.strides[0]) )))); - - /* "robo_utils/core.pyx":35 - * valid_count += 1 - * float_sum += dur[i] - * rounded_dur = round_to_int(float_sum - int_sum) # <<<<<<<<<<<<<< - * if rounded_dur <= 0: - * rounded_dur = 1 # Ensure each duration is greater than 0 - */ - __pyx_t_6 = __pyx_f_10robo_utils_4core_round_to_int((__pyx_v_float_sum - __pyx_v_int_sum)); if (unlikely(__pyx_t_6 == ((int)-1) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 35, __pyx_L1_error) - __pyx_v_rounded_dur = __pyx_t_6; - - /* "robo_utils/core.pyx":36 - * float_sum += dur[i] - * rounded_dur = round_to_int(float_sum - int_sum) - * if rounded_dur <= 0: # <<<<<<<<<<<<<< - * rounded_dur = 1 # Ensure each duration is greater than 0 - * int_dur[i] = rounded_dur - */ - __pyx_t_5 = (__pyx_v_rounded_dur <= 0); - if (__pyx_t_5) { - - /* "robo_utils/core.pyx":37 - * rounded_dur = round_to_int(float_sum - int_sum) - * if rounded_dur <= 0: - * rounded_dur = 1 # Ensure each duration is greater than 0 # <<<<<<<<<<<<<< - * int_dur[i] = rounded_dur - * int_sum += rounded_dur - */ - __pyx_v_rounded_dur = 1; - - /* "robo_utils/core.pyx":36 - * float_sum += dur[i] - * rounded_dur = round_to_int(float_sum - int_sum) - * if rounded_dur <= 0: # <<<<<<<<<<<<<< - * rounded_dur = 1 # Ensure each duration is greater than 0 - * int_dur[i] = rounded_dur - */ - } - - /* "robo_utils/core.pyx":38 - * if rounded_dur <= 0: - * rounded_dur = 1 # Ensure each duration is greater than 0 - * int_dur[i] = rounded_dur # <<<<<<<<<<<<<< - * int_sum += rounded_dur - * else: - */ - __pyx_t_4 = __pyx_v_i; - *((int *) ( /* dim=0 */ (__pyx_v_int_dur.data + __pyx_t_4 * __pyx_v_int_dur.strides[0]) )) = __pyx_v_rounded_dur; - - /* "robo_utils/core.pyx":39 - * rounded_dur = 1 # Ensure each duration is greater than 0 - * int_dur[i] = rounded_dur - * int_sum += rounded_dur # <<<<<<<<<<<<<< - * else: - * break - */ - __pyx_v_int_sum = (__pyx_v_int_sum + __pyx_v_rounded_dur); - - /* "robo_utils/core.pyx":32 - * - * for i in range(I): - * if mask[i] == 1: # <<<<<<<<<<<<<< - * valid_count += 1 - * float_sum += dur[i] - */ - goto __pyx_L5; - } - - /* "robo_utils/core.pyx":41 - * int_sum += rounded_dur - * else: - * break # <<<<<<<<<<<<<< - * - * # Adjust the durations to ensure they are valid - */ - /*else*/ { - goto __pyx_L4_break; - } - __pyx_L5:; - } - __pyx_L4_break:; - - /* "robo_utils/core.pyx":45 - * # Adjust the durations to ensure they are valid - * cdef int remaining_time, j - * if valid_count > 0: # <<<<<<<<<<<<<< - * remaining_time = T - int_sum - * j = valid_count - 1 - */ - __pyx_t_5 = (__pyx_v_valid_count > 0); - if (__pyx_t_5) { - - /* "robo_utils/core.pyx":46 - * cdef int remaining_time, j - * if valid_count > 0: - * remaining_time = T - int_sum # <<<<<<<<<<<<<< - * j = valid_count - 1 - * while j >= 0: - */ - __pyx_v_remaining_time = (__pyx_v_T - __pyx_v_int_sum); - - /* "robo_utils/core.pyx":47 - * if valid_count > 0: - * remaining_time = T - int_sum - * j = valid_count - 1 # <<<<<<<<<<<<<< - * while j >= 0: - * if int_dur[j] + remaining_time >= 1: - */ - __pyx_v_j = (__pyx_v_valid_count - 1); - - /* "robo_utils/core.pyx":48 - * remaining_time = T - int_sum - * j = valid_count - 1 - * while j >= 0: # <<<<<<<<<<<<<< - * if int_dur[j] + remaining_time >= 1: - * int_dur[j] += remaining_time - */ - while (1) { - __pyx_t_5 = (__pyx_v_j >= 0); - if (!__pyx_t_5) break; - - /* "robo_utils/core.pyx":49 - * j = valid_count - 1 - * while j >= 0: - * if int_dur[j] + remaining_time >= 1: # <<<<<<<<<<<<<< - * int_dur[j] += remaining_time - * break - */ - __pyx_t_4 = __pyx_v_j; - __pyx_t_5 = (((*((int *) ( /* dim=0 */ (__pyx_v_int_dur.data + __pyx_t_4 * __pyx_v_int_dur.strides[0]) ))) + __pyx_v_remaining_time) >= 1); - if (__pyx_t_5) { - - /* "robo_utils/core.pyx":50 - * while j >= 0: - * if int_dur[j] + remaining_time >= 1: - * int_dur[j] += remaining_time # <<<<<<<<<<<<<< - * break - * else: - */ - __pyx_t_4 = __pyx_v_j; - *((int *) ( /* dim=0 */ (__pyx_v_int_dur.data + __pyx_t_4 * __pyx_v_int_dur.strides[0]) )) += __pyx_v_remaining_time; - - /* "robo_utils/core.pyx":51 - * if int_dur[j] + remaining_time >= 1: - * int_dur[j] += remaining_time - * break # <<<<<<<<<<<<<< - * else: - * remaining_time += int_dur[j] - 1 - */ - goto __pyx_L9_break; - - /* "robo_utils/core.pyx":49 - * j = valid_count - 1 - * while j >= 0: - * if int_dur[j] + remaining_time >= 1: # <<<<<<<<<<<<<< - * int_dur[j] += remaining_time - * break - */ - } - - /* "robo_utils/core.pyx":53 - * break - * else: - * remaining_time += int_dur[j] - 1 # <<<<<<<<<<<<<< - * int_dur[j] = 1 - * j -= 1 - */ - /*else*/ { - __pyx_t_4 = __pyx_v_j; - __pyx_v_remaining_time = (__pyx_v_remaining_time + ((*((int *) ( /* dim=0 */ (__pyx_v_int_dur.data + __pyx_t_4 * __pyx_v_int_dur.strides[0]) ))) - 1)); - - /* "robo_utils/core.pyx":54 - * else: - * remaining_time += int_dur[j] - 1 - * int_dur[j] = 1 # <<<<<<<<<<<<<< - * j -= 1 - * - */ - __pyx_t_4 = __pyx_v_j; - *((int *) ( /* dim=0 */ (__pyx_v_int_dur.data + __pyx_t_4 * __pyx_v_int_dur.strides[0]) )) = 1; - } - - /* "robo_utils/core.pyx":55 - * remaining_time += int_dur[j] - 1 - * int_dur[j] = 1 - * j -= 1 # <<<<<<<<<<<<<< - * - * @cython.boundscheck(False) - */ - __pyx_v_j = (__pyx_v_j - 1); - } - __pyx_L9_break:; - - /* "robo_utils/core.pyx":45 - * # Adjust the durations to ensure they are valid - * cdef int remaining_time, j - * if valid_count > 0: # <<<<<<<<<<<<<< - * remaining_time = T - int_sum - * j = valid_count - 1 - */ - } - - /* "robo_utils/core.pyx":16 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * cdef void float_to_int_duration_each(float[:] dur, int[:] int_dur, int T, int[:] mask) nogil: # <<<<<<<<<<<<<< - * """ - * Convert float duration to int duration - */ - - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - #ifdef WITH_THREAD - __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_AddTraceback("robo_utils.core.float_to_int_duration_each", __pyx_clineno, __pyx_lineno, __pyx_filename); - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - __pyx_L0:; -} - -/* "robo_utils/core.pyx":59 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * cpdef void float_to_int_duration_batch_c(float[:, :] dur, int[:] T, int[:, :] mask, int[:, :] int_dur) nogil: # <<<<<<<<<<<<<< - * """ - * Args: - */ - -static PyObject *__pyx_pw_10robo_utils_4core_1float_to_int_duration_batch_c(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static void __pyx_f_10robo_utils_4core_float_to_int_duration_batch_c(__Pyx_memviewslice __pyx_v_dur, __Pyx_memviewslice __pyx_v_T, __Pyx_memviewslice __pyx_v_mask, __Pyx_memviewslice __pyx_v_int_dur, CYTHON_UNUSED int __pyx_skip_dispatch) { - CYTHON_UNUSED int __pyx_v_B; - int __pyx_v_i; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - __Pyx_memviewslice __pyx_t_4 = { 0, 0, { 0 }, { 0 }, { 0 } }; - __Pyx_memviewslice __pyx_t_5 = { 0, 0, { 0 }, { 0 }, { 0 } }; - Py_ssize_t __pyx_t_6; - __Pyx_memviewslice __pyx_t_7 = { 0, 0, { 0 }, { 0 }, { 0 } }; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save; - #endif - __Pyx_RefNannySetupContext("float_to_int_duration_batch_c", 1); - - /* "robo_utils/core.pyx":67 - * int_dur (int[:, :]): int duration, shape (B, I) - * """ - * cdef int B = dur.shape[0] # <<<<<<<<<<<<<< - * cdef int i - * for i in prange(B, nogil=True): - */ - __pyx_v_B = (__pyx_v_dur.shape[0]); - - /* "robo_utils/core.pyx":69 - * cdef int B = dur.shape[0] - * cdef int i - * for i in prange(B, nogil=True): # <<<<<<<<<<<<<< - * float_to_int_duration_each(dur[i], int_dur[i], T[i], mask[i]) - * - */ - { - #ifdef WITH_THREAD - PyThreadState *_save; - _save = NULL; - if (PyGILState_Check()) { - Py_UNBLOCK_THREADS - } - __Pyx_FastGIL_Remember(); - #endif - /*try:*/ { - __pyx_t_1 = __pyx_v_B; - { - int __pyx_parallel_temp0 = ((int)0xbad0bad0); - const char *__pyx_parallel_filename = NULL; int __pyx_parallel_lineno = 0, __pyx_parallel_clineno = 0; - PyObject *__pyx_parallel_exc_type = NULL, *__pyx_parallel_exc_value = NULL, *__pyx_parallel_exc_tb = NULL; - int __pyx_parallel_why; - __pyx_parallel_why = 0; - #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_3 = (__pyx_t_1 - 0 + 1 - 1/abs(1)) / 1; - if (__pyx_t_3 > 0) - { - #ifdef _OPENMP - #pragma omp parallel private(__pyx_t_6) firstprivate(__pyx_t_4, __pyx_t_5, __pyx_t_7) private(__pyx_filename, __pyx_lineno, __pyx_clineno) shared(__pyx_parallel_why, __pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb) - #endif /* _OPENMP */ - { - #ifdef _OPENMP - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - Py_BEGIN_ALLOW_THREADS - #endif /* _OPENMP */ - #ifdef _OPENMP - #pragma omp for firstprivate(__pyx_v_i) lastprivate(__pyx_v_i) - #endif /* _OPENMP */ - for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_3; __pyx_t_2++){ - if (__pyx_parallel_why < 2) - { - __pyx_v_i = (int)(0 + 1 * __pyx_t_2); - - /* "robo_utils/core.pyx":70 - * cdef int i - * for i in prange(B, nogil=True): - * float_to_int_duration_each(dur[i], int_dur[i], T[i], mask[i]) # <<<<<<<<<<<<<< - * - * cdef int generate_random(int start, int end) nogil: - */ - __pyx_t_4.data = __pyx_v_dur.data; - __pyx_t_4.memview = __pyx_v_dur.memview; - __PYX_INC_MEMVIEW(&__pyx_t_4, 0); - { - Py_ssize_t __pyx_tmp_idx = __pyx_v_i; - Py_ssize_t __pyx_tmp_stride = __pyx_v_dur.strides[0]; - __pyx_t_4.data += __pyx_tmp_idx * __pyx_tmp_stride; -} - -__pyx_t_4.shape[0] = __pyx_v_dur.shape[1]; -__pyx_t_4.strides[0] = __pyx_v_dur.strides[1]; - __pyx_t_4.suboffsets[0] = -1; - -__pyx_t_5.data = __pyx_v_int_dur.data; - __pyx_t_5.memview = __pyx_v_int_dur.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_int_dur.strides[0]; - __pyx_t_5.data += __pyx_tmp_idx * __pyx_tmp_stride; -} - -__pyx_t_5.shape[0] = __pyx_v_int_dur.shape[1]; -__pyx_t_5.strides[0] = __pyx_v_int_dur.strides[1]; - __pyx_t_5.suboffsets[0] = -1; - -__pyx_t_6 = __pyx_v_i; - __pyx_t_7.data = __pyx_v_mask.data; - __pyx_t_7.memview = __pyx_v_mask.memview; - __PYX_INC_MEMVIEW(&__pyx_t_7, 0); - { - Py_ssize_t __pyx_tmp_idx = __pyx_v_i; - Py_ssize_t __pyx_tmp_stride = __pyx_v_mask.strides[0]; - __pyx_t_7.data += __pyx_tmp_idx * __pyx_tmp_stride; -} - -__pyx_t_7.shape[0] = __pyx_v_mask.shape[1]; -__pyx_t_7.strides[0] = __pyx_v_mask.strides[1]; - __pyx_t_7.suboffsets[0] = -1; - -__pyx_f_10robo_utils_4core_float_to_int_duration_each(__pyx_t_4, __pyx_t_5, (*((int *) ( /* dim=0 */ (__pyx_v_T.data + __pyx_t_6 * __pyx_v_T.strides[0]) ))), __pyx_t_7); if (unlikely(__Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 70, __pyx_L8_error) - __PYX_XCLEAR_MEMVIEW(&__pyx_t_4, 0); - __pyx_t_4.memview = NULL; __pyx_t_4.data = NULL; - __PYX_XCLEAR_MEMVIEW(&__pyx_t_5, 0); - __pyx_t_5.memview = NULL; __pyx_t_5.data = NULL; - __PYX_XCLEAR_MEMVIEW(&__pyx_t_7, 0); - __pyx_t_7.memview = NULL; __pyx_t_7.data = NULL; - goto __pyx_L11; - __pyx_L8_error:; - { - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - #ifdef _OPENMP - #pragma omp flush(__pyx_parallel_exc_type) - #endif /* _OPENMP */ - if (!__pyx_parallel_exc_type) { - __Pyx_ErrFetchWithState(&__pyx_parallel_exc_type, &__pyx_parallel_exc_value, &__pyx_parallel_exc_tb); - __pyx_parallel_filename = __pyx_filename; __pyx_parallel_lineno = __pyx_lineno; __pyx_parallel_clineno = __pyx_clineno; - __Pyx_GOTREF(__pyx_parallel_exc_type); - } - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - } - __pyx_parallel_why = 4; - goto __pyx_L10; - __pyx_L10:; - #ifdef _OPENMP - #pragma omp critical(__pyx_parallel_lastprivates0) - #endif /* _OPENMP */ - { - __pyx_parallel_temp0 = __pyx_v_i; - } - __pyx_L11:; - #ifdef _OPENMP - #pragma omp flush(__pyx_parallel_why) - #endif /* _OPENMP */ - } - } - #ifdef _OPENMP - Py_END_ALLOW_THREADS - #else -{ -#ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - #endif /* _OPENMP */ - /* Clean up any temporaries */ - __PYX_XCLEAR_MEMVIEW(&__pyx_t_4, 0); - __pyx_t_4.memview = NULL; __pyx_t_4.data = NULL; - __PYX_XCLEAR_MEMVIEW(&__pyx_t_5, 0); - __pyx_t_5.memview = NULL; __pyx_t_5.data = NULL; - __PYX_XCLEAR_MEMVIEW(&__pyx_t_7, 0); - __pyx_t_7.memview = NULL; __pyx_t_7.data = NULL; - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - #ifndef _OPENMP -} -#endif /* _OPENMP */ - } - } - if (__pyx_parallel_exc_type) { - /* This may have been overridden by a continue, break or return in another thread. Prefer the error. */ - __pyx_parallel_why = 4; - } - if (__pyx_parallel_why) { - __pyx_v_i = __pyx_parallel_temp0; - switch (__pyx_parallel_why) { - case 4: - { - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_GIVEREF(__pyx_parallel_exc_type); - __Pyx_ErrRestoreWithState(__pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb); - __pyx_filename = __pyx_parallel_filename; __pyx_lineno = __pyx_parallel_lineno; __pyx_clineno = __pyx_parallel_clineno; - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - } - goto __pyx_L4_error; - } - } - } - #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 - } - - /* "robo_utils/core.pyx":69 - * cdef int B = dur.shape[0] - * cdef int i - * for i in prange(B, nogil=True): # <<<<<<<<<<<<<< - * float_to_int_duration_each(dur[i], int_dur[i], T[i], mask[i]) - * - */ - /*finally:*/ { - /*normal exit:*/{ - #ifdef WITH_THREAD - __Pyx_FastGIL_Forget(); - if (_save) { - Py_BLOCK_THREADS - } - #endif - goto __pyx_L5; - } - __pyx_L4_error: { - #ifdef WITH_THREAD - __Pyx_FastGIL_Forget(); - if (_save) { - Py_BLOCK_THREADS - } - #endif - goto __pyx_L1_error; - } - __pyx_L5:; - } - } - - /* "robo_utils/core.pyx":59 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * cpdef void float_to_int_duration_batch_c(float[:, :] dur, int[:] T, int[:, :] mask, int[:, :] int_dur) nogil: # <<<<<<<<<<<<<< - * """ - * Args: - */ - - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - #ifdef WITH_THREAD - __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __PYX_XCLEAR_MEMVIEW(&__pyx_t_4, 1); - __PYX_XCLEAR_MEMVIEW(&__pyx_t_5, 1); - __PYX_XCLEAR_MEMVIEW(&__pyx_t_7, 1); - __Pyx_AddTraceback("robo_utils.core.float_to_int_duration_batch_c", __pyx_clineno, __pyx_lineno, __pyx_filename); - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - __pyx_L0:; - __Pyx_RefNannyFinishContextNogil() -} - -/* Python wrapper */ -static PyObject *__pyx_pw_10robo_utils_4core_1float_to_int_duration_batch_c(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -PyDoc_STRVAR(__pyx_doc_10robo_utils_4core_float_to_int_duration_batch_c, "\n Args:\n dur (float[:, :]): float duration, shape (B, I)\n T (int[:]): total duration, shape (B,)\n mask (int[:, :]): mask, shape (B, I)\n int_dur (int[:, :]): int duration, shape (B, I)\n "); -static PyMethodDef __pyx_mdef_10robo_utils_4core_1float_to_int_duration_batch_c = {"float_to_int_duration_batch_c", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10robo_utils_4core_1float_to_int_duration_batch_c, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10robo_utils_4core_float_to_int_duration_batch_c}; -static PyObject *__pyx_pw_10robo_utils_4core_1float_to_int_duration_batch_c(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - __Pyx_memviewslice __pyx_v_dur = { 0, 0, { 0 }, { 0 }, { 0 } }; - __Pyx_memviewslice __pyx_v_T = { 0, 0, { 0 }, { 0 }, { 0 } }; - __Pyx_memviewslice __pyx_v_mask = { 0, 0, { 0 }, { 0 }, { 0 } }; - __Pyx_memviewslice __pyx_v_int_dur = { 0, 0, { 0 }, { 0 }, { 0 } }; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[4] = {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("float_to_int_duration_batch_c (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_dur,&__pyx_n_s_T,&__pyx_n_s_mask,&__pyx_n_s_int_dur,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dur)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 59, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_T)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 59, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("float_to_int_duration_batch_c", 1, 4, 4, 1); __PYX_ERR(0, 59, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_mask)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 59, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("float_to_int_duration_batch_c", 1, 4, 4, 2); __PYX_ERR(0, 59, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_int_dur)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 59, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("float_to_int_duration_batch_c", 1, 4, 4, 3); __PYX_ERR(0, 59, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "float_to_int_duration_batch_c") < 0)) __PYX_ERR(0, 59, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 4)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); - } - __pyx_v_dur = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_dur.memview)) __PYX_ERR(0, 59, __pyx_L3_error) - __pyx_v_T = __Pyx_PyObject_to_MemoryviewSlice_ds_int(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_T.memview)) __PYX_ERR(0, 59, __pyx_L3_error) - __pyx_v_mask = __Pyx_PyObject_to_MemoryviewSlice_dsds_int(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_mask.memview)) __PYX_ERR(0, 59, __pyx_L3_error) - __pyx_v_int_dur = __Pyx_PyObject_to_MemoryviewSlice_dsds_int(values[3], PyBUF_WRITABLE); if (unlikely(!__pyx_v_int_dur.memview)) __PYX_ERR(0, 59, __pyx_L3_error) - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("float_to_int_duration_batch_c", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 59, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __PYX_XCLEAR_MEMVIEW(&__pyx_v_dur, 1); - __PYX_XCLEAR_MEMVIEW(&__pyx_v_T, 1); - __PYX_XCLEAR_MEMVIEW(&__pyx_v_mask, 1); - __PYX_XCLEAR_MEMVIEW(&__pyx_v_int_dur, 1); - __Pyx_AddTraceback("robo_utils.core.float_to_int_duration_batch_c", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_10robo_utils_4core_float_to_int_duration_batch_c(__pyx_self, __pyx_v_dur, __pyx_v_T, __pyx_v_mask, __pyx_v_int_dur); - - /* function exit code */ - __PYX_XCLEAR_MEMVIEW(&__pyx_v_dur, 1); - __PYX_XCLEAR_MEMVIEW(&__pyx_v_T, 1); - __PYX_XCLEAR_MEMVIEW(&__pyx_v_mask, 1); - __PYX_XCLEAR_MEMVIEW(&__pyx_v_int_dur, 1); - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_10robo_utils_4core_float_to_int_duration_batch_c(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_dur, __Pyx_memviewslice __pyx_v_T, __Pyx_memviewslice __pyx_v_mask, __Pyx_memviewslice __pyx_v_int_dur) { - 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("float_to_int_duration_batch_c", 1); - __Pyx_XDECREF(__pyx_r); - if (unlikely(!__pyx_v_dur.memview)) { __Pyx_RaiseUnboundLocalError("dur"); __PYX_ERR(0, 59, __pyx_L1_error) } - if (unlikely(!__pyx_v_T.memview)) { __Pyx_RaiseUnboundLocalError("T"); __PYX_ERR(0, 59, __pyx_L1_error) } - if (unlikely(!__pyx_v_mask.memview)) { __Pyx_RaiseUnboundLocalError("mask"); __PYX_ERR(0, 59, __pyx_L1_error) } - if (unlikely(!__pyx_v_int_dur.memview)) { __Pyx_RaiseUnboundLocalError("int_dur"); __PYX_ERR(0, 59, __pyx_L1_error) } - __pyx_f_10robo_utils_4core_float_to_int_duration_batch_c(__pyx_v_dur, __pyx_v_T, __pyx_v_mask, __pyx_v_int_dur, 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 59, __pyx_L1_error) - __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 59, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("robo_utils.core.float_to_int_duration_batch_c", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "robo_utils/core.pyx":72 - * float_to_int_duration_each(dur[i], int_dur[i], T[i], mask[i]) - * - * cdef int generate_random(int start, int end) nogil: # <<<<<<<<<<<<<< - * # generate a random integer in [start, end) - * return start + ((end - start) * (rand() / RAND_MAX)) - */ - -static int __pyx_f_10robo_utils_4core_generate_random(int __pyx_v_start, int __pyx_v_end) { - int __pyx_r; - int __pyx_t_1; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save; - #endif - - /* "robo_utils/core.pyx":74 - * cdef int generate_random(int start, int end) nogil: - * # generate a random integer in [start, end) - * return start + ((end - start) * (rand() / RAND_MAX)) # <<<<<<<<<<<<<< - * - * @cython.cdivision(True) - */ - __pyx_t_1 = rand(); - if (unlikely(((float)RAND_MAX) == 0)) { - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - PyErr_SetString(PyExc_ZeroDivisionError, "float division"); - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - __PYX_ERR(0, 74, __pyx_L1_error) - } - __pyx_r = (__pyx_v_start + ((int)(((float)(__pyx_v_end - __pyx_v_start)) * (((float)__pyx_t_1) / ((float)RAND_MAX))))); - goto __pyx_L0; - - /* "robo_utils/core.pyx":72 - * float_to_int_duration_each(dur[i], int_dur[i], T[i], mask[i]) - * - * cdef int generate_random(int start, int end) nogil: # <<<<<<<<<<<<<< - * # generate a random integer in [start, end) - * return start + ((end - start) * (rand() / RAND_MAX)) - */ - - /* function exit code */ - __pyx_L1_error:; - #ifdef WITH_THREAD - __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_AddTraceback("robo_utils.core.generate_random", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - __pyx_L0:; - return __pyx_r; -} - -/* "robo_utils/core.pyx":79 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * cdef void generate_random_intervals_each(int[:] boundaries, int[:] result, int num_randoms) nogil: # <<<<<<<<<<<<<< - * """ - * Generate random intervals for a single batch - */ - -static void __pyx_f_10robo_utils_4core_generate_random_intervals_each(__Pyx_memviewslice __pyx_v_boundaries, __Pyx_memviewslice __pyx_v_result, int __pyx_v_num_randoms) { - int __pyx_v_N; - int __pyx_v_idx; - int __pyx_v_i; - int __pyx_v_j; - int __pyx_v_start; - int __pyx_v_end; - long __pyx_t_1; - long __pyx_t_2; - int __pyx_t_3; - Py_ssize_t __pyx_t_4; - int __pyx_t_5; - int __pyx_t_6; - int __pyx_t_7; - int __pyx_t_8; - int __pyx_t_9; - int __pyx_t_10; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save; - #endif - - /* "robo_utils/core.pyx":88 - * num_randoms (int): number of random values to generate per interval - * """ - * cdef int N = boundaries.shape[0] # <<<<<<<<<<<<<< - * cdef int idx = 0 - * cdef int i, j - */ - __pyx_v_N = (__pyx_v_boundaries.shape[0]); - - /* "robo_utils/core.pyx":89 - * """ - * cdef int N = boundaries.shape[0] - * cdef int idx = 0 # <<<<<<<<<<<<<< - * cdef int i, j - * - */ - __pyx_v_idx = 0; - - /* "robo_utils/core.pyx":92 - * cdef int i, j - * - * for i in range(N - 1): # <<<<<<<<<<<<<< - * start = boundaries[i] - * end = boundaries[i + 1] - */ - __pyx_t_1 = (__pyx_v_N - 1); - __pyx_t_2 = __pyx_t_1; - for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { - __pyx_v_i = __pyx_t_3; - - /* "robo_utils/core.pyx":93 - * - * for i in range(N - 1): - * start = boundaries[i] # <<<<<<<<<<<<<< - * end = boundaries[i + 1] - * if end == 0 and i > 0: - */ - __pyx_t_4 = __pyx_v_i; - __pyx_v_start = (*((int *) ( /* dim=0 */ (__pyx_v_boundaries.data + __pyx_t_4 * __pyx_v_boundaries.strides[0]) ))); - - /* "robo_utils/core.pyx":94 - * for i in range(N - 1): - * start = boundaries[i] - * end = boundaries[i + 1] # <<<<<<<<<<<<<< - * if end == 0 and i > 0: - * break - */ - __pyx_t_4 = (__pyx_v_i + 1); - __pyx_v_end = (*((int *) ( /* dim=0 */ (__pyx_v_boundaries.data + __pyx_t_4 * __pyx_v_boundaries.strides[0]) ))); - - /* "robo_utils/core.pyx":95 - * start = boundaries[i] - * end = boundaries[i + 1] - * if end == 0 and i > 0: # <<<<<<<<<<<<<< - * break - * for j in range(num_randoms): - */ - __pyx_t_6 = (__pyx_v_end == 0); - if (__pyx_t_6) { - } else { - __pyx_t_5 = __pyx_t_6; - goto __pyx_L6_bool_binop_done; - } - __pyx_t_6 = (__pyx_v_i > 0); - __pyx_t_5 = __pyx_t_6; - __pyx_L6_bool_binop_done:; - if (__pyx_t_5) { - - /* "robo_utils/core.pyx":96 - * end = boundaries[i + 1] - * if end == 0 and i > 0: - * break # <<<<<<<<<<<<<< - * for j in range(num_randoms): - * result[idx + j] = generate_random(start, end) - */ - goto __pyx_L4_break; - - /* "robo_utils/core.pyx":95 - * start = boundaries[i] - * end = boundaries[i + 1] - * if end == 0 and i > 0: # <<<<<<<<<<<<<< - * break - * for j in range(num_randoms): - */ - } - - /* "robo_utils/core.pyx":97 - * if end == 0 and i > 0: - * break - * for j in range(num_randoms): # <<<<<<<<<<<<<< - * result[idx + j] = generate_random(start, end) - * result[idx + num_randoms] = end - */ - __pyx_t_7 = __pyx_v_num_randoms; - __pyx_t_8 = __pyx_t_7; - for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_8; __pyx_t_9+=1) { - __pyx_v_j = __pyx_t_9; - - /* "robo_utils/core.pyx":98 - * break - * for j in range(num_randoms): - * result[idx + j] = generate_random(start, end) # <<<<<<<<<<<<<< - * result[idx + num_randoms] = end - * idx += (num_randoms + 1) - */ - __pyx_t_10 = __pyx_f_10robo_utils_4core_generate_random(__pyx_v_start, __pyx_v_end); if (unlikely(__pyx_t_10 == ((int)-1) && __Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 98, __pyx_L1_error) - __pyx_t_4 = (__pyx_v_idx + __pyx_v_j); - *((int *) ( /* dim=0 */ (__pyx_v_result.data + __pyx_t_4 * __pyx_v_result.strides[0]) )) = __pyx_t_10; - } - - /* "robo_utils/core.pyx":99 - * for j in range(num_randoms): - * result[idx + j] = generate_random(start, end) - * result[idx + num_randoms] = end # <<<<<<<<<<<<<< - * idx += (num_randoms + 1) - * - */ - __pyx_t_4 = (__pyx_v_idx + __pyx_v_num_randoms); - *((int *) ( /* dim=0 */ (__pyx_v_result.data + __pyx_t_4 * __pyx_v_result.strides[0]) )) = __pyx_v_end; - - /* "robo_utils/core.pyx":100 - * result[idx + j] = generate_random(start, end) - * result[idx + num_randoms] = end - * idx += (num_randoms + 1) # <<<<<<<<<<<<<< - * - * @cython.boundscheck(False) - */ - __pyx_v_idx = (__pyx_v_idx + (__pyx_v_num_randoms + 1)); - } - __pyx_L4_break:; - - /* "robo_utils/core.pyx":79 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * cdef void generate_random_intervals_each(int[:] boundaries, int[:] result, int num_randoms) nogil: # <<<<<<<<<<<<<< - * """ - * Generate random intervals for a single batch - */ - - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - #ifdef WITH_THREAD - __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_AddTraceback("robo_utils.core.generate_random_intervals_each", __pyx_clineno, __pyx_lineno, __pyx_filename); - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - __pyx_L0:; -} - -/* "robo_utils/core.pyx":104 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * cpdef void generate_random_intervals_batch_c(int[:, :] boundaries_batch, int[:, :] result_batch, int num_randoms) nogil: # <<<<<<<<<<<<<< - * """ - * Generate random intervals for a batch of boundaries - */ - -static PyObject *__pyx_pw_10robo_utils_4core_3generate_random_intervals_batch_c(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static void __pyx_f_10robo_utils_4core_generate_random_intervals_batch_c(__Pyx_memviewslice __pyx_v_boundaries_batch, __Pyx_memviewslice __pyx_v_result_batch, int __pyx_v_num_randoms, CYTHON_UNUSED int __pyx_skip_dispatch) { - CYTHON_UNUSED int __pyx_v_B; - int __pyx_v_i; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - __Pyx_memviewslice __pyx_t_4 = { 0, 0, { 0 }, { 0 }, { 0 } }; - __Pyx_memviewslice __pyx_t_5 = { 0, 0, { 0 }, { 0 }, { 0 } }; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save; - #endif - __Pyx_RefNannySetupContext("generate_random_intervals_batch_c", 1); - - /* "robo_utils/core.pyx":113 - * num_randoms (int): number of random values to generate per interval - * """ - * cdef int B = boundaries_batch.shape[0] # <<<<<<<<<<<<<< - * cdef int i - * for i in prange(B, nogil=True): - */ - __pyx_v_B = (__pyx_v_boundaries_batch.shape[0]); - - /* "robo_utils/core.pyx":115 - * cdef int B = boundaries_batch.shape[0] - * cdef int i - * for i in prange(B, nogil=True): # <<<<<<<<<<<<<< - * generate_random_intervals_each(boundaries_batch[i], result_batch[i], num_randoms) - */ - { - #ifdef WITH_THREAD - PyThreadState *_save; - _save = NULL; - if (PyGILState_Check()) { - Py_UNBLOCK_THREADS - } - __Pyx_FastGIL_Remember(); - #endif - /*try:*/ { - __pyx_t_1 = __pyx_v_B; - { - int __pyx_parallel_temp0 = ((int)0xbad0bad0); - const char *__pyx_parallel_filename = NULL; int __pyx_parallel_lineno = 0, __pyx_parallel_clineno = 0; - PyObject *__pyx_parallel_exc_type = NULL, *__pyx_parallel_exc_value = NULL, *__pyx_parallel_exc_tb = NULL; - int __pyx_parallel_why; - __pyx_parallel_why = 0; - #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_3 = (__pyx_t_1 - 0 + 1 - 1/abs(1)) / 1; - if (__pyx_t_3 > 0) - { - #ifdef _OPENMP - #pragma omp parallel firstprivate(__pyx_t_4, __pyx_t_5) private(__pyx_filename, __pyx_lineno, __pyx_clineno) shared(__pyx_parallel_why, __pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb) - #endif /* _OPENMP */ - { - #ifdef _OPENMP - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - Py_BEGIN_ALLOW_THREADS - #endif /* _OPENMP */ - #ifdef _OPENMP - #pragma omp for firstprivate(__pyx_v_i) lastprivate(__pyx_v_i) - #endif /* _OPENMP */ - for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_3; __pyx_t_2++){ - if (__pyx_parallel_why < 2) - { - __pyx_v_i = (int)(0 + 1 * __pyx_t_2); - - /* "robo_utils/core.pyx":116 - * cdef int i - * for i in prange(B, nogil=True): - * generate_random_intervals_each(boundaries_batch[i], result_batch[i], num_randoms) # <<<<<<<<<<<<<< - */ - __pyx_t_4.data = __pyx_v_boundaries_batch.data; - __pyx_t_4.memview = __pyx_v_boundaries_batch.memview; - __PYX_INC_MEMVIEW(&__pyx_t_4, 0); - { - Py_ssize_t __pyx_tmp_idx = __pyx_v_i; - Py_ssize_t __pyx_tmp_stride = __pyx_v_boundaries_batch.strides[0]; - __pyx_t_4.data += __pyx_tmp_idx * __pyx_tmp_stride; -} - -__pyx_t_4.shape[0] = __pyx_v_boundaries_batch.shape[1]; -__pyx_t_4.strides[0] = __pyx_v_boundaries_batch.strides[1]; - __pyx_t_4.suboffsets[0] = -1; - -__pyx_t_5.data = __pyx_v_result_batch.data; - __pyx_t_5.memview = __pyx_v_result_batch.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_result_batch.strides[0]; - __pyx_t_5.data += __pyx_tmp_idx * __pyx_tmp_stride; -} - -__pyx_t_5.shape[0] = __pyx_v_result_batch.shape[1]; -__pyx_t_5.strides[0] = __pyx_v_result_batch.strides[1]; - __pyx_t_5.suboffsets[0] = -1; - -__pyx_f_10robo_utils_4core_generate_random_intervals_each(__pyx_t_4, __pyx_t_5, __pyx_v_num_randoms); if (unlikely(__Pyx_ErrOccurredWithGIL())) __PYX_ERR(0, 116, __pyx_L8_error) - __PYX_XCLEAR_MEMVIEW(&__pyx_t_4, 0); - __pyx_t_4.memview = NULL; __pyx_t_4.data = NULL; - __PYX_XCLEAR_MEMVIEW(&__pyx_t_5, 0); - __pyx_t_5.memview = NULL; __pyx_t_5.data = NULL; - goto __pyx_L11; - __pyx_L8_error:; - { - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - #ifdef _OPENMP - #pragma omp flush(__pyx_parallel_exc_type) - #endif /* _OPENMP */ - if (!__pyx_parallel_exc_type) { - __Pyx_ErrFetchWithState(&__pyx_parallel_exc_type, &__pyx_parallel_exc_value, &__pyx_parallel_exc_tb); - __pyx_parallel_filename = __pyx_filename; __pyx_parallel_lineno = __pyx_lineno; __pyx_parallel_clineno = __pyx_clineno; - __Pyx_GOTREF(__pyx_parallel_exc_type); - } - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - } - __pyx_parallel_why = 4; - goto __pyx_L10; - __pyx_L10:; - #ifdef _OPENMP - #pragma omp critical(__pyx_parallel_lastprivates1) - #endif /* _OPENMP */ - { - __pyx_parallel_temp0 = __pyx_v_i; - } - __pyx_L11:; - #ifdef _OPENMP - #pragma omp flush(__pyx_parallel_why) - #endif /* _OPENMP */ - } - } - #ifdef _OPENMP - Py_END_ALLOW_THREADS - #else -{ -#ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - #endif /* _OPENMP */ - /* Clean up any temporaries */ - __PYX_XCLEAR_MEMVIEW(&__pyx_t_4, 0); - __pyx_t_4.memview = NULL; __pyx_t_4.data = NULL; - __PYX_XCLEAR_MEMVIEW(&__pyx_t_5, 0); - __pyx_t_5.memview = NULL; __pyx_t_5.data = NULL; - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - #ifndef _OPENMP -} -#endif /* _OPENMP */ - } - } - if (__pyx_parallel_exc_type) { - /* This may have been overridden by a continue, break or return in another thread. Prefer the error. */ - __pyx_parallel_why = 4; - } - if (__pyx_parallel_why) { - __pyx_v_i = __pyx_parallel_temp0; - switch (__pyx_parallel_why) { - case 4: - { - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_GIVEREF(__pyx_parallel_exc_type); - __Pyx_ErrRestoreWithState(__pyx_parallel_exc_type, __pyx_parallel_exc_value, __pyx_parallel_exc_tb); - __pyx_filename = __pyx_parallel_filename; __pyx_lineno = __pyx_parallel_lineno; __pyx_clineno = __pyx_parallel_clineno; - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - } - goto __pyx_L4_error; - } - } - } - #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 - } - - /* "robo_utils/core.pyx":115 - * cdef int B = boundaries_batch.shape[0] - * cdef int i - * for i in prange(B, nogil=True): # <<<<<<<<<<<<<< - * generate_random_intervals_each(boundaries_batch[i], result_batch[i], num_randoms) - */ - /*finally:*/ { - /*normal exit:*/{ - #ifdef WITH_THREAD - __Pyx_FastGIL_Forget(); - if (_save) { - Py_BLOCK_THREADS - } - #endif - goto __pyx_L5; - } - __pyx_L4_error: { - #ifdef WITH_THREAD - __Pyx_FastGIL_Forget(); - if (_save) { - Py_BLOCK_THREADS - } - #endif - goto __pyx_L1_error; - } - __pyx_L5:; - } - } - - /* "robo_utils/core.pyx":104 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * cpdef void generate_random_intervals_batch_c(int[:, :] boundaries_batch, int[:, :] result_batch, int num_randoms) nogil: # <<<<<<<<<<<<<< - * """ - * Generate random intervals for a batch of boundaries - */ - - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - #ifdef WITH_THREAD - __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __PYX_XCLEAR_MEMVIEW(&__pyx_t_4, 1); - __PYX_XCLEAR_MEMVIEW(&__pyx_t_5, 1); - __Pyx_AddTraceback("robo_utils.core.generate_random_intervals_batch_c", __pyx_clineno, __pyx_lineno, __pyx_filename); - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - __pyx_L0:; - __Pyx_RefNannyFinishContextNogil() -} - -/* Python wrapper */ -static PyObject *__pyx_pw_10robo_utils_4core_3generate_random_intervals_batch_c(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -PyDoc_STRVAR(__pyx_doc_10robo_utils_4core_2generate_random_intervals_batch_c, "\n Generate random intervals for a batch of boundaries\n\n Args:\n boundaries_batch (int[:, :]): input boundaries, shape (B, N)\n result_batch (int[:, :]): output random values, shape (B, (N-1) * num_randoms)\n num_randoms (int): number of random values to generate per interval\n "); -static PyMethodDef __pyx_mdef_10robo_utils_4core_3generate_random_intervals_batch_c = {"generate_random_intervals_batch_c", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10robo_utils_4core_3generate_random_intervals_batch_c, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10robo_utils_4core_2generate_random_intervals_batch_c}; -static PyObject *__pyx_pw_10robo_utils_4core_3generate_random_intervals_batch_c(PyObject *__pyx_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - __Pyx_memviewslice __pyx_v_boundaries_batch = { 0, 0, { 0 }, { 0 }, { 0 } }; - __Pyx_memviewslice __pyx_v_result_batch = { 0, 0, { 0 }, { 0 }, { 0 } }; - int __pyx_v_num_randoms; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[3] = {0,0,0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("generate_random_intervals_batch_c (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_boundaries_batch,&__pyx_n_s_result_batch,&__pyx_n_s_num_randoms,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_boundaries_batch)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 104, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_result_batch)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 104, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("generate_random_intervals_batch_c", 1, 3, 3, 1); __PYX_ERR(0, 104, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_num_randoms)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 104, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("generate_random_intervals_batch_c", 1, 3, 3, 2); __PYX_ERR(0, 104, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "generate_random_intervals_batch_c") < 0)) __PYX_ERR(0, 104, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 3)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - } - __pyx_v_boundaries_batch = __Pyx_PyObject_to_MemoryviewSlice_dsds_int(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_boundaries_batch.memview)) __PYX_ERR(0, 104, __pyx_L3_error) - __pyx_v_result_batch = __Pyx_PyObject_to_MemoryviewSlice_dsds_int(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_result_batch.memview)) __PYX_ERR(0, 104, __pyx_L3_error) - __pyx_v_num_randoms = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_num_randoms == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 104, __pyx_L3_error) - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("generate_random_intervals_batch_c", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 104, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __PYX_XCLEAR_MEMVIEW(&__pyx_v_boundaries_batch, 1); - __PYX_XCLEAR_MEMVIEW(&__pyx_v_result_batch, 1); - __Pyx_AddTraceback("robo_utils.core.generate_random_intervals_batch_c", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_10robo_utils_4core_2generate_random_intervals_batch_c(__pyx_self, __pyx_v_boundaries_batch, __pyx_v_result_batch, __pyx_v_num_randoms); - - /* function exit code */ - __PYX_XCLEAR_MEMVIEW(&__pyx_v_boundaries_batch, 1); - __PYX_XCLEAR_MEMVIEW(&__pyx_v_result_batch, 1); - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_10robo_utils_4core_2generate_random_intervals_batch_c(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_boundaries_batch, __Pyx_memviewslice __pyx_v_result_batch, int __pyx_v_num_randoms) { - 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("generate_random_intervals_batch_c", 1); - __Pyx_XDECREF(__pyx_r); - if (unlikely(!__pyx_v_boundaries_batch.memview)) { __Pyx_RaiseUnboundLocalError("boundaries_batch"); __PYX_ERR(0, 104, __pyx_L1_error) } - if (unlikely(!__pyx_v_result_batch.memview)) { __Pyx_RaiseUnboundLocalError("result_batch"); __PYX_ERR(0, 104, __pyx_L1_error) } - __pyx_f_10robo_utils_4core_generate_random_intervals_batch_c(__pyx_v_boundaries_batch, __pyx_v_result_batch, __pyx_v_num_randoms, 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 104, __pyx_L1_error) - __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 104, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("robo_utils.core.generate_random_intervals_batch_c", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} -static struct __pyx_vtabstruct_array __pyx_vtable_array; - -static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k) { - struct __pyx_array_obj *p; - PyObject *o; - #if CYTHON_COMPILING_IN_LIMITED_API - allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); - o = alloc_func(t, 0); - #else - if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { - o = (*t->tp_alloc)(t, 0); - } else { - o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); - } - if (unlikely(!o)) return 0; - #endif - p = ((struct __pyx_array_obj *)o); - p->__pyx_vtab = __pyx_vtabptr_array; - p->mode = ((PyObject*)Py_None); Py_INCREF(Py_None); - p->_format = ((PyObject*)Py_None); Py_INCREF(Py_None); - if (unlikely(__pyx_array___cinit__(o, a, k) < 0)) goto bad; - return o; - bad: - Py_DECREF(o); o = 0; - return NULL; -} - -static void __pyx_tp_dealloc_array(PyObject *o) { - struct __pyx_array_obj *p = (struct __pyx_array_obj *)o; - #if CYTHON_USE_TP_FINALIZE - if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { - if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_array) { - if (PyObject_CallFinalizerFromDealloc(o)) return; - } - } - #endif - { - PyObject *etype, *eval, *etb; - PyErr_Fetch(&etype, &eval, &etb); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); - __pyx_array___dealloc__(o); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); - PyErr_Restore(etype, eval, etb); - } - Py_CLEAR(p->mode); - Py_CLEAR(p->_format); - #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY - (*Py_TYPE(o)->tp_free)(o); - #else - { - freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); - if (tp_free) tp_free(o); - } - #endif -} -static PyObject *__pyx_sq_item_array(PyObject *o, Py_ssize_t i) { - PyObject *r; - PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; - r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); - Py_DECREF(x); - return r; -} - -static int __pyx_mp_ass_subscript_array(PyObject *o, PyObject *i, PyObject *v) { - if (v) { - return __pyx_array___setitem__(o, i, v); - } - else { - __Pyx_TypeName o_type_name; - o_type_name = __Pyx_PyType_GetName(Py_TYPE(o)); - PyErr_Format(PyExc_NotImplementedError, - "Subscript deletion not supported by " __Pyx_FMT_TYPENAME, o_type_name); - __Pyx_DECREF_TypeName(o_type_name); - return -1; - } -} - -static PyObject *__pyx_tp_getattro_array(PyObject *o, PyObject *n) { - PyObject *v = __Pyx_PyObject_GenericGetAttr(o, n); - if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) { - PyErr_Clear(); - v = __pyx_array___getattr__(o, n); - } - return v; -} - -static PyObject *__pyx_getprop___pyx_array_memview(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(o); -} - -static PyMethodDef __pyx_methods_array[] = { - {"__getattr__", (PyCFunction)__pyx_array___getattr__, METH_O|METH_COEXIST, 0}, - {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_array_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_array_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {0, 0, 0, 0} -}; - -static struct PyGetSetDef __pyx_getsets_array[] = { - {(char *)"memview", __pyx_getprop___pyx_array_memview, 0, (char *)0, 0}, - {0, 0, 0, 0, 0} -}; -#if CYTHON_USE_TYPE_SPECS -#if !CYTHON_COMPILING_IN_LIMITED_API - -static PyBufferProcs __pyx_tp_as_buffer_array = { - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getreadbuffer*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getwritebuffer*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getsegcount*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getcharbuffer*/ - #endif - __pyx_array_getbuffer, /*bf_getbuffer*/ - 0, /*bf_releasebuffer*/ -}; -#endif -static PyType_Slot __pyx_type___pyx_array_slots[] = { - {Py_tp_dealloc, (void *)__pyx_tp_dealloc_array}, - {Py_sq_length, (void *)__pyx_array___len__}, - {Py_sq_item, (void *)__pyx_sq_item_array}, - {Py_mp_length, (void *)__pyx_array___len__}, - {Py_mp_subscript, (void *)__pyx_array___getitem__}, - {Py_mp_ass_subscript, (void *)__pyx_mp_ass_subscript_array}, - {Py_tp_getattro, (void *)__pyx_tp_getattro_array}, - #if defined(Py_bf_getbuffer) - {Py_bf_getbuffer, (void *)__pyx_array_getbuffer}, - #endif - {Py_tp_methods, (void *)__pyx_methods_array}, - {Py_tp_getset, (void *)__pyx_getsets_array}, - {Py_tp_new, (void *)__pyx_tp_new_array}, - {0, 0}, -}; -static PyType_Spec __pyx_type___pyx_array_spec = { - "robo_utils.core.array", - sizeof(struct __pyx_array_obj), - 0, - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_SEQUENCE, - __pyx_type___pyx_array_slots, -}; -#else - -static PySequenceMethods __pyx_tp_as_sequence_array = { - __pyx_array___len__, /*sq_length*/ - 0, /*sq_concat*/ - 0, /*sq_repeat*/ - __pyx_sq_item_array, /*sq_item*/ - 0, /*sq_slice*/ - 0, /*sq_ass_item*/ - 0, /*sq_ass_slice*/ - 0, /*sq_contains*/ - 0, /*sq_inplace_concat*/ - 0, /*sq_inplace_repeat*/ -}; - -static PyMappingMethods __pyx_tp_as_mapping_array = { - __pyx_array___len__, /*mp_length*/ - __pyx_array___getitem__, /*mp_subscript*/ - __pyx_mp_ass_subscript_array, /*mp_ass_subscript*/ -}; - -static PyBufferProcs __pyx_tp_as_buffer_array = { - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getreadbuffer*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getwritebuffer*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getsegcount*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getcharbuffer*/ - #endif - __pyx_array_getbuffer, /*bf_getbuffer*/ - 0, /*bf_releasebuffer*/ -}; - -static PyTypeObject __pyx_type___pyx_array = { - PyVarObject_HEAD_INIT(0, 0) - "robo_utils.core.""array", /*tp_name*/ - 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 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - &__pyx_tp_as_sequence_array, /*tp_as_sequence*/ - &__pyx_tp_as_mapping_array, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - __pyx_tp_getattro_array, /*tp_getattro*/ - 0, /*tp_setattro*/ - &__pyx_tp_as_buffer_array, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_SEQUENCE, /*tp_flags*/ - 0, /*tp_doc*/ - 0, /*tp_traverse*/ - 0, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods_array, /*tp_methods*/ - 0, /*tp_members*/ - __pyx_getsets_array, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - #if !CYTHON_USE_TYPE_SPECS - 0, /*tp_dictoffset*/ - #endif - 0, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_array, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - #if CYTHON_USE_TP_FINALIZE - 0, /*tp_finalize*/ - #else - NULL, /*tp_finalize*/ - #endif - #endif - #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) - 0, /*tp_vectorcall*/ - #endif - #if __PYX_NEED_TP_PRINT_SLOT == 1 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030C0000 - 0, /*tp_watched*/ - #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 - 0, /*tp_pypy_flags*/ - #endif -}; -#endif - -static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - struct __pyx_MemviewEnum_obj *p; - PyObject *o; - #if CYTHON_COMPILING_IN_LIMITED_API - allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); - o = alloc_func(t, 0); - #else - if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { - o = (*t->tp_alloc)(t, 0); - } else { - o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); - } - if (unlikely(!o)) return 0; - #endif - p = ((struct __pyx_MemviewEnum_obj *)o); - p->name = Py_None; Py_INCREF(Py_None); - return o; -} - -static void __pyx_tp_dealloc_Enum(PyObject *o) { - struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; - #if CYTHON_USE_TP_FINALIZE - if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { - if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_Enum) { - if (PyObject_CallFinalizerFromDealloc(o)) return; - } - } - #endif - PyObject_GC_UnTrack(o); - Py_CLEAR(p->name); - #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY - (*Py_TYPE(o)->tp_free)(o); - #else - { - freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); - if (tp_free) tp_free(o); - } - #endif -} - -static int __pyx_tp_traverse_Enum(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; - if (p->name) { - e = (*v)(p->name, a); if (e) return e; - } - return 0; -} - -static int __pyx_tp_clear_Enum(PyObject *o) { - PyObject* tmp; - struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; - tmp = ((PyObject*)p->name); - p->name = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - return 0; -} - -static PyObject *__pyx_specialmethod___pyx_MemviewEnum___repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { - return __pyx_MemviewEnum___repr__(self); -} - -static PyMethodDef __pyx_methods_Enum[] = { - {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_MemviewEnum___repr__, METH_NOARGS|METH_COEXIST, 0}, - {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_MemviewEnum_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_MemviewEnum_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {0, 0, 0, 0} -}; -#if CYTHON_USE_TYPE_SPECS -static PyType_Slot __pyx_type___pyx_MemviewEnum_slots[] = { - {Py_tp_dealloc, (void *)__pyx_tp_dealloc_Enum}, - {Py_tp_repr, (void *)__pyx_MemviewEnum___repr__}, - {Py_tp_traverse, (void *)__pyx_tp_traverse_Enum}, - {Py_tp_clear, (void *)__pyx_tp_clear_Enum}, - {Py_tp_methods, (void *)__pyx_methods_Enum}, - {Py_tp_init, (void *)__pyx_MemviewEnum___init__}, - {Py_tp_new, (void *)__pyx_tp_new_Enum}, - {0, 0}, -}; -static PyType_Spec __pyx_type___pyx_MemviewEnum_spec = { - "robo_utils.core.Enum", - sizeof(struct __pyx_MemviewEnum_obj), - 0, - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, - __pyx_type___pyx_MemviewEnum_slots, -}; -#else - -static PyTypeObject __pyx_type___pyx_MemviewEnum = { - PyVarObject_HEAD_INIT(0, 0) - "robo_utils.core.""Enum", /*tp_name*/ - 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 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - __pyx_MemviewEnum___repr__, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - 0, /*tp_doc*/ - __pyx_tp_traverse_Enum, /*tp_traverse*/ - __pyx_tp_clear_Enum, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods_Enum, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - #if !CYTHON_USE_TYPE_SPECS - 0, /*tp_dictoffset*/ - #endif - __pyx_MemviewEnum___init__, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_Enum, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - #if CYTHON_USE_TP_FINALIZE - 0, /*tp_finalize*/ - #else - NULL, /*tp_finalize*/ - #endif - #endif - #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) - 0, /*tp_vectorcall*/ - #endif - #if __PYX_NEED_TP_PRINT_SLOT == 1 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030C0000 - 0, /*tp_watched*/ - #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 - 0, /*tp_pypy_flags*/ - #endif -}; -#endif -static struct __pyx_vtabstruct_memoryview __pyx_vtable_memoryview; - -static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k) { - struct __pyx_memoryview_obj *p; - PyObject *o; - #if CYTHON_COMPILING_IN_LIMITED_API - allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); - o = alloc_func(t, 0); - #else - if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { - o = (*t->tp_alloc)(t, 0); - } else { - o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); - } - if (unlikely(!o)) return 0; - #endif - p = ((struct __pyx_memoryview_obj *)o); - p->__pyx_vtab = __pyx_vtabptr_memoryview; - p->obj = Py_None; Py_INCREF(Py_None); - p->_size = Py_None; Py_INCREF(Py_None); - p->_array_interface = Py_None; Py_INCREF(Py_None); - p->view.obj = NULL; - if (unlikely(__pyx_memoryview___cinit__(o, a, k) < 0)) goto bad; - return o; - bad: - Py_DECREF(o); o = 0; - return NULL; -} - -static void __pyx_tp_dealloc_memoryview(PyObject *o) { - struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; - #if CYTHON_USE_TP_FINALIZE - if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { - if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_memoryview) { - if (PyObject_CallFinalizerFromDealloc(o)) return; - } - } - #endif - PyObject_GC_UnTrack(o); - { - PyObject *etype, *eval, *etb; - PyErr_Fetch(&etype, &eval, &etb); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); - __pyx_memoryview___dealloc__(o); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); - PyErr_Restore(etype, eval, etb); - } - Py_CLEAR(p->obj); - Py_CLEAR(p->_size); - Py_CLEAR(p->_array_interface); - #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY - (*Py_TYPE(o)->tp_free)(o); - #else - { - freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); - if (tp_free) tp_free(o); - } - #endif -} - -static int __pyx_tp_traverse_memoryview(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; - if (p->obj) { - e = (*v)(p->obj, a); if (e) return e; - } - if (p->_size) { - e = (*v)(p->_size, a); if (e) return e; - } - if (p->_array_interface) { - e = (*v)(p->_array_interface, a); if (e) return e; - } - if (p->view.obj) { - e = (*v)(p->view.obj, a); if (e) return e; - } - return 0; -} - -static int __pyx_tp_clear_memoryview(PyObject *o) { - PyObject* tmp; - struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; - tmp = ((PyObject*)p->obj); - p->obj = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->_size); - p->_size = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->_array_interface); - p->_array_interface = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - Py_CLEAR(p->view.obj); - return 0; -} -static PyObject *__pyx_sq_item_memoryview(PyObject *o, Py_ssize_t i) { - PyObject *r; - PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; - r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); - Py_DECREF(x); - return r; -} - -static int __pyx_mp_ass_subscript_memoryview(PyObject *o, PyObject *i, PyObject *v) { - if (v) { - return __pyx_memoryview___setitem__(o, i, v); - } - else { - __Pyx_TypeName o_type_name; - o_type_name = __Pyx_PyType_GetName(Py_TYPE(o)); - PyErr_Format(PyExc_NotImplementedError, - "Subscript deletion not supported by " __Pyx_FMT_TYPENAME, o_type_name); - __Pyx_DECREF_TypeName(o_type_name); - return -1; - } -} - -static PyObject *__pyx_getprop___pyx_memoryview_T(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(o); -} - -static PyObject *__pyx_getprop___pyx_memoryview_base(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(o); -} - -static PyObject *__pyx_getprop___pyx_memoryview_shape(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(o); -} - -static PyObject *__pyx_getprop___pyx_memoryview_strides(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(o); -} - -static PyObject *__pyx_getprop___pyx_memoryview_suboffsets(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(o); -} - -static PyObject *__pyx_getprop___pyx_memoryview_ndim(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(o); -} - -static PyObject *__pyx_getprop___pyx_memoryview_itemsize(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(o); -} - -static PyObject *__pyx_getprop___pyx_memoryview_nbytes(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(o); -} - -static PyObject *__pyx_getprop___pyx_memoryview_size(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(o); -} - -static PyObject *__pyx_specialmethod___pyx_memoryview___repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { - return __pyx_memoryview___repr__(self); -} - -static PyMethodDef __pyx_methods_memoryview[] = { - {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_memoryview___repr__, METH_NOARGS|METH_COEXIST, 0}, - {"is_c_contig", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_memoryview_is_c_contig, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"is_f_contig", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_memoryview_is_f_contig, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"copy", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_memoryview_copy, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"copy_fortran", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_memoryview_copy_fortran, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_memoryview_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_memoryview_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {0, 0, 0, 0} -}; - -static struct PyGetSetDef __pyx_getsets_memoryview[] = { - {(char *)"T", __pyx_getprop___pyx_memoryview_T, 0, (char *)0, 0}, - {(char *)"base", __pyx_getprop___pyx_memoryview_base, 0, (char *)0, 0}, - {(char *)"shape", __pyx_getprop___pyx_memoryview_shape, 0, (char *)0, 0}, - {(char *)"strides", __pyx_getprop___pyx_memoryview_strides, 0, (char *)0, 0}, - {(char *)"suboffsets", __pyx_getprop___pyx_memoryview_suboffsets, 0, (char *)0, 0}, - {(char *)"ndim", __pyx_getprop___pyx_memoryview_ndim, 0, (char *)0, 0}, - {(char *)"itemsize", __pyx_getprop___pyx_memoryview_itemsize, 0, (char *)0, 0}, - {(char *)"nbytes", __pyx_getprop___pyx_memoryview_nbytes, 0, (char *)0, 0}, - {(char *)"size", __pyx_getprop___pyx_memoryview_size, 0, (char *)0, 0}, - {0, 0, 0, 0, 0} -}; -#if CYTHON_USE_TYPE_SPECS -#if !CYTHON_COMPILING_IN_LIMITED_API - -static PyBufferProcs __pyx_tp_as_buffer_memoryview = { - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getreadbuffer*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getwritebuffer*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getsegcount*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getcharbuffer*/ - #endif - __pyx_memoryview_getbuffer, /*bf_getbuffer*/ - 0, /*bf_releasebuffer*/ -}; -#endif -static PyType_Slot __pyx_type___pyx_memoryview_slots[] = { - {Py_tp_dealloc, (void *)__pyx_tp_dealloc_memoryview}, - {Py_tp_repr, (void *)__pyx_memoryview___repr__}, - {Py_sq_length, (void *)__pyx_memoryview___len__}, - {Py_sq_item, (void *)__pyx_sq_item_memoryview}, - {Py_mp_length, (void *)__pyx_memoryview___len__}, - {Py_mp_subscript, (void *)__pyx_memoryview___getitem__}, - {Py_mp_ass_subscript, (void *)__pyx_mp_ass_subscript_memoryview}, - {Py_tp_str, (void *)__pyx_memoryview___str__}, - #if defined(Py_bf_getbuffer) - {Py_bf_getbuffer, (void *)__pyx_memoryview_getbuffer}, - #endif - {Py_tp_traverse, (void *)__pyx_tp_traverse_memoryview}, - {Py_tp_clear, (void *)__pyx_tp_clear_memoryview}, - {Py_tp_methods, (void *)__pyx_methods_memoryview}, - {Py_tp_getset, (void *)__pyx_getsets_memoryview}, - {Py_tp_new, (void *)__pyx_tp_new_memoryview}, - {0, 0}, -}; -static PyType_Spec __pyx_type___pyx_memoryview_spec = { - "robo_utils.core.memoryview", - sizeof(struct __pyx_memoryview_obj), - 0, - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, - __pyx_type___pyx_memoryview_slots, -}; -#else - -static PySequenceMethods __pyx_tp_as_sequence_memoryview = { - __pyx_memoryview___len__, /*sq_length*/ - 0, /*sq_concat*/ - 0, /*sq_repeat*/ - __pyx_sq_item_memoryview, /*sq_item*/ - 0, /*sq_slice*/ - 0, /*sq_ass_item*/ - 0, /*sq_ass_slice*/ - 0, /*sq_contains*/ - 0, /*sq_inplace_concat*/ - 0, /*sq_inplace_repeat*/ -}; - -static PyMappingMethods __pyx_tp_as_mapping_memoryview = { - __pyx_memoryview___len__, /*mp_length*/ - __pyx_memoryview___getitem__, /*mp_subscript*/ - __pyx_mp_ass_subscript_memoryview, /*mp_ass_subscript*/ -}; - -static PyBufferProcs __pyx_tp_as_buffer_memoryview = { - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getreadbuffer*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getwritebuffer*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getsegcount*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getcharbuffer*/ - #endif - __pyx_memoryview_getbuffer, /*bf_getbuffer*/ - 0, /*bf_releasebuffer*/ -}; - -static PyTypeObject __pyx_type___pyx_memoryview = { - PyVarObject_HEAD_INIT(0, 0) - "robo_utils.core.""memoryview", /*tp_name*/ - 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 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - __pyx_memoryview___repr__, /*tp_repr*/ - 0, /*tp_as_number*/ - &__pyx_tp_as_sequence_memoryview, /*tp_as_sequence*/ - &__pyx_tp_as_mapping_memoryview, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - __pyx_memoryview___str__, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - &__pyx_tp_as_buffer_memoryview, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - 0, /*tp_doc*/ - __pyx_tp_traverse_memoryview, /*tp_traverse*/ - __pyx_tp_clear_memoryview, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods_memoryview, /*tp_methods*/ - 0, /*tp_members*/ - __pyx_getsets_memoryview, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - #if !CYTHON_USE_TYPE_SPECS - 0, /*tp_dictoffset*/ - #endif - 0, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_memoryview, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - #if CYTHON_USE_TP_FINALIZE - 0, /*tp_finalize*/ - #else - NULL, /*tp_finalize*/ - #endif - #endif - #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) - 0, /*tp_vectorcall*/ - #endif - #if __PYX_NEED_TP_PRINT_SLOT == 1 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030C0000 - 0, /*tp_watched*/ - #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 - 0, /*tp_pypy_flags*/ - #endif -}; -#endif -static struct __pyx_vtabstruct__memoryviewslice __pyx_vtable__memoryviewslice; - -static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k) { - struct __pyx_memoryviewslice_obj *p; - PyObject *o = __pyx_tp_new_memoryview(t, a, k); - if (unlikely(!o)) return 0; - p = ((struct __pyx_memoryviewslice_obj *)o); - p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_memoryview*)__pyx_vtabptr__memoryviewslice; - p->from_object = Py_None; Py_INCREF(Py_None); - p->from_slice.memview = NULL; - return o; -} - -static void __pyx_tp_dealloc__memoryviewslice(PyObject *o) { - struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; - #if CYTHON_USE_TP_FINALIZE - if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { - if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc__memoryviewslice) { - if (PyObject_CallFinalizerFromDealloc(o)) return; - } - } - #endif - PyObject_GC_UnTrack(o); - { - PyObject *etype, *eval, *etb; - PyErr_Fetch(&etype, &eval, &etb); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); - __pyx_memoryviewslice___dealloc__(o); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); - PyErr_Restore(etype, eval, etb); - } - Py_CLEAR(p->from_object); - PyObject_GC_Track(o); - __pyx_tp_dealloc_memoryview(o); -} - -static int __pyx_tp_traverse__memoryviewslice(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; - e = __pyx_tp_traverse_memoryview(o, v, a); if (e) return e; - if (p->from_object) { - e = (*v)(p->from_object, a); if (e) return e; - } - return 0; -} - -static int __pyx_tp_clear__memoryviewslice(PyObject *o) { - PyObject* tmp; - struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; - __pyx_tp_clear_memoryview(o); - tmp = ((PyObject*)p->from_object); - p->from_object = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - __PYX_XCLEAR_MEMVIEW(&p->from_slice, 1); - return 0; -} - -static PyMethodDef __pyx_methods__memoryviewslice[] = { - {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_memoryviewslice_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_memoryviewslice_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {0, 0, 0, 0} -}; -#if CYTHON_USE_TYPE_SPECS -static PyType_Slot __pyx_type___pyx_memoryviewslice_slots[] = { - {Py_tp_dealloc, (void *)__pyx_tp_dealloc__memoryviewslice}, - {Py_tp_doc, (void *)PyDoc_STR("Internal class for passing memoryview slices to Python")}, - {Py_tp_traverse, (void *)__pyx_tp_traverse__memoryviewslice}, - {Py_tp_clear, (void *)__pyx_tp_clear__memoryviewslice}, - {Py_tp_methods, (void *)__pyx_methods__memoryviewslice}, - {Py_tp_new, (void *)__pyx_tp_new__memoryviewslice}, - {0, 0}, -}; -static PyType_Spec __pyx_type___pyx_memoryviewslice_spec = { - "robo_utils.core._memoryviewslice", - sizeof(struct __pyx_memoryviewslice_obj), - 0, - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_SEQUENCE, - __pyx_type___pyx_memoryviewslice_slots, -}; -#else - -static PyTypeObject __pyx_type___pyx_memoryviewslice = { - PyVarObject_HEAD_INIT(0, 0) - "robo_utils.core.""_memoryviewslice", /*tp_name*/ - 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 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - #if CYTHON_COMPILING_IN_PYPY || 0 - __pyx_memoryview___repr__, /*tp_repr*/ - #else - 0, /*tp_repr*/ - #endif - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - #if CYTHON_COMPILING_IN_PYPY || 0 - __pyx_memoryview___str__, /*tp_str*/ - #else - 0, /*tp_str*/ - #endif - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_SEQUENCE, /*tp_flags*/ - PyDoc_STR("Internal class for passing memoryview slices to Python"), /*tp_doc*/ - __pyx_tp_traverse__memoryviewslice, /*tp_traverse*/ - __pyx_tp_clear__memoryviewslice, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods__memoryviewslice, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - #if !CYTHON_USE_TYPE_SPECS - 0, /*tp_dictoffset*/ - #endif - 0, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new__memoryviewslice, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - #if CYTHON_USE_TP_FINALIZE - 0, /*tp_finalize*/ - #else - NULL, /*tp_finalize*/ - #endif - #endif - #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) - 0, /*tp_vectorcall*/ - #endif - #if __PYX_NEED_TP_PRINT_SLOT == 1 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030C0000 - 0, /*tp_watched*/ - #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 - 0, /*tp_pypy_flags*/ - #endif -}; -#endif - -static PyMethodDef __pyx_methods[] = { - {0, 0, 0, 0} -}; -#ifndef CYTHON_SMALL_CODE -#if defined(__clang__) - #define CYTHON_SMALL_CODE -#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) - #define CYTHON_SMALL_CODE __attribute__((cold)) -#else - #define CYTHON_SMALL_CODE -#endif -#endif -/* #### Code section: pystring_table ### */ - -static int __Pyx_CreateStringTabAndInitStrings(void) { - __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_kp_u_, __pyx_k_, sizeof(__pyx_k_), 0, 1, 0, 0}, - {&__pyx_n_s_ASCII, __pyx_k_ASCII, sizeof(__pyx_k_ASCII), 0, 0, 1, 1}, - {&__pyx_kp_s_All_dimensions_preceding_dimensi, __pyx_k_All_dimensions_preceding_dimensi, sizeof(__pyx_k_All_dimensions_preceding_dimensi), 0, 0, 1, 0}, - {&__pyx_n_s_AssertionError, __pyx_k_AssertionError, sizeof(__pyx_k_AssertionError), 0, 0, 1, 1}, - {&__pyx_kp_s_Buffer_view_does_not_expose_stri, __pyx_k_Buffer_view_does_not_expose_stri, sizeof(__pyx_k_Buffer_view_does_not_expose_stri), 0, 0, 1, 0}, - {&__pyx_kp_s_Can_only_create_a_buffer_that_is, __pyx_k_Can_only_create_a_buffer_that_is, sizeof(__pyx_k_Can_only_create_a_buffer_that_is), 0, 0, 1, 0}, - {&__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_u_Cannot_index_with_type, __pyx_k_Cannot_index_with_type, sizeof(__pyx_k_Cannot_index_with_type), 0, 1, 0, 0}, - {&__pyx_kp_s_Cannot_transpose_memoryview_with, __pyx_k_Cannot_transpose_memoryview_with, sizeof(__pyx_k_Cannot_transpose_memoryview_with), 0, 0, 1, 0}, - {&__pyx_kp_s_Dimension_d_is_not_direct, __pyx_k_Dimension_d_is_not_direct, sizeof(__pyx_k_Dimension_d_is_not_direct), 0, 0, 1, 0}, - {&__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_s_Incompatible_checksums_0x_x_vs_0, __pyx_k_Incompatible_checksums_0x_x_vs_0, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0), 0, 0, 1, 0}, - {&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1}, - {&__pyx_kp_s_Index_out_of_bounds_axis_d, __pyx_k_Index_out_of_bounds_axis_d, sizeof(__pyx_k_Index_out_of_bounds_axis_d), 0, 0, 1, 0}, - {&__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_u_Invalid_mode_expected_c_or_fortr, __pyx_k_Invalid_mode_expected_c_or_fortr, sizeof(__pyx_k_Invalid_mode_expected_c_or_fortr), 0, 1, 0, 0}, - {&__pyx_kp_u_Invalid_shape_in_axis, __pyx_k_Invalid_shape_in_axis, sizeof(__pyx_k_Invalid_shape_in_axis), 0, 1, 0, 0}, - {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, - {&__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_k_MemoryView_of_r_at_0x_x, sizeof(__pyx_k_MemoryView_of_r_at_0x_x), 0, 0, 1, 0}, - {&__pyx_kp_s_MemoryView_of_r_object, __pyx_k_MemoryView_of_r_object, sizeof(__pyx_k_MemoryView_of_r_object), 0, 0, 1, 0}, - {&__pyx_n_b_O, __pyx_k_O, sizeof(__pyx_k_O), 0, 0, 0, 1}, - {&__pyx_kp_u_Out_of_bounds_on_buffer_access_a, __pyx_k_Out_of_bounds_on_buffer_access_a, sizeof(__pyx_k_Out_of_bounds_on_buffer_access_a), 0, 1, 0, 0}, - {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, - {&__pyx_n_s_Sequence, __pyx_k_Sequence, sizeof(__pyx_k_Sequence), 0, 0, 1, 1}, - {&__pyx_kp_s_Step_may_not_be_zero_axis_d, __pyx_k_Step_may_not_be_zero_axis_d, sizeof(__pyx_k_Step_may_not_be_zero_axis_d), 0, 0, 1, 0}, - {&__pyx_n_s_T, __pyx_k_T, sizeof(__pyx_k_T), 0, 0, 1, 1}, - {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, - {&__pyx_kp_s_Unable_to_convert_item_to_object, __pyx_k_Unable_to_convert_item_to_object, sizeof(__pyx_k_Unable_to_convert_item_to_object), 0, 0, 1, 0}, - {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, - {&__pyx_n_s_View_MemoryView, __pyx_k_View_MemoryView, sizeof(__pyx_k_View_MemoryView), 0, 0, 1, 1}, - {&__pyx_kp_u__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 1, 0, 0}, - {&__pyx_n_s__24, __pyx_k__24, sizeof(__pyx_k__24), 0, 0, 1, 1}, - {&__pyx_n_s__3, __pyx_k__3, sizeof(__pyx_k__3), 0, 0, 1, 1}, - {&__pyx_kp_u__6, __pyx_k__6, sizeof(__pyx_k__6), 0, 1, 0, 0}, - {&__pyx_kp_u__7, __pyx_k__7, sizeof(__pyx_k__7), 0, 1, 0, 0}, - {&__pyx_n_s_abc, __pyx_k_abc, sizeof(__pyx_k_abc), 0, 0, 1, 1}, - {&__pyx_n_s_allocate_buffer, __pyx_k_allocate_buffer, sizeof(__pyx_k_allocate_buffer), 0, 0, 1, 1}, - {&__pyx_kp_u_and, __pyx_k_and, sizeof(__pyx_k_and), 0, 1, 0, 0}, - {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1}, - {&__pyx_n_s_base, __pyx_k_base, sizeof(__pyx_k_base), 0, 0, 1, 1}, - {&__pyx_n_s_boundaries_batch, __pyx_k_boundaries_batch, sizeof(__pyx_k_boundaries_batch), 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_class, __pyx_k_class, sizeof(__pyx_k_class), 0, 0, 1, 1}, - {&__pyx_n_s_class_getitem, __pyx_k_class_getitem, sizeof(__pyx_k_class_getitem), 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_n_s_collections, __pyx_k_collections, sizeof(__pyx_k_collections), 0, 0, 1, 1}, - {&__pyx_kp_s_collections_abc, __pyx_k_collections_abc, sizeof(__pyx_k_collections_abc), 0, 0, 1, 0}, - {&__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_kp_s_core_pyx, __pyx_k_core_pyx, sizeof(__pyx_k_core_pyx), 0, 0, 1, 0}, - {&__pyx_n_s_count, __pyx_k_count, sizeof(__pyx_k_count), 0, 0, 1, 1}, - {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, - {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0}, - {&__pyx_n_s_dtype_is_object, __pyx_k_dtype_is_object, sizeof(__pyx_k_dtype_is_object), 0, 0, 1, 1}, - {&__pyx_n_s_dur, __pyx_k_dur, sizeof(__pyx_k_dur), 0, 0, 1, 1}, - {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0}, - {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1}, - {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1}, - {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1}, - {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1}, - {&__pyx_n_s_float_to_int_duration_batch_c, __pyx_k_float_to_int_duration_batch_c, sizeof(__pyx_k_float_to_int_duration_batch_c), 0, 0, 1, 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}, - {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0}, - {&__pyx_n_s_generate_random_intervals_batch, __pyx_k_generate_random_intervals_batch, sizeof(__pyx_k_generate_random_intervals_batch), 0, 0, 1, 1}, - {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, - {&__pyx_kp_u_got, __pyx_k_got, sizeof(__pyx_k_got), 0, 1, 0, 0}, - {&__pyx_kp_u_got_differing_extents_in_dimensi, __pyx_k_got_differing_extents_in_dimensi, sizeof(__pyx_k_got_differing_extents_in_dimensi), 0, 1, 0, 0}, - {&__pyx_n_s_id, __pyx_k_id, sizeof(__pyx_k_id), 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_initializing, __pyx_k_initializing, sizeof(__pyx_k_initializing), 0, 0, 1, 1}, - {&__pyx_n_s_int_dur, __pyx_k_int_dur, sizeof(__pyx_k_int_dur), 0, 0, 1, 1}, - {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, - {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0}, - {&__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_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_memview, __pyx_k_memview, sizeof(__pyx_k_memview), 0, 0, 1, 1}, - {&__pyx_n_s_mode, __pyx_k_mode, sizeof(__pyx_k_mode), 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_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 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_num_randoms, __pyx_k_num_randoms, sizeof(__pyx_k_num_randoms), 0, 0, 1, 1}, - {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, - {&__pyx_n_s_obj, __pyx_k_obj, sizeof(__pyx_k_obj), 0, 0, 1, 1}, - {&__pyx_n_s_pack, __pyx_k_pack, sizeof(__pyx_k_pack), 0, 0, 1, 1}, - {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 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_result, __pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, - {&__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_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_register, __pyx_k_register, sizeof(__pyx_k_register), 0, 0, 1, 1}, - {&__pyx_n_s_result_batch, __pyx_k_result_batch, sizeof(__pyx_k_result_batch), 0, 0, 1, 1}, - {&__pyx_n_s_robo_utils_core, __pyx_k_robo_utils_core, sizeof(__pyx_k_robo_utils_core), 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_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1}, - {&__pyx_n_s_spec, __pyx_k_spec, sizeof(__pyx_k_spec), 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}, - {&__pyx_kp_s_strided_and_direct, __pyx_k_strided_and_direct, sizeof(__pyx_k_strided_and_direct), 0, 0, 1, 0}, - {&__pyx_kp_s_strided_and_direct_or_indirect, __pyx_k_strided_and_direct_or_indirect, sizeof(__pyx_k_strided_and_direct_or_indirect), 0, 0, 1, 0}, - {&__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_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {&__pyx_kp_s_unable_to_allocate_array_data, __pyx_k_unable_to_allocate_array_data, sizeof(__pyx_k_unable_to_allocate_array_data), 0, 0, 1, 0}, - {&__pyx_kp_s_unable_to_allocate_shape_and_str, __pyx_k_unable_to_allocate_shape_and_str, sizeof(__pyx_k_unable_to_allocate_shape_and_str), 0, 0, 1, 0}, - {&__pyx_n_s_unpack, __pyx_k_unpack, sizeof(__pyx_k_unpack), 0, 0, 1, 1}, - {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, - {&__pyx_n_s_version_info, __pyx_k_version_info, sizeof(__pyx_k_version_info), 0, 0, 1, 1}, - {0, 0, 0, 0, 0, 0, 0} - }; - return __Pyx_InitStrings(__pyx_string_tab); -} -/* #### Code section: cached_builtins ### */ -static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { - __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 31, __pyx_L1_error) - __pyx_builtin___import__ = __Pyx_GetBuiltinName(__pyx_n_s_import); if (!__pyx_builtin___import__) __PYX_ERR(1, 100, __pyx_L1_error) - __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 141, __pyx_L1_error) - __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(1, 156, __pyx_L1_error) - __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(1, 159, __pyx_L1_error) - __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error) - __pyx_builtin_AssertionError = __Pyx_GetBuiltinName(__pyx_n_s_AssertionError); if (!__pyx_builtin_AssertionError) __PYX_ERR(1, 373, __pyx_L1_error) - __pyx_builtin_Ellipsis = __Pyx_GetBuiltinName(__pyx_n_s_Ellipsis); if (!__pyx_builtin_Ellipsis) __PYX_ERR(1, 408, __pyx_L1_error) - __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(1, 618, __pyx_L1_error) - __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(1, 914, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; -} -/* #### Code section: cached_constants ### */ - -static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - - /* "View.MemoryView":582 - * 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__4 = PyTuple_New(1); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 582, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__4); - __Pyx_INCREF(__pyx_int_neg_1); - __Pyx_GIVEREF(__pyx_int_neg_1); - if (__Pyx_PyTuple_SET_ITEM(__pyx_tuple__4, 0, __pyx_int_neg_1)) __PYX_ERR(1, 582, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_tuple__4); - - /* "View.MemoryView":679 - * tup = index if isinstance(index, tuple) else (index,) - * - * result = [slice(None)] * ndim # <<<<<<<<<<<<<< - * have_slices = False - * seen_ellipsis = False - */ - __pyx_slice__5 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__5)) __PYX_ERR(1, 679, __pyx_L1_error) - __Pyx_GOTREF(__pyx_slice__5); - __Pyx_GIVEREF(__pyx_slice__5); - - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * if __pyx_checksum not in (0x82a3537, 0x6ae9995, 0xb068931): # <<<<<<<<<<<<<< - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x82a3537, 0x6ae9995, 0xb068931) = (name))" % __pyx_checksum - */ - __pyx_tuple__8 = PyTuple_Pack(3, __pyx_int_136983863, __pyx_int_112105877, __pyx_int_184977713); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__8); - __Pyx_GIVEREF(__pyx_tuple__8); - - /* "View.MemoryView":100 - * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" - * try: - * if __import__("sys").version_info >= (3, 3): # <<<<<<<<<<<<<< - * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence - * else: - */ - __pyx_tuple__9 = PyTuple_Pack(1, __pyx_n_s_sys); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 100, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__9); - __Pyx_GIVEREF(__pyx_tuple__9); - __pyx_tuple__10 = PyTuple_Pack(2, __pyx_int_3, __pyx_int_3); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 100, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__10); - __Pyx_GIVEREF(__pyx_tuple__10); - - /* "View.MemoryView":101 - * try: - * if __import__("sys").version_info >= (3, 3): - * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence # <<<<<<<<<<<<<< - * else: - * __pyx_collections_abc_Sequence = __import__("collections").Sequence - */ - __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_collections_abc); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__11); - __Pyx_GIVEREF(__pyx_tuple__11); - - /* "View.MemoryView":103 - * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence - * else: - * __pyx_collections_abc_Sequence = __import__("collections").Sequence # <<<<<<<<<<<<<< - * except: - * - */ - __pyx_tuple__12 = PyTuple_Pack(1, __pyx_n_s_collections); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 103, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__12); - __Pyx_GIVEREF(__pyx_tuple__12); - - /* "View.MemoryView":309 - * return self.name - * - * cdef generic = Enum("") # <<<<<<<<<<<<<< - * cdef strided = Enum("") # default - * cdef indirect = Enum("") - */ - __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 309, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__13); - __Pyx_GIVEREF(__pyx_tuple__13); - - /* "View.MemoryView":310 - * - * cdef generic = Enum("") - * cdef strided = Enum("") # default # <<<<<<<<<<<<<< - * cdef indirect = Enum("") - * - */ - __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 310, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__14); - __Pyx_GIVEREF(__pyx_tuple__14); - - /* "View.MemoryView":311 - * cdef generic = Enum("") - * cdef strided = Enum("") # default - * cdef indirect = Enum("") # <<<<<<<<<<<<<< - * - * - */ - __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_s_strided_and_indirect); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(1, 311, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__15); - __Pyx_GIVEREF(__pyx_tuple__15); - - /* "View.MemoryView":314 - * - * - * cdef contiguous = Enum("") # <<<<<<<<<<<<<< - * cdef indirect_contiguous = Enum("") - * - */ - __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(1, 314, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__16); - __Pyx_GIVEREF(__pyx_tuple__16); - - /* "View.MemoryView":315 - * - * cdef contiguous = Enum("") - * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< - * - * - */ - __pyx_tuple__17 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_indirect); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(1, 315, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__17); - __Pyx_GIVEREF(__pyx_tuple__17); - - /* "(tree fragment)":1 - * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ - __pyx_tuple__18 = 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__18)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__18); - __Pyx_GIVEREF(__pyx_tuple__18); - __pyx_codeobj__19 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) __PYX_ERR(1, 1, __pyx_L1_error) - - /* "robo_utils/core.pyx":59 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * cpdef void float_to_int_duration_batch_c(float[:, :] dur, int[:] T, int[:, :] mask, int[:, :] int_dur) nogil: # <<<<<<<<<<<<<< - * """ - * Args: - */ - __pyx_tuple__20 = PyTuple_Pack(4, __pyx_n_s_dur, __pyx_n_s_T, __pyx_n_s_mask, __pyx_n_s_int_dur); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 59, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__20); - __Pyx_GIVEREF(__pyx_tuple__20); - __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__20, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_core_pyx, __pyx_n_s_float_to_int_duration_batch_c, 59, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(0, 59, __pyx_L1_error) - - /* "robo_utils/core.pyx":104 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * cpdef void generate_random_intervals_batch_c(int[:, :] boundaries_batch, int[:, :] result_batch, int num_randoms) nogil: # <<<<<<<<<<<<<< - * """ - * Generate random intervals for a batch of boundaries - */ - __pyx_tuple__22 = PyTuple_Pack(3, __pyx_n_s_boundaries_batch, __pyx_n_s_result_batch, __pyx_n_s_num_randoms); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 104, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__22); - __Pyx_GIVEREF(__pyx_tuple__22); - __pyx_codeobj__23 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__22, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_core_pyx, __pyx_n_s_generate_random_intervals_batch, 104, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__23)) __PYX_ERR(0, 104, __pyx_L1_error) - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} -/* #### Code section: init_constants ### */ - -static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { - if (__Pyx_CreateStringTabAndInitStrings() < 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_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_112105877 = PyInt_FromLong(112105877L); if (unlikely(!__pyx_int_112105877)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_136983863 = PyInt_FromLong(136983863L); if (unlikely(!__pyx_int_136983863)) __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; - __pyx_L1_error:; - return -1; -} -/* #### Code section: init_globals ### */ - -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - /* AssertionsEnabled.init */ - if (likely(__Pyx_init_assertions_enabled() == 0)); else - -if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) - - /* InitThreads.init */ - #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 -PyEval_InitThreads(); -#endif - -if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) - - return 0; - __pyx_L1_error:; - return -1; -} -/* #### Code section: init_module ### */ - -static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ - -static int __Pyx_modinit_global_init_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); - /*--- Global init code ---*/ - __pyx_collections_abc_Sequence = Py_None; Py_INCREF(Py_None); - generic = Py_None; Py_INCREF(Py_None); - strided = Py_None; Py_INCREF(Py_None); - indirect = Py_None; Py_INCREF(Py_None); - contiguous = Py_None; Py_INCREF(Py_None); - indirect_contiguous = Py_None; Py_INCREF(Py_None); - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_variable_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); - /*--- Variable export code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_function_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); - /*--- Function export code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_type_init_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_init_code", 0); - /*--- Type init code ---*/ - __pyx_vtabptr_array = &__pyx_vtable_array; - __pyx_vtable_array.get_memview = (PyObject *(*)(struct __pyx_array_obj *))__pyx_array_get_memview; - #if CYTHON_USE_TYPE_SPECS - __pyx_array_type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type___pyx_array_spec, NULL); if (unlikely(!__pyx_array_type)) __PYX_ERR(1, 114, __pyx_L1_error) - #if !CYTHON_COMPILING_IN_LIMITED_API - __pyx_array_type->tp_as_buffer = &__pyx_tp_as_buffer_array; - if (!__pyx_array_type->tp_as_buffer->bf_releasebuffer && __pyx_array_type->tp_base->tp_as_buffer && __pyx_array_type->tp_base->tp_as_buffer->bf_releasebuffer) { - __pyx_array_type->tp_as_buffer->bf_releasebuffer = __pyx_array_type->tp_base->tp_as_buffer->bf_releasebuffer; - } - #elif defined(Py_bf_getbuffer) && defined(Py_bf_releasebuffer) - /* PY_VERSION_HEX >= 0x03090000 || Py_LIMITED_API >= 0x030B0000 */ - #elif defined(_MSC_VER) - #pragma message ("The buffer protocol is not supported in the Limited C-API < 3.11.") - #else - #warning "The buffer protocol is not supported in the Limited C-API < 3.11." - #endif - if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type___pyx_array_spec, __pyx_array_type) < 0) __PYX_ERR(1, 114, __pyx_L1_error) - #else - __pyx_array_type = &__pyx_type___pyx_array; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - #endif - #if !CYTHON_USE_TYPE_SPECS - if (__Pyx_PyType_Ready(__pyx_array_type) < 0) __PYX_ERR(1, 114, __pyx_L1_error) - #endif - #if PY_MAJOR_VERSION < 3 - __pyx_array_type->tp_print = 0; - #endif - if (__Pyx_SetVtable(__pyx_array_type, __pyx_vtabptr_array) < 0) __PYX_ERR(1, 114, __pyx_L1_error) - #if !CYTHON_COMPILING_IN_LIMITED_API - if (__Pyx_MergeVtables(__pyx_array_type) < 0) __PYX_ERR(1, 114, __pyx_L1_error) - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - if (__Pyx_setup_reduce((PyObject *) __pyx_array_type) < 0) __PYX_ERR(1, 114, __pyx_L1_error) - #endif - #if CYTHON_USE_TYPE_SPECS - __pyx_MemviewEnum_type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type___pyx_MemviewEnum_spec, NULL); if (unlikely(!__pyx_MemviewEnum_type)) __PYX_ERR(1, 302, __pyx_L1_error) - if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type___pyx_MemviewEnum_spec, __pyx_MemviewEnum_type) < 0) __PYX_ERR(1, 302, __pyx_L1_error) - #else - __pyx_MemviewEnum_type = &__pyx_type___pyx_MemviewEnum; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - #endif - #if !CYTHON_USE_TYPE_SPECS - if (__Pyx_PyType_Ready(__pyx_MemviewEnum_type) < 0) __PYX_ERR(1, 302, __pyx_L1_error) - #endif - #if PY_MAJOR_VERSION < 3 - __pyx_MemviewEnum_type->tp_print = 0; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_MemviewEnum_type->tp_dictoffset && __pyx_MemviewEnum_type->tp_getattro == PyObject_GenericGetAttr)) { - __pyx_MemviewEnum_type->tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - if (__Pyx_setup_reduce((PyObject *) __pyx_MemviewEnum_type) < 0) __PYX_ERR(1, 302, __pyx_L1_error) - #endif - __pyx_vtabptr_memoryview = &__pyx_vtable_memoryview; - __pyx_vtable_memoryview.get_item_pointer = (char *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_get_item_pointer; - __pyx_vtable_memoryview.is_slice = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_is_slice; - __pyx_vtable_memoryview.setitem_slice_assignment = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_slice_assignment; - __pyx_vtable_memoryview.setitem_slice_assign_scalar = (PyObject *(*)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_setitem_slice_assign_scalar; - __pyx_vtable_memoryview.setitem_indexed = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_indexed; - __pyx_vtable_memoryview.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryview_convert_item_to_object; - __pyx_vtable_memoryview.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryview_assign_item_from_object; - __pyx_vtable_memoryview._get_base = (PyObject *(*)(struct __pyx_memoryview_obj *))__pyx_memoryview__get_base; - #if CYTHON_USE_TYPE_SPECS - __pyx_memoryview_type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type___pyx_memoryview_spec, NULL); if (unlikely(!__pyx_memoryview_type)) __PYX_ERR(1, 337, __pyx_L1_error) - #if !CYTHON_COMPILING_IN_LIMITED_API - __pyx_memoryview_type->tp_as_buffer = &__pyx_tp_as_buffer_memoryview; - if (!__pyx_memoryview_type->tp_as_buffer->bf_releasebuffer && __pyx_memoryview_type->tp_base->tp_as_buffer && __pyx_memoryview_type->tp_base->tp_as_buffer->bf_releasebuffer) { - __pyx_memoryview_type->tp_as_buffer->bf_releasebuffer = __pyx_memoryview_type->tp_base->tp_as_buffer->bf_releasebuffer; - } - #elif defined(Py_bf_getbuffer) && defined(Py_bf_releasebuffer) - /* PY_VERSION_HEX >= 0x03090000 || Py_LIMITED_API >= 0x030B0000 */ - #elif defined(_MSC_VER) - #pragma message ("The buffer protocol is not supported in the Limited C-API < 3.11.") - #else - #warning "The buffer protocol is not supported in the Limited C-API < 3.11." - #endif - if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type___pyx_memoryview_spec, __pyx_memoryview_type) < 0) __PYX_ERR(1, 337, __pyx_L1_error) - #else - __pyx_memoryview_type = &__pyx_type___pyx_memoryview; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - #endif - #if !CYTHON_USE_TYPE_SPECS - if (__Pyx_PyType_Ready(__pyx_memoryview_type) < 0) __PYX_ERR(1, 337, __pyx_L1_error) - #endif - #if PY_MAJOR_VERSION < 3 - __pyx_memoryview_type->tp_print = 0; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_memoryview_type->tp_dictoffset && __pyx_memoryview_type->tp_getattro == PyObject_GenericGetAttr)) { - __pyx_memoryview_type->tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - #endif - if (__Pyx_SetVtable(__pyx_memoryview_type, __pyx_vtabptr_memoryview) < 0) __PYX_ERR(1, 337, __pyx_L1_error) - #if !CYTHON_COMPILING_IN_LIMITED_API - if (__Pyx_MergeVtables(__pyx_memoryview_type) < 0) __PYX_ERR(1, 337, __pyx_L1_error) - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - if (__Pyx_setup_reduce((PyObject *) __pyx_memoryview_type) < 0) __PYX_ERR(1, 337, __pyx_L1_error) - #endif - __pyx_vtabptr__memoryviewslice = &__pyx_vtable__memoryviewslice; - __pyx_vtable__memoryviewslice.__pyx_base = *__pyx_vtabptr_memoryview; - __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_vtable__memoryviewslice.__pyx_base._get_base = (PyObject *(*)(struct __pyx_memoryview_obj *))__pyx_memoryviewslice__get_base; - #if CYTHON_USE_TYPE_SPECS - __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_memoryview_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 952, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_memoryviewslice_type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type___pyx_memoryviewslice_spec, __pyx_t_1); - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_memoryviewslice_type)) __PYX_ERR(1, 952, __pyx_L1_error) - if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type___pyx_memoryviewslice_spec, __pyx_memoryviewslice_type) < 0) __PYX_ERR(1, 952, __pyx_L1_error) - #else - __pyx_memoryviewslice_type = &__pyx_type___pyx_memoryviewslice; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - __pyx_memoryviewslice_type->tp_base = __pyx_memoryview_type; - #endif - #if !CYTHON_USE_TYPE_SPECS - if (__Pyx_PyType_Ready(__pyx_memoryviewslice_type) < 0) __PYX_ERR(1, 952, __pyx_L1_error) - #endif - #if PY_MAJOR_VERSION < 3 - __pyx_memoryviewslice_type->tp_print = 0; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_memoryviewslice_type->tp_dictoffset && __pyx_memoryviewslice_type->tp_getattro == PyObject_GenericGetAttr)) { - __pyx_memoryviewslice_type->tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - #endif - if (__Pyx_SetVtable(__pyx_memoryviewslice_type, __pyx_vtabptr__memoryviewslice) < 0) __PYX_ERR(1, 952, __pyx_L1_error) - #if !CYTHON_COMPILING_IN_LIMITED_API - if (__Pyx_MergeVtables(__pyx_memoryviewslice_type) < 0) __PYX_ERR(1, 952, __pyx_L1_error) - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - if (__Pyx_setup_reduce((PyObject *) __pyx_memoryviewslice_type) < 0) __PYX_ERR(1, 952, __pyx_L1_error) - #endif - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_RefNannyFinishContext(); - return -1; -} - -static int __Pyx_modinit_type_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); - /*--- Type import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_variable_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); - /*--- Variable import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_function_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); - /*--- Function import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - - -#if PY_MAJOR_VERSION >= 3 -#if CYTHON_PEP489_MULTI_PHASE_INIT -static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ -static int __pyx_pymod_exec_core(PyObject* module); /*proto*/ -static PyModuleDef_Slot __pyx_moduledef_slots[] = { - {Py_mod_create, (void*)__pyx_pymod_create}, - {Py_mod_exec, (void*)__pyx_pymod_exec_core}, - {0, NULL} -}; -#endif - -#ifdef __cplusplus -namespace { - struct PyModuleDef __pyx_moduledef = - #else - static struct PyModuleDef __pyx_moduledef = - #endif - { - PyModuleDef_HEAD_INIT, - "core", - 0, /* m_doc */ - #if CYTHON_PEP489_MULTI_PHASE_INIT - 0, /* m_size */ - #elif CYTHON_USE_MODULE_STATE - sizeof(__pyx_mstate), /* m_size */ - #else - -1, /* m_size */ - #endif - __pyx_methods /* m_methods */, - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_moduledef_slots, /* m_slots */ - #else - NULL, /* m_reload */ - #endif - #if CYTHON_USE_MODULE_STATE - __pyx_m_traverse, /* m_traverse */ - __pyx_m_clear, /* m_clear */ - NULL /* m_free */ - #else - NULL, /* m_traverse */ - NULL, /* m_clear */ - NULL /* m_free */ - #endif - }; - #ifdef __cplusplus -} /* anonymous namespace */ -#endif -#endif - -#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 -#define __Pyx_PyMODINIT_FUNC void -#endif -#else -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * -#else -#define __Pyx_PyMODINIT_FUNC PyObject * -#endif -#endif - - -#if PY_MAJOR_VERSION < 3 -__Pyx_PyMODINIT_FUNC initcore(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC initcore(void) -#else -__Pyx_PyMODINIT_FUNC PyInit_core(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC PyInit_core(void) -#if CYTHON_PEP489_MULTI_PHASE_INIT -{ - return PyModuleDef_Init(&__pyx_moduledef); -} -static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { - #if PY_VERSION_HEX >= 0x030700A1 - static PY_INT64_T main_interpreter_id = -1; - PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); - if (main_interpreter_id == -1) { - main_interpreter_id = current_id; - return (unlikely(current_id == -1)) ? -1 : 0; - } else if (unlikely(main_interpreter_id != current_id)) - #else - static PyInterpreterState *main_interpreter = NULL; - PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; - if (!main_interpreter) { - main_interpreter = current_interpreter; - } else if (unlikely(main_interpreter != current_interpreter)) - #endif - { - PyErr_SetString( - PyExc_ImportError, - "Interpreter change detected - this module can only be loaded into one interpreter per process."); - return -1; - } - return 0; -} -#if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) -#else -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) -#endif -{ - PyObject *value = PyObject_GetAttrString(spec, from_name); - int result = 0; - if (likely(value)) { - if (allow_none || value != Py_None) { -#if CYTHON_COMPILING_IN_LIMITED_API - result = PyModule_AddObject(module, to_name, value); -#else - result = PyDict_SetItemString(moddict, to_name, value); -#endif - } - Py_DECREF(value); - } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { - PyErr_Clear(); - } else { - result = -1; - } - return result; -} -static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { - PyObject *module = NULL, *moddict, *modname; - CYTHON_UNUSED_VAR(def); - if (__Pyx_check_single_interpreter()) - return NULL; - if (__pyx_m) - return __Pyx_NewRef(__pyx_m); - modname = PyObject_GetAttrString(spec, "name"); - if (unlikely(!modname)) goto bad; - module = PyModule_NewObject(modname); - Py_DECREF(modname); - if (unlikely(!module)) goto bad; -#if CYTHON_COMPILING_IN_LIMITED_API - moddict = module; -#else - moddict = PyModule_GetDict(module); - if (unlikely(!moddict)) goto bad; -#endif - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; - return module; -bad: - Py_XDECREF(module); - return NULL; -} - - -static CYTHON_SMALL_CODE int __pyx_pymod_exec_core(PyObject *__pyx_pyinit_module) -#endif -#endif -{ - int stringtab_initialized = 0; - #if CYTHON_USE_MODULE_STATE - int pystate_addmodule_run = 0; - #endif - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - int __pyx_t_6; - PyObject *__pyx_t_7 = NULL; - static PyThread_type_lock __pyx_t_8[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) { - if (__pyx_m == __pyx_pyinit_module) return 0; - PyErr_SetString(PyExc_RuntimeError, "Module 'core' has already been imported. Re-initialisation is not supported."); - return -1; - } - #elif PY_MAJOR_VERSION >= 3 - if (__pyx_m) return __Pyx_NewRef(__pyx_m); - #endif - /*--- Module creation code ---*/ - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_m = __pyx_pyinit_module; - Py_INCREF(__pyx_m); - #else - #if PY_MAJOR_VERSION < 3 - __pyx_m = Py_InitModule4("core", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #elif CYTHON_USE_MODULE_STATE - __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) - { - int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef); - __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "core" pseudovariable */ - if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) - pystate_addmodule_run = 1; - } - #else - __pyx_m = PyModule_Create(&__pyx_moduledef); - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #endif - CYTHON_UNUSED_VAR(__pyx_t_1); - __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_d); - __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) - if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #if CYTHON_REFNANNY -__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); -if (!__Pyx_RefNanny) { - PyErr_Clear(); - __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); - if (!__Pyx_RefNanny) - Py_FatalError("failed to import 'refnanny' module"); -} -#endif - __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_core(void)", 0); - if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pxy_PyFrame_Initialize_Offsets - __Pxy_PyFrame_Initialize_Offsets(); - #endif - __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pyx_CyFunction_USED - if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_FusedFunction_USED - if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Coroutine_USED - if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Generator_USED - if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_AsyncGen_USED - if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_StopAsyncIteration_USED - if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - /*--- Library function declarations ---*/ - /*--- Threads initialization code ---*/ - #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS - PyEval_InitThreads(); - #endif - /*--- Initialize various global constants etc. ---*/ - if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - stringtab_initialized = 1; - if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) - if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - if (__pyx_module_is_main_robo_utils__core) { - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - } - #if PY_MAJOR_VERSION >= 3 - { - PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) - if (!PyDict_GetItemString(modules, "robo_utils.core")) { - if (unlikely((PyDict_SetItemString(modules, "robo_utils.core", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) - } - } - #endif - /*--- Builtin init code ---*/ - if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Constants init code ---*/ - if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __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) - (void)__Pyx_modinit_type_import_code(); - (void)__Pyx_modinit_variable_import_code(); - (void)__Pyx_modinit_function_import_code(); - /*--- Execution code ---*/ - #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) - if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - - /* "View.MemoryView":99 - * - * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" - * try: # <<<<<<<<<<<<<< - * if __import__("sys").version_info >= (3, 3): - * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence - */ - { - __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:*/ { - - /* "View.MemoryView":100 - * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" - * try: - * if __import__("sys").version_info >= (3, 3): # <<<<<<<<<<<<<< - * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence - * else: - */ - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 100, __pyx_L2_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_version_info); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 100, __pyx_L2_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyObject_RichCompare(__pyx_t_5, __pyx_tuple__10, Py_GE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 100, __pyx_L2_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(1, 100, __pyx_L2_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - - /* "View.MemoryView":101 - * try: - * if __import__("sys").version_info >= (3, 3): - * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence # <<<<<<<<<<<<<< - * else: - * __pyx_collections_abc_Sequence = __import__("collections").Sequence - */ - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 101, __pyx_L2_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_abc); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 101, __pyx_L2_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_Sequence); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 101, __pyx_L2_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_XGOTREF(__pyx_collections_abc_Sequence); - __Pyx_DECREF_SET(__pyx_collections_abc_Sequence, __pyx_t_4); - __Pyx_GIVEREF(__pyx_t_4); - __pyx_t_4 = 0; - - /* "View.MemoryView":100 - * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" - * try: - * if __import__("sys").version_info >= (3, 3): # <<<<<<<<<<<<<< - * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence - * else: - */ - goto __pyx_L8; - } - - /* "View.MemoryView":103 - * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence - * else: - * __pyx_collections_abc_Sequence = __import__("collections").Sequence # <<<<<<<<<<<<<< - * except: - * - */ - /*else*/ { - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin___import__, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 103, __pyx_L2_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Sequence); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 103, __pyx_L2_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_XGOTREF(__pyx_collections_abc_Sequence); - __Pyx_DECREF_SET(__pyx_collections_abc_Sequence, __pyx_t_5); - __Pyx_GIVEREF(__pyx_t_5); - __pyx_t_5 = 0; - } - __pyx_L8:; - - /* "View.MemoryView":99 - * - * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" - * try: # <<<<<<<<<<<<<< - * if __import__("sys").version_info >= (3, 3): - * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence - */ - } - __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_L7_try_end; - __pyx_L2_error:; - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - - /* "View.MemoryView":104 - * else: - * __pyx_collections_abc_Sequence = __import__("collections").Sequence - * except: # <<<<<<<<<<<<<< - * - * __pyx_collections_abc_Sequence = None - */ - /*except:*/ { - __Pyx_AddTraceback("View.MemoryView", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_7) < 0) __PYX_ERR(1, 104, __pyx_L4_except_error) - __Pyx_XGOTREF(__pyx_t_5); - __Pyx_XGOTREF(__pyx_t_4); - __Pyx_XGOTREF(__pyx_t_7); - - /* "View.MemoryView":106 - * except: - * - * __pyx_collections_abc_Sequence = None # <<<<<<<<<<<<<< - * - * - */ - __Pyx_INCREF(Py_None); - __Pyx_XGOTREF(__pyx_collections_abc_Sequence); - __Pyx_DECREF_SET(__pyx_collections_abc_Sequence, Py_None); - __Pyx_GIVEREF(Py_None); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - goto __pyx_L3_exception_handled; - } - - /* "View.MemoryView":99 - * - * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" - * try: # <<<<<<<<<<<<<< - * if __import__("sys").version_info >= (3, 3): - * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence - */ - __pyx_L4_except_error:; - __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_L3_exception_handled:; - __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); - __pyx_L7_try_end:; - } - - /* "View.MemoryView":241 - * - * - * try: # <<<<<<<<<<<<<< - * count = __pyx_collections_abc_Sequence.count - * index = __pyx_collections_abc_Sequence.index - */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1); - __Pyx_XGOTREF(__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_2); - __Pyx_XGOTREF(__pyx_t_1); - /*try:*/ { - - /* "View.MemoryView":242 - * - * try: - * count = __pyx_collections_abc_Sequence.count # <<<<<<<<<<<<<< - * index = __pyx_collections_abc_Sequence.index - * except: - */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_n_s_count); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 242, __pyx_L11_error) - __Pyx_GOTREF(__pyx_t_7); - if (__Pyx_SetItemOnTypeDict(__pyx_array_type, __pyx_n_s_count, __pyx_t_7) < 0) __PYX_ERR(1, 242, __pyx_L11_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - PyType_Modified(__pyx_array_type); - - /* "View.MemoryView":243 - * try: - * count = __pyx_collections_abc_Sequence.count - * index = __pyx_collections_abc_Sequence.index # <<<<<<<<<<<<<< - * except: - * pass - */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_n_s_index); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 243, __pyx_L11_error) - __Pyx_GOTREF(__pyx_t_7); - if (__Pyx_SetItemOnTypeDict(__pyx_array_type, __pyx_n_s_index, __pyx_t_7) < 0) __PYX_ERR(1, 243, __pyx_L11_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - PyType_Modified(__pyx_array_type); - - /* "View.MemoryView":241 - * - * - * try: # <<<<<<<<<<<<<< - * count = __pyx_collections_abc_Sequence.count - * index = __pyx_collections_abc_Sequence.index - */ - } - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - goto __pyx_L16_try_end; - __pyx_L11_error:; - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "View.MemoryView":244 - * count = __pyx_collections_abc_Sequence.count - * index = __pyx_collections_abc_Sequence.index - * except: # <<<<<<<<<<<<<< - * pass - * - */ - /*except:*/ { - __Pyx_ErrRestore(0,0,0); - goto __pyx_L12_exception_handled; - } - __pyx_L12_exception_handled:; - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_2, __pyx_t_1); - __pyx_L16_try_end:; - } - - /* "View.MemoryView":309 - * return self.name - * - * cdef generic = Enum("") # <<<<<<<<<<<<<< - * cdef strided = Enum("") # default - * cdef indirect = Enum("") - */ - __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 309, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_XGOTREF(generic); - __Pyx_DECREF_SET(generic, __pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - __pyx_t_7 = 0; - - /* "View.MemoryView":310 - * - * cdef generic = Enum("") - * cdef strided = Enum("") # default # <<<<<<<<<<<<<< - * cdef indirect = Enum("") - * - */ - __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 310, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_XGOTREF(strided); - __Pyx_DECREF_SET(strided, __pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - __pyx_t_7 = 0; - - /* "View.MemoryView":311 - * cdef generic = Enum("") - * cdef strided = Enum("") # default - * cdef indirect = Enum("") # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 311, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_XGOTREF(indirect); - __Pyx_DECREF_SET(indirect, __pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - __pyx_t_7 = 0; - - /* "View.MemoryView":314 - * - * - * cdef contiguous = Enum("") # <<<<<<<<<<<<<< - * cdef indirect_contiguous = Enum("") - * - */ - __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 314, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_XGOTREF(contiguous); - __Pyx_DECREF_SET(contiguous, __pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - __pyx_t_7 = 0; - - /* "View.MemoryView":315 - * - * cdef contiguous = Enum("") - * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 315, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_XGOTREF(indirect_contiguous); - __Pyx_DECREF_SET(indirect_contiguous, __pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - __pyx_t_7 = 0; - - /* "View.MemoryView":323 - * - * - * cdef int __pyx_memoryview_thread_locks_used = 0 # <<<<<<<<<<<<<< - * cdef PyThread_type_lock[8] __pyx_memoryview_thread_locks = [ - * PyThread_allocate_lock(), - */ - __pyx_memoryview_thread_locks_used = 0; - - /* "View.MemoryView":324 - * - * cdef int __pyx_memoryview_thread_locks_used = 0 - * cdef PyThread_type_lock[8] __pyx_memoryview_thread_locks = [ # <<<<<<<<<<<<<< - * PyThread_allocate_lock(), - * PyThread_allocate_lock(), - */ - __pyx_t_8[0] = PyThread_allocate_lock(); - __pyx_t_8[1] = PyThread_allocate_lock(); - __pyx_t_8[2] = PyThread_allocate_lock(); - __pyx_t_8[3] = PyThread_allocate_lock(); - __pyx_t_8[4] = PyThread_allocate_lock(); - __pyx_t_8[5] = PyThread_allocate_lock(); - __pyx_t_8[6] = PyThread_allocate_lock(); - __pyx_t_8[7] = PyThread_allocate_lock(); - memcpy(&(__pyx_memoryview_thread_locks[0]), __pyx_t_8, sizeof(__pyx_memoryview_thread_locks[0]) * (8)); - - /* "View.MemoryView":982 - * - * - * try: # <<<<<<<<<<<<<< - * count = __pyx_collections_abc_Sequence.count - * index = __pyx_collections_abc_Sequence.index - */ - { - __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:*/ { - - /* "View.MemoryView":983 - * - * try: - * count = __pyx_collections_abc_Sequence.count # <<<<<<<<<<<<<< - * index = __pyx_collections_abc_Sequence.index - * except: - */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_n_s_count); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 983, __pyx_L17_error) - __Pyx_GOTREF(__pyx_t_7); - if (__Pyx_SetItemOnTypeDict(__pyx_memoryviewslice_type, __pyx_n_s_count, __pyx_t_7) < 0) __PYX_ERR(1, 983, __pyx_L17_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - PyType_Modified(__pyx_memoryviewslice_type); - - /* "View.MemoryView":984 - * try: - * count = __pyx_collections_abc_Sequence.count - * index = __pyx_collections_abc_Sequence.index # <<<<<<<<<<<<<< - * except: - * pass - */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_n_s_index); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 984, __pyx_L17_error) - __Pyx_GOTREF(__pyx_t_7); - if (__Pyx_SetItemOnTypeDict(__pyx_memoryviewslice_type, __pyx_n_s_index, __pyx_t_7) < 0) __PYX_ERR(1, 984, __pyx_L17_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - PyType_Modified(__pyx_memoryviewslice_type); - - /* "View.MemoryView":982 - * - * - * try: # <<<<<<<<<<<<<< - * count = __pyx_collections_abc_Sequence.count - * index = __pyx_collections_abc_Sequence.index - */ - } - __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_L22_try_end; - __pyx_L17_error:; - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "View.MemoryView":985 - * count = __pyx_collections_abc_Sequence.count - * index = __pyx_collections_abc_Sequence.index - * except: # <<<<<<<<<<<<<< - * pass - * - */ - /*except:*/ { - __Pyx_ErrRestore(0,0,0); - goto __pyx_L18_exception_handled; - } - __pyx_L18_exception_handled:; - __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); - __pyx_L22_try_end:; - } - - /* "View.MemoryView":988 - * pass - * - * try: # <<<<<<<<<<<<<< - * if __pyx_collections_abc_Sequence: - * - */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1); - __Pyx_XGOTREF(__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_2); - __Pyx_XGOTREF(__pyx_t_1); - /*try:*/ { - - /* "View.MemoryView":989 - * - * try: - * if __pyx_collections_abc_Sequence: # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_collections_abc_Sequence); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(1, 989, __pyx_L23_error) - if (__pyx_t_6) { - - /* "View.MemoryView":993 - * - * - * __pyx_collections_abc_Sequence.register(_memoryviewslice) # <<<<<<<<<<<<<< - * __pyx_collections_abc_Sequence.register(array) - * except: - */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_n_s_register); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 993, __pyx_L23_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_7, ((PyObject *)__pyx_memoryviewslice_type)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 993, __pyx_L23_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - - /* "View.MemoryView":994 - * - * __pyx_collections_abc_Sequence.register(_memoryviewslice) - * __pyx_collections_abc_Sequence.register(array) # <<<<<<<<<<<<<< - * except: - * pass # ignore failure, it's a minor issue - */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_n_s_register); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 994, __pyx_L23_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_4, ((PyObject *)__pyx_array_type)); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 994, __pyx_L23_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "View.MemoryView":989 - * - * try: - * if __pyx_collections_abc_Sequence: # <<<<<<<<<<<<<< - * - * - */ - } - - /* "View.MemoryView":988 - * pass - * - * try: # <<<<<<<<<<<<<< - * if __pyx_collections_abc_Sequence: - * - */ - } - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - goto __pyx_L28_try_end; - __pyx_L23_error:; - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "View.MemoryView":995 - * __pyx_collections_abc_Sequence.register(_memoryviewslice) - * __pyx_collections_abc_Sequence.register(array) - * except: # <<<<<<<<<<<<<< - * pass # ignore failure, it's a minor issue - * - */ - /*except:*/ { - __Pyx_ErrRestore(0,0,0); - goto __pyx_L24_exception_handled; - } - __pyx_L24_exception_handled:; - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_2, __pyx_t_1); - __pyx_L28_try_end:; - } - - /* "(tree fragment)":1 - * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ - __pyx_t_7 = PyCFunction_NewEx(&__pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum, NULL, __pyx_n_s_View_MemoryView); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Enum, __pyx_t_7) < 0) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "robo_utils/core.pyx":5 - * from cython.parallel import prange - * - * import numpy as np # <<<<<<<<<<<<<< - * - * from libc.stdlib cimport rand, RAND_MAX - */ - __pyx_t_7 = __Pyx_ImportDottedModule(__pyx_n_s_numpy, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_7) < 0) __PYX_ERR(0, 5, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "robo_utils/core.pyx":59 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * cpdef void float_to_int_duration_batch_c(float[:, :] dur, int[:] T, int[:, :] mask, int[:, :] int_dur) nogil: # <<<<<<<<<<<<<< - * """ - * Args: - */ - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_10robo_utils_4core_1float_to_int_duration_batch_c, 0, __pyx_n_s_float_to_int_duration_batch_c, NULL, __pyx_n_s_robo_utils_core, __pyx_d, ((PyObject *)__pyx_codeobj__21)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 59, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_float_to_int_duration_batch_c, __pyx_t_7) < 0) __PYX_ERR(0, 59, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "robo_utils/core.pyx":104 - * @cython.boundscheck(False) - * @cython.wraparound(False) - * cpdef void generate_random_intervals_batch_c(int[:, :] boundaries_batch, int[:, :] result_batch, int num_randoms) nogil: # <<<<<<<<<<<<<< - * """ - * Generate random intervals for a batch of boundaries - */ - __pyx_t_7 = __Pyx_CyFunction_New(&__pyx_mdef_10robo_utils_4core_3generate_random_intervals_batch_c, 0, __pyx_n_s_generate_random_intervals_batch, NULL, __pyx_n_s_robo_utils_core, __pyx_d, ((PyObject *)__pyx_codeobj__23)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 104, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_generate_random_intervals_batch, __pyx_t_7) < 0) __PYX_ERR(0, 104, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "robo_utils/core.pyx":1 - * cimport cython # <<<<<<<<<<<<<< - * - * from cython.parallel import prange - */ - __pyx_t_7 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_7) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - /*--- Wrapped vars code ---*/ - - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_7); - if (__pyx_m) { - if (__pyx_d && stringtab_initialized) { - __Pyx_AddTraceback("init robo_utils.core", __pyx_clineno, __pyx_lineno, __pyx_filename); - } - #if !CYTHON_USE_MODULE_STATE - Py_CLEAR(__pyx_m); - #else - Py_DECREF(__pyx_m); - if (pystate_addmodule_run) { - PyObject *tp, *value, *tb; - PyErr_Fetch(&tp, &value, &tb); - PyState_RemoveModule(&__pyx_moduledef); - PyErr_Restore(tp, value, tb); - } - #endif - } else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_ImportError, "init robo_utils.core"); - } - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - #if CYTHON_PEP489_MULTI_PHASE_INIT - return (__pyx_m != NULL) ? 0 : -1; - #elif PY_MAJOR_VERSION >= 3 - return __pyx_m; - #else - return; - #endif -} -/* #### Code section: cleanup_globals ### */ -/* #### Code section: cleanup_module ### */ -/* #### Code section: main_method ### */ -/* #### Code section: utility_code_pragmas ### */ -#ifdef _MSC_VER -#pragma warning( push ) -/* Warning 4127: conditional expression is constant - * Cython uses constant conditional expressions to allow in inline functions to be optimized at - * compile-time, so this warning is not useful - */ -#pragma warning( disable : 4127 ) -#endif - - - -/* #### Code section: utility_code_def ### */ - -/* --- Runtime support code --- */ -/* Refnanny */ -#if CYTHON_REFNANNY -static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { - PyObject *m = NULL, *p = NULL; - void *r = NULL; - m = PyImport_ImportModule(modname); - if (!m) goto end; - p = PyObject_GetAttrString(m, "RefNannyAPI"); - if (!p) goto end; - r = PyLong_AsVoidPtr(p); -end: - Py_XDECREF(p); - Py_XDECREF(m); - return (__Pyx_RefNannyAPIStruct *)r; -} -#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; i= 0x030C00A6 - PyObject *current_exception = tstate->current_exception; - if (unlikely(!current_exception)) return 0; - exc_type = (PyObject*) Py_TYPE(current_exception); - if (exc_type == err) return 1; -#else - exc_type = tstate->curexc_type; - if (exc_type == err) return 1; - if (unlikely(!exc_type)) return 0; -#endif - #if CYTHON_AVOID_BORROWED_REFS - Py_INCREF(exc_type); - #endif - if (unlikely(PyTuple_Check(err))) { - result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); - } else { - result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); - } - #if CYTHON_AVOID_BORROWED_REFS - Py_DECREF(exc_type); - #endif - return result; -} -#endif - -/* PyErrFetchRestore */ -#if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { -#if PY_VERSION_HEX >= 0x030C00A6 - PyObject *tmp_value; - assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); - if (value) { - #if CYTHON_COMPILING_IN_CPYTHON - if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) - #endif - PyException_SetTraceback(value, tb); - } - tmp_value = tstate->current_exception; - tstate->current_exception = value; - Py_XDECREF(tmp_value); - Py_XDECREF(type); - Py_XDECREF(tb); -#else - PyObject *tmp_type, *tmp_value, *tmp_tb; - tmp_type = tstate->curexc_type; - tmp_value = tstate->curexc_value; - tmp_tb = tstate->curexc_traceback; - tstate->curexc_type = type; - tstate->curexc_value = value; - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); -#endif -} -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { -#if PY_VERSION_HEX >= 0x030C00A6 - PyObject* exc_value; - exc_value = tstate->current_exception; - tstate->current_exception = 0; - *value = exc_value; - *type = NULL; - *tb = NULL; - if (exc_value) { - *type = (PyObject*) Py_TYPE(exc_value); - Py_INCREF(*type); - #if CYTHON_COMPILING_IN_CPYTHON - *tb = ((PyBaseExceptionObject*) exc_value)->traceback; - Py_XINCREF(*tb); - #else - *tb = PyException_GetTraceback(exc_value); - #endif - } -#else - *type = tstate->curexc_type; - *value = tstate->curexc_value; - *tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; -#endif -} -#endif - -/* PyObjectGetAttrStr */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { - PyTypeObject* tp = Py_TYPE(obj); - if (likely(tp->tp_getattro)) - return tp->tp_getattro(obj, attr_name); -#if PY_MAJOR_VERSION < 3 - if (likely(tp->tp_getattr)) - return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); -#endif - return PyObject_GetAttr(obj, attr_name); -} -#endif - -/* PyObjectGetAttrStrNoError */ -#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 -static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) - __Pyx_PyErr_Clear(); -} -#endif -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { - PyObject *result; -#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 - (void) PyObject_GetOptionalAttr(obj, attr_name, &result); - return result; -#else -#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; -#endif -} - -/* GetBuiltinName */ -static PyObject *__Pyx_GetBuiltinName(PyObject *name) { - PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name); - if (unlikely(!result) && !PyErr_Occurred()) { - PyErr_Format(PyExc_NameError, -#if PY_MAJOR_VERSION >= 3 - "name '%U' is not defined", name); -#else - "name '%.200s' is not defined", PyString_AS_STRING(name)); -#endif - } - return result; -} - -/* TupleAndListFromArray */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { - PyObject *v; - Py_ssize_t i; - for (i = 0; i < length; i++) { - v = dest[i] = src[i]; - Py_INCREF(v); - } -} -static CYTHON_INLINE PyObject * -__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) -{ - PyObject *res; - if (n <= 0) { - Py_INCREF(__pyx_empty_tuple); - return __pyx_empty_tuple; - } - res = PyTuple_New(n); - if (unlikely(res == NULL)) return NULL; - __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); - return res; -} -static CYTHON_INLINE PyObject * -__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) -{ - PyObject *res; - if (n <= 0) { - return PyList_New(0); - } - res = PyList_New(n); - if (unlikely(res == NULL)) return NULL; - __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); - return res; -} -#endif - -/* BytesEquals */ -static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { -#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API - 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_VERSION_HEX < 0x030B0000) - 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 || CYTHON_COMPILING_IN_LIMITED_API - 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); - } -#endif - if (s1_is_unicode & s2_is_unicode) { - Py_ssize_t length; - int kind; - void *data1, *data2; - if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) - return -1; - length = __Pyx_PyUnicode_GET_LENGTH(s1); - if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { - goto return_ne; - } -#if CYTHON_USE_UNICODE_INTERNALS - { - Py_hash_t hash1, hash2; - #if CYTHON_PEP393_ENABLED - hash1 = ((PyASCIIObject*)s1)->hash; - hash2 = ((PyASCIIObject*)s2)->hash; - #else - hash1 = ((PyUnicodeObject*)s1)->hash; - hash2 = ((PyUnicodeObject*)s2)->hash; - #endif - if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { - goto return_ne; - } - } -#endif - kind = __Pyx_PyUnicode_KIND(s1); - if (kind != __Pyx_PyUnicode_KIND(s2)) { - goto return_ne; - } - data1 = __Pyx_PyUnicode_DATA(s1); - data2 = __Pyx_PyUnicode_DATA(s2); - if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { - goto return_ne; - } else if (length == 1) { - goto return_eq; - } else { - int result = memcmp(data1, data2, (size_t)(length * kind)); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - return (equals == Py_EQ) ? (result == 0) : (result != 0); - } - } else if ((s1 == Py_None) & s2_is_unicode) { - goto return_ne; - } else if ((s2 == Py_None) & s1_is_unicode) { - goto return_ne; - } else { - int result; - PyObject* py_result = PyObject_RichCompare(s1, s2, equals); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - if (!py_result) - return -1; - result = __Pyx_PyObject_IsTrue(py_result); - Py_DECREF(py_result); - return result; - } -return_eq: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - return (equals == Py_EQ); -return_ne: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - return (equals == Py_NE); -#endif -} - -/* fastcall */ -#if CYTHON_METH_FASTCALL -static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) -{ - Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames); - for (i = 0; i < n; i++) - { - if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i]; - } - for (i = 0; i < n; i++) - { - int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ); - if (unlikely(eq != 0)) { - if (unlikely(eq < 0)) return NULL; - return kwvalues[i]; - } - } - return NULL; -} -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 -CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { - Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames); - PyObject *dict; - dict = PyDict_New(); - if (unlikely(!dict)) - return NULL; - for (i=0; i= 3 - "%s() got multiple values for keyword argument '%U'", func_name, kw_name); - #else - "%s() got multiple values for keyword argument '%s'", func_name, - PyString_AsString(kw_name)); - #endif -} - -/* ParseKeywords */ -static int __Pyx_ParseOptionalKeywords( - PyObject *kwds, - PyObject *const *kwvalues, - PyObject **argnames[], - PyObject *kwds2, - PyObject *values[], - Py_ssize_t num_pos_args, - const char* function_name) -{ - PyObject *key = 0, *value = 0; - Py_ssize_t pos = 0; - PyObject*** name; - PyObject*** first_kw_arg = argnames + num_pos_args; - int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)); - while (1) { - Py_XDECREF(key); key = NULL; - Py_XDECREF(value); value = NULL; - if (kwds_is_tuple) { - Py_ssize_t size; -#if CYTHON_ASSUME_SAFE_MACROS - size = PyTuple_GET_SIZE(kwds); -#else - size = PyTuple_Size(kwds); - if (size < 0) goto bad; -#endif - if (pos >= size) break; -#if CYTHON_AVOID_BORROWED_REFS - key = __Pyx_PySequence_ITEM(kwds, pos); - if (!key) goto bad; -#elif CYTHON_ASSUME_SAFE_MACROS - key = PyTuple_GET_ITEM(kwds, pos); -#else - key = PyTuple_GetItem(kwds, pos); - if (!key) goto bad; -#endif - value = kwvalues[pos]; - pos++; - } - else - { - if (!PyDict_Next(kwds, &pos, &key, &value)) break; -#if CYTHON_AVOID_BORROWED_REFS - Py_INCREF(key); -#endif - } - name = first_kw_arg; - while (*name && (**name != key)) name++; - if (*name) { - values[name-argnames] = value; -#if CYTHON_AVOID_BORROWED_REFS - Py_INCREF(value); - Py_DECREF(key); -#endif - key = NULL; - value = NULL; - continue; - } -#if !CYTHON_AVOID_BORROWED_REFS - Py_INCREF(key); -#endif - Py_INCREF(value); - name = first_kw_arg; - #if PY_MAJOR_VERSION < 3 - if (likely(PyString_Check(key))) { - while (*name) { - if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) - && _PyString_Eq(**name, key)) { - values[name-argnames] = value; -#if CYTHON_AVOID_BORROWED_REFS - value = NULL; -#endif - break; - } - name++; - } - if (*name) continue; - else { - PyObject*** argname = argnames; - while (argname != first_kw_arg) { - if ((**argname == key) || ( - (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) - && _PyString_Eq(**argname, key))) { - goto arg_passed_twice; - } - argname++; - } - } - } else - #endif - if (likely(PyUnicode_Check(key))) { - while (*name) { - int cmp = ( - #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : - #endif - PyUnicode_Compare(**name, key) - ); - if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; - if (cmp == 0) { - values[name-argnames] = value; -#if CYTHON_AVOID_BORROWED_REFS - value = NULL; -#endif - break; - } - name++; - } - if (*name) continue; - else { - PyObject*** argname = argnames; - 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 : - #endif - PyUnicode_Compare(**argname, key); - if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; - if (cmp == 0) goto arg_passed_twice; - argname++; - } - } - } else - goto invalid_keyword_type; - if (kwds2) { - if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; - } else { - goto invalid_keyword; - } - } - Py_XDECREF(key); - Py_XDECREF(value); - return 0; -arg_passed_twice: - __Pyx_RaiseDoubleKeywordsError(function_name, key); - goto bad; -invalid_keyword_type: - PyErr_Format(PyExc_TypeError, - "%.200s() keywords must be strings", function_name); - goto bad; -invalid_keyword: - #if PY_MAJOR_VERSION < 3 - PyErr_Format(PyExc_TypeError, - "%.200s() got an unexpected keyword argument '%.200s'", - function_name, PyString_AsString(key)); - #else - PyErr_Format(PyExc_TypeError, - "%s() got an unexpected keyword argument '%U'", - function_name, key); - #endif -bad: - Py_XDECREF(key); - Py_XDECREF(value); - return -1; -} - -/* ArgTypeTest */ -static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) -{ - __Pyx_TypeName type_name; - __Pyx_TypeName obj_type_name; - 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; - } - type_name = __Pyx_PyType_GetName(type); - obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); - PyErr_Format(PyExc_TypeError, - "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME - ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name); - __Pyx_DECREF_TypeName(type_name); - __Pyx_DECREF_TypeName(obj_type_name); - return 0; -} - -/* RaiseException */ -#if PY_MAJOR_VERSION < 3 -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { - __Pyx_PyThreadState_declare - CYTHON_UNUSED_VAR(cause); - 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 PY_VERSION_HEX >= 0x030C00A6 - PyException_SetTraceback(value, tb); - #elif CYTHON_FAST_THREAD_STATE - 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); - } -#else - 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); -#endif - } -bad: - Py_XDECREF(owned_instance); - return; -} -#endif - -/* PyFunctionFastCall */ -#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL -static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, - PyObject *globals) { - PyFrameObject *f; - PyThreadState *tstate = __Pyx_PyThreadState_Current; - PyObject **fastlocals; - Py_ssize_t i; - PyObject *result; - assert(globals != NULL); - /* XXX Perhaps we should create a specialized - PyFrame_New() that doesn't take locals, but does - take builtins without sanity checking them. - */ - assert(tstate != NULL); - f = PyFrame_New(tstate, co, globals, NULL); - if (f == NULL) { - return NULL; - } - fastlocals = __Pyx_PyFrame_GetLocalsplus(f); - for (i = 0; i < na; i++) { - Py_INCREF(*args); - fastlocals[i] = *args++; - } - result = PyEval_EvalFrameEx(f,0); - ++tstate->recursion_depth; - Py_DECREF(f); - --tstate->recursion_depth; - return result; -} -static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { - PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); - PyObject *globals = PyFunction_GET_GLOBALS(func); - PyObject *argdefs = PyFunction_GET_DEFAULTS(func); - PyObject *closure; -#if PY_MAJOR_VERSION >= 3 - PyObject *kwdefs; -#endif - PyObject *kwtuple, **k; - PyObject **d; - Py_ssize_t nd; - Py_ssize_t nk; - PyObject *result; - assert(kwargs == NULL || PyDict_Check(kwargs)); - nk = kwargs ? PyDict_Size(kwargs) : 0; - #if PY_MAJOR_VERSION < 3 - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) { - return NULL; - } - #else - if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { - return NULL; - } - #endif - if ( -#if PY_MAJOR_VERSION >= 3 - co->co_kwonlyargcount == 0 && -#endif - likely(kwargs == NULL || nk == 0) && - co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { - if (argdefs == NULL && co->co_argcount == nargs) { - result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); - goto done; - } - else if (nargs == 0 && argdefs != NULL - && co->co_argcount == Py_SIZE(argdefs)) { - /* function called with no arguments, but all parameters have - a default value: use default values as arguments .*/ - args = &PyTuple_GET_ITEM(argdefs, 0); - result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); - goto done; - } - } - if (kwargs != NULL) { - Py_ssize_t pos, i; - kwtuple = PyTuple_New(2 * nk); - if (kwtuple == NULL) { - result = NULL; - goto done; - } - k = &PyTuple_GET_ITEM(kwtuple, 0); - pos = i = 0; - while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { - Py_INCREF(k[i]); - Py_INCREF(k[i+1]); - i += 2; - } - nk = i / 2; - } - else { - kwtuple = NULL; - k = NULL; - } - closure = PyFunction_GET_CLOSURE(func); -#if PY_MAJOR_VERSION >= 3 - kwdefs = PyFunction_GET_KW_DEFAULTS(func); -#endif - if (argdefs != NULL) { - d = &PyTuple_GET_ITEM(argdefs, 0); - nd = Py_SIZE(argdefs); - } - else { - d = NULL; - nd = 0; - } -#if PY_MAJOR_VERSION >= 3 - result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, kwdefs, closure); -#else - result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, closure); -#endif - Py_XDECREF(kwtuple); -done: - Py_LeaveRecursiveCall(); - return result; -} -#endif - -/* PyObjectCall */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { - PyObject *result; - ternaryfunc call = Py_TYPE(func)->tp_call; - if (unlikely(!call)) - return PyObject_Call(func, arg, kw); - #if PY_MAJOR_VERSION < 3 - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - #else - if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) - return NULL; - #endif - result = (*call)(func, arg, kw); - Py_LeaveRecursiveCall(); - if (unlikely(!result) && unlikely(!PyErr_Occurred())) { - PyErr_SetString( - PyExc_SystemError, - "NULL result without error in PyObject_Call"); - } - return result; -} -#endif - -/* PyObjectCallMethO */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { - PyObject *self, *result; - PyCFunction cfunc; - cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); - self = __Pyx_CyOrPyCFunction_GET_SELF(func); - #if PY_MAJOR_VERSION < 3 - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - #else - if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) - return NULL; - #endif - result = cfunc(self, arg); - Py_LeaveRecursiveCall(); - if (unlikely(!result) && unlikely(!PyErr_Occurred())) { - PyErr_SetString( - PyExc_SystemError, - "NULL result without error in PyObject_Call"); - } - return result; -} -#endif - -/* PyObjectFastCall */ -#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API -static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) { - PyObject *argstuple; - PyObject *result = 0; - size_t i; - argstuple = PyTuple_New((Py_ssize_t)nargs); - if (unlikely(!argstuple)) return NULL; - for (i = 0; i < nargs; i++) { - Py_INCREF(args[i]); - if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad; - } - result = __Pyx_PyObject_Call(func, argstuple, kwargs); - bad: - Py_DECREF(argstuple); - return result; -} -#endif -static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) { - Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); -#if CYTHON_COMPILING_IN_CPYTHON - if (nargs == 0 && kwargs == NULL) { - if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) - return __Pyx_PyObject_CallMethO(func, NULL); - } - else if (nargs == 1 && kwargs == NULL) { - if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) - return __Pyx_PyObject_CallMethO(func, args[0]); - } -#endif - #if PY_VERSION_HEX < 0x030800B1 - #if CYTHON_FAST_PYCCALL - if (PyCFunction_Check(func)) { - if (kwargs) { - return _PyCFunction_FastCallDict(func, args, nargs, kwargs); - } else { - return _PyCFunction_FastCallKeywords(func, args, nargs, NULL); - } - } - #if PY_VERSION_HEX >= 0x030700A1 - if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { - return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); - } - #endif - #endif - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(func)) { - return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs); - } - #endif - #endif - if (kwargs == NULL) { - #if CYTHON_VECTORCALL - #if PY_VERSION_HEX < 0x03090000 - vectorcallfunc f = _PyVectorcall_Function(func); - #else - vectorcallfunc f = PyVectorcall_Function(func); - #endif - if (f) { - return f(func, args, (size_t)nargs, NULL); - } - #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL - if (__Pyx_CyFunction_CheckExact(func)) { - __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func); - if (f) return f(func, args, (size_t)nargs, NULL); - } - #endif - } - if (nargs == 0) { - return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs); - } - #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API - return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); - #else - return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); - #endif -} - -/* RaiseUnexpectedTypeError */ -static int -__Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj) -{ - __Pyx_TypeName obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); - PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME, - expected, obj_type_name); - __Pyx_DECREF_TypeName(obj_type_name); - return 0; -} - -/* CIntToDigits */ -static const char DIGIT_PAIRS_10[2*10*10+1] = { - "00010203040506070809" - "10111213141516171819" - "20212223242526272829" - "30313233343536373839" - "40414243444546474849" - "50515253545556575859" - "60616263646566676869" - "70717273747576777879" - "80818283848586878889" - "90919293949596979899" -}; -static const char DIGIT_PAIRS_8[2*8*8+1] = { - "0001020304050607" - "1011121314151617" - "2021222324252627" - "3031323334353637" - "4041424344454647" - "5051525354555657" - "6061626364656667" - "7071727374757677" -}; -static const char DIGITS_HEX[2*16+1] = { - "0123456789abcdef" - "0123456789ABCDEF" -}; - -/* BuildPyUnicode */ -static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, char* chars, int clength, - int prepend_sign, char padding_char) { - PyObject *uval; - Py_ssize_t uoffset = ulength - clength; -#if CYTHON_USE_UNICODE_INTERNALS - Py_ssize_t i; -#if CYTHON_PEP393_ENABLED - void *udata; - uval = PyUnicode_New(ulength, 127); - if (unlikely(!uval)) return NULL; - udata = PyUnicode_DATA(uval); -#else - Py_UNICODE *udata; - uval = PyUnicode_FromUnicode(NULL, ulength); - if (unlikely(!uval)) return NULL; - udata = PyUnicode_AS_UNICODE(uval); -#endif - if (uoffset > 0) { - i = 0; - if (prepend_sign) { - __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, 0, '-'); - i++; - } - for (; i < uoffset; i++) { - __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, i, padding_char); - } - } - for (i=0; i < clength; i++) { - __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, uoffset+i, chars[i]); - } -#else - { - PyObject *sign = NULL, *padding = NULL; - uval = NULL; - if (uoffset > 0) { - prepend_sign = !!prepend_sign; - if (uoffset > prepend_sign) { - padding = PyUnicode_FromOrdinal(padding_char); - if (likely(padding) && uoffset > prepend_sign + 1) { - PyObject *tmp; - PyObject *repeat = PyInt_FromSsize_t(uoffset - prepend_sign); - if (unlikely(!repeat)) goto done_or_error; - tmp = PyNumber_Multiply(padding, repeat); - Py_DECREF(repeat); - Py_DECREF(padding); - padding = tmp; - } - if (unlikely(!padding)) goto done_or_error; - } - if (prepend_sign) { - sign = PyUnicode_FromOrdinal('-'); - if (unlikely(!sign)) goto done_or_error; - } - } - uval = PyUnicode_DecodeASCII(chars, clength, NULL); - if (likely(uval) && padding) { - PyObject *tmp = PyNumber_Add(padding, uval); - Py_DECREF(uval); - uval = tmp; - } - if (likely(uval) && sign) { - PyObject *tmp = PyNumber_Add(sign, uval); - Py_DECREF(uval); - uval = tmp; - } -done_or_error: - Py_XDECREF(padding); - Py_XDECREF(sign); - } -#endif - return uval; -} - -/* CIntToPyUnicode */ -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char) { - char digits[sizeof(int)*3+2]; - char *dpos, *end = digits + sizeof(int)*3+2; - const char *hex_digits = DIGITS_HEX; - Py_ssize_t length, ulength; - int prepend_sign, last_one_off; - int remaining; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const int neg_one = (int) -1, const_zero = (int) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; - if (format_char == 'X') { - hex_digits += 16; - format_char = 'x'; - } - remaining = value; - last_one_off = 0; - dpos = end; - do { - int digit_pos; - switch (format_char) { - case 'o': - digit_pos = abs((int)(remaining % (8*8))); - remaining = (int) (remaining / (8*8)); - dpos -= 2; - memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2); - last_one_off = (digit_pos < 8); - break; - case 'd': - digit_pos = abs((int)(remaining % (10*10))); - remaining = (int) (remaining / (10*10)); - dpos -= 2; - memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2); - last_one_off = (digit_pos < 10); - break; - case 'x': - *(--dpos) = hex_digits[abs((int)(remaining % 16))]; - remaining = (int) (remaining / 16); - break; - default: - assert(0); - break; - } - } while (unlikely(remaining != 0)); - assert(!last_one_off || *dpos == '0'); - dpos += last_one_off; - length = end - dpos; - ulength = length; - prepend_sign = 0; - if (!is_unsigned && value <= neg_one) { - if (padding_char == ' ' || width <= length + 1) { - *(--dpos) = '-'; - ++length; - } else { - prepend_sign = 1; - } - ++ulength; - } - if (width > ulength) { - ulength = width; - } - if (ulength == 1) { - return PyUnicode_FromOrdinal(*dpos); - } - return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char); -} - -/* CIntToPyUnicode */ -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char) { - char digits[sizeof(Py_ssize_t)*3+2]; - char *dpos, *end = digits + sizeof(Py_ssize_t)*3+2; - const char *hex_digits = DIGITS_HEX; - Py_ssize_t length, ulength; - int prepend_sign, last_one_off; - Py_ssize_t remaining; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const Py_ssize_t neg_one = (Py_ssize_t) -1, const_zero = (Py_ssize_t) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; - if (format_char == 'X') { - hex_digits += 16; - format_char = 'x'; - } - remaining = value; - last_one_off = 0; - dpos = end; - do { - int digit_pos; - switch (format_char) { - case 'o': - digit_pos = abs((int)(remaining % (8*8))); - remaining = (Py_ssize_t) (remaining / (8*8)); - dpos -= 2; - memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2); - last_one_off = (digit_pos < 8); - break; - case 'd': - digit_pos = abs((int)(remaining % (10*10))); - remaining = (Py_ssize_t) (remaining / (10*10)); - dpos -= 2; - memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2); - last_one_off = (digit_pos < 10); - break; - case 'x': - *(--dpos) = hex_digits[abs((int)(remaining % 16))]; - remaining = (Py_ssize_t) (remaining / 16); - break; - default: - assert(0); - break; - } - } while (unlikely(remaining != 0)); - assert(!last_one_off || *dpos == '0'); - dpos += last_one_off; - length = end - dpos; - ulength = length; - prepend_sign = 0; - if (!is_unsigned && value <= neg_one) { - if (padding_char == ' ' || width <= length + 1) { - *(--dpos) = '-'; - ++length; - } else { - prepend_sign = 1; - } - ++ulength; - } - if (width > ulength) { - ulength = width; - } - if (ulength == 1) { - return PyUnicode_FromOrdinal(*dpos); - } - return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char); -} - -/* JoinPyUnicode */ -static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, - Py_UCS4 max_char) { -#if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - PyObject *result_uval; - int result_ukind, kind_shift; - Py_ssize_t i, char_pos; - void *result_udata; - CYTHON_MAYBE_UNUSED_VAR(max_char); -#if CYTHON_PEP393_ENABLED - result_uval = PyUnicode_New(result_ulength, max_char); - if (unlikely(!result_uval)) return NULL; - result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND; - kind_shift = (result_ukind == PyUnicode_4BYTE_KIND) ? 2 : result_ukind - 1; - result_udata = PyUnicode_DATA(result_uval); -#else - result_uval = PyUnicode_FromUnicode(NULL, result_ulength); - if (unlikely(!result_uval)) return NULL; - result_ukind = sizeof(Py_UNICODE); - kind_shift = (result_ukind == 4) ? 2 : result_ukind - 1; - result_udata = PyUnicode_AS_UNICODE(result_uval); -#endif - assert(kind_shift == 2 || kind_shift == 1 || kind_shift == 0); - char_pos = 0; - for (i=0; i < value_count; i++) { - int ukind; - Py_ssize_t ulength; - void *udata; - PyObject *uval = PyTuple_GET_ITEM(value_tuple, i); - if (unlikely(__Pyx_PyUnicode_READY(uval))) - goto bad; - ulength = __Pyx_PyUnicode_GET_LENGTH(uval); - if (unlikely(!ulength)) - continue; - if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - ulength < char_pos)) - goto overflow; - ukind = __Pyx_PyUnicode_KIND(uval); - udata = __Pyx_PyUnicode_DATA(uval); - if (!CYTHON_PEP393_ENABLED || ukind == result_ukind) { - memcpy((char *)result_udata + (char_pos << kind_shift), udata, (size_t) (ulength << kind_shift)); - } else { - #if PY_VERSION_HEX >= 0x030d0000 - if (unlikely(PyUnicode_CopyCharacters(result_uval, char_pos, uval, 0, ulength) < 0)) goto bad; - #elif CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030300F0 || defined(_PyUnicode_FastCopyCharacters) - _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength); - #else - Py_ssize_t j; - for (j=0; j < ulength; j++) { - Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j); - __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar); - } - #endif - } - char_pos += ulength; - } - return result_uval; -overflow: - PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string"); -bad: - Py_DECREF(result_uval); - return NULL; -#else - CYTHON_UNUSED_VAR(max_char); - CYTHON_UNUSED_VAR(result_ulength); - CYTHON_UNUSED_VAR(value_count); - return PyUnicode_Join(__pyx_empty_unicode, value_tuple); -#endif -} - -/* GetAttr */ -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))) -#else - if (likely(PyString_Check(n))) -#endif - return __Pyx_PyObject_GetAttrStr(o, n); -#endif - return PyObject_GetAttr(o, n); -} - -/* GetItemInt */ -static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { - PyObject *r; - if (unlikely(!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 { - PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; - PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; - if (mm && mm->mp_subscript) { - PyObject *r, *key = PyInt_FromSsize_t(i); - if (unlikely(!key)) return NULL; - r = mm->mp_subscript(o, key); - Py_DECREF(key); - return r; - } - if (likely(sm && sm->sq_item)) { - if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { - Py_ssize_t l = sm->sq_length(o); - if (likely(l >= 0)) { - i += l; - } else { - if (!PyErr_ExceptionMatches(PyExc_OverflowError)) - return NULL; - PyErr_Clear(); - } - } - return sm->sq_item(o, i); - } - } -#else - if (is_list || !PyMapping_Check(o)) { - return PySequence_GetItem(o, i); - } -#endif - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); -} - -/* PyObjectCallOneArg */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *args[2] = {NULL, arg}; - return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); -} - -/* ObjectGetItem */ -#if CYTHON_USE_TYPE_SLOTS -static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject *index) { - PyObject *runerr = NULL; - Py_ssize_t key_value; - key_value = __Pyx_PyIndex_AsSsize_t(index); - if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { - return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); - } - if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { - __Pyx_TypeName index_type_name = __Pyx_PyType_GetName(Py_TYPE(index)); - PyErr_Clear(); - PyErr_Format(PyExc_IndexError, - "cannot fit '" __Pyx_FMT_TYPENAME "' into an index-sized integer", index_type_name); - __Pyx_DECREF_TypeName(index_type_name); - } - return NULL; -} -static PyObject *__Pyx_PyObject_GetItem_Slow(PyObject *obj, PyObject *key) { - __Pyx_TypeName obj_type_name; - if (likely(PyType_Check(obj))) { - PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(obj, __pyx_n_s_class_getitem); - if (!meth) { - PyErr_Clear(); - } else { - PyObject *result = __Pyx_PyObject_CallOneArg(meth, key); - Py_DECREF(meth); - return result; - } - } - obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); - PyErr_Format(PyExc_TypeError, - "'" __Pyx_FMT_TYPENAME "' object is not subscriptable", obj_type_name); - __Pyx_DECREF_TypeName(obj_type_name); - return NULL; -} -static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key) { - PyTypeObject *tp = Py_TYPE(obj); - PyMappingMethods *mm = tp->tp_as_mapping; - PySequenceMethods *sm = tp->tp_as_sequence; - if (likely(mm && mm->mp_subscript)) { - return mm->mp_subscript(obj, key); - } - if (likely(sm && sm->sq_item)) { - return __Pyx_PyObject_GetIndex(obj, key); - } - return __Pyx_PyObject_GetItem_Slow(obj, key); -} -#endif - -/* KeywordStringCheck */ -static int __Pyx_CheckKeywordStrings( - PyObject *kw, - const char* function_name, - int kw_allowed) -{ - PyObject* key = 0; - Py_ssize_t pos = 0; -#if CYTHON_COMPILING_IN_PYPY - if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0)) - goto invalid_keyword; - return 1; -#else - if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) { - Py_ssize_t kwsize; -#if CYTHON_ASSUME_SAFE_MACROS - kwsize = PyTuple_GET_SIZE(kw); -#else - kwsize = PyTuple_Size(kw); - if (kwsize < 0) return 0; -#endif - if (unlikely(kwsize == 0)) - return 1; - if (!kw_allowed) { -#if CYTHON_ASSUME_SAFE_MACROS - key = PyTuple_GET_ITEM(kw, 0); -#else - key = PyTuple_GetItem(kw, pos); - if (!key) return 0; -#endif - goto invalid_keyword; - } -#if PY_VERSION_HEX < 0x03090000 - for (pos = 0; pos < kwsize; pos++) { -#if CYTHON_ASSUME_SAFE_MACROS - key = PyTuple_GET_ITEM(kw, pos); -#else - key = PyTuple_GetItem(kw, pos); - if (!key) return 0; -#endif - if (unlikely(!PyUnicode_Check(key))) - goto invalid_keyword_type; - } -#endif - return 1; - } - while (PyDict_Next(kw, &pos, &key, 0)) { - #if PY_MAJOR_VERSION < 3 - if (unlikely(!PyString_Check(key))) - #endif - if (unlikely(!PyUnicode_Check(key))) - goto invalid_keyword_type; - } - if (!kw_allowed && unlikely(key)) - goto invalid_keyword; - return 1; -invalid_keyword_type: - PyErr_Format(PyExc_TypeError, - "%.200s() keywords must be strings", function_name); - return 0; -#endif -invalid_keyword: - #if PY_MAJOR_VERSION < 3 - PyErr_Format(PyExc_TypeError, - "%.200s() got an unexpected keyword argument '%.200s'", - function_name, PyString_AsString(key)); - #else - PyErr_Format(PyExc_TypeError, - "%s() got an unexpected keyword argument '%U'", - function_name, key); - #endif - return 0; -} - -/* DivInt[Py_ssize_t] */ -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)); - return q; -} - -/* GetAttr3 */ -#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 -static PyObject *__Pyx_GetAttr3Default(PyObject *d) { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) - return NULL; - __Pyx_PyErr_Clear(); - Py_INCREF(d); - return d; -} -#endif -static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { - PyObject *r; -#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 - int res = PyObject_GetOptionalAttr(o, n, &r); - return (res != 0) ? r : __Pyx_NewRef(d); -#else - #if CYTHON_USE_TYPE_SLOTS - if (likely(PyString_Check(n))) { - r = __Pyx_PyObject_GetAttrStrNoError(o, n); - if (unlikely(!r) && likely(!PyErr_Occurred())) { - r = __Pyx_NewRef(d); - } - return r; - } - #endif - r = PyObject_GetAttr(o, n); - return (likely(r)) ? r : __Pyx_GetAttr3Default(d); -#endif -} - -/* PyDictVersioning */ -#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { - PyObject *dict = Py_TYPE(obj)->tp_dict; - return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; -} -static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { - PyObject **dictptr = NULL; - Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; - if (offset) { -#if CYTHON_COMPILING_IN_CPYTHON - dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); -#else - dictptr = _PyObject_GetDictPtr(obj); -#endif - } - return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; -} -static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { - PyObject *dict = Py_TYPE(obj)->tp_dict; - if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) - return 0; - return obj_dict_version == __Pyx_get_object_dict_version(obj); -} -#endif - -/* GetModuleGlobalName */ -#if CYTHON_USE_DICT_VERSIONS -static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) -#else -static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) -#endif -{ - PyObject *result; -#if !CYTHON_AVOID_BORROWED_REFS -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000 - result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } else if (unlikely(PyErr_Occurred())) { - return NULL; - } -#elif CYTHON_COMPILING_IN_LIMITED_API - if (unlikely(!__pyx_m)) { - return NULL; - } - result = PyObject_GetAttr(__pyx_m, name); - if (likely(result)) { - return result; - } -#else - result = PyDict_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } -#endif -#else - result = PyObject_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } - PyErr_Clear(); -#endif - return __Pyx_GetBuiltinName(name); -} - -/* 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 */ -static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { - __Pyx_TypeName obj_type_name; - __Pyx_TypeName type_name; - if (unlikely(!type)) { - PyErr_SetString(PyExc_SystemError, "Missing type object"); - return 0; - } - if (likely(__Pyx_TypeCheck(obj, type))) - return 1; - obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); - type_name = __Pyx_PyType_GetName(type); - PyErr_Format(PyExc_TypeError, - "Cannot convert " __Pyx_FMT_TYPENAME " to " __Pyx_FMT_TYPENAME, - obj_type_name, type_name); - __Pyx_DECREF_TypeName(obj_type_name); - __Pyx_DECREF_TypeName(type_name); - return 0; -} - -/* GetTopmostException */ -#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE -static _PyErr_StackItem * -__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) -{ - _PyErr_StackItem *exc_info = tstate->exc_info; - while ((exc_info->exc_value == NULL || exc_info->exc_value == 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 && PY_VERSION_HEX >= 0x030B00a4 - _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); - PyObject *exc_value = exc_info->exc_value; - if (exc_value == NULL || exc_value == Py_None) { - *value = NULL; - *type = NULL; - *tb = NULL; - } else { - *value = exc_value; - Py_INCREF(*value); - *type = (PyObject*) Py_TYPE(exc_value); - Py_INCREF(*type); - *tb = PyException_GetTraceback(exc_value); - } - #elif 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; - Py_XINCREF(*type); - Py_XINCREF(*value); - Py_XINCREF(*tb); - #else - *type = tstate->exc_type; - *value = tstate->exc_value; - *tb = tstate->exc_traceback; - Py_XINCREF(*type); - Py_XINCREF(*value); - Py_XINCREF(*tb); - #endif -} -static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 - _PyErr_StackItem *exc_info = tstate->exc_info; - PyObject *tmp_value = exc_info->exc_value; - exc_info->exc_value = value; - Py_XDECREF(tmp_value); - Py_XDECREF(type); - Py_XDECREF(tb); - #else - 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 -} -#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 = NULL, *local_value, *local_tb = NULL; -#if CYTHON_FAST_THREAD_STATE - PyObject *tmp_type, *tmp_value, *tmp_tb; - #if PY_VERSION_HEX >= 0x030C00A6 - local_value = tstate->current_exception; - tstate->current_exception = 0; - if (likely(local_value)) { - local_type = (PyObject*) Py_TYPE(local_value); - Py_INCREF(local_type); - local_tb = PyException_GetTraceback(local_value); - } - #else - 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; - #endif -#else - PyErr_Fetch(&local_type, &local_value, &local_tb); -#endif - PyErr_NormalizeException(&local_type, &local_value, &local_tb); -#if CYTHON_FAST_THREAD_STATE && PY_VERSION_HEX >= 0x030C00A6 - if (unlikely(tstate->current_exception)) -#elif 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; - #if PY_VERSION_HEX >= 0x030B00a4 - tmp_value = exc_info->exc_value; - exc_info->exc_value = local_value; - tmp_type = NULL; - tmp_tb = NULL; - Py_XDECREF(local_type); - Py_XDECREF(local_tb); - #else - 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; - #endif - } - #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; -} - -/* SwapException */ -#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 && PY_VERSION_HEX >= 0x030B00a4 - _PyErr_StackItem *exc_info = tstate->exc_info; - tmp_value = exc_info->exc_value; - exc_info->exc_value = *value; - if (tmp_value == NULL || tmp_value == Py_None) { - Py_XDECREF(tmp_value); - tmp_value = NULL; - tmp_type = NULL; - tmp_tb = NULL; - } else { - tmp_type = (PyObject*) Py_TYPE(tmp_value); - Py_INCREF(tmp_type); - #if CYTHON_COMPILING_IN_CPYTHON - tmp_tb = ((PyBaseExceptionObject*) tmp_value)->traceback; - Py_XINCREF(tmp_tb); - #else - tmp_tb = PyException_GetTraceback(tmp_value); - #endif - } - #elif 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 - *type = tmp_type; - *value = tmp_value; - *tb = tmp_tb; -} -#else -static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); - PyErr_SetExcInfo(*type, *value, *tb); - *type = tmp_type; - *value = tmp_value; - *tb = tmp_tb; -} -#endif - -/* Import */ -static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { - PyObject *module = 0; - PyObject *empty_dict = 0; - PyObject *empty_list = 0; - #if PY_MAJOR_VERSION < 3 - PyObject *py_import; - py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); - if (unlikely(!py_import)) - goto bad; - if (!from_list) { - empty_list = PyList_New(0); - if (unlikely(!empty_list)) - goto bad; - from_list = empty_list; - } - #endif - empty_dict = PyDict_New(); - if (unlikely(!empty_dict)) - goto bad; - { - #if PY_MAJOR_VERSION >= 3 - if (level == -1) { - if (strchr(__Pyx_MODULE_NAME, '.') != NULL) { - module = PyImport_ImportModuleLevelObject( - name, __pyx_d, empty_dict, from_list, 1); - if (unlikely(!module)) { - if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) - goto bad; - PyErr_Clear(); - } - } - level = 0; - } - #endif - if (!module) { - #if PY_MAJOR_VERSION < 3 - PyObject *py_level = PyInt_FromLong(level); - if (unlikely(!py_level)) - goto bad; - module = PyObject_CallFunctionObjArgs(py_import, - name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL); - Py_DECREF(py_level); - #else - module = PyImport_ImportModuleLevelObject( - name, __pyx_d, empty_dict, from_list, level); - #endif - } - } -bad: - Py_XDECREF(empty_dict); - Py_XDECREF(empty_list); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(py_import); - #endif - return module; -} - -/* ImportDottedModule */ -#if PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx__ImportDottedModule_Error(PyObject *name, PyObject *parts_tuple, Py_ssize_t count) { - PyObject *partial_name = NULL, *slice = NULL, *sep = NULL; - if (unlikely(PyErr_Occurred())) { - PyErr_Clear(); - } - if (likely(PyTuple_GET_SIZE(parts_tuple) == count)) { - partial_name = name; - } else { - slice = PySequence_GetSlice(parts_tuple, 0, count); - if (unlikely(!slice)) - goto bad; - sep = PyUnicode_FromStringAndSize(".", 1); - if (unlikely(!sep)) - goto bad; - partial_name = PyUnicode_Join(sep, slice); - } - PyErr_Format( -#if PY_MAJOR_VERSION < 3 - PyExc_ImportError, - "No module named '%s'", PyString_AS_STRING(partial_name)); -#else -#if PY_VERSION_HEX >= 0x030600B1 - PyExc_ModuleNotFoundError, -#else - PyExc_ImportError, -#endif - "No module named '%U'", partial_name); -#endif -bad: - Py_XDECREF(sep); - Py_XDECREF(slice); - Py_XDECREF(partial_name); - return NULL; -} -#endif -#if PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx__ImportDottedModule_Lookup(PyObject *name) { - PyObject *imported_module; -#if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) - PyObject *modules = PyImport_GetModuleDict(); - if (unlikely(!modules)) - return NULL; - imported_module = __Pyx_PyDict_GetItemStr(modules, name); - Py_XINCREF(imported_module); -#else - imported_module = PyImport_GetModule(name); -#endif - return imported_module; -} -#endif -#if PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple) { - Py_ssize_t i, nparts; - nparts = PyTuple_GET_SIZE(parts_tuple); - for (i=1; i < nparts && module; i++) { - PyObject *part, *submodule; -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - part = PyTuple_GET_ITEM(parts_tuple, i); -#else - part = PySequence_ITEM(parts_tuple, i); -#endif - submodule = __Pyx_PyObject_GetAttrStrNoError(module, part); -#if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) - Py_DECREF(part); -#endif - Py_DECREF(module); - module = submodule; - } - if (unlikely(!module)) { - return __Pyx__ImportDottedModule_Error(name, parts_tuple, i); - } - return module; -} -#endif -static PyObject *__Pyx__ImportDottedModule(PyObject *name, PyObject *parts_tuple) { -#if PY_MAJOR_VERSION < 3 - PyObject *module, *from_list, *star = __pyx_n_s__3; - CYTHON_UNUSED_VAR(parts_tuple); - from_list = PyList_New(1); - if (unlikely(!from_list)) - return NULL; - Py_INCREF(star); - PyList_SET_ITEM(from_list, 0, star); - module = __Pyx_Import(name, from_list, 0); - Py_DECREF(from_list); - return module; -#else - PyObject *imported_module; - PyObject *module = __Pyx_Import(name, NULL, 0); - if (!parts_tuple || unlikely(!module)) - return module; - imported_module = __Pyx__ImportDottedModule_Lookup(name); - if (likely(imported_module)) { - Py_DECREF(module); - return imported_module; - } - PyErr_Clear(); - return __Pyx_ImportDottedModule_WalkParts(module, name, parts_tuple); -#endif -} -static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple) { -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030400B1 - PyObject *module = __Pyx__ImportDottedModule_Lookup(name); - if (likely(module)) { - PyObject *spec = __Pyx_PyObject_GetAttrStrNoError(module, __pyx_n_s_spec); - if (likely(spec)) { - PyObject *unsafe = __Pyx_PyObject_GetAttrStrNoError(spec, __pyx_n_s_initializing); - if (likely(!unsafe || !__Pyx_PyObject_IsTrue(unsafe))) { - Py_DECREF(spec); - spec = NULL; - } - Py_XDECREF(unsafe); - } - if (likely(!spec)) { - PyErr_Clear(); - return module; - } - Py_DECREF(spec); - Py_DECREF(module); - } else if (PyErr_Occurred()) { - PyErr_Clear(); - } -#endif - return __Pyx__ImportDottedModule(name, parts_tuple); -} - -/* FastTypeChecks */ -#if CYTHON_COMPILING_IN_CPYTHON -static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { - while (a) { - a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); - if (a == b) - return 1; - } - return b == &PyBaseObject_Type; -} -static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { - PyObject *mro; - if (a == b) return 1; - mro = a->tp_mro; - if (likely(mro)) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(mro); - for (i = 0; i < n; i++) { - if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) - return 1; - } - return 0; - } - return __Pyx_InBases(a, b); -} -static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { - PyObject *mro; - if (cls == a || cls == b) return 1; - mro = cls->tp_mro; - if (likely(mro)) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(mro); - for (i = 0; i < n; i++) { - PyObject *base = PyTuple_GET_ITEM(mro, i); - if (base == (PyObject *)a || base == (PyObject *)b) - return 1; - } - return 0; - } - return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); -} -#if PY_MAJOR_VERSION == 2 -static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { - PyObject *exception, *value, *tb; - int res; - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ErrFetch(&exception, &value, &tb); - res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; - if (unlikely(res == -1)) { - PyErr_WriteUnraisable(err); - res = 0; - } - if (!res) { - res = PyObject_IsSubclass(err, exc_type2); - if (unlikely(res == -1)) { - PyErr_WriteUnraisable(err); - res = 0; - } - } - __Pyx_ErrRestore(exception, value, tb); - return res; -} -#else -static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { - if (exc_type1) { - return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); - } else { - return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); - } -} -#endif -static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { - Py_ssize_t i, n; - assert(PyExceptionClass_Check(exc_type)); - n = PyTuple_GET_SIZE(tuple); -#if PY_MAJOR_VERSION >= 3 - for (i=0; itp_as_sequence && type->tp_as_sequence->sq_repeat)) { - return type->tp_as_sequence->sq_repeat(seq, mul); - } else -#endif - { - return __Pyx_PySequence_Multiply_Generic(seq, mul); - } -} - -/* SetItemInt */ -static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { - int r; - if (unlikely(!j)) return -1; - r = PyObject_SetItem(o, j, v); - Py_DECREF(j); - return r; -} -static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, 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) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o)); - if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o)))) { - PyObject* old = PyList_GET_ITEM(o, n); - Py_INCREF(v); - PyList_SET_ITEM(o, n, v); - Py_DECREF(old); - return 1; - } - } else { - PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; - PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; - if (mm && mm->mp_ass_subscript) { - int r; - PyObject *key = PyInt_FromSsize_t(i); - if (unlikely(!key)) return -1; - r = mm->mp_ass_subscript(o, key, v); - Py_DECREF(key); - return r; - } - if (likely(sm && sm->sq_ass_item)) { - if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { - Py_ssize_t l = sm->sq_length(o); - if (likely(l >= 0)) { - i += l; - } else { - if (!PyErr_ExceptionMatches(PyExc_OverflowError)) - return -1; - PyErr_Clear(); - } - } - return sm->sq_ass_item(o, i, v); - } - } -#else - if (is_list || !PyMapping_Check(o)) - { - return PySequence_SetItem(o, i, v); - } -#endif - return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v); -} - -/* RaiseUnboundLocalError */ -static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { - PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); -} - -/* DivInt[long] */ -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)); - return q; -} - -/* ImportFrom */ -static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { - PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); - if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { - const char* module_name_str = 0; - PyObject* module_name = 0; - PyObject* module_dot = 0; - PyObject* full_name = 0; - PyErr_Clear(); - module_name_str = PyModule_GetName(module); - if (unlikely(!module_name_str)) { goto modbad; } - module_name = PyUnicode_FromString(module_name_str); - if (unlikely(!module_name)) { goto modbad; } - module_dot = PyUnicode_Concat(module_name, __pyx_kp_u__2); - if (unlikely(!module_dot)) { goto modbad; } - full_name = PyUnicode_Concat(module_dot, name); - if (unlikely(!full_name)) { goto modbad; } - #if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) - { - PyObject *modules = PyImport_GetModuleDict(); - if (unlikely(!modules)) - goto modbad; - value = PyObject_GetItem(modules, full_name); - } - #else - value = PyImport_GetModule(full_name); - #endif - modbad: - Py_XDECREF(full_name); - Py_XDECREF(module_dot); - Py_XDECREF(module_name); - } - if (unlikely(!value)) { - PyErr_Format(PyExc_ImportError, - #if PY_MAJOR_VERSION < 3 - "cannot import name %.230s", PyString_AS_STRING(name)); - #else - "cannot import name %S", name); - #endif - } - return value; -} - -/* HasAttr */ -#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 -static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { - PyObject *r; - if (unlikely(!__Pyx_PyBaseString_Check(n))) { - PyErr_SetString(PyExc_TypeError, - "hasattr(): attribute name must be string"); - return -1; - } - r = __Pyx_GetAttr(o, n); - if (!r) { - PyErr_Clear(); - return 0; - } else { - Py_DECREF(r); - return 1; - } -} -#endif - -/* ErrOccurredWithGIL */ -static CYTHON_INLINE int __Pyx_ErrOccurredWithGIL(void) { - int err; - #ifdef WITH_THREAD - PyGILState_STATE _save = PyGILState_Ensure(); - #endif - err = !!PyErr_Occurred(); - #ifdef WITH_THREAD - PyGILState_Release(_save); - #endif - return err; -} - -/* PyObject_GenericGetAttrNoDict */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { - __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp); - PyErr_Format(PyExc_AttributeError, -#if PY_MAJOR_VERSION >= 3 - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", - type_name, attr_name); -#else - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", - type_name, PyString_AS_STRING(attr_name)); -#endif - __Pyx_DECREF_TypeName(type_name); - return NULL; -} -static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { - PyObject *descr; - PyTypeObject *tp = Py_TYPE(obj); - if (unlikely(!PyString_Check(attr_name))) { - return PyObject_GenericGetAttr(obj, attr_name); - } - assert(!tp->tp_dictoffset); - descr = _PyType_Lookup(tp, attr_name); - if (unlikely(!descr)) { - return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); - } - Py_INCREF(descr); - #if PY_MAJOR_VERSION < 3 - if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) - #endif - { - descrgetfunc f = Py_TYPE(descr)->tp_descr_get; - if (unlikely(f)) { - PyObject *res = f(descr, obj, (PyObject *)tp); - Py_DECREF(descr); - return res; - } - } - return descr; -} -#endif - -/* PyObject_GenericGetAttr */ -#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); - } - return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); -} -#endif - -/* FixUpExtensionType */ -#if CYTHON_USE_TYPE_SPECS -static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { -#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API - CYTHON_UNUSED_VAR(spec); - CYTHON_UNUSED_VAR(type); -#else - const PyType_Slot *slot = spec->slots; - while (slot && slot->slot && slot->slot != Py_tp_members) - slot++; - if (slot && slot->slot == Py_tp_members) { - int changed = 0; -#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON) - const -#endif - PyMemberDef *memb = (PyMemberDef*) slot->pfunc; - while (memb && memb->name) { - if (memb->name[0] == '_' && memb->name[1] == '_') { -#if PY_VERSION_HEX < 0x030900b1 - if (strcmp(memb->name, "__weaklistoffset__") == 0) { - assert(memb->type == T_PYSSIZET); - assert(memb->flags == READONLY); - type->tp_weaklistoffset = memb->offset; - changed = 1; - } - else if (strcmp(memb->name, "__dictoffset__") == 0) { - assert(memb->type == T_PYSSIZET); - assert(memb->flags == READONLY); - type->tp_dictoffset = memb->offset; - changed = 1; - } -#if CYTHON_METH_FASTCALL - else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { - assert(memb->type == T_PYSSIZET); - assert(memb->flags == READONLY); -#if PY_VERSION_HEX >= 0x030800b4 - type->tp_vectorcall_offset = memb->offset; -#else - type->tp_print = (printfunc) memb->offset; -#endif - changed = 1; - } -#endif -#else - if ((0)); -#endif -#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON - else if (strcmp(memb->name, "__module__") == 0) { - PyObject *descr; - assert(memb->type == T_OBJECT); - assert(memb->flags == 0 || memb->flags == READONLY); - descr = PyDescr_NewMember(type, memb); - if (unlikely(!descr)) - return -1; - if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) { - Py_DECREF(descr); - return -1; - } - Py_DECREF(descr); - changed = 1; - } -#endif - } - memb++; - } - if (changed) - PyType_Modified(type); - } -#endif - return 0; -} -#endif - -/* PyObjectCallNoArg */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { - PyObject *arg[2] = {NULL, NULL}; - return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); -} - -/* PyObjectGetMethod */ -static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { - PyObject *attr; -#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP - __Pyx_TypeName type_name; - PyTypeObject *tp = Py_TYPE(obj); - PyObject *descr; - descrgetfunc f = NULL; - PyObject **dictptr, *dict; - int meth_found = 0; - assert (*method == NULL); - if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { - attr = __Pyx_PyObject_GetAttrStr(obj, name); - goto try_unpack; - } - if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { - return 0; - } - descr = _PyType_Lookup(tp, name); - if (likely(descr != NULL)) { - Py_INCREF(descr); -#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR - if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) -#elif PY_MAJOR_VERSION >= 3 - #ifdef __Pyx_CyFunction_USED - if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) - #else - if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) - #endif -#else - #ifdef __Pyx_CyFunction_USED - if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) - #else - if (likely(PyFunction_Check(descr))) - #endif -#endif - { - meth_found = 1; - } else { - f = Py_TYPE(descr)->tp_descr_get; - if (f != NULL && PyDescr_IsData(descr)) { - attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); - Py_DECREF(descr); - goto try_unpack; - } - } - } - dictptr = _PyObject_GetDictPtr(obj); - if (dictptr != NULL && (dict = *dictptr) != NULL) { - Py_INCREF(dict); - attr = __Pyx_PyDict_GetItemStr(dict, name); - if (attr != NULL) { - Py_INCREF(attr); - Py_DECREF(dict); - Py_XDECREF(descr); - goto try_unpack; - } - Py_DECREF(dict); - } - if (meth_found) { - *method = descr; - return 1; - } - if (f != NULL) { - attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); - Py_DECREF(descr); - goto try_unpack; - } - if (likely(descr != NULL)) { - *method = descr; - return 0; - } - type_name = __Pyx_PyType_GetName(tp); - PyErr_Format(PyExc_AttributeError, -#if PY_MAJOR_VERSION >= 3 - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", - type_name, name); -#else - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", - type_name, PyString_AS_STRING(name)); -#endif - __Pyx_DECREF_TypeName(type_name); - return 0; -#else - attr = __Pyx_PyObject_GetAttrStr(obj, name); - goto try_unpack; -#endif -try_unpack: -#if CYTHON_UNPACK_METHODS - if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { - PyObject *function = PyMethod_GET_FUNCTION(attr); - Py_INCREF(function); - Py_DECREF(attr); - *method = function; - return 1; - } -#endif - *method = attr; - return 0; -} - -/* PyObjectCallMethod0 */ -static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { - PyObject *method = NULL, *result = NULL; - int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); - if (likely(is_method)) { - result = __Pyx_PyObject_CallOneArg(method, obj); - Py_DECREF(method); - return result; - } - if (unlikely(!method)) goto bad; - result = __Pyx_PyObject_CallNoArg(method); - Py_DECREF(method); -bad: - return result; -} - -/* ValidateBasesTuple */ -#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS -static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) { - Py_ssize_t i, n; -#if CYTHON_ASSUME_SAFE_MACROS - n = PyTuple_GET_SIZE(bases); -#else - n = PyTuple_Size(bases); - if (n < 0) return -1; -#endif - for (i = 1; i < n; i++) - { -#if CYTHON_AVOID_BORROWED_REFS - PyObject *b0 = PySequence_GetItem(bases, i); - if (!b0) return -1; -#elif CYTHON_ASSUME_SAFE_MACROS - PyObject *b0 = PyTuple_GET_ITEM(bases, i); -#else - PyObject *b0 = PyTuple_GetItem(bases, i); - if (!b0) return -1; -#endif - PyTypeObject *b; -#if PY_MAJOR_VERSION < 3 - if (PyClass_Check(b0)) - { - PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class", - PyString_AS_STRING(((PyClassObject*)b0)->cl_name)); -#if CYTHON_AVOID_BORROWED_REFS - Py_DECREF(b0); -#endif - return -1; - } -#endif - b = (PyTypeObject*) b0; - if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) - { - __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); - PyErr_Format(PyExc_TypeError, - "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name); - __Pyx_DECREF_TypeName(b_name); -#if CYTHON_AVOID_BORROWED_REFS - Py_DECREF(b0); -#endif - return -1; - } - if (dictoffset == 0) - { - Py_ssize_t b_dictoffset = 0; -#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY - b_dictoffset = b->tp_dictoffset; -#else - PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__"); - if (!py_b_dictoffset) goto dictoffset_return; - b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset); - Py_DECREF(py_b_dictoffset); - if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; -#endif - if (b_dictoffset) { - { - __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); - PyErr_Format(PyExc_TypeError, - "extension type '%.200s' has no __dict__ slot, " - "but base type '" __Pyx_FMT_TYPENAME "' has: " - "either add 'cdef dict __dict__' to the extension type " - "or add '__slots__ = [...]' to the base type", - type_name, b_name); - __Pyx_DECREF_TypeName(b_name); - } -#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY) - dictoffset_return: -#endif -#if CYTHON_AVOID_BORROWED_REFS - Py_DECREF(b0); -#endif - return -1; - } - } -#if CYTHON_AVOID_BORROWED_REFS - Py_DECREF(b0); -#endif - } - return 0; -} -#endif - -/* PyType_Ready */ -static int __Pyx_PyType_Ready(PyTypeObject *t) { -#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION) - (void)__Pyx_PyObject_CallMethod0; -#if CYTHON_USE_TYPE_SPECS - (void)__Pyx_validate_bases_tuple; -#endif - return PyType_Ready(t); -#else - int r; - PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); - if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1)) - return -1; -#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) - { - int gc_was_enabled; - #if PY_VERSION_HEX >= 0x030A00b1 - gc_was_enabled = PyGC_Disable(); - (void)__Pyx_PyObject_CallMethod0; - #else - PyObject *ret, *py_status; - PyObject *gc = NULL; - #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) - gc = PyImport_GetModule(__pyx_kp_u_gc); - #endif - if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc); - if (unlikely(!gc)) return -1; - py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled); - if (unlikely(!py_status)) { - Py_DECREF(gc); - return -1; - } - gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); - Py_DECREF(py_status); - if (gc_was_enabled > 0) { - ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable); - if (unlikely(!ret)) { - Py_DECREF(gc); - return -1; - } - Py_DECREF(ret); - } else if (unlikely(gc_was_enabled == -1)) { - Py_DECREF(gc); - return -1; - } - #endif - t->tp_flags |= Py_TPFLAGS_HEAPTYPE; -#if PY_VERSION_HEX >= 0x030A0000 - t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; -#endif -#else - (void)__Pyx_PyObject_CallMethod0; -#endif - r = PyType_Ready(t); -#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) - t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; - #if PY_VERSION_HEX >= 0x030A00b1 - if (gc_was_enabled) - PyGC_Enable(); - #else - if (gc_was_enabled) { - PyObject *tp, *v, *tb; - PyErr_Fetch(&tp, &v, &tb); - ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable); - if (likely(ret || r == -1)) { - Py_XDECREF(ret); - PyErr_Restore(tp, v, tb); - } else { - Py_XDECREF(tp); - Py_XDECREF(v); - Py_XDECREF(tb); - r = -1; - } - } - Py_DECREF(gc); - #endif - } -#endif - return r; -#endif -} - -/* SetVTable */ -static int __Pyx_SetVtable(PyTypeObject *type, void *vtable) { - PyObject *ob = PyCapsule_New(vtable, 0, 0); - if (unlikely(!ob)) - goto bad; -#if CYTHON_COMPILING_IN_LIMITED_API - if (unlikely(PyObject_SetAttr((PyObject *) type, __pyx_n_s_pyx_vtable, ob) < 0)) -#else - if (unlikely(PyDict_SetItem(type->tp_dict, __pyx_n_s_pyx_vtable, ob) < 0)) -#endif - goto bad; - Py_DECREF(ob); - return 0; -bad: - Py_XDECREF(ob); - return -1; -} - -/* GetVTable */ -static void* __Pyx_GetVtable(PyTypeObject *type) { - void* ptr; -#if CYTHON_COMPILING_IN_LIMITED_API - PyObject *ob = PyObject_GetAttr((PyObject *)type, __pyx_n_s_pyx_vtable); -#else - PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_n_s_pyx_vtable); -#endif - if (!ob) - goto bad; - ptr = PyCapsule_GetPointer(ob, 0); - if (!ptr && !PyErr_Occurred()) - PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); - Py_DECREF(ob); - return ptr; -bad: - Py_XDECREF(ob); - return NULL; -} - -/* MergeVTables */ -#if !CYTHON_COMPILING_IN_LIMITED_API -static int __Pyx_MergeVtables(PyTypeObject *type) { - int i; - void** base_vtables; - __Pyx_TypeName tp_base_name; - __Pyx_TypeName base_name; - void* unknown = (void*)-1; - PyObject* bases = type->tp_bases; - int base_depth = 0; - { - PyTypeObject* base = type->tp_base; - while (base) { - base_depth += 1; - base = base->tp_base; - } - } - base_vtables = (void**) malloc(sizeof(void*) * (size_t)(base_depth + 1)); - base_vtables[0] = unknown; - for (i = 1; i < PyTuple_GET_SIZE(bases); i++) { - void* base_vtable = __Pyx_GetVtable(((PyTypeObject*)PyTuple_GET_ITEM(bases, i))); - if (base_vtable != NULL) { - int j; - PyTypeObject* base = type->tp_base; - for (j = 0; j < base_depth; j++) { - if (base_vtables[j] == unknown) { - base_vtables[j] = __Pyx_GetVtable(base); - base_vtables[j + 1] = unknown; - } - if (base_vtables[j] == base_vtable) { - break; - } else if (base_vtables[j] == NULL) { - goto bad; - } - base = base->tp_base; - } - } - } - PyErr_Clear(); - free(base_vtables); - return 0; -bad: - tp_base_name = __Pyx_PyType_GetName(type->tp_base); - base_name = __Pyx_PyType_GetName((PyTypeObject*)PyTuple_GET_ITEM(bases, i)); - PyErr_Format(PyExc_TypeError, - "multiple bases have vtable conflict: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", tp_base_name, base_name); - __Pyx_DECREF_TypeName(tp_base_name); - __Pyx_DECREF_TypeName(base_name); - free(base_vtables); - return -1; -} -#endif - -/* SetupReduce */ -#if !CYTHON_COMPILING_IN_LIMITED_API -static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { - int ret; - PyObject *name_attr; - name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name_2); - if (likely(name_attr)) { - ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); - } else { - ret = -1; - } - if (unlikely(ret < 0)) { - PyErr_Clear(); - ret = 0; - } - Py_XDECREF(name_attr); - return ret; -} -static int __Pyx_setup_reduce(PyObject* type_obj) { - int ret = 0; - PyObject *object_reduce = NULL; - PyObject *object_getstate = NULL; - PyObject *object_reduce_ex = NULL; - PyObject *reduce = NULL; - PyObject *reduce_ex = NULL; - PyObject *reduce_cython = NULL; - PyObject *setstate = NULL; - PyObject *setstate_cython = NULL; - PyObject *getstate = NULL; -#if CYTHON_USE_PYTYPE_LOOKUP - getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); -#else - getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); - if (!getstate && PyErr_Occurred()) { - goto __PYX_BAD; - } -#endif - if (getstate) { -#if CYTHON_USE_PYTYPE_LOOKUP - object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); -#else - object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); - if (!object_getstate && PyErr_Occurred()) { - goto __PYX_BAD; - } -#endif - if (object_getstate != getstate) { - goto __PYX_GOOD; - } - } -#if CYTHON_USE_PYTYPE_LOOKUP - object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; -#else - object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; -#endif - reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_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; -#else - object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; -#endif - reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_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; - } - setstate = __Pyx_PyObject_GetAttrStrNoError(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; - } - } - PyType_Modified((PyTypeObject*)type_obj); - } - } - goto __PYX_GOOD; -__PYX_BAD: - if (!PyErr_Occurred()) { - __Pyx_TypeName type_obj_name = - __Pyx_PyType_GetName((PyTypeObject*)type_obj); - PyErr_Format(PyExc_RuntimeError, - "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name); - __Pyx_DECREF_TypeName(type_obj_name); - } - ret = -1; -__PYX_GOOD: -#if !CYTHON_USE_PYTYPE_LOOKUP - Py_XDECREF(object_reduce); - Py_XDECREF(object_reduce_ex); - Py_XDECREF(object_getstate); - Py_XDECREF(getstate); -#endif - Py_XDECREF(reduce); - Py_XDECREF(reduce_ex); - Py_XDECREF(reduce_cython); - Py_XDECREF(setstate); - Py_XDECREF(setstate_cython); - return ret; -} -#endif - -/* FetchSharedCythonModule */ -static PyObject *__Pyx_FetchSharedCythonABIModule(void) { - return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME); -} - -/* FetchCommonType */ -static int __Pyx_VerifyCachedType(PyObject *cached_type, - const char *name, - Py_ssize_t basicsize, - Py_ssize_t expected_basicsize) { - if (!PyType_Check(cached_type)) { - PyErr_Format(PyExc_TypeError, - "Shared Cython type %.200s is not a type object", name); - return -1; - } - if (basicsize != expected_basicsize) { - PyErr_Format(PyExc_TypeError, - "Shared Cython type %.200s has the wrong size, try recompiling", - name); - return -1; - } - return 0; -} -#if !CYTHON_USE_TYPE_SPECS -static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { - PyObject* abi_module; - const char* object_name; - PyTypeObject *cached_type = NULL; - abi_module = __Pyx_FetchSharedCythonABIModule(); - if (!abi_module) return NULL; - object_name = strrchr(type->tp_name, '.'); - object_name = object_name ? object_name+1 : type->tp_name; - cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name); - if (cached_type) { - if (__Pyx_VerifyCachedType( - (PyObject *)cached_type, - object_name, - cached_type->tp_basicsize, - type->tp_basicsize) < 0) { - goto bad; - } - goto done; - } - if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; - PyErr_Clear(); - if (PyType_Ready(type) < 0) goto bad; - if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) - goto bad; - Py_INCREF(type); - cached_type = type; -done: - Py_DECREF(abi_module); - return cached_type; -bad: - Py_XDECREF(cached_type); - cached_type = NULL; - goto done; -} -#else -static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { - PyObject *abi_module, *cached_type = NULL; - const char* object_name = strrchr(spec->name, '.'); - object_name = object_name ? object_name+1 : spec->name; - abi_module = __Pyx_FetchSharedCythonABIModule(); - if (!abi_module) return NULL; - cached_type = PyObject_GetAttrString(abi_module, object_name); - if (cached_type) { - Py_ssize_t basicsize; -#if CYTHON_COMPILING_IN_LIMITED_API - PyObject *py_basicsize; - py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); - if (unlikely(!py_basicsize)) goto bad; - basicsize = PyLong_AsSsize_t(py_basicsize); - Py_DECREF(py_basicsize); - py_basicsize = 0; - if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; -#else - basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1; -#endif - if (__Pyx_VerifyCachedType( - cached_type, - object_name, - basicsize, - spec->basicsize) < 0) { - goto bad; - } - goto done; - } - if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; - PyErr_Clear(); - CYTHON_UNUSED_VAR(module); - cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases); - if (unlikely(!cached_type)) goto bad; - if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; - if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad; -done: - Py_DECREF(abi_module); - assert(cached_type == NULL || PyType_Check(cached_type)); - return (PyTypeObject *) cached_type; -bad: - Py_XDECREF(cached_type); - cached_type = NULL; - goto done; -} -#endif - -/* PyVectorcallFastCallDict */ -#if CYTHON_METH_FASTCALL -static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) -{ - PyObject *res = NULL; - PyObject *kwnames; - PyObject **newargs; - PyObject **kwvalues; - Py_ssize_t i, pos; - size_t j; - PyObject *key, *value; - unsigned long keys_are_strings; - Py_ssize_t nkw = PyDict_GET_SIZE(kw); - newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); - if (unlikely(newargs == NULL)) { - PyErr_NoMemory(); - return NULL; - } - for (j = 0; j < nargs; j++) newargs[j] = args[j]; - kwnames = PyTuple_New(nkw); - if (unlikely(kwnames == NULL)) { - PyMem_Free(newargs); - return NULL; - } - kwvalues = newargs + nargs; - pos = i = 0; - keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; - while (PyDict_Next(kw, &pos, &key, &value)) { - keys_are_strings &= Py_TYPE(key)->tp_flags; - Py_INCREF(key); - Py_INCREF(value); - PyTuple_SET_ITEM(kwnames, i, key); - kwvalues[i] = value; - i++; - } - if (unlikely(!keys_are_strings)) { - PyErr_SetString(PyExc_TypeError, "keywords must be strings"); - goto cleanup; - } - res = vc(func, newargs, nargs, kwnames); -cleanup: - Py_DECREF(kwnames); - for (i = 0; i < nkw; i++) - Py_DECREF(kwvalues[i]); - PyMem_Free(newargs); - return res; -} -static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) -{ - if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) { - return vc(func, args, nargs, NULL); - } - return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); -} -#endif - -/* CythonFunctionShared */ -#if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { - if (__Pyx_CyFunction_Check(func)) { - return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; - } else if (PyCFunction_Check(func)) { - return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; - } - return 0; -} -#else -static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { - return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; -} -#endif -static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { -#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API - __Pyx_Py_XDECREF_SET( - __Pyx_CyFunction_GetClassObj(f), - ((classobj) ? __Pyx_NewRef(classobj) : NULL)); -#else - __Pyx_Py_XDECREF_SET( - ((PyCMethodObject *) (f))->mm_class, - (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); -#endif -} -static PyObject * -__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) -{ - CYTHON_UNUSED_VAR(closure); - if (unlikely(op->func_doc == NULL)) { -#if CYTHON_COMPILING_IN_LIMITED_API - op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); - if (unlikely(!op->func_doc)) return NULL; -#else - if (((PyCFunctionObject*)op)->m_ml->ml_doc) { -#if PY_MAJOR_VERSION >= 3 - op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); -#else - op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); -#endif - if (unlikely(op->func_doc == NULL)) - return NULL; - } else { - Py_INCREF(Py_None); - return Py_None; - } -#endif - } - Py_INCREF(op->func_doc); - return op->func_doc; -} -static int -__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) -{ - CYTHON_UNUSED_VAR(context); - if (value == NULL) { - value = Py_None; - } - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->func_doc, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(context); - if (unlikely(op->func_name == NULL)) { -#if CYTHON_COMPILING_IN_LIMITED_API - op->func_name = PyObject_GetAttrString(op->func, "__name__"); -#elif PY_MAJOR_VERSION >= 3 - op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); -#else - op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->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, void *context) -{ - CYTHON_UNUSED_VAR(context); -#if PY_MAJOR_VERSION >= 3 - if (unlikely(value == NULL || !PyUnicode_Check(value))) -#else - if (unlikely(value == NULL || !PyString_Check(value))) -#endif - { - PyErr_SetString(PyExc_TypeError, - "__name__ must be set to a string object"); - return -1; - } - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->func_name, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(context); - Py_INCREF(op->func_qualname); - return op->func_qualname; -} -static int -__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) -{ - CYTHON_UNUSED_VAR(context); -#if PY_MAJOR_VERSION >= 3 - if (unlikely(value == NULL || !PyUnicode_Check(value))) -#else - if (unlikely(value == NULL || !PyString_Check(value))) -#endif - { - PyErr_SetString(PyExc_TypeError, - "__qualname__ must be set to a string object"); - return -1; - } - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->func_qualname, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(context); - if (unlikely(op->func_dict == NULL)) { - op->func_dict = PyDict_New(); - if (unlikely(op->func_dict == NULL)) - return NULL; - } - Py_INCREF(op->func_dict); - return op->func_dict; -} -static int -__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context) -{ - CYTHON_UNUSED_VAR(context); - if (unlikely(value == NULL)) { - PyErr_SetString(PyExc_TypeError, - "function's dictionary may not be deleted"); - return -1; - } - if (unlikely(!PyDict_Check(value))) { - PyErr_SetString(PyExc_TypeError, - "setting function's dictionary to a non-dict"); - return -1; - } - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->func_dict, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(context); - Py_INCREF(op->func_globals); - return op->func_globals; -} -static PyObject * -__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(op); - CYTHON_UNUSED_VAR(context); - Py_INCREF(Py_None); - return Py_None; -} -static PyObject * -__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) -{ - PyObject* result = (op->func_code) ? op->func_code : Py_None; - CYTHON_UNUSED_VAR(context); - 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 = __Pyx_PySequence_ITEM(res, 0); - if (unlikely(!op->defaults_tuple)) result = -1; - else { - op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1); - if (unlikely(!op->defaults_kwdict)) result = -1; - } - #endif - Py_DECREF(res); - return result; -} -static int -__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { - CYTHON_UNUSED_VAR(context); - if (!value) { - value = Py_None; - } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { - PyErr_SetString(PyExc_TypeError, - "__defaults__ must be set to a tuple object"); - return -1; - } - PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " - "currently affect the values used in function calls", 1); - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { - PyObject* result = op->defaults_tuple; - CYTHON_UNUSED_VAR(context); - if (unlikely(!result)) { - if (op->defaults_getter) { - if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; - result = op->defaults_tuple; - } else { - result = Py_None; - } - } - Py_INCREF(result); - return result; -} -static int -__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { - CYTHON_UNUSED_VAR(context); - if (!value) { - value = Py_None; - } else if (unlikely(value != Py_None && !PyDict_Check(value))) { - PyErr_SetString(PyExc_TypeError, - "__kwdefaults__ must be set to a dict object"); - return -1; - } - PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " - "currently affect the values used in function calls", 1); - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { - PyObject* result = op->defaults_kwdict; - CYTHON_UNUSED_VAR(context); - if (unlikely(!result)) { - if (op->defaults_getter) { - if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; - result = op->defaults_kwdict; - } else { - result = Py_None; - } - } - Py_INCREF(result); - return result; -} -static int -__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { - CYTHON_UNUSED_VAR(context); - if (!value || value == Py_None) { - value = NULL; - } else if (unlikely(!PyDict_Check(value))) { - PyErr_SetString(PyExc_TypeError, - "__annotations__ must be set to a dict object"); - return -1; - } - Py_XINCREF(value); - __Pyx_Py_XDECREF_SET(op->func_annotations, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { - PyObject* result = op->func_annotations; - CYTHON_UNUSED_VAR(context); - if (unlikely(!result)) { - result = PyDict_New(); - if (unlikely(!result)) return NULL; - op->func_annotations = result; - } - Py_INCREF(result); - return result; -} -static PyObject * -__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { - int is_coroutine; - CYTHON_UNUSED_VAR(context); - if (op->func_is_coroutine) { - return __Pyx_NewRef(op->func_is_coroutine); - } - is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; -#if PY_VERSION_HEX >= 0x03050000 - if (is_coroutine) { - PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine; - fromlist = PyList_New(1); - if (unlikely(!fromlist)) return NULL; - Py_INCREF(marker); -#if CYTHON_ASSUME_SAFE_MACROS - PyList_SET_ITEM(fromlist, 0, marker); -#else - if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { - Py_DECREF(marker); - Py_DECREF(fromlist); - return NULL; - } -#endif - module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0); - Py_DECREF(fromlist); - if (unlikely(!module)) goto ignore; - op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker); - Py_DECREF(module); - if (likely(op->func_is_coroutine)) { - return __Pyx_NewRef(op->func_is_coroutine); - } -ignore: - PyErr_Clear(); - } -#endif - op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine); - return __Pyx_NewRef(op->func_is_coroutine); -} -#if CYTHON_COMPILING_IN_LIMITED_API -static PyObject * -__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { - CYTHON_UNUSED_VAR(context); - return PyObject_GetAttrString(op->func, "__module__"); -} -static int -__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { - CYTHON_UNUSED_VAR(context); - return PyObject_SetAttrString(op->func, "__module__", value); -} -#endif -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 *) "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}, - {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, -#if CYTHON_COMPILING_IN_LIMITED_API - {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, -#endif - {0, 0, 0, 0, 0} -}; -static PyMemberDef __pyx_CyFunction_members[] = { -#if !CYTHON_COMPILING_IN_LIMITED_API - {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, -#endif -#if CYTHON_USE_TYPE_SPECS - {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, -#if CYTHON_METH_FASTCALL -#if CYTHON_BACKPORT_VECTORCALL - {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, -#else -#if !CYTHON_COMPILING_IN_LIMITED_API - {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, -#endif -#endif -#endif -#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API - {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, -#else - {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, -#endif -#endif - {0, 0, 0, 0, 0} -}; -static PyObject * -__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) -{ - CYTHON_UNUSED_VAR(args); -#if PY_MAJOR_VERSION >= 3 - Py_INCREF(m->func_qualname); - return m->func_qualname; -#else - return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name); -#endif -} -static PyMethodDef __pyx_CyFunction_methods[] = { - {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, - {0, 0, 0, 0} -}; -#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API -#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) -#else -#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->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 !CYTHON_COMPILING_IN_LIMITED_API - PyCFunctionObject *cf = (PyCFunctionObject*) op; -#endif - if (unlikely(op == NULL)) - return NULL; -#if CYTHON_COMPILING_IN_LIMITED_API - op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); - if (unlikely(!op->func)) return NULL; -#endif - op->flags = flags; - __Pyx_CyFunction_weakreflist(op) = NULL; -#if !CYTHON_COMPILING_IN_LIMITED_API - cf->m_ml = ml; - cf->m_self = (PyObject *) op; -#endif - Py_XINCREF(closure); - op->func_closure = closure; -#if !CYTHON_COMPILING_IN_LIMITED_API - Py_XINCREF(module); - cf->m_module = module; -#endif - op->func_dict = NULL; - op->func_name = NULL; - Py_INCREF(qualname); - op->func_qualname = qualname; - op->func_doc = NULL; -#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API - op->func_classobj = NULL; -#else - ((PyCMethodObject*)op)->mm_class = NULL; -#endif - op->func_globals = globals; - Py_INCREF(op->func_globals); - 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; - op->func_is_coroutine = NULL; -#if CYTHON_METH_FASTCALL - switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { - case METH_NOARGS: - __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; - break; - case METH_O: - __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; - break; - case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: - __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; - break; - case METH_FASTCALL | METH_KEYWORDS: - __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; - break; - case METH_VARARGS | METH_KEYWORDS: - __Pyx_CyFunction_func_vectorcall(op) = NULL; - break; - default: - PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); - Py_DECREF(op); - return NULL; - } -#endif - return (PyObject *) op; -} -static int -__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) -{ - Py_CLEAR(m->func_closure); -#if CYTHON_COMPILING_IN_LIMITED_API - Py_CLEAR(m->func); -#else - Py_CLEAR(((PyCFunctionObject*)m)->m_module); -#endif - 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); -#if !CYTHON_COMPILING_IN_LIMITED_API -#if PY_VERSION_HEX < 0x030900B1 - Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); -#else - { - PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; - ((PyCMethodObject *) (m))->mm_class = NULL; - Py_XDECREF(cls); - } -#endif -#endif - Py_CLEAR(m->defaults_tuple); - Py_CLEAR(m->defaults_kwdict); - Py_CLEAR(m->func_annotations); - Py_CLEAR(m->func_is_coroutine); - 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; - } - return 0; -} -static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) -{ - if (__Pyx_CyFunction_weakreflist(m) != NULL) - PyObject_ClearWeakRefs((PyObject *) m); - __Pyx_CyFunction_clear(m); - __Pyx_PyHeapTypeObject_GC_Del(m); -} -static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) -{ - PyObject_GC_UnTrack(m); - __Pyx__CyFunction_dealloc(m); -} -static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) -{ - Py_VISIT(m->func_closure); -#if CYTHON_COMPILING_IN_LIMITED_API - Py_VISIT(m->func); -#else - Py_VISIT(((PyCFunctionObject*)m)->m_module); -#endif - 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); -#if !CYTHON_COMPILING_IN_LIMITED_API - Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); -#endif - Py_VISIT(m->defaults_tuple); - Py_VISIT(m->defaults_kwdict); - Py_VISIT(m->func_is_coroutine); - if (m->defaults) { - PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); - int i; - for (i = 0; i < m->defaults_pyobjects; i++) - Py_VISIT(pydefaults[i]); - } - return 0; -} -static PyObject* -__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) -{ -#if PY_MAJOR_VERSION >= 3 - return PyUnicode_FromFormat("", - op->func_qualname, (void *)op); -#else - return PyString_FromFormat("", - PyString_AsString(op->func_qualname), (void *)op); -#endif -} -static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { -#if CYTHON_COMPILING_IN_LIMITED_API - PyObject *f = ((__pyx_CyFunctionObject*)func)->func; - PyObject *py_name = NULL; - PyCFunction meth; - int flags; - meth = PyCFunction_GetFunction(f); - if (unlikely(!meth)) return NULL; - flags = PyCFunction_GetFlags(f); - if (unlikely(flags < 0)) return NULL; -#else - PyCFunctionObject* f = (PyCFunctionObject*)func; - PyCFunction meth = f->m_ml->ml_meth; - int flags = f->m_ml->ml_flags; -#endif - Py_ssize_t size; - switch (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)) { -#if CYTHON_ASSUME_SAFE_MACROS - size = PyTuple_GET_SIZE(arg); -#else - size = PyTuple_Size(arg); - if (unlikely(size < 0)) return NULL; -#endif - if (likely(size == 0)) - return (*meth)(self, NULL); -#if CYTHON_COMPILING_IN_LIMITED_API - py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); - if (!py_name) return NULL; - PyErr_Format(PyExc_TypeError, - "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - py_name, size); - Py_DECREF(py_name); -#else - PyErr_Format(PyExc_TypeError, - "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - f->m_ml->ml_name, size); -#endif - return NULL; - } - break; - case METH_O: - if (likely(kw == NULL || PyDict_Size(kw) == 0)) { -#if CYTHON_ASSUME_SAFE_MACROS - size = PyTuple_GET_SIZE(arg); -#else - size = PyTuple_Size(arg); - if (unlikely(size < 0)) return NULL; -#endif - if (likely(size == 1)) { - PyObject *result, *arg0; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - arg0 = PyTuple_GET_ITEM(arg, 0); - #else - arg0 = __Pyx_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; - } -#if CYTHON_COMPILING_IN_LIMITED_API - py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); - if (!py_name) return NULL; - PyErr_Format(PyExc_TypeError, - "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - py_name, size); - Py_DECREF(py_name); -#else - PyErr_Format(PyExc_TypeError, - "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - f->m_ml->ml_name, size); -#endif - return NULL; - } - break; - default: - PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); - return NULL; - } -#if CYTHON_COMPILING_IN_LIMITED_API - py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); - if (!py_name) return NULL; - PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", - py_name); - Py_DECREF(py_name); -#else - PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", - f->m_ml->ml_name); -#endif - return NULL; -} -static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { - PyObject *self, *result; -#if CYTHON_COMPILING_IN_LIMITED_API - self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); - if (unlikely(!self) && PyErr_Occurred()) return NULL; -#else - self = ((PyCFunctionObject*)func)->m_self; -#endif - result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); - return result; -} -static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { - PyObject *result; - __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; -#if CYTHON_METH_FASTCALL - __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); - if (vc) { -#if CYTHON_ASSUME_SAFE_MACROS - return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); -#else - (void) &__Pyx_PyVectorcall_FastCallDict; - return PyVectorcall_Call(func, args, kw); -#endif - } -#endif - if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { - Py_ssize_t argc; - PyObject *new_args; - PyObject *self; -#if CYTHON_ASSUME_SAFE_MACROS - argc = PyTuple_GET_SIZE(args); -#else - argc = PyTuple_Size(args); - if (unlikely(!argc) < 0) return NULL; -#endif - 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); -#if PY_MAJOR_VERSION > 2 - PyErr_Format(PyExc_TypeError, - "unbound method %.200S() needs an argument", - cyfunc->func_qualname); -#else - PyErr_SetString(PyExc_TypeError, - "unbound method needs an argument"); -#endif - return NULL; - } - result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); - Py_DECREF(new_args); - } else { - result = __Pyx_CyFunction_Call(func, args, kw); - } - return result; -} -#if CYTHON_METH_FASTCALL -static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) -{ - int ret = 0; - if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { - if (unlikely(nargs < 1)) { - PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", - ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); - return -1; - } - ret = 1; - } - if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) { - PyErr_Format(PyExc_TypeError, - "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); - return -1; - } - return ret; -} -static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) -{ - __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else - Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif - PyObject *self; - switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; - } - if (unlikely(nargs != 0)) { - PyErr_Format(PyExc_TypeError, - "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - def->ml_name, nargs); - return NULL; - } - return def->ml_meth(self, NULL); -} -static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) -{ - __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else - Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif - PyObject *self; - switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; - } - if (unlikely(nargs != 1)) { - PyErr_Format(PyExc_TypeError, - "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - def->ml_name, nargs); - return NULL; - } - return def->ml_meth(self, args[0]); -} -static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) -{ - __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else - Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif - PyObject *self; - switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; - } - return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames); -} -static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) -{ - __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; - PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else - Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif - PyObject *self; - switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; - } - return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames); -} -#endif -#if CYTHON_USE_TYPE_SPECS -static PyType_Slot __pyx_CyFunctionType_slots[] = { - {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, - {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, - {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, - {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, - {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, - {Py_tp_methods, (void *)__pyx_CyFunction_methods}, - {Py_tp_members, (void *)__pyx_CyFunction_members}, - {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, - {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, - {0, 0}, -}; -static PyType_Spec __pyx_CyFunctionType_spec = { - __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", - sizeof(__pyx_CyFunctionObject), - 0, -#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR - Py_TPFLAGS_METHOD_DESCRIPTOR | -#endif -#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL) - _Py_TPFLAGS_HAVE_VECTORCALL | -#endif - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, - __pyx_CyFunctionType_slots -}; -#else -static PyTypeObject __pyx_CyFunctionType_type = { - PyVarObject_HEAD_INIT(0, 0) - __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", - sizeof(__pyx_CyFunctionObject), - 0, - (destructor) __Pyx_CyFunction_dealloc, -#if !CYTHON_METH_FASTCALL - 0, -#elif CYTHON_BACKPORT_VECTORCALL - (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall), -#else - offsetof(PyCFunctionObject, vectorcall), -#endif - 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, -#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR - Py_TPFLAGS_METHOD_DESCRIPTOR | -#endif -#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL - _Py_TPFLAGS_HAVE_VECTORCALL | -#endif - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, - 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_PyMethod_New, - 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 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) - 0, -#endif -#if __PYX_NEED_TP_PRINT_SLOT - 0, -#endif -#if PY_VERSION_HEX >= 0x030C0000 - 0, -#endif -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 - 0, -#endif -}; -#endif -static int __pyx_CyFunction_init(PyObject *module) { -#if CYTHON_USE_TYPE_SPECS - __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); -#else - CYTHON_UNUSED_VAR(module); - __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); -#endif - 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; - m->defaults_size = size; - 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); -} - -/* 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; -} - -/* 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 - CYTHON_MAYBE_UNUSED_VAR(tstate); - 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_GetAttrStrNoError(__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; - } - } - if (!use_cline) { - c_line = 0; - (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); - } - 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; -} -#endif - -/* CodeObjectCache */ -#if !CYTHON_COMPILING_IN_LIMITED_API -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 PyCodeObject *__pyx_find_code_object(int code_line) { - PyCodeObject* code_object; - int pos; - if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { - return NULL; - } - 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 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; - } - 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; - } - 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); -} -#endif - -/* AddTraceback */ -#include "compile.h" -#include "frameobject.h" -#include "traceback.h" -#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API - #ifndef Py_BUILD_CORE - #define Py_BUILD_CORE 1 - #endif - #include "internal/pycore_frame.h" -#endif -#if CYTHON_COMPILING_IN_LIMITED_API -static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, - PyObject *firstlineno, PyObject *name) { - PyObject *replace = NULL; - if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; - if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; - replace = PyObject_GetAttrString(code, "replace"); - if (likely(replace)) { - PyObject *result; - result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); - Py_DECREF(replace); - return result; - } - PyErr_Clear(); - #if __PYX_LIMITED_VERSION_HEX < 0x030780000 - { - PyObject *compiled = NULL, *result = NULL; - if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; - if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; - compiled = Py_CompileString( - "out = type(code)(\n" - " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" - " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" - " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" - " code.co_lnotab)\n", "", Py_file_input); - if (!compiled) return NULL; - result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); - Py_DECREF(compiled); - if (!result) PyErr_Print(); - Py_DECREF(result); - result = PyDict_GetItemString(scratch_dict, "out"); - if (result) Py_INCREF(result); - return result; - } - #else - return NULL; - #endif -} -static void __Pyx_AddTraceback(const char *funcname, int c_line, - int py_line, const char *filename) { - PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; - PyObject *replace = NULL, *getframe = NULL, *frame = NULL; - PyObject *exc_type, *exc_value, *exc_traceback; - int success = 0; - if (c_line) { - (void) __pyx_cfilenm; - (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); - } - PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); - code_object = Py_CompileString("_getframe()", filename, Py_eval_input); - if (unlikely(!code_object)) goto bad; - py_py_line = PyLong_FromLong(py_line); - if (unlikely(!py_py_line)) goto bad; - py_funcname = PyUnicode_FromString(funcname); - if (unlikely(!py_funcname)) goto bad; - dict = PyDict_New(); - if (unlikely(!dict)) goto bad; - { - PyObject *old_code_object = code_object; - code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); - Py_DECREF(old_code_object); - } - if (unlikely(!code_object)) goto bad; - getframe = PySys_GetObject("_getframe"); - if (unlikely(!getframe)) goto bad; - if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; - frame = PyEval_EvalCode(code_object, dict, dict); - if (unlikely(!frame) || frame == Py_None) goto bad; - success = 1; - bad: - PyErr_Restore(exc_type, exc_value, exc_traceback); - Py_XDECREF(code_object); - Py_XDECREF(py_py_line); - Py_XDECREF(py_funcname); - Py_XDECREF(dict); - Py_XDECREF(replace); - if (success) { - PyTraceBack_Here( - (struct _frame*)frame); - } - Py_XDECREF(frame); -} -#else -static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( - const char *funcname, int c_line, - int py_line, const char *filename) { - PyCodeObject *py_code = NULL; - PyObject *py_funcname = NULL; - #if PY_MAJOR_VERSION < 3 - PyObject *py_srcfile = NULL; - py_srcfile = PyString_FromString(filename); - if (!py_srcfile) goto bad; - #endif - if (c_line) { - #if PY_MAJOR_VERSION < 3 - py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); - if (!py_funcname) goto bad; - #else - py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); - if (!py_funcname) goto bad; - funcname = PyUnicode_AsUTF8(py_funcname); - if (!funcname) goto bad; - #endif - } - else { - #if PY_MAJOR_VERSION < 3 - py_funcname = PyString_FromString(funcname); - if (!py_funcname) goto bad; - #endif - } - #if PY_MAJOR_VERSION < 3 - py_code = __Pyx_PyCode_New( - 0, - 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); - #else - py_code = PyCode_NewEmpty(filename, funcname, py_line); - #endif - Py_XDECREF(py_funcname); - return py_code; -bad: - Py_XDECREF(py_funcname); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(py_srcfile); - #endif - 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; - PyObject *ptype, *pvalue, *ptraceback; - if (c_line) { - c_line = __Pyx_CLineForTraceback(tstate, c_line); - } - py_code = __pyx_find_code_object(c_line ? -c_line : py_line); - if (!py_code) { - __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); - py_code = __Pyx_CreateCodeObjectForTraceback( - funcname, c_line, py_line, filename); - if (!py_code) { - /* If the code object creation fails, then we should clear the - fetched exception references and propagate the new exception */ - Py_XDECREF(ptype); - Py_XDECREF(pvalue); - Py_XDECREF(ptraceback); - goto bad; - } - __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); - __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); -} -#endif - -#if PY_MAJOR_VERSION < 3 -static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { - __Pyx_TypeName obj_type_name; - if (PyObject_CheckBuffer(obj)) return PyObject_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); - obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); - PyErr_Format(PyExc_TypeError, - "'" __Pyx_FMT_TYPENAME "' does not have the buffer interface", - obj_type_name); - __Pyx_DECREF_TypeName(obj_type_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; - } - if ((0)) {} - view->obj = NULL; - Py_DECREF(obj); -} -#endif - - -/* MemviewSliceIsContig */ -static int -__pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim) -{ - 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; - } - 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; -} - -/* 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); - } - } - *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); -} - -/* 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; -} - -/* 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'; - } - } - *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; -} -static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { - PyErr_Format(PyExc_ValueError, - "Unexpected format string character: '%c'", 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'"; - 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 "unparsable 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; - } - case 'O': case 'P': return sizeof(void*); - default: - __Pyx_BufFmt_RaiseUnexpectedChar(ch); - return 0; - } -} -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 '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; - } - } -} -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, int is_complex) { - CYTHON_UNUSED_VAR(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; - } -} -/* 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, int is_complex) { - CYTHON_UNUSED_VAR(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; - } -} -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 '?': 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; - } - } -} -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 = "'"; - } - 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; - } - } - if (!ctx->is_valid_array) { - PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", - ctx->head->field->type->ndim, ndim); - return -1; - } - for (i = 0; i < ctx->head->field->type->ndim; i++) { - arraysize *= ctx->head->field->type->arraysize[i]; - } - 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); - } - 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 (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; - } - } - 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 int -__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) -{ - const char *ts = *tsp; - int i = 0, number, ndim; - ++ts; - if (ctx->new_count != 1) { - PyErr_SetString(PyExc_ValueError, - "Cannot handle repeated arrays in format string"); - return -1; - } - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return -1; - ndim = ctx->head->field->type->ndim; - 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 -1; - if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) { - PyErr_Format(PyExc_ValueError, - "Expected a dimension of size %zu, got %d", - ctx->head->field->type->arraysize[i], number); - return -1; - } - if (*ts != ',' && *ts != ')') { - PyErr_Format(PyExc_ValueError, - "Expected a comma in format string, got '%c'", *ts); - return -1; - } - if (*ts == ',') ts++; - i++; - } - if (i != ndim) { - PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", - ctx->head->field->type->ndim, i); - return -1; - } - if (!*ts) { - PyErr_SetString(PyExc_ValueError, - "Unexpected end of format string, expected ')'"); - return -1; - } - ctx->is_valid_array = 1; - ctx->new_count = 1; - *tsp = ++ts; - return 0; -} -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 '?': 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)) { - 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) < 0) return NULL; - break; - default: - { - int number = __Pyx_BufFmt_ExpectNumber(&ts); - if (number == -1) return NULL; - ctx->new_count = (size_t)number; - } - } - } -} - -/* TypeInfoCompare */ - static int -__pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b) -{ - int i; - if (!a || !b) - return 0; - if (a == b) - return 1; - if (a->size != b->size || a->typegroup != b->typegroup || - a->is_unsigned != b->is_unsigned || a->ndim != b->ndim) { - if (a->typegroup == 'H' || b->typegroup == 'H') { - return a->size == b->size; - } else { - return 0; - } - } - if (a->ndim) { - for (i = 0; i < a->ndim; i++) - if (a->arraysize[i] != b->arraysize[i]) - return 0; - } - if (a->typegroup == 'S') { - if (a->flags != b->flags) - return 0; - if (a->fields || b->fields) { - if (!(a->fields && b->fields)) - return 0; - for (i = 0; a->fields[i].type && b->fields[i].type; i++) { - __Pyx_StructField *field_a = a->fields + i; - __Pyx_StructField *field_b = b->fields + i; - if (field_a->offset != field_b->offset || - !__pyx_typeinfo_cmp(field_a->type, field_b->type)) - return 0; - } - return !a->fields[i].type && !b->fields[i].type; - } - } - return 1; -} - -/* MemviewSliceValidateAndInit */ - static int -__pyx_check_strides(Py_buffer *buf, int dim, int ndim, int spec) -{ - if (buf->shape[dim] <= 1) - return 1; - if (buf->strides) { - if (spec & __Pyx_MEMVIEW_CONTIG) { - if (spec & (__Pyx_MEMVIEW_PTR|__Pyx_MEMVIEW_FULL)) { - if (unlikely(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)) { - PyErr_SetString(PyExc_ValueError, - "Buffer and memoryview are not contiguous " - "in the same dimension."); - goto fail; - } - } - if (spec & __Pyx_MEMVIEW_FOLLOW) { - Py_ssize_t stride = buf->strides[dim]; - if (stride < 0) - stride = -stride; - if (unlikely(stride < buf->itemsize)) { - PyErr_SetString(PyExc_ValueError, - "Buffer and memoryview are not contiguous " - "in the same dimension."); - goto fail; - } - } - } else { - if (unlikely(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))) { - PyErr_Format(PyExc_ValueError, - "C-contiguous buffer is not indirect in " - "dimension %d", dim); - goto fail; - } else if (unlikely(buf->suboffsets)) { - PyErr_SetString(PyExc_ValueError, - "Buffer exposes suboffsets but no strides"); - goto fail; - } - } - return 1; -fail: - return 0; -} -static int -__pyx_check_suboffsets(Py_buffer *buf, int dim, int ndim, int spec) -{ - CYTHON_UNUSED_VAR(ndim); - if (spec & __Pyx_MEMVIEW_DIRECT) { - if (unlikely(buf->suboffsets && buf->suboffsets[dim] >= 0)) { - PyErr_Format(PyExc_ValueError, - "Buffer not compatible with direct access " - "in dimension %d.", dim); - goto fail; - } - } - if (spec & __Pyx_MEMVIEW_PTR) { - if (unlikely(!buf->suboffsets || (buf->suboffsets[dim] < 0))) { - PyErr_Format(PyExc_ValueError, - "Buffer is not indirectly accessible " - "in dimension %d.", dim); - goto fail; - } - } - return 1; -fail: - return 0; -} -static int -__pyx_verify_contig(Py_buffer *buf, int ndim, int c_or_f_flag) -{ - int i; - 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)) { - PyErr_SetString(PyExc_ValueError, - "Buffer not fortran contiguous."); - goto fail; - } - stride = stride * buf->shape[i]; - } - } 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)) { - PyErr_SetString(PyExc_ValueError, - "Buffer not C contiguous."); - goto fail; - } - stride = stride * buf->shape[i]; - } - } - return 1; -fail: - return 0; -} -static int __Pyx_ValidateAndInit_memviewslice( - int *axes_specs, - int c_or_f_flag, - int buf_flags, - int ndim, - __Pyx_TypeInfo *dtype, - __Pyx_BufFmt_StackElem stack[], - __Pyx_memviewslice *memviewslice, - PyObject *original_obj) -{ - struct __pyx_memoryview_obj *memview, *new_memview; - __Pyx_RefNannyDeclarations - Py_buffer *buf; - int i, spec = 0, retval = -1; - __Pyx_BufFmt_Context ctx; - int from_memoryview = __pyx_memoryview_check(original_obj); - __Pyx_RefNannySetupContext("ValidateAndInit_memviewslice", 0); - if (from_memoryview && __pyx_typeinfo_cmp(dtype, ((struct __pyx_memoryview_obj *) - original_obj)->typeinfo)) { - memview = (struct __pyx_memoryview_obj *) original_obj; - new_memview = NULL; - } else { - memview = (struct __pyx_memoryview_obj *) __pyx_memoryview_new( - original_obj, buf_flags, 0, dtype); - new_memview = memview; - if (unlikely(!memview)) - goto fail; - } - buf = &memview->view; - if (unlikely(buf->ndim != ndim)) { - PyErr_Format(PyExc_ValueError, - "Buffer has wrong number of dimensions (expected %d, got %d)", - ndim, buf->ndim); - goto fail; - } - if (new_memview) { - __Pyx_BufFmt_Init(&ctx, stack, dtype); - if (unlikely(!__Pyx_BufFmt_CheckString(&ctx, buf->format))) goto fail; - } - if (unlikely((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)", - buf->itemsize, - (buf->itemsize > 1) ? "s" : "", - dtype->name, - dtype->size, - (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))) - goto fail; - } - if (unlikely(__Pyx_init_memviewslice(memview, ndim, memviewslice, - new_memview != NULL) == -1)) { - goto fail; - } - retval = 0; - goto no_fail; -fail: - Py_XDECREF(new_memview); - retval = -1; -no_fail: - __Pyx_RefNannyFinishContext(); - return retval; -} - -/* ObjectToMemviewSlice */ - static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dsds_float(PyObject *obj, int writable_flag) { - __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; - __Pyx_BufFmt_StackElem stack[1]; - int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_STRIDED), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_STRIDED) }; - int retcode; - if (obj == Py_None) { - result.memview = (struct __pyx_memoryview_obj *) Py_None; - return result; - } - retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, 0, - PyBUF_RECORDS_RO | writable_flag, 2, - &__Pyx_TypeInfo_float, stack, - &result, obj); - if (unlikely(retcode == -1)) - goto __pyx_fail; - return result; -__pyx_fail: - result.memview = NULL; - result.data = NULL; - return result; -} - -/* ObjectToMemviewSlice */ - static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_ds_int(PyObject *obj, int writable_flag) { - __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; - __Pyx_BufFmt_StackElem stack[1]; - int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_STRIDED) }; - int retcode; - if (obj == Py_None) { - result.memview = (struct __pyx_memoryview_obj *) Py_None; - return result; - } - retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, 0, - PyBUF_RECORDS_RO | writable_flag, 1, - &__Pyx_TypeInfo_int, stack, - &result, obj); - if (unlikely(retcode == -1)) - goto __pyx_fail; - return result; -__pyx_fail: - result.memview = NULL; - result.data = NULL; - return result; -} - -/* ObjectToMemviewSlice */ - static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dsds_int(PyObject *obj, int writable_flag) { - __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; - __Pyx_BufFmt_StackElem stack[1]; - int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_STRIDED), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_STRIDED) }; - int retcode; - if (obj == Py_None) { - result.memview = (struct __pyx_memoryview_obj *) Py_None; - return result; - } - retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, 0, - PyBUF_RECORDS_RO | writable_flag, 2, - &__Pyx_TypeInfo_int, stack, - &result, obj); - if (unlikely(retcode == -1)) - goto __pyx_fail; - return result; -__pyx_fail: - result.memview = NULL; - result.data = NULL; - return result; -} - -/* CIntFromPyVerify */ - #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ - __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) -#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ - __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) -#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ - {\ - func_type value = func_value;\ - if (sizeof(target_type) < sizeof(func_type)) {\ - if (unlikely(value != (func_type) (target_type) value)) {\ - func_type zero = 0;\ - if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ - return (target_type) -1;\ - if (is_unsigned && unlikely(value < zero))\ - goto raise_neg_overflow;\ - else\ - goto raise_overflow;\ - }\ - }\ - return (target_type) value;\ - } - -/* MemviewSliceCopyTemplate */ - static __Pyx_memviewslice -__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, - const char *mode, int ndim, - size_t sizeof_dtype, int contig_flag, - int dtype_is_object) -{ - __Pyx_RefNannyDeclarations - int i; - __Pyx_memviewslice new_mvs = { 0, 0, { 0 }, { 0 }, { 0 } }; - struct __pyx_memoryview_obj *from_memview = from_mvs->memview; - Py_buffer *buf = &from_memview->view; - PyObject *shape_tuple = NULL; - PyObject *temp_int = NULL; - struct __pyx_array_obj *array_obj = NULL; - 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)) { - PyErr_Format(PyExc_ValueError, "Cannot copy memoryview slice with " - "indirect dimensions (axis %d)", i); - goto fail; - } - } - shape_tuple = PyTuple_New(ndim); - if (unlikely(!shape_tuple)) { - goto fail; - } - __Pyx_GOTREF(shape_tuple); - for(i = 0; i < ndim; i++) { - temp_int = PyInt_FromSsize_t(from_mvs->shape[i]); - if(unlikely(!temp_int)) { - goto fail; - } else { - PyTuple_SET_ITEM(shape_tuple, i, temp_int); - temp_int = NULL; - } - } - array_obj = __pyx_array_new(shape_tuple, sizeof_dtype, buf->format, (char *) mode, NULL); - if (unlikely(!array_obj)) { - goto fail; - } - __Pyx_GOTREF(array_obj); - memview_obj = (struct __pyx_memoryview_obj *) __pyx_memoryview_new( - (PyObject *) array_obj, contig_flag, - dtype_is_object, - from_mvs->memview->typeinfo); - if (unlikely(!memview_obj)) - goto fail; - if (unlikely(__Pyx_init_memviewslice(memview_obj, ndim, &new_mvs, 1) < 0)) - goto fail; - if (unlikely(__pyx_memoryview_copy_contents(*from_mvs, new_mvs, ndim, ndim, - dtype_is_object) < 0)) - goto fail; - goto no_fail; -fail: - __Pyx_XDECREF(new_mvs.memview); - new_mvs.memview = NULL; - new_mvs.data = NULL; -no_fail: - __Pyx_XDECREF(shape_tuple); - __Pyx_XDECREF(temp_int); - __Pyx_XDECREF(array_obj); - __Pyx_RefNannyFinishContext(); - return new_mvs; -} - -/* MemviewSliceInit */ - static int -__Pyx_init_memviewslice(struct __pyx_memoryview_obj *memview, - int ndim, - __Pyx_memviewslice *memviewslice, - int memview_is_new_reference) -{ - __Pyx_RefNannyDeclarations - int i, retval=-1; - Py_buffer *buf = &memview->view; - __Pyx_RefNannySetupContext("init_memviewslice", 0); - if (unlikely(memviewslice->memview || memviewslice->data)) { - PyErr_SetString(PyExc_ValueError, - "memviewslice is already initialized!"); - goto fail; - } - if (buf->strides) { - for (i = 0; i < ndim; i++) { - memviewslice->strides[i] = buf->strides[i]; - } - } else { - Py_ssize_t stride = buf->itemsize; - for (i = ndim - 1; i >= 0; i--) { - memviewslice->strides[i] = stride; - stride *= buf->shape[i]; - } - } - for (i = 0; i < ndim; i++) { - memviewslice->shape[i] = buf->shape[i]; - if (buf->suboffsets) { - memviewslice->suboffsets[i] = buf->suboffsets[i]; - } else { - memviewslice->suboffsets[i] = -1; - } - } - memviewslice->memview = memview; - memviewslice->data = (char *)buf->buf; - if (__pyx_add_acquisition_count(memview) == 0 && !memview_is_new_reference) { - Py_INCREF(memview); - } - retval = 0; - goto no_fail; -fail: - memviewslice->memview = 0; - memviewslice->data = 0; - retval = -1; -no_fail: - __Pyx_RefNannyFinishContext(); - return retval; -} -#ifndef Py_NO_RETURN -#define Py_NO_RETURN -#endif -static void __pyx_fatalerror(const char *fmt, ...) Py_NO_RETURN { - va_list vargs; - char msg[200]; -#if PY_VERSION_HEX >= 0x030A0000 || defined(HAVE_STDARG_PROTOTYPES) - va_start(vargs, fmt); -#else - va_start(vargs); -#endif - vsnprintf(msg, 200, fmt, vargs); - va_end(vargs); - Py_FatalError(msg); -} -static CYTHON_INLINE int -__pyx_add_acquisition_count_locked(__pyx_atomic_int_type *acquisition_count, - PyThread_type_lock lock) -{ - int result; - PyThread_acquire_lock(lock, 1); - result = (*acquisition_count)++; - PyThread_release_lock(lock); - return result; -} -static CYTHON_INLINE int -__pyx_sub_acquisition_count_locked(__pyx_atomic_int_type *acquisition_count, - PyThread_type_lock lock) -{ - int result; - PyThread_acquire_lock(lock, 1); - result = (*acquisition_count)--; - PyThread_release_lock(lock); - return result; -} -static CYTHON_INLINE void -__Pyx_INC_MEMVIEW(__Pyx_memviewslice *memslice, int have_gil, int lineno) -{ - __pyx_nonatomic_int_type old_acquisition_count; - struct __pyx_memoryview_obj *memview = memslice->memview; - if (unlikely(!memview || (PyObject *) memview == Py_None)) { - return; - } - old_acquisition_count = __pyx_add_acquisition_count(memview); - if (unlikely(old_acquisition_count <= 0)) { - if (likely(old_acquisition_count == 0)) { - if (have_gil) { - Py_INCREF((PyObject *) memview); - } else { - PyGILState_STATE _gilstate = PyGILState_Ensure(); - Py_INCREF((PyObject *) memview); - PyGILState_Release(_gilstate); - } - } else { - __pyx_fatalerror("Acquisition count is %d (line %d)", - old_acquisition_count+1, lineno); - } - } -} -static CYTHON_INLINE void __Pyx_XCLEAR_MEMVIEW(__Pyx_memviewslice *memslice, - int have_gil, int lineno) { - __pyx_nonatomic_int_type old_acquisition_count; - struct __pyx_memoryview_obj *memview = memslice->memview; - if (unlikely(!memview || (PyObject *) memview == Py_None)) { - memslice->memview = NULL; - return; - } - old_acquisition_count = __pyx_sub_acquisition_count(memview); - memslice->data = NULL; - if (likely(old_acquisition_count > 1)) { - memslice->memview = NULL; - } else if (likely(old_acquisition_count == 1)) { - if (have_gil) { - Py_CLEAR(memslice->memview); - } else { - PyGILState_STATE _gilstate = PyGILState_Ensure(); - Py_CLEAR(memslice->memview); - PyGILState_Release(_gilstate); - } - } else { - __pyx_fatalerror("Acquisition count is %d (line %d)", - old_acquisition_count-1, lineno); - } -} - -/* CIntFromPy */ - static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const int neg_one = (int) -1, const_zero = (int) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(int) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (int) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { -#if CYTHON_USE_PYLONG_INTERNALS - if (unlikely(__Pyx_PyLong_IsNeg(x))) { - goto raise_neg_overflow; - } else if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_DigitCount(x)) { - case 2: - if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { - return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); - } - } - break; - case 3: - if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { - return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); - } - } - break; - case 4: - if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(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(int) >= 4 * PyLong_SHIFT)) { - return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); - } - } - break; - } - } -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 - 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 (int) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#endif - if ((sizeof(int) <= sizeof(unsigned long))) { - __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif - } - } else { -#if CYTHON_USE_PYLONG_INTERNALS - if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_SignedDigitCount(x)) { - case -2: - if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { - return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case 2: - if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { - return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case -3: - if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { - return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case 3: - if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { - return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case -4: - if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(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(int) - 1 > 4 * PyLong_SHIFT)) { - return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case 4: - if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(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(int) - 1 > 4 * PyLong_SHIFT)) { - return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - } - } -#endif - if ((sizeof(int) <= sizeof(long))) { - __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif - } - } - { - 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 ret = -1; -#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (int) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (int) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (int) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (int) -1; - } else { - stepval = __Pyx_NewRef(v); - } - val = (int) 0; - mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; - shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; - for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { - PyObject *tmp, *digit; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((int) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - idigit = PyLong_AsLong(stepval); - if (unlikely(idigit < 0)) goto done; - remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); - if (unlikely(idigit >= (1L << remaining_bits))) - goto raise_overflow; - val |= ((int) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - if (!is_unsigned) { - if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) - goto raise_overflow; - if (is_negative) - val = ~val; - } - ret = 0; - done: - Py_XDECREF(shift); - Py_XDECREF(mask); - Py_XDECREF(stepval); -#endif - Py_DECREF(v); - if (likely(!ret)) - return val; - } - return (int) -1; - } - } else { - int val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (int) -1; - val = __Pyx_PyInt_As_int(tmp); - Py_DECREF(tmp); - return val; - } -raise_overflow: - PyErr_SetString(PyExc_OverflowError, - "value too large to convert to int"); - return (int) -1; -raise_neg_overflow: - PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to int"); - return (int) -1; -} - -/* CIntToPy */ - static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const int neg_one = (int) -1, const_zero = (int) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(int) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(int) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(int) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(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; -#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 - return _PyLong_FromByteArray(bytes, sizeof(int), - little, !is_unsigned); -#else - PyObject *from_bytes, *result = NULL; - PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; - from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); - if (!from_bytes) return NULL; - py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); - if (!py_bytes) goto limited_bad; - order_str = PyUnicode_FromString(little ? "little" : "big"); - if (!order_str) goto limited_bad; - arg_tuple = PyTuple_Pack(2, py_bytes, order_str); - if (!arg_tuple) goto limited_bad; - if (!is_unsigned) { - kwds = PyDict_New(); - if (!kwds) goto limited_bad; - if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; - } - result = PyObject_Call(from_bytes, arg_tuple, kwds); - limited_bad: - Py_XDECREF(kwds); - Py_XDECREF(arg_tuple); - Py_XDECREF(order_str); - Py_XDECREF(py_bytes); - Py_XDECREF(from_bytes); - return result; -#endif - } -} - -/* CIntToPy */ - static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const long neg_one = (long) -1, const_zero = (long) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(long) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(long) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(long) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= 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; -#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 - return _PyLong_FromByteArray(bytes, sizeof(long), - little, !is_unsigned); -#else - PyObject *from_bytes, *result = NULL; - PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; - from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); - if (!from_bytes) return NULL; - py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); - if (!py_bytes) goto limited_bad; - order_str = PyUnicode_FromString(little ? "little" : "big"); - if (!order_str) goto limited_bad; - arg_tuple = PyTuple_Pack(2, py_bytes, order_str); - if (!arg_tuple) goto limited_bad; - if (!is_unsigned) { - kwds = PyDict_New(); - if (!kwds) goto limited_bad; - if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; - } - result = PyObject_Call(from_bytes, arg_tuple, kwds); - limited_bad: - Py_XDECREF(kwds); - Py_XDECREF(arg_tuple); - Py_XDECREF(order_str); - Py_XDECREF(py_bytes); - Py_XDECREF(from_bytes); - return result; -#endif - } -} - -/* CIntFromPy */ - static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const long neg_one = (long) -1, const_zero = (long) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(long) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (long) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { -#if CYTHON_USE_PYLONG_INTERNALS - if (unlikely(__Pyx_PyLong_IsNeg(x))) { - goto raise_neg_overflow; - } else if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_DigitCount(x)) { - case 2: - if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { - return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); - } - } - break; - case 3: - if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { - return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); - } - } - break; - case 4: - if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, 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(long) >= 4 * PyLong_SHIFT)) { - return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); - } - } - break; - } - } -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 - 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 (long) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#endif - if ((sizeof(long) <= sizeof(unsigned long))) { - __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif - } - } else { -#if CYTHON_USE_PYLONG_INTERNALS - if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_SignedDigitCount(x)) { - case -2: - if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { - return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case 2: - if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { - return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case -3: - if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { - return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case 3: - if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { - return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case -4: - if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, 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(long) - 1 > 4 * PyLong_SHIFT)) { - return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case 4: - if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, 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(long) - 1 > 4 * PyLong_SHIFT)) { - return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - } - } -#endif - if ((sizeof(long) <= sizeof(long))) { - __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif - } - } - { - long 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 ret = -1; -#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (long) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (long) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (long) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (long) -1; - } else { - stepval = __Pyx_NewRef(v); - } - val = (long) 0; - mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; - shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; - for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { - PyObject *tmp, *digit; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((long) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - idigit = PyLong_AsLong(stepval); - if (unlikely(idigit < 0)) goto done; - remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); - if (unlikely(idigit >= (1L << remaining_bits))) - goto raise_overflow; - val |= ((long) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - if (!is_unsigned) { - if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) - goto raise_overflow; - if (is_negative) - val = ~val; - } - ret = 0; - done: - Py_XDECREF(shift); - Py_XDECREF(mask); - Py_XDECREF(stepval); -#endif - Py_DECREF(v); - if (likely(!ret)) - return val; - } - return (long) -1; - } - } else { - long val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (long) -1; - val = __Pyx_PyInt_As_long(tmp); - Py_DECREF(tmp); - return val; - } -raise_overflow: - PyErr_SetString(PyExc_OverflowError, - "value too large to convert to long"); - return (long) -1; -raise_neg_overflow: - PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to long"); - return (long) -1; -} - -/* CIntFromPy */ - static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const char neg_one = (char) -1, const_zero = (char) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(char) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(char, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (char) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { -#if CYTHON_USE_PYLONG_INTERNALS - if (unlikely(__Pyx_PyLong_IsNeg(x))) { - goto raise_neg_overflow; - } else if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(char, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_DigitCount(x)) { - case 2: - if ((8 * sizeof(char) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(char) >= 2 * PyLong_SHIFT)) { - return (char) (((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); - } - } - break; - case 3: - if ((8 * sizeof(char) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(char) >= 3 * PyLong_SHIFT)) { - return (char) (((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); - } - } - break; - case 4: - if ((8 * sizeof(char) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(char, 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(char) >= 4 * PyLong_SHIFT)) { - return (char) (((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); - } - } - break; - } - } -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 - 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 (char) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#endif - if ((sizeof(char) <= sizeof(unsigned long))) { - __PYX_VERIFY_RETURN_INT_EXC(char, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(char) <= sizeof(unsigned PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(char, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif - } - } else { -#if CYTHON_USE_PYLONG_INTERNALS - if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(char, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_SignedDigitCount(x)) { - case -2: - if ((8 * sizeof(char) - 1 > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(char) - 1 > 2 * PyLong_SHIFT)) { - return (char) (((char)-1)*(((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); - } - } - break; - case 2: - if ((8 * sizeof(char) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(char) - 1 > 2 * PyLong_SHIFT)) { - return (char) ((((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); - } - } - break; - case -3: - if ((8 * sizeof(char) - 1 > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(char) - 1 > 3 * PyLong_SHIFT)) { - return (char) (((char)-1)*(((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); - } - } - break; - case 3: - if ((8 * sizeof(char) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(char) - 1 > 3 * PyLong_SHIFT)) { - return (char) ((((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); - } - } - break; - case -4: - if ((8 * sizeof(char) - 1 > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(char, 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(char) - 1 > 4 * PyLong_SHIFT)) { - return (char) (((char)-1)*(((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); - } - } - break; - case 4: - if ((8 * sizeof(char) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(char, 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(char) - 1 > 4 * PyLong_SHIFT)) { - return (char) ((((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); - } - } - break; - } - } -#endif - if ((sizeof(char) <= sizeof(long))) { - __PYX_VERIFY_RETURN_INT_EXC(char, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(char) <= sizeof(PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(char, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif - } - } - { - char 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 ret = -1; -#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (char) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (char) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (char) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (char) -1; - } else { - stepval = __Pyx_NewRef(v); - } - val = (char) 0; - mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; - shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; - for (bits = 0; bits < (int) sizeof(char) * 8 - chunk_size; bits += chunk_size) { - PyObject *tmp, *digit; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((char) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - idigit = PyLong_AsLong(stepval); - if (unlikely(idigit < 0)) goto done; - remaining_bits = ((int) sizeof(char) * 8) - bits - (is_unsigned ? 0 : 1); - if (unlikely(idigit >= (1L << remaining_bits))) - goto raise_overflow; - val |= ((char) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - if (!is_unsigned) { - if (unlikely(val & (((char) 1) << (sizeof(char) * 8 - 1)))) - goto raise_overflow; - if (is_negative) - val = ~val; - } - ret = 0; - done: - Py_XDECREF(shift); - Py_XDECREF(mask); - Py_XDECREF(stepval); -#endif - Py_DECREF(v); - if (likely(!ret)) - return val; - } - return (char) -1; - } - } else { - char val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (char) -1; - val = __Pyx_PyInt_As_char(tmp); - Py_DECREF(tmp); - return val; - } -raise_overflow: - PyErr_SetString(PyExc_OverflowError, - "value too large to convert to char"); - return (char) -1; -raise_neg_overflow: - PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to char"); - return (char) -1; -} - -/* FormatTypeName */ - #if CYTHON_COMPILING_IN_LIMITED_API -static __Pyx_TypeName -__Pyx_PyType_GetName(PyTypeObject* tp) -{ - PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, - __pyx_n_s_name_2); - if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { - PyErr_Clear(); - Py_XDECREF(name); - name = __Pyx_NewRef(__pyx_n_s__24); - } - return name; -} -#endif - -/* CheckBinaryVersion */ - static unsigned long __Pyx_get_runtime_version(void) { -#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4 - return Py_Version & ~0xFFUL; -#else - const char* rt_version = Py_GetVersion(); - unsigned long version = 0; - unsigned long factor = 0x01000000UL; - unsigned int digit = 0; - int i = 0; - while (factor) { - while ('0' <= rt_version[i] && rt_version[i] <= '9') { - digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); - ++i; - } - version += factor * digit; - if (rt_version[i] != '.') - break; - digit = 0; - factor >>= 8; - ++i; - } - return version; -#endif -} -static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { - const unsigned long MAJOR_MINOR = 0xFFFF0000UL; - if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) - return 0; - if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) - return 1; - { - char message[200]; - PyOS_snprintf(message, sizeof(message), - "compile time Python version %d.%d " - "of module '%.100s' " - "%s " - "runtime version %d.%d", - (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), - __Pyx_MODULE_NAME, - (allow_newer) ? "was newer than" : "does not match", - (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) - ); - return PyErr_WarnEx(NULL, message, 1); - } -} - -/* InitStrings */ - #if PY_MAJOR_VERSION >= 3 -static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { - if (t.is_unicode | t.is_str) { - if (t.intern) { - *str = PyUnicode_InternFromString(t.s); - } else if (t.encoding) { - *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL); - } else { - *str = PyUnicode_FromStringAndSize(t.s, t.n - 1); - } - } else { - *str = PyBytes_FromStringAndSize(t.s, t.n - 1); - } - if (!*str) - return -1; - if (PyObject_Hash(*str) == -1) - return -1; - return 0; -} -#endif -static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { - while (t->p) { - #if PY_MAJOR_VERSION >= 3 - __Pyx_InitString(*t, t->p); - #else - if (t->is_unicode) { - *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); - } else if (t->intern) { - *t->p = PyString_InternFromString(t->s); - } else { - *t->p = PyString_FromStringAndSize(t->s, t->n - 1); - } - if (!*t->p) - return -1; - if (PyObject_Hash(*t->p) == -1) - return -1; - #endif - ++t; - } - return 0; -} - -#include -static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { - size_t len = strlen(s); - if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { - PyErr_SetString(PyExc_OverflowError, "byte string is too long"); - return -1; - } - return (Py_ssize_t) len; -} -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { - Py_ssize_t len = __Pyx_ssize_strlen(c_str); - if (unlikely(len < 0)) return NULL; - return __Pyx_PyUnicode_FromStringAndSize(c_str, len); -} -static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { - Py_ssize_t len = __Pyx_ssize_strlen(c_str); - if (unlikely(len < 0)) return NULL; - return PyByteArray_FromStringAndSize(c_str, len); -} -static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { - Py_ssize_t ignore; - return __Pyx_PyObject_AsStringAndSize(o, &ignore); -} -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT -#if !CYTHON_PEP393_ENABLED -static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { - char* defenc_c; - PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); - if (!defenc) return NULL; - defenc_c = PyBytes_AS_STRING(defenc); -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII - { - char* end = defenc_c + PyBytes_GET_SIZE(defenc); - char* c; - for (c = defenc_c; c < end; c++) { - if ((unsigned char) (*c) >= 128) { - PyUnicode_AsASCIIString(o); - return NULL; - } - } - } -#endif - *length = PyBytes_GET_SIZE(defenc); - return defenc_c; -} -#else -static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { - if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII - if (likely(PyUnicode_IS_ASCII(o))) { - *length = PyUnicode_GET_LENGTH(o); - return PyUnicode_AsUTF8(o); - } else { - PyUnicode_AsASCIIString(o); - return NULL; - } -#else - return PyUnicode_AsUTF8AndSize(o, length); -#endif -} -#endif -#endif -static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT - if ( -#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII - __Pyx_sys_getdefaultencoding_not_ascii && -#endif - PyUnicode_Check(o)) { - return __Pyx_PyUnicode_AsStringAndSize(o, length); - } else -#endif -#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) - if (PyByteArray_Check(o)) { - *length = PyByteArray_GET_SIZE(o); - return PyByteArray_AS_STRING(o); - } else -#endif - { - char* result; - int r = PyBytes_AsStringAndSize(o, &result, length); - if (unlikely(r < 0)) { - return NULL; - } else { - return result; - } - } -} -static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { - int is_true = x == Py_True; - if (is_true | (x == Py_False) | (x == Py_None)) return is_true; - else return PyObject_IsTrue(x); -} -static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { - int retval; - if (unlikely(!x)) return -1; - retval = __Pyx_PyObject_IsTrue(x); - Py_DECREF(x); - return retval; -} -static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { - __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); -#if PY_MAJOR_VERSION >= 3 - if (PyLong_Check(result)) { - if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, - "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " - "The ability to return an instance of a strict subclass of int is deprecated, " - "and may be removed in a future version of Python.", - result_type_name)) { - __Pyx_DECREF_TypeName(result_type_name); - Py_DECREF(result); - return NULL; - } - __Pyx_DECREF_TypeName(result_type_name); - return result; - } -#endif - PyErr_Format(PyExc_TypeError, - "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", - type_name, type_name, result_type_name); - __Pyx_DECREF_TypeName(result_type_name); - Py_DECREF(result); - return NULL; -} -static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { -#if CYTHON_USE_TYPE_SLOTS - PyNumberMethods *m; -#endif - const char *name = NULL; - PyObject *res = NULL; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x) || PyLong_Check(x))) -#else - if (likely(PyLong_Check(x))) -#endif - return __Pyx_NewRef(x); -#if CYTHON_USE_TYPE_SLOTS - m = Py_TYPE(x)->tp_as_number; - #if PY_MAJOR_VERSION < 3 - if (m && m->nb_int) { - name = "int"; - res = m->nb_int(x); - } - else if (m && m->nb_long) { - name = "long"; - res = m->nb_long(x); - } - #else - if (likely(m && m->nb_int)) { - name = "int"; - res = m->nb_int(x); - } - #endif -#else - if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { - res = PyNumber_Int(x); - } -#endif - if (likely(res)) { -#if PY_MAJOR_VERSION < 3 - if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { -#else - if (unlikely(!PyLong_CheckExact(res))) { -#endif - return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); - } - } - else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_TypeError, - "an integer is required"); - } - return res; -} -static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { - Py_ssize_t ival; - PyObject *x; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_CheckExact(b))) { - if (sizeof(Py_ssize_t) >= sizeof(long)) - return PyInt_AS_LONG(b); - else - return PyInt_AsSsize_t(b); - } -#endif - if (likely(PyLong_CheckExact(b))) { - #if CYTHON_USE_PYLONG_INTERNALS - if (likely(__Pyx_PyLong_IsCompact(b))) { - return __Pyx_PyLong_CompactValue(b); - } else { - const digit* digits = __Pyx_PyLong_Digits(b); - const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); - switch (size) { - case 2: - if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { - return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case -2: - if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { - return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case 3: - if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { - return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case -3: - if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { - return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case 4: - if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { - return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case -4: - if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { - return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - } - } - #endif - return PyLong_AsSsize_t(b); - } - x = PyNumber_Index(b); - if (!x) return -1; - ival = PyInt_AsSsize_t(x); - Py_DECREF(x); - return ival; -} -static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { - if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { - return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); -#if PY_MAJOR_VERSION < 3 - } else if (likely(PyInt_CheckExact(o))) { - return PyInt_AS_LONG(o); -#endif - } else { - Py_ssize_t ival; - PyObject *x; - x = PyNumber_Index(o); - if (!x) return -1; - ival = PyInt_AsLong(x); - Py_DECREF(x); - return ival; - } -} -static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { - return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); -} -static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { - return PyInt_FromSize_t(ival); -} - - -/* #### Code section: utility_code_pragmas_end ### */ -#ifdef _MSC_VER -#pragma warning( pop ) -#endif - - - -/* #### Code section: end ### */ -#endif /* Py_PYTHON_H */ diff --git a/robo_utils/core.pyx b/robo_utils/core.pyx deleted file mode 100644 index 8829985..0000000 --- a/robo_utils/core.pyx +++ /dev/null @@ -1,116 +0,0 @@ -cimport cython - -from cython.parallel import prange - -import numpy as np - -from libc.stdlib cimport rand, RAND_MAX -from libc.math cimport floor - -cdef int round_to_int(float x) nogil: - return (x + 0.5) - -@cython.cdivision(True) -@cython.boundscheck(False) -@cython.wraparound(False) -cdef void float_to_int_duration_each(float[:] dur, int[:] int_dur, int T, int[:] mask) nogil: - """ - Convert float duration to int duration - - Args: - dur (float[:]): input float duration, shape (I,) - int_dur (int[:]): output int duration, shape (I,) - T (int): total duration - mask (int[:]): mask, shape (I,) - """ - cdef int I = dur.shape[0] - cdef float float_sum = 0 - cdef int int_sum = 0, i, rounded_dur, valid_count - valid_count = 0 - - for i in range(I): - if mask[i] == 1: - valid_count += 1 - float_sum += dur[i] - rounded_dur = round_to_int(float_sum - int_sum) - if rounded_dur <= 0: - rounded_dur = 1 # Ensure each duration is greater than 0 - int_dur[i] = rounded_dur - int_sum += rounded_dur - else: - break - - # Adjust the durations to ensure they are valid - cdef int remaining_time, j - if valid_count > 0: - remaining_time = T - int_sum - j = valid_count - 1 - while j >= 0: - if int_dur[j] + remaining_time >= 1: - int_dur[j] += remaining_time - break - else: - remaining_time += int_dur[j] - 1 - int_dur[j] = 1 - j -= 1 - -@cython.boundscheck(False) -@cython.wraparound(False) -cpdef void float_to_int_duration_batch_c(float[:, :] dur, int[:] T, int[:, :] mask, int[:, :] int_dur) nogil: - """ - Args: - dur (float[:, :]): float duration, shape (B, I) - T (int[:]): total duration, shape (B,) - mask (int[:, :]): mask, shape (B, I) - int_dur (int[:, :]): int duration, shape (B, I) - """ - cdef int B = dur.shape[0] - cdef int i - for i in prange(B, nogil=True): - float_to_int_duration_each(dur[i], int_dur[i], T[i], mask[i]) - -cdef int generate_random(int start, int end) nogil: - # generate a random integer in [start, end) - return start + ((end - start) * (rand() / RAND_MAX)) - -@cython.cdivision(True) -@cython.boundscheck(False) -@cython.wraparound(False) -cdef void generate_random_intervals_each(int[:] boundaries, int[:] result, int num_randoms) nogil: - """ - Generate random intervals for a single batch - - Args: - boundaries (int[:]): input boundaries, shape (N,) - result (int[:]): output random values, shape ((N-1) * (num_randoms + 1),) - num_randoms (int): number of random values to generate per interval - """ - cdef int N = boundaries.shape[0] - cdef int idx = 0 - cdef int i, j - - for i in range(N - 1): - start = boundaries[i] - end = boundaries[i + 1] - if end == 0 and i > 0: - break - for j in range(num_randoms): - result[idx + j] = generate_random(start, end) - result[idx + num_randoms] = end - idx += (num_randoms + 1) - -@cython.boundscheck(False) -@cython.wraparound(False) -cpdef void generate_random_intervals_batch_c(int[:, :] boundaries_batch, int[:, :] result_batch, int num_randoms) nogil: - """ - Generate random intervals for a batch of boundaries - - Args: - boundaries_batch (int[:, :]): input boundaries, shape (B, N) - result_batch (int[:, :]): output random values, shape (B, (N-1) * num_randoms) - num_randoms (int): number of random values to generate per interval - """ - cdef int B = boundaries_batch.shape[0] - cdef int i - for i in prange(B, nogil=True): - generate_random_intervals_each(boundaries_batch[i], result_batch[i], num_randoms) \ No newline at end of file diff --git a/robo_utils/robo_utils/core.cpython-39-x86_64-linux-gnu.so b/robo_utils/robo_utils/core.cpython-39-x86_64-linux-gnu.so deleted file mode 100755 index 814bbbee2fb8315c493686e138b75061fe9c1311..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 207016 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 diff --git a/robo_utils/setup.py b/robo_utils/setup.py deleted file mode 100644 index 1d2ba05..0000000 --- a/robo_utils/setup.py +++ /dev/null @@ -1,11 +0,0 @@ -from distutils.core import setup -from Cython.Build import cythonize -import numpy - -setup( - name = 'robo_utils', - ext_modules=cythonize("core.pyx"), - include_dirs=[numpy.get_include()] -) - -# cd robo_utils; mkdir robo_utils; python setup.py build_ext --inplace \ No newline at end of file diff --git a/romo_aligner.py b/romo_aligner.py deleted file mode 100644 index 1ed2abf..0000000 --- a/romo_aligner.py +++ /dev/null @@ -1,399 +0,0 @@ -import warnings -from typing import List, Optional, Tuple - -import numpy as np -import torch -import torch.nn as nn -import torch.nn.functional as F -from espnet.nets.pytorch_backend.conformer.encoder import Encoder as ConformerEncoder - -from layers import LinearNorm -from rough_aligner import RoughAligner -from mobo_aligner import MoBoAligner -from tensor_utils import get_mat_p_f, get_valid_max, cal_max_hidden_memory_size -import robo_utils - -class RoMoAligner(nn.Module): - def __init__( - self, - text_embeddings, - mel_embeddings, - attention_dim, - attention_head, - conformer_linear_units, - conformer_num_blocks, - conformer_enc_kernel_size, - conformer_dec_kernel_size, - skip_text_conformer=False, - skip_mel_conformer=False, - skip_rough_aligner=False, - dropout=0.1, - noise_scale=2.0, # the scale of the noise used in the MoBo aligner - max_dur=10, # the maximum duration of the MoBo aligner - num_candidate_boundaries=3, # number of candidate boundaries inserted between every two tokens - verbose=False, # whether to print the memory size of the hidden state - ): - super(RoMoAligner, self).__init__() - - if num_candidate_boundaries < 1: - raise ValueError( - "The number of boundary candidates must be greater than or equal to 1." - ) - - if num_candidate_boundaries + 1 > max_dur: # for MoBo Aligner - raise ValueError( - "The number of boundary candidates must be less than or equal to max_dur. Trt to decrease the number of boundary candidates or increase the max_dur." - ) - - self.text_fc = LinearNorm(text_embeddings, attention_dim) - if not skip_text_conformer: - self.text_conformer = ConformerEncoder( - idim=0, - attention_dim=attention_dim, - attention_heads=attention_head, - linear_units=conformer_linear_units, - num_blocks=conformer_num_blocks, - input_layer=None, - dropout_rate=dropout, - positional_dropout_rate=dropout, - attention_dropout_rate=dropout, - normalize_before=True, - concat_after=False, - positionwise_layer_type="conv1d", - positionwise_conv_kernel_size=3, - macaron_style=True, - pos_enc_layer_type="rel_pos", - selfattention_layer_type="rel_selfattn", - activation_type="swish", - use_cnn_module=True, - cnn_module_kernel=conformer_enc_kernel_size, - ) - - self.mel_fc = LinearNorm(mel_embeddings, attention_dim) - if not skip_mel_conformer: - self.mel_conformer = ConformerEncoder( - idim=0, - attention_dim=attention_dim, - attention_heads=attention_head, - linear_units=conformer_linear_units, - num_blocks=conformer_num_blocks, - input_layer=None, - dropout_rate=dropout, - positional_dropout_rate=dropout, - attention_dropout_rate=dropout, - normalize_before=True, - concat_after=False, - positionwise_layer_type="conv1d", - positionwise_conv_kernel_size=3, - macaron_style=True, - pos_enc_layer_type="rel_pos", - selfattention_layer_type="rel_selfattn", - activation_type="swish", - use_cnn_module=True, - cnn_module_kernel=conformer_dec_kernel_size, - ) - - if not skip_rough_aligner: - self.rough_aligner = RoughAligner(attention_dim, attention_head, dropout) - self.mobo_aligner = MoBoAligner( - attention_dim, attention_dim, attention_dim, noise_scale, max_dur - ) - self.max_dur = max_dur - - if skip_text_conformer or skip_mel_conformer: - warnings.warn( - "Beacause alignment need positional information, please ensure that the input to the RoMoAligner contains positional information along the time dimension." - ) - self.num_candidate_boundaries = num_candidate_boundaries - self.skip_text_conformer = skip_text_conformer - self.skip_mel_conformer = skip_mel_conformer - self.skip_rough_aligner = skip_rough_aligner - self.verbose = verbose - - def encoder(self, text_embeddings, mel_embeddings, text_mask, mel_mask): - """ - Encode the input text and mel embeddings using the Conformer. - - Args: - text_embeddings (torch.FloatTensor): The input text embeddings, with a shape of (B, I, C1). - mel_embeddings (torch.FloatTensor): The input mel embeddings, with a shape of (B, J, C2). - text_mask (torch.BoolTensor): The mask for the input text, with a shape of (B, I). - mel_mask (torch.BoolTensor): The mask for the input mel, with a shape of (B, J). - Returns: - text_hiddens (torch.FloatTensor): The hidden sequence of the input text, with a shape of (B, I, H). - mel_hiddens (torch.FloatTensor): The hidden sequence of the input mel, with a shape of (B, J, H). - """ - text_hiddens = self.text_fc(text_embeddings) * text_mask.unsqueeze(2) - mel_hiddens = self.mel_fc(mel_embeddings) * mel_mask.unsqueeze(2) - - if not self.skip_text_conformer: - text_hiddens, _ = self.text_conformer(text_hiddens, text_mask.unsqueeze(1)) - text_hiddens = text_hiddens * text_mask.unsqueeze(2) - - if not self.skip_mel_conformer: - mel_hiddens, _ = self.mel_conformer(mel_hiddens, mel_mask.unsqueeze(1)) - mel_hiddens = mel_hiddens * mel_mask.unsqueeze(2) - - return text_hiddens, mel_hiddens - - @torch.no_grad() - def get_nearest_boundaries(self, int_dur, text_mask): - """ - Calculate the possible boundaries of each text token based on the results of the rough aligner. - If the length of text tokens is I, the number of possible boundaries is approximately K ≈ I*(2*D+1), where 2D+1 represents last, current, and next and D is num_boundary_candidates_one_side. - - Args: - int_dur (torch.LongTensor): The integer duration sequence, with a shape of (B, I). - text_mask (torch.BoolTensor): The mask for the input text, with a shape of (B, I). - - Returns: - unique_indices (torch.LongTensor): The indices of the possible boundaries, with a shape of (B, I, K). - unique_indices_mask (torch.BoolTensor): The mask for the possible boundaries, with a shape of (B, I, K). - """ - - boundary_index = (int_dur.cumsum(1) - 1) * text_mask - min_index, max_index = get_valid_max(boundary_index, text_mask) - - indices = robo_utils.generate_random_intervals(boundary_index, self.num_candidate_boundaries) - indices = torch.clamp(indices, min=min_index, max=max_index) - - unique_indices = (torch.unique(i) for i in indices) - unique_indices = torch.nn.utils.rnn.pad_sequence( - unique_indices, batch_first=True, padding_value=-1 - ) - - unique_indices_mask = unique_indices != -1 - unique_indices = unique_indices * unique_indices_mask - - return unique_indices, unique_indices_mask - - def select_mel_hiddens(self, mel_hiddens, int_dur_by_rough, text_mask): - """ - Selects the corresponding mel_hiddens according to the possible boundary indices predicted by the rough aligner. - - Args: - mel_hiddens (torch.FloatTensor): The original mel feature sequence, with a shape of (B, J, C). - int_dur_by_rough (torch.LongTensor): The integer duration sequence predicted by the rough aligner, with a shape of (B, I). - text_mask (torch.BoolTensor): The mask for the input text, with a shape of (B, I). - - Returns: - selected_boundary_indices (torch.LongTensor): The selected boundary indices, with a shape of (B, K). - selected_boundary_indices_mask (torch.BoolTensor): The mask for the selected boundary indices, with a shape of (B, K). - selected_mel_hiddens (torch.FloatTensor): The selected mel hidden sequence, with a shape of (B, K, C). - """ - selected_boundary_indices, selected_boundary_indices_mask = ( - self.get_nearest_boundaries(int_dur_by_rough, text_mask) - ) - - mel_channels = mel_hiddens.shape[2] - - selected_mel_hiddens = torch.gather( - mel_hiddens, - 1, - selected_boundary_indices.unsqueeze(-1).expand(-1, -1, mel_channels), - ) - - selected_mel_hiddens = ( - selected_mel_hiddens * selected_boundary_indices_mask.unsqueeze(-1) - ) - - return ( - selected_boundary_indices, - selected_boundary_indices_mask, - selected_mel_hiddens, - ) - - def get_mat_p_f( - self, - mat_p_d, - hard_mat_p_d, - selected_boundary_indices, - selected_boundary_indices_mask, - ): - """ - Calculate the mat_d_f matrix (a hard alignment) based on the selected boundary indices - - Args: - mat_p_d (torch.FloatTensor): The soft alignment matrix, with a shape of (B, I, K). - hard_mat_p_d (torch.FloatTensor): The hard alignment matrix, with a shape of (B, I, K). - selected_boundary_indices (torch.LongTensor): The indices of the possible boundaries, with a shape of (B, K). - selected_boundary_indices_mask (torch.BoolTensor): The mask for the possible boundaries, with a shape of (B, K). - - Returns: - mat_p_f (torch.FloatTensor): The hard alignment matrix, with a shape of (B, I, J). - hard_mat_p_f (torch.FloatTensor): The hard alignment matrix, with a shape of (B, I, J). - dur_by_mobo (torch.FloatTensor): The duration searched by the MoBo aligner (hard alignment mode), with a shape of (B, I). - """ - repeat_times = F.pad( - selected_boundary_indices, (1, 0), mode="constant", value=-1 - ).diff(1) - repeat_times = repeat_times * selected_boundary_indices_mask - mat_d_f = get_mat_p_f( - mat_p_d.transpose(1, 2), repeat_times - ) # (B, K, I) -> (B, K, J) - - mat_p_f = torch.bmm(mat_p_d, mat_d_f) - hard_mat_p_f = torch.bmm(hard_mat_p_d, mat_d_f) - dur_by_mobo = hard_mat_p_f.sum(2) - - return mat_p_f, hard_mat_p_f, dur_by_mobo - - def forward( - self, - text_embeddings: torch.FloatTensor, - mel_embeddings: torch.FloatTensor, - text_mask: torch.BoolTensor, - mel_mask: torch.BoolTensor, - direction: List[str], - ) -> Tuple[ - torch.FloatTensor, - torch.FloatTensor, - torch.FloatTensor, - torch.FloatTensor, - torch.FloatTensor, - ]: - """ - Args: - text_embeddings (torch.FloatTensor): The input text embeddings, with a shape of (B, I, C1). - mel_embeddings (torch.FloatTensor): The input mel embeddings, with a shape of (B, J, C2). - text_mask (torch.BoolTensor): The mask for the input text, with a shape of (B, I). - mel_mask (torch.BoolTensor): The mask for the input mel, with a shape of (B, J). - direction (List[str]): The direction of the alignment, can be "forward" or "backward". - Returns: - mat_p_f (torch.FloatTensor): The soft alignment matrix, with a shape of (B, I, J). - hard_mat_p_f (torch.FloatTensor): The hard alignment matrix, with a shape of (B, I, J). - expanded_text_embeddings (torch.FloatTensor): The expanded text embeddings, with a shape of (B, J, C1). - dur_by_rough (torch.FloatTensor): The duration predicted by the rough aligner, with a shape of (B, I). - dur_by_mobo (torch.FloatTensor): The duration searched by the MoBo aligner (hard alignment mode), with a shape of (B, I). - """ - text_hiddens, mel_hiddens = self.encoder( - text_embeddings, mel_embeddings, text_mask, mel_mask - ) - - if not self.skip_rough_aligner: - dur_by_rough, int_dur_by_rough = self.rough_aligner( - text_hiddens, mel_hiddens, text_mask, mel_mask - ) - - # Select the corresponding mel_hiddens based on the possible boundary indices - ( - selected_boundary_indices, - selected_boundary_indices_mask, - selected_mel_hiddens, - ) = self.select_mel_hiddens(mel_hiddens, int_dur_by_rough, text_mask) - - if self.verbose: - cal_max_hidden_memory_size(selected_boundary_indices, self.max_dur, text_mask) - else: - selected_mel_hiddens = mel_hiddens - selected_boundary_indices_mask = mel_mask - dur_by_rough = None - - # Run a fine-grained MoBoAligner - mat_p_d, hard_mat_p_d = self.mobo_aligner( - text_hiddens, - selected_mel_hiddens, - text_mask, - selected_boundary_indices_mask, - direction, - return_hard_alignment=True, - ) - - if not self.skip_rough_aligner: - # mat_p_d * mat_d_f (computed by selected_boundary_indices) = mat_p_f - mat_p_f, hard_mat_p_f, dur_by_mobo = self.get_mat_p_f( - mat_p_d, - hard_mat_p_d, - selected_boundary_indices, - selected_boundary_indices_mask, - ) - else: - mat_p_f = mat_p_d - hard_mat_p_f = hard_mat_p_d - dur_by_mobo = None - - # Use mat_p_f to compute the expanded text_embeddings - expanded_text_embeddings = mat_p_f.transpose(1, 2) @ text_embeddings - - return ( - mat_p_f, # has grad - hard_mat_p_f, # no grad - expanded_text_embeddings, # has grad - dur_by_rough, # has grad - dur_by_mobo, # no grad - ) - - -if __name__ == "__main__": - torch.manual_seed(0) - - text_embeddings = 10 - mel_embeddings = 20 - attention_dim = 128 - attention_head = 8 - dropout = 0.1 - noise_scale = 2.0 - - aligner = RoMoAligner( - text_embeddings=text_embeddings, - mel_embeddings=mel_embeddings, - attention_dim=128, - attention_head=2, - conformer_linear_units=256, - conformer_num_blocks=2, - conformer_enc_kernel_size=7, - conformer_dec_kernel_size=31, - skip_text_conformer=False, - skip_mel_conformer=False, - num_candidate_boundaries=3, - verbose=True, - ) - - batch_size = 2 - text_len = 5 - mel_len = 30 - device = "cpu" - - aligner = aligner.to(device) - - text_embeddings = torch.randn( - batch_size, text_len, text_embeddings, requires_grad=True, device=device - ) - mel_embeddings = torch.randn( - batch_size, mel_len, mel_embeddings, requires_grad=True, device=device - ) - text_mask = torch.ones(batch_size, text_len, device=device).bool() - mel_mask = torch.ones(batch_size, mel_len, device=device).bool() - text_mask[1, 3:] = False - mel_mask[1, 7:] = False - - ( - soft_alignment, - hard_alignment, - expanded_text_embeddings, - dur_by_rough, - dur_by_mobo, - ) = aligner( - text_embeddings, - mel_embeddings, - text_mask, - mel_mask, - direction=["forward", "backward"], - ) - - print("Soft alignment shape:", soft_alignment.shape) - print("Hard alignment shape:", hard_alignment.shape) - print("Expanded text embeddings shape:", expanded_text_embeddings.shape) - - # Backward pass test - dur_by_mobo = (dur_by_mobo + 1).log() # computed by hard alignment, no gradient - dur_by_rough = (dur_by_rough + 1).log() - dur_loss = F.mse_loss(dur_by_rough, dur_by_mobo, reduction="mean") - loss = dur_loss + expanded_text_embeddings.mean() - with torch.autograd.detect_anomaly(): - loss.backward() - - print("Gradient for text_embeddings:") - print(text_embeddings.grad.mean()) - print("Gradient for mel_embeddings:") - print(mel_embeddings.grad.mean()) diff --git a/rough_aligner.py b/rough_aligner.py deleted file mode 100644 index a8f06b5..0000000 --- a/rough_aligner.py +++ /dev/null @@ -1,71 +0,0 @@ -import torch -import torch.nn as nn -import torch.nn.functional as F -from espnet.nets.pytorch_backend.transformer.attention import MultiHeadedAttention - -from layers import LinearNorm -import robo_utils - - -class RoughAligner(nn.Module): - def __init__(self, attention_dim, attention_head, dropout): - super(RoughAligner, self).__init__() - - self.cross_attention = MultiHeadedAttention( - attention_head, attention_dim, dropout - ) - - def forward(self, text_embeddings, mel_embeddings, text_mask, mel_mask): - """ - Compute the normalized durations of each text token based on the cross-attention of the text and mel embeddings. - - Args: - text_embeddings (torch.Tensor): The text embeddings of shape (B, I, H). - mel_embeddings (torch.Tensor): The mel embeddings of shape (B, J, H). - text_mask (torch.Tensor): The text mask of shape (B, I). - mel_mask (torch.Tensor): The mel mask of shape (B, J). - - Returns: - float_dur (torch.Tensor): The float durations of each text token, with shape (B, I), which the sum of each row may not be equal to the corresponding mel length. - int_dur (torch.Tensor): The integer durations of each text token, with shape (B, I), which the sum of each row is equal to the corresponding mel length. - """ - - self.cross_attention( - mel_embeddings, text_embeddings, text_embeddings, text_mask.unsqueeze(1) - ) - attn = self.cross_attention.attn - x = attn.sum(2).transpose(1, 2) # (B, I, head) - x = x.mean(-1) # (B, I) - float_dur = F.relu(x) * text_mask - - T = mel_mask.sum(dim=1) - int_dur = robo_utils.float_to_int_duration(float_dur, T, text_mask) - - return float_dur, int_dur - - -if __name__ == "__main__": - torch.manual_seed(0) - - attention_dim = 128 - attention_head = 8 - dropout = 0.1 - - aligner = RoughAligner(attention_dim, attention_head, dropout) - - batch_size = 2 - text_len = 5 - audio_len = 30 - - text_embeddings = torch.randn(batch_size, text_len, attention_dim) - audio_embeddings = torch.randn(batch_size, audio_len, attention_dim) - text_mask = torch.ones(batch_size, text_len).bool() - audio_mask = torch.ones(batch_size, audio_len).bool() - - text_mask[1, 3:] = False - audio_mask[1, 7:] = False - - durations_normalized = aligner( - text_embeddings, audio_embeddings, text_mask, audio_mask - ) - print(durations_normalized) diff --git a/tensor_utils.py b/tensor_utils.py deleted file mode 100644 index 811afc4..0000000 --- a/tensor_utils.py +++ /dev/null @@ -1,537 +0,0 @@ -import math - -import torch -import torch.nn.functional as F -import numpy as np - -# Define a very small logarithmic value to replace -float("inf") in logarithmic calculations -LOG_EPS = -1000 -# Calculate the natural logarithm of 2 and store it for repeated use to improve efficiency -LOG_2 = math.log(2.0) - - -def compute_alignment_mask(text_mask, mel_mask): - """ - Compute the alignment mask for the given text and mel masks. - - Args: - text_mask (torch.BoolTensor): The text mask of shape (B, I) for forward or (B, I-1) for backward. - mel_mask (torch.BoolTensor): The mel mask of shape (B, J) for forward or (B, J-1) for backward. - - Returns: - alignment_mask (torch.BoolTensor): The alignment mask of shape (B, I, J) for forward or (B, I-1, J-1) for backward. - """ - return text_mask.unsqueeze(-1) * mel_mask.unsqueeze(1) # (B, I, J) - - -def roll_tensor(tensor, shifts, dim): - """ - Right shift the multi-dimensional tensor (2D or 3D or 4D...) along the given dimension. - - Args: - tensor (torch.Tensor): The input tensor of shape (B, I) or (B, I, J) or (B, I, J, K) or .... - shifts (torch.Tensor): The shift amounts along the dimension of shape (B,) - dim (int): The dimension to roll. - - Returns: - result (torch.Tensor): The rolled tensor of shape (B, I) or (B, I, J) or (B, I, J, K) or .... - """ - - # Get the shape of the tensor - shape = tensor.size() - - # Ensure that dim is within the valid range - assert dim >= 0 and dim < len(shape), "Invalid hidden" - - # Generate an index tensor - indices = ( - torch.arange(shape[dim], device=tensor.device) - .view([1] * dim + [-1] + [1] * (len(shape) - dim - 1)) - .expand(shape) - ) - - # Reshape shifts - shifts = shifts.view([-1] + [1] * (len(shape) - 1)) - - # Calculate the shifted indices - shifted_indices = (indices - shifts) % shape[dim] - - # Use the shifted indices to index the tensor - result = tensor.gather(dim, shifted_indices.expand(shape)) - - return result - - -def shift_tensor(x, shifts_text_dim, shifts_mel_dim): - """ - Shift the tensor x to the right along the text and mel hiddens. - - Args: - x (torch.Tensor): The input tensor of shape (B, I, J, K). - shifts_text_dim (torch.Tensor): The shift amounts along the text hidden of shape (B,). - shifts_mel_dim (torch.Tensor): The shift amounts along the mel hidden of shape (B,). - - Returns: - x (torch.Tensor): The right-shifted tensor of shape (B, I, J, K). - """ - x = roll_tensor(x, shifts=shifts_text_dim, dim=1) - x = roll_tensor(x, shifts=shifts_mel_dim, dim=2) - return x - - -def log_one_hot(I, device): - """ - Generate a log one-hot vector of shape (I,) on the device. - """ - x = torch.full((I,), LOG_EPS, device=device) - x[0] = 0 - return x - - -def pad_and_reverse_alignment(log_interval_backward, text_mask_backward, mel_mask_backward): - """ - Reverse the alignment and pad the boundary matrix for backward. - - Args: - log_interval_backward (torch.Tensor): The log boundary matrix of shape (B, I-1, J-1). - text_mask_backward (torch.Tensor): The text mask of shape (B, I-1). - mel_mask_backward (torch.Tensor): The mel spectrogram mask of shape (B, J-1). - - Returns: - log_interval_backward (torch.Tensor): The reversed and padded alignment matrix of shape (B, I, J). - """ - B, I_minus_1, _ = log_interval_backward.shape - log_interval_backward = F.pad( - log_interval_backward, (0, 0, 1, 0, 0, 0), "constant", LOG_EPS - ) # (B, I, J-1) - - onehot = log_one_hot(I_minus_1 + 1, device=log_interval_backward.device)[ - None, :, None - ].repeat(B, 1, 1) - log_interval_backward = torch.cat( - (onehot, log_interval_backward), dim=2 - ) # (B, I, J) - - shifts_text_dim = compute_max_length_diff(text_mask_backward) - shifts_mel_dim = compute_max_length_diff(mel_mask_backward) - log_interval_backward = shift_tensor( - log_interval_backward.flip(1, 2), - shifts_text_dim=-shifts_text_dim, - shifts_mel_dim=-shifts_mel_dim, - ) - return log_interval_backward - - -def compute_max_length_diff(mask): - # returned value is always >= 0 - lengths = mask.sum(1) - return lengths.max() - lengths - - -def arange_for_left(lens: torch.LongTensor) -> torch.LongTensor: - """ - gen arange from 0. - - Args: - lens (torch.LongTensor): The length tensor of shape (B,). - - Returns: - x (torch.LongTensor): The arange tensor of shape (B, I). - """ - B = len(lens) - I = lens.max() - x = torch.arange(I, device=lens.device).unsqueeze(0).repeat(B, 1) - mask = x >= lens.unsqueeze(1) - x.masked_fill_(mask, 0) - return x - - -def arange_for_right( - i_lens: torch.LongTensor, j_lens: torch.LongTensor -) -> torch.LongTensor: - """ - gen arange from j_lens - i_lens. - - Args: - i_lens (torch.LongTensor): The text length tensor of shape (B,). - j_lens (torch.LongTensor): The mel length tensor of shape (B,). - - Returns: - x (torch.LongTensor): The arange tensor of shape (B, I). - """ - B = len(i_lens) - I = i_lens.max() - strat = j_lens - i_lens - x = torch.arange(I, device=i_lens.device).unsqueeze(0).repeat( - B, 1 - ) + strat.unsqueeze(1) - mask = x >= j_lens.unsqueeze(1) - x.masked_fill_(mask, 0) - return x - - -def gen_left_right_mask( - B: int, - I: int, - D: int, - J: int, - text_mask: torch.BoolTensor, - mel_mask: torch.BoolTensor, -) -> torch.BoolTensor: - """ - Generate a mask which mask the impossible boundary mel index range. - - Args: - B (int): The batch size. - I (int): The number of text hiddens. - D (int): The number of candidate mel hiddens. - J (int): The number of mel hiddens. - text_mask (torch.BoolTensor): The text mask of shape (B, I). - mel_mask (torch.BoolTensor): The mel mask of shape (B, J). - - Returns: - mask (torch.BoolTensor): The mask of shape (B, I, D, J), in which True means valid, False means invalid. - arange_for_left is used to generate the left triangle marked with "-", arange_for_right is used to generate the right triangle marked with "-". - - - - + + + + - - - - - + + + + - - - - - + + + + - - - - - + + + + - - - - - - """ - i_lens = text_mask.sum(1).long() - j_lens = mel_mask.sum(1).long() - - indices_d = torch.arange(D, device=i_lens.device)[:, None] - indices_j = torch.arange(J, device=i_lens.device)[None, :] - indices = (indices_d + indices_j).unsqueeze(0).unsqueeze(0).repeat(B, I, 1, 1) - - mask_b = ( - indices > (arange_for_left(i_lens) - 1)[:, :, None, None] - ) # True means valid, False means invalid. - mask_e = ( - indices <= arange_for_right(i_lens, j_lens)[:, :, None, None] - ) # True means valid, False means invalid. - mask = (mask_b & mask_e) * text_mask.unsqueeze(-1).unsqueeze(-1) - return mask - - -def convert_geq_to_gt(log_cond_prob_geq_backward): - """ - "greater than or equal to" format to "greater than" format - - Args: - log_cond_prob_geq_backward (torch.FloatTensor): The log cumulative conditional probability tensor of shape (B, I-1, D+1, J-1). - - Returns: - log_cond_prob_geq_backward (torch.FloatTensor): The log cumulative conditional probability tensor of shape (B, I-1, D, J-1). - """ - return log_cond_prob_geq_backward[:, :, 1:] - - -def get_valid_max(tensor, mask, inf_value=1e6): - """ - Calculate the minimum and maximum values of the valid elements in the given 2D tensor. - - Args: - tensor (torch.FloatTensor): The input tensor of shape (B, L). - mask (torch.BoolTensor): The mask tensor of shape (B, L), valid elements are 1, invalid elements are 0. - inf_value (float): The value to use for masking invalid elements. - - Returns: - min_values (torch.FloatTensor): The minimum value of the valid elements in each sample, shape (B, 1) - max_values (torch.FloatTensor): The maximum value of the valid elements in each sample, shape (B, 1) - """ - masked_tensor = tensor.masked_fill(~mask, inf_value) - min_values, _ = torch.min(masked_tensor, dim=1) - - masked_tensor = tensor.masked_fill(~mask, -inf_value) - max_values, _ = torch.max(masked_tensor, dim=1) - - min_values = min_values.unsqueeze(1) - max_values = max_values.unsqueeze(1) - - return min_values, max_values - - -def lengths_to_padding_mask( - lens: torch.LongTensor, max_lens: int = None -) -> torch.BoolTensor: - bsz = lens.size(0) - if max_lens is None: - max_lens = torch.max(lens).item() - mask = torch.arange(max_lens).to(lens.device).view(1, max_lens) - mask = mask.expand(bsz, -1) >= lens.view(bsz, 1).expand(-1, max_lens) - return mask - - -def lengths_to_mask(lens: torch.LongTensor, max_lens: int = None) -> torch.BoolTensor: - return ~lengths_to_padding_mask(lens, max_lens) - - -def get_mat_p_f(src_tokens, durations): - """ - Calculate the mapping matrix (mat_p_f) from the text tokens, e.g. phone, to the mel spectrograms. - - Args: - src_tokens (torch.FloatTensor): The input tensor of shape (B, L, C). - durations (torch.LongTensor): The duration tensor of shape (B, L). - - Returns: - mat_p_f (torch.FloatTensor): The mapping matrix of shape (B, L, T). - """ - assert ( - src_tokens.shape[:2] == durations.shape - ), "src_tokens and durations should have the same batch size and length" - B, L, _ = src_tokens.shape - T = durations.sum(axis=-1).max() - cumsum_dur_1 = torch.cumsum(durations, dim=-1) # [B, L] - cumsum_dur_0 = cumsum_dur_1 - durations # [B, L] - - mask1 = lengths_to_mask(cumsum_dur_1.flatten(), T).reshape(B, L, T) - mask0 = lengths_to_mask(cumsum_dur_0.flatten(), T).reshape(B, L, T) - mat_p_f = (mask1 & ~mask0).float() - return mat_p_f - - -def calculate_tensor_memory_size(shape, dtype): - """ - Calculate the memory size of a tensor in MB. - - Args: - shape (tuple): The shape of the tensor. - dtype (torch.dtype): The data type of the tensor. - - Returns: - float: The memory size of the tensor in MB. - """ - total_elements = 1 - for dim in shape: - total_elements *= dim - - dtype_size = torch.tensor([], dtype=dtype, device="cpu").element_size() - memory_size_in_bytes = total_elements * dtype_size - memory_size_in_mb = memory_size_in_bytes / (1024 * 1024) - return memory_size_in_mb - - -def cal_max_hidden_memory_size(selected_boundary_indices, D, text_mask): - B, K = selected_boundary_indices.shape - _, I = text_mask.shape - shape = (B, I, D, K) # max tensor shape in MoBo aligner - dtype = torch.float32 - memory_size_mb = calculate_tensor_memory_size(shape, dtype) - print( - f"Memory size for tensor with shape {shape} and dtype {dtype}: {memory_size_mb:.2f} MB" - ) - - -def diag_logsumexp(x, from_ind): - """ - Calculate the logsumexp of the diagonals of a 3D tensor, from the diagonal with index from_ind to the main diagonal. - - Args: - x (torch.FloatTensor): The input tensor of shape (B, I, J). - from_ind (int): The index of the diagonal to start from. - - Returns: - x (torch.FloatTensor): The logsumexp of the diagonals of the input tensor of shape (B, J). - """ - B, I, J = x.size() - assert from_ind < J, "from_ind should be less than J" - x = x.permute(1, 0, 2) # (I, B, J) - x = roll_tensor(x, shifts=torch.arange(I, device=x.device), dim=2) # (I, B, J) - - mask = ( - torch.tril(torch.ones((I, J), device=x.device), diagonal=-1) - .unsqueeze(1) - .repeat(1, B, 1) - .bool() - ) - x.masked_fill_(mask, LOG_EPS) - x = x.permute(1, 0, 2) # (B, I, J) - x = x[:, :, from_ind:].logsumexp(1) - return x - - -def BIJ_to_BIK(Bij): - """ - from j index (j = 1...J) to k index (k = 0...J-1) and drop the last text index. - - Args: - Bij (torch.Tensor): The input tensor of shape (B, I+1, J+1) for forward, or (B, I, J) for backward. - - Returns: - Bij (torch.Tensor): The output tensor of shape (B, I, J) for forward, or (B, I-1, J-1) for backward. - """ - Bij = Bij[:, :-1, :-1] - return Bij - - -def BIJ_to_BIDK(x, D, padding_direction="left"): - """ - Transform BIJ to BIDK format. - - Args: - x (torch.FloatTensor): The input tensor of shape (B, I, J). - D (int): The max duration of text tokens. - padding_direction (str): The direction of padding. - - Return: - y (torch.FloatTensor): The output tensor of shape (B, I, D, K). - """ - if padding_direction == "left": - x = F.pad( - x, (D - 1, 0, 0, 0, 0, 0), mode="constant", value=LOG_EPS - ) # (B, I, J+D-1), padding at the beginning of j index - elif padding_direction == "right": - x = F.pad( - x, (0, D - 1, 0, 0, 0, 0), mode="constant", value=LOG_EPS - ) # (B, I, J+D-1), padding at the end of j index - else: - raise ValueError("Invalid padding direction") - y = x.unfold(dimension=2, size=D, step=1) # (B, I, J+D-1) -> (B, I, J, D) - y = y.permute(0, 1, 3, 2) # (B, I, J, D) -> (B, I, D, J) - return y - - -def BIDK_transform(x): - """ - Transform BIDK format with k fixed and j from k+1 to K+D to BIDK format with j fixed and k from j-D to j-1. - - Args: - x (torch.FloatTensor): The input tensor of shape (B, I, D, K). - - Returns: - y (torch.FloatTensor): The transformed tensor of shape (B, I, D, K). - """ - _, _, D, K = x.size() - # view x[0, :, :, 0], x[0, :, :, 1], x[0, :, :, 2] ... - x = x.permute(2, 3, 0, 1) # (D, K, B, I) - x = roll_tensor(x, shifts=torch.arange(D, device=x.device), dim=1) # (D, K, B, I) - x = torch.rot90(x, dims=(1, 0)) # (K, D, B, I) - x = x.permute(2, 3, 1, 0) # (B, I, D, K) - mask = ( - torch.triu(torch.ones((D, K), device=x.device), diagonal=K - D + 1) - .flip(1) - .unsqueeze(0) - .unsqueeze(0) - .bool() - ) - x.masked_fill_(mask, LOG_EPS) - # view x[0, :, :, 0], x[0, :, :, 1], x[0, :, :, 2] ... - return x - - -def force_assign_last_text_prob(log_interval_prob, prob, text_mask, alignment_mask): - """ - Use the cumulative sum of boundary probabilities from the last text in prob to directly assign interval probabilities of the last text in log_interval_prob. - Not a inplace operation version. - - Args: - log_interval_prob (torch.FloatTensor): The log interval probability tensor of shape (B, I, J). - prob (torch.FloatTensor): The probability tensor of shape (B, I, K). - text_mask (torch.BoolTensor): The text mask tensor of shape (B, I). - alignment_mask (torch.Tensor): The alignment mask tensor of shape (B, I). - - Returns: - log_interval_prob (torch.FloatTensor): The log interval probability tensor of shape (B, I, J). - """ - B, _, K = log_interval_prob.shape - - log_interval_prob = log_interval_prob.masked_fill(~alignment_mask[:, 1:], 0) - log_interval_prob = torch.cat( - (log_interval_prob, torch.zeros(B, 1, K, device=prob.device)), dim=1 - ) # (B, I-1, J) -> (B, I, J) - - i_lens = text_mask.sum(1) - last = prob[torch.arange(B), i_lens - 1].logcumsumexp(1) # (B, K) - log_interval_prob[torch.arange(B), i_lens - 1] += last - - log_interval_prob = log_interval_prob.masked_fill(~alignment_mask, LOG_EPS) - return log_interval_prob - - -if __name__ == "__main__": - # Example usage 1 (4D tensor) - tensor1 = torch.tensor( - [ - [[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]], - [[[13, 14, 15], [16, 17, 18]], [[19, 20, 21], [22, 23, 24]]], - ] - ) # shape is (2, 2, 2, 3) - shifts1 = torch.tensor( - [1, 2] - ) # Right shift amount for each sample in the last dimension - dim1 = 3 # Perform the shift on the last dimension - result1 = roll_tensor(tensor1, shifts1, dim1) - print("Example 1 - Shift on the last dimension:") - print(result1) - - # Example usage 2 (3D tensor) - tensor2 = torch.tensor( - [ - [[1, 2], [3, 4], [5, 6]], - [[7, 8], [9, 10], [11, 12]], - [[13, 14], [15, 16], [17, 18]], - ] - ) # shape is (3, 3, 2) - shifts2 = torch.tensor( - [1, 2, 3] - ) # Left shift amount for each sample in the second dimension - dim2 = 1 # Perform the shift on the second dimension - result2 = roll_tensor(tensor2, shifts2, dim2) - print("Example 2 - Shift on the second dimension:") - print(result2) - - # Example usage 3 (2D tensor) - tensor3 = torch.tensor( - [ - [1, 2, 3], - [4, 5, 6], - [7, 8, 9], - ] - ) # shape is (3, 3) - shifts3 = torch.tensor([1, 2, 3]) - dim3 = 1 - result3 = roll_tensor(tensor3, shifts3, dim3) - print("Example 3 - Shift on the first dimension:") - print(result3) - - # Test case 4 - B, I, D, J = 2, 5, 10, 16 - text_mask = torch.ones(2, 5, dtype=torch.bool) - text_mask[1, 2:] = 0 - mel_mask = torch.ones(2, 16, dtype=torch.bool) - mel_mask[1, 5:] = 0 - print("Example 4 - gen_left_right_mask") - masked_tensor = gen_left_right_mask(B, I, D, J, text_mask, mel_mask).int() - print(masked_tensor) - - # Test case 5 - i_lens = text_mask.sum(1).long() - j_lens = mel_mask.sum(1).long() - print("Example 5.1 - arange_for_left") - print(arange_for_left(i_lens)) - print("Example 5.2 - arange_for_right") - print(arange_for_right(i_lens, j_lens)) - - # Test case 6 - tensor = torch.tensor( - [ - [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], - [[13, 14, 15, 16], [17, 18, 19, 20], [21, 22, 23, 24]], - ] - ) - - # Call the function to compute the logsumexp along the off-diagonal and get the result tensor - result = diag_logsumexp(tensor.float(), from_ind=0) - print("Example 6 - diag_logsumexp") - print(result) - - x = torch.tensor(range(1400)).reshape(2, 5, 10, 14).float() # K=14, D=10 - print(x) - print("Example 7 - BIDK_transform") - print(BIDK_transform(x)) - - x = torch.arange(180).view(2, 3, 30).float() - print("Example 8 - BIJ_to_BIDK") - print(BIJ_to_BIDK(x, D=10)) diff --git a/test_robo_utils.py b/test_robo_utils.py deleted file mode 100644 index f92c757..0000000 --- a/test_robo_utils.py +++ /dev/null @@ -1,49 +0,0 @@ -import robo_utils -import numpy as np -import torch - -def test_float_to_int_duration_batch(): - # Case 1 - dur = torch.FloatTensor([[0.5, 1.2, 2.7, 1.8], - [0.3, 0.8, 1.5, 2.4]]) - T = torch.LongTensor([6, 5]) - mask = torch.BoolTensor([[1, 1, 1, 1], - [1, 1, 1, 1]]) - int_dur = robo_utils.float_to_int_duration(dur, T, mask) - - expected_output = np.array([[1, 1, 2, 2], - [1, 1, 1, 2]]) - assert np.array_equal(int_dur.data.cpu().numpy(), expected_output) - - # Case 2 - dur = torch.FloatTensor([[0.1, 19.2, 0, 0, 0], - [0.2, 0.3, 0.4, 0, 0]]) - T = torch.LongTensor([2, 3]) - mask = torch.BoolTensor([[1, 1, 0, 0, 0], - [1, 1, 1, 0, 0]]) - int_dur = robo_utils.float_to_int_duration(dur, T, mask) - - expected_output = np.array([[1, 1, 0, 0, 0], - [1, 1, 1, 0, 0]]) - assert np.array_equal(int_dur.data.cpu().numpy(), expected_output) - - print("All tests passed!") - -def test_generate_random_intervals_batch(): - - # 定义一个包含多个批次边界值的数组 - boundaries_batch = torch.tensor([ - [10, 20, 50, 70], - [10, 20, 0, 0], - ]).int() - - result_batch = robo_utils.generate_random_intervals(boundaries_batch, 2) - print(result_batch) - """ - tensor([[ x, x, 10, x, x, 20, x, x, 50, x, x, 70], - [ x, x, 10, x, x, 20, 0, 0, 0, 0, 0, 0]]) - """ - -if __name__ == "__main__": - test_float_to_int_duration_batch() - test_generate_random_intervals_batch()