diff --git a/MANIFEST.in b/MANIFEST.in index da4b2ee47e..fe5947fbe2 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -33,3 +33,7 @@ include gensim/corpora/_mmreader.c include gensim/corpora/_mmreader.pyx include gensim/_matutils.c include gensim/_matutils.pyx + +include gensim/models/nmf_pgd.c +include gensim/models/nmf_pgd.pyx + diff --git a/docs/notebooks/nmf_tutorial.ipynb b/docs/notebooks/nmf_tutorial.ipynb new file mode 100644 index 0000000000..49e5f02bc3 --- /dev/null +++ b/docs/notebooks/nmf_tutorial.ipynb @@ -0,0 +1,1749 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Tutorial on Online Non-Negative Matrix Factorization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebooks explains basic ideas behind NMF implementation, training examples and use-cases." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "lines_to_next_cell": 2 + }, + "source": [ + "**Matrix Factorizations** are useful for many things: recomendation systems, bi-clustering, image compression and, in particular, topic modeling.\n", + "\n", + "Why **Non-Negative**? It makes the problem more strict and allows us to apply some optimizations.\n", + "\n", + "Why **Online**? Because corpora are large and RAM is limited. Online NMF can learn topics iteratively.\n", + "\n", + "This particular implementation is based on [this paper](arxiv.org/abs/1604.02634)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Preprocessing" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import logging\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import time\n", + "from numpy.random import RandomState\n", + "from sklearn import decomposition\n", + "from sklearn.cluster import MiniBatchKMeans\n", + "from sklearn.datasets import fetch_olivetti_faces\n", + "from sklearn.decomposition.nmf import NMF as SklearnNmf\n", + "from sklearn.linear_model import LogisticRegressionCV\n", + "from sklearn.metrics import f1_score\n", + "from sklearn.model_selection import ParameterGrid\n", + "\n", + "import gensim.downloader as api\n", + "from gensim import matutils\n", + "from gensim.corpora import Dictionary\n", + "from gensim.models import CoherenceModel, LdaModel\n", + "from gensim.models.nmf import Nmf as GensimNmf\n", + "from gensim.parsing.preprocessing import preprocess_string\n", + "\n", + "logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Dataset preprocessing" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "newsgroups = api.load('20-newsgroups')\n", + "\n", + "categories = [\n", + " 'alt.atheism',\n", + " 'comp.graphics',\n", + " 'rec.motorcycles',\n", + " 'talk.politics.mideast',\n", + " 'sci.space'\n", + "]\n", + "\n", + "categories = {\n", + " name: idx\n", + " for idx, name\n", + " in enumerate(categories)\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "random_state = RandomState(42)\n", + "\n", + "trainset = np.array([\n", + " {\n", + " 'data': doc['data'],\n", + " 'target': categories[doc['topic']],\n", + " }\n", + " for doc\n", + " in newsgroups\n", + " if doc['topic'] in categories\n", + " and doc['set'] == 'train'\n", + "])\n", + "random_state.shuffle(trainset)\n", + "\n", + "testset = np.array([\n", + " {\n", + " 'data': doc['data'],\n", + " 'target': categories[doc['topic']],\n", + " }\n", + " for doc\n", + " in newsgroups\n", + " if doc['topic'] in categories\n", + " and doc['set'] == 'test'\n", + "])\n", + "random_state.shuffle(testset)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "train_documents = [preprocess_string(doc['data']) for doc in trainset]\n", + "test_documents = [preprocess_string(doc['data']) for doc in testset]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Dictionary compilation" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2019-01-17 14:47:54,339 : INFO : adding document #0 to Dictionary(0 unique tokens: [])\n", + "2019-01-17 14:47:54,673 : INFO : built Dictionary(25279 unique tokens: ['actual', 'assum', 'babbl', 'batka', 'batkaj']...) from 2819 documents (total 435328 corpus positions)\n", + "2019-01-17 14:47:54,701 : INFO : discarding 18198 tokens: [('batka', 1), ('batkaj', 1), ('beatl', 1), ('ccmail', 3), ('dayton', 4), ('edu', 1785), ('inhibit', 1), ('jbatka', 1), ('line', 2748), ('organ', 2602)]...\n", + "2019-01-17 14:47:54,702 : INFO : keeping 7081 tokens which were in no less than 5 and no more than 1409 (=50.0%) documents\n", + "2019-01-17 14:47:54,712 : INFO : resulting dictionary: Dictionary(7081 unique tokens: ['actual', 'assum', 'babbl', 'burster', 'caus']...)\n" + ] + } + ], + "source": [ + "dictionary = Dictionary(train_documents)\n", + "dictionary.filter_extremes()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Corpora compilation" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "train_corpus = [\n", + " dictionary.doc2bow(document)\n", + " for document\n", + " in train_documents\n", + "]\n", + "\n", + "test_corpus = [\n", + " dictionary.doc2bow(document)\n", + " for document\n", + " in test_documents\n", + "]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training\n", + "\n", + "The API works in the way similar to [Gensim.models.LdaModel](https://radimrehurek.com/gensim/models/ldamodel.html).\n", + "\n", + "Specific parameters:\n", + "\n", + "- `use_r` - whether to use residuals. Effectively adds regularization to the model\n", + "- `kappa` - optimizer step size coefficient.\n", + "- `lambda_` - residuals coefficient. The larger it is, the less more regularized result gets.\n", + "- `sparse_coef` - internal matrices sparse coefficient. The more it is, the faster and less accurate training is." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2019-01-17 14:47:56,086 : INFO : Loss (no outliers): 547.4249457586467\tLoss (with outliers): 547.4249457586467\n", + "2019-01-17 14:47:56,387 : INFO : Loss (no outliers): 638.2126742605573\tLoss (with outliers): 638.2126742605573\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 1.23 s, sys: 30.1 ms, total: 1.26 s\n", + "Wall time: 1.27 s\n" + ] + } + ], + "source": [ + "%%time\n", + "\n", + "nmf = GensimNmf(\n", + " corpus=train_corpus,\n", + " chunksize=1000,\n", + " num_topics=5,\n", + " id2word=dictionary,\n", + " passes=5,\n", + " eval_every=10,\n", + " minimum_probability=0,\n", + " random_state=42,\n", + " use_r=False,\n", + " lambda_=1000,\n", + " kappa=1,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Topics" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[(0,\n", + " '0.021*\"armenian\" + 0.020*\"peopl\" + 0.019*\"said\" + 0.017*\"know\" + 0.010*\"went\" + 0.010*\"sai\" + 0.010*\"like\" + 0.010*\"apart\" + 0.009*\"come\" + 0.009*\"azerbaijani\"'),\n", + " (1,\n", + " '0.094*\"jpeg\" + 0.040*\"file\" + 0.039*\"gif\" + 0.033*\"imag\" + 0.030*\"color\" + 0.021*\"format\" + 0.018*\"qualiti\" + 0.016*\"convert\" + 0.016*\"compress\" + 0.016*\"version\"'),\n", + " (2,\n", + " '0.046*\"imag\" + 0.021*\"graphic\" + 0.018*\"data\" + 0.016*\"file\" + 0.016*\"ftp\" + 0.016*\"pub\" + 0.015*\"avail\" + 0.013*\"format\" + 0.012*\"program\" + 0.012*\"packag\"'),\n", + " (3,\n", + " '0.035*\"god\" + 0.029*\"atheist\" + 0.021*\"believ\" + 0.021*\"exist\" + 0.018*\"atheism\" + 0.016*\"religion\" + 0.015*\"peopl\" + 0.014*\"christian\" + 0.013*\"religi\" + 0.012*\"israel\"'),\n", + " (4,\n", + " '0.044*\"space\" + 0.029*\"launch\" + 0.020*\"satellit\" + 0.013*\"orbit\" + 0.013*\"nasa\" + 0.011*\"year\" + 0.010*\"mission\" + 0.009*\"new\" + 0.009*\"commerci\" + 0.009*\"market\"')]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nmf.show_topics()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Coherence" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2019-01-17 14:47:56,425 : INFO : CorpusAccumulator accumulated stats from 1000 documents\n" + ] + }, + { + "data": { + "text/plain": [ + "-1.7121027413685233" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "CoherenceModel(\n", + " model=nmf,\n", + " corpus=test_corpus,\n", + " coherence='u_mass'\n", + ").get_coherence()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Perplexity" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "55.22863930899718" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.exp(-nmf.log_perplexity(test_corpus))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "lines_to_next_cell": 2 + }, + "source": [ + "### Document topics inference" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "From: spl@ivem.ucsd.edu (Steve Lamont)\n", + "Subject: Re: RGB to HVS, and back\n", + "Organization: University of Calif., San Diego/Microscopy and Imaging Resource\n", + "Lines: 18\n", + "Distribution: world\n", + "NNTP-Posting-Host: ivem.ucsd.edu\n", + "\n", + "In article zyeh@caspian.usc.edu (zhenghao yeh) writes:\n", + ">|> See Foley, van Dam, Feiner, and Hughes, _Computer Graphics: Principles\n", + ">|> and Practice, Second Edition_.\n", + ">|> \n", + ">|> [If people would *read* this book, 75 percent of the questions in this\n", + ">|> froup would disappear overnight...]\n", + ">|> \n", + ">\tNot really. I think it is less than 10%.\n", + "\n", + "Nah... I figure most people would be so busy reading that they wouldn't\n", + "have *time* to post. :-) :-) :-)\n", + "\n", + "\t\t\t\t\t\t\tspl\n", + "-- \n", + "Steve Lamont, SciViGuy -- (619) 534-7968 -- spl@szechuan.ucsd.edu\n", + "San Diego Microscopy and Imaging Resource/UC San Diego/La Jolla, CA 92093-0608\n", + "\"Until I meet you, then, in Upper Hell\n", + "Convulsed, foaming immortal blood: farewell\" - J. Berryman, \"A Professor's Song\"\n", + "\n", + "Topics: [(0, 0.29204189080735804), (1, 0.026352973191825578), (2, 0.36870720087404435), (3, 0.28605983002406815), (4, 0.02683810510270401)]\n" + ] + } + ], + "source": [ + "print(testset[0]['data'])\n", + "print(\"Topics: {}\".format(nmf[test_corpus[0]]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Word topic inference" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Word: actual\n", + "Topics: [(1, 0.20201598559144582), (3, 0.7979840144085542)]\n" + ] + } + ], + "source": [ + "word = dictionary[0]\n", + "print(\"Word: {}\".format(word))\n", + "print(\"Topics: {}\".format(nmf.get_term_topics(word)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Internal state" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "def density(sparse_matrix):\n", + " return sparse_matrix.nnz / np.multiply(*sparse_matrix.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Term-topic matrix of shape `(words, topics)`." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<7081x5 sparse matrix of type ''\n", + "\twith 1735 stored elements in Compressed Sparse Column format>" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nmf._W" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Density: 0.04900437791272419\n" + ] + } + ], + "source": [ + "print(\"Density: {}\".format(density(nmf._W)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Topic-document matrix for the last batch of shape `(topics, batch)`" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<5x819 sparse matrix of type ''\n", + "\twith 3593 stored elements in Compressed Sparse Row format>" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nmf._h" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Density: 0.8774114774114774\n" + ] + } + ], + "source": [ + "print(\"Density: {}\".format(density(nmf._h)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Residuals matrix of the last batch of shape `(words, batch)`" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<7081x819 sparse matrix of type ''\n", + "\twith 0 stored elements in Compressed Sparse Row format>" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nmf._r" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Density: 0.0\n" + ] + } + ], + "source": [ + "print(\"Density: {}\".format(density(nmf._r)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Benchmarks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Gensim NMF vs Sklearn NMF vs Gensim LDA" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "variable_params_grid = list(ParameterGrid(dict(\n", + " use_r=[False, True],\n", + " sparse_coef=[0, 3],\n", + " lambda_=[1, 10, 100]\n", + ")))\n", + "\n", + "fixed_params = dict(\n", + " corpus=train_corpus,\n", + " chunksize=1000,\n", + " num_topics=5,\n", + " id2word=dictionary,\n", + " passes=5,\n", + " eval_every=10,\n", + " minimum_probability=0,\n", + " random_state=42,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "def get_execution_time(func):\n", + " start = time.time()\n", + "\n", + " result = func()\n", + "\n", + " return (time.time() - start), result\n", + "\n", + "\n", + "def get_tm_f1(model, train_corpus, X_test, y_train, y_test):\n", + " X_train = np.zeros((len(train_corpus), model.num_topics))\n", + " for bow_id, bow in enumerate(train_corpus):\n", + " for topic_id, factor in model.get_document_topics(bow):\n", + " X_train[bow_id, topic_id] = factor\n", + "\n", + " log_reg = LogisticRegressionCV(multi_class='multinomial')\n", + " log_reg.fit(X_train, y_train)\n", + "\n", + " pred_labels = log_reg.predict(X_test)\n", + "\n", + " return f1_score(y_test, pred_labels, average='micro')\n", + "\n", + "\n", + "def get_sklearn_f1(model, train_corpus, X_test, y_train, y_test):\n", + " X_train = model.transform((train_corpus / train_corpus.sum(axis=0)).T)\n", + "\n", + " log_reg = LogisticRegressionCV(multi_class='multinomial')\n", + " log_reg.fit(X_train, y_train)\n", + "\n", + " pred_labels = log_reg.predict(X_test)\n", + "\n", + " return f1_score(y_test, pred_labels, average='micro')\n", + "\n", + "\n", + "def get_tm_metrics(model, train_corpus, test_corpus, dense_corpus, y_train, y_test):\n", + " W = model.get_topics().T\n", + " H = np.zeros((model.num_topics, len(test_corpus)))\n", + " for bow_id, bow in enumerate(test_corpus):\n", + " for topic_id, factor in model.get_document_topics(bow):\n", + " H[topic_id, bow_id] = factor\n", + "\n", + " pred_factors = W.dot(H)\n", + " pred_factors /= pred_factors.sum(axis=0)\n", + "\n", + " perplexity = get_tm_perplexity(pred_factors, dense_corpus)\n", + "\n", + " l2_norm = get_tm_l2_norm(pred_factors, dense_corpus)\n", + "\n", + " f1 = get_tm_f1(model, train_corpus, H.T, y_train, y_test)\n", + "\n", + " model.normalize = True\n", + "\n", + " coherence = CoherenceModel(\n", + " model=model,\n", + " corpus=test_corpus,\n", + " coherence='u_mass'\n", + " ).get_coherence()\n", + "\n", + " topics = model.show_topics()\n", + "\n", + " model.normalize = False\n", + "\n", + " return dict(\n", + " perplexity=perplexity,\n", + " coherence=coherence,\n", + " topics=topics,\n", + " l2_norm=l2_norm,\n", + " f1=f1,\n", + " )\n", + "\n", + "\n", + "def get_tm_perplexity(pred_factors, dense_corpus):\n", + " return np.exp(-(np.log(pred_factors, where=pred_factors > 0) * dense_corpus).sum() / dense_corpus.sum())\n", + "\n", + "\n", + "def get_tm_l2_norm(pred_factors, dense_corpus):\n", + " return np.linalg.norm(dense_corpus / dense_corpus.sum(axis=0) - pred_factors)\n", + "\n", + "\n", + "def get_sklearn_metrics(model, train_corpus, test_corpus, y_train, y_test):\n", + " W = model.components_.T\n", + " H = model.transform((test_corpus / test_corpus.sum(axis=0)).T).T\n", + " pred_factors = W.dot(H)\n", + " pred_factors /= pred_factors.sum(axis=0)\n", + "\n", + " perplexity = np.exp(\n", + " -(np.log(pred_factors, where=pred_factors > 0) * test_corpus).sum()\n", + " / test_corpus.sum()\n", + " )\n", + "\n", + " l2_norm = np.linalg.norm(test_corpus / test_corpus.sum(axis=0) - pred_factors)\n", + "\n", + " f1 = get_sklearn_f1(model, train_corpus, H.T, y_train, y_test)\n", + "\n", + " return dict(\n", + " perplexity=perplexity,\n", + " l2_norm=l2_norm,\n", + " f1=f1,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2019-01-17 14:48:02,685 : INFO : using symmetric alpha at 0.2\n", + "2019-01-17 14:48:02,685 : INFO : using symmetric eta at 0.2\n", + "2019-01-17 14:48:02,687 : INFO : using serial LDA version on this node\n", + "2019-01-17 14:48:02,693 : INFO : running online (multi-pass) LDA training, 5 topics, 5 passes over the supplied corpus of 2819 documents, updating model once every 1000 documents, evaluating perplexity every 2819 documents, iterating 50x with a convergence threshold of 0.001000\n", + "2019-01-17 14:48:02,694 : INFO : PROGRESS: pass 0, at document #1000/2819\n", + "2019-01-17 14:48:03,679 : INFO : merging changes from 1000 documents into a model of 2819 documents\n", + "2019-01-17 14:48:03,684 : INFO : topic #0 (0.200): 0.006*\"com\" + 0.005*\"new\" + 0.005*\"peopl\" + 0.004*\"space\" + 0.004*\"like\" + 0.004*\"univers\" + 0.004*\"time\" + 0.004*\"nntp\" + 0.004*\"armenian\" + 0.004*\"host\"\n", + "2019-01-17 14:48:03,684 : INFO : topic #1 (0.200): 0.007*\"com\" + 0.005*\"like\" + 0.005*\"peopl\" + 0.005*\"know\" + 0.004*\"think\" + 0.004*\"time\" + 0.004*\"god\" + 0.004*\"univers\" + 0.004*\"said\" + 0.004*\"host\"\n", + "2019-01-17 14:48:03,685 : INFO : topic #2 (0.200): 0.005*\"time\" + 0.005*\"like\" + 0.005*\"com\" + 0.005*\"israel\" + 0.005*\"space\" + 0.005*\"univers\" + 0.004*\"peopl\" + 0.004*\"islam\" + 0.004*\"host\" + 0.004*\"isra\"\n", + "2019-01-17 14:48:03,686 : INFO : topic #3 (0.200): 0.008*\"com\" + 0.006*\"jpeg\" + 0.006*\"imag\" + 0.005*\"nntp\" + 0.005*\"think\" + 0.005*\"file\" + 0.005*\"host\" + 0.004*\"like\" + 0.004*\"univers\" + 0.004*\"graphic\"\n", + "2019-01-17 14:48:03,687 : INFO : topic #4 (0.200): 0.007*\"peopl\" + 0.006*\"space\" + 0.006*\"com\" + 0.005*\"armenian\" + 0.004*\"know\" + 0.004*\"nasa\" + 0.003*\"right\" + 0.003*\"like\" + 0.003*\"point\" + 0.003*\"time\"\n", + "2019-01-17 14:48:03,687 : INFO : topic diff=1.649469, rho=1.000000\n", + "2019-01-17 14:48:03,688 : INFO : PROGRESS: pass 0, at document #2000/2819\n", + "2019-01-17 14:48:04,584 : INFO : merging changes from 1000 documents into a model of 2819 documents\n", + "2019-01-17 14:48:04,589 : INFO : topic #0 (0.200): 0.006*\"com\" + 0.006*\"space\" + 0.005*\"new\" + 0.005*\"armenian\" + 0.005*\"univers\" + 0.004*\"like\" + 0.004*\"peopl\" + 0.004*\"time\" + 0.004*\"nntp\" + 0.004*\"turkish\"\n", + "2019-01-17 14:48:04,590 : INFO : topic #1 (0.200): 0.007*\"peopl\" + 0.007*\"com\" + 0.006*\"know\" + 0.006*\"like\" + 0.006*\"think\" + 0.005*\"god\" + 0.005*\"said\" + 0.004*\"time\" + 0.004*\"thing\" + 0.004*\"univers\"\n", + "2019-01-17 14:48:04,590 : INFO : topic #2 (0.200): 0.007*\"israel\" + 0.005*\"isra\" + 0.005*\"peopl\" + 0.005*\"islam\" + 0.005*\"like\" + 0.005*\"time\" + 0.005*\"univers\" + 0.005*\"state\" + 0.004*\"god\" + 0.004*\"know\"\n", + "2019-01-17 14:48:04,591 : INFO : topic #3 (0.200): 0.011*\"imag\" + 0.009*\"com\" + 0.007*\"file\" + 0.006*\"graphic\" + 0.005*\"program\" + 0.005*\"like\" + 0.005*\"host\" + 0.004*\"nntp\" + 0.004*\"univers\" + 0.004*\"us\"\n", + "2019-01-17 14:48:04,592 : INFO : topic #4 (0.200): 0.011*\"armenian\" + 0.009*\"peopl\" + 0.009*\"space\" + 0.005*\"know\" + 0.005*\"nasa\" + 0.004*\"com\" + 0.004*\"right\" + 0.004*\"like\" + 0.003*\"said\" + 0.003*\"armenia\"\n", + "2019-01-17 14:48:04,592 : INFO : topic diff=0.848670, rho=0.707107\n", + "2019-01-17 14:48:05,706 : INFO : -8.075 per-word bound, 269.6 perplexity estimate based on a held-out corpus of 819 documents with 113268 words\n", + "2019-01-17 14:48:05,707 : INFO : PROGRESS: pass 0, at document #2819/2819\n", + "2019-01-17 14:48:06,380 : INFO : merging changes from 819 documents into a model of 2819 documents\n", + "2019-01-17 14:48:06,384 : INFO : topic #0 (0.200): 0.006*\"com\" + 0.006*\"space\" + 0.005*\"new\" + 0.005*\"turkish\" + 0.005*\"bike\" + 0.005*\"univers\" + 0.004*\"year\" + 0.004*\"like\" + 0.004*\"armenian\" + 0.004*\"time\"\n", + "2019-01-17 14:48:06,386 : INFO : topic #1 (0.200): 0.009*\"com\" + 0.007*\"peopl\" + 0.007*\"like\" + 0.006*\"think\" + 0.006*\"god\" + 0.006*\"know\" + 0.005*\"thing\" + 0.005*\"said\" + 0.004*\"moral\" + 0.004*\"time\"\n", + "2019-01-17 14:48:06,386 : INFO : topic #2 (0.200): 0.010*\"israel\" + 0.007*\"isra\" + 0.006*\"jew\" + 0.006*\"peopl\" + 0.005*\"state\" + 0.005*\"univers\" + 0.005*\"islam\" + 0.005*\"think\" + 0.005*\"time\" + 0.004*\"arab\"\n", + "2019-01-17 14:48:06,387 : INFO : topic #3 (0.200): 0.011*\"com\" + 0.009*\"graphic\" + 0.009*\"imag\" + 0.007*\"file\" + 0.006*\"program\" + 0.005*\"host\" + 0.005*\"nntp\" + 0.005*\"softwar\" + 0.005*\"us\" + 0.005*\"like\"\n", + "2019-01-17 14:48:06,388 : INFO : topic #4 (0.200): 0.014*\"armenian\" + 0.010*\"space\" + 0.008*\"peopl\" + 0.006*\"turkish\" + 0.005*\"launch\" + 0.004*\"nasa\" + 0.004*\"year\" + 0.004*\"turkei\" + 0.004*\"armenia\" + 0.004*\"know\"\n", + "2019-01-17 14:48:06,389 : INFO : topic diff=0.663292, rho=0.577350\n", + "2019-01-17 14:48:06,390 : INFO : PROGRESS: pass 1, at document #1000/2819\n", + "2019-01-17 14:48:07,142 : INFO : merging changes from 1000 documents into a model of 2819 documents\n", + "2019-01-17 14:48:07,147 : INFO : topic #0 (0.200): 0.007*\"com\" + 0.007*\"space\" + 0.005*\"new\" + 0.005*\"bike\" + 0.005*\"univers\" + 0.004*\"like\" + 0.004*\"turkish\" + 0.004*\"time\" + 0.004*\"year\" + 0.004*\"nntp\"\n", + "2019-01-17 14:48:07,148 : INFO : topic #1 (0.200): 0.009*\"com\" + 0.007*\"peopl\" + 0.007*\"like\" + 0.007*\"god\" + 0.006*\"think\" + 0.006*\"know\" + 0.005*\"thing\" + 0.005*\"moral\" + 0.005*\"time\" + 0.004*\"said\"\n", + "2019-01-17 14:48:07,148 : INFO : topic #2 (0.200): 0.011*\"israel\" + 0.009*\"isra\" + 0.006*\"peopl\" + 0.006*\"jew\" + 0.005*\"arab\" + 0.005*\"islam\" + 0.005*\"think\" + 0.005*\"right\" + 0.005*\"state\" + 0.004*\"univers\"\n", + "2019-01-17 14:48:07,149 : INFO : topic #3 (0.200): 0.012*\"imag\" + 0.010*\"com\" + 0.009*\"file\" + 0.009*\"graphic\" + 0.006*\"program\" + 0.005*\"host\" + 0.005*\"us\" + 0.005*\"jpeg\" + 0.005*\"nntp\" + 0.005*\"univers\"\n", + "2019-01-17 14:48:07,150 : INFO : topic #4 (0.200): 0.014*\"armenian\" + 0.011*\"space\" + 0.008*\"peopl\" + 0.006*\"nasa\" + 0.006*\"turkish\" + 0.005*\"launch\" + 0.004*\"year\" + 0.004*\"armenia\" + 0.004*\"said\" + 0.004*\"orbit\"\n", + "2019-01-17 14:48:07,150 : INFO : topic diff=0.431707, rho=0.455535\n", + "2019-01-17 14:48:07,151 : INFO : PROGRESS: pass 1, at document #2000/2819\n", + "2019-01-17 14:48:07,831 : INFO : merging changes from 1000 documents into a model of 2819 documents\n", + "2019-01-17 14:48:07,836 : INFO : topic #0 (0.200): 0.008*\"space\" + 0.007*\"com\" + 0.006*\"new\" + 0.005*\"bike\" + 0.005*\"univers\" + 0.004*\"like\" + 0.004*\"year\" + 0.004*\"nntp\" + 0.004*\"host\" + 0.004*\"time\"\n", + "2019-01-17 14:48:07,837 : INFO : topic #1 (0.200): 0.009*\"com\" + 0.008*\"god\" + 0.007*\"peopl\" + 0.007*\"like\" + 0.007*\"think\" + 0.006*\"know\" + 0.005*\"thing\" + 0.005*\"moral\" + 0.005*\"time\" + 0.004*\"said\"\n", + "2019-01-17 14:48:07,838 : INFO : topic #2 (0.200): 0.011*\"israel\" + 0.009*\"isra\" + 0.007*\"jew\" + 0.006*\"peopl\" + 0.006*\"arab\" + 0.006*\"islam\" + 0.005*\"state\" + 0.005*\"right\" + 0.005*\"think\" + 0.004*\"univers\"\n", + "2019-01-17 14:48:07,838 : INFO : topic #3 (0.200): 0.013*\"imag\" + 0.010*\"com\" + 0.008*\"file\" + 0.008*\"graphic\" + 0.007*\"program\" + 0.005*\"us\" + 0.005*\"host\" + 0.005*\"univers\" + 0.005*\"softwar\" + 0.005*\"nntp\"\n", + "2019-01-17 14:48:07,839 : INFO : topic #4 (0.200): 0.016*\"armenian\" + 0.010*\"space\" + 0.009*\"peopl\" + 0.005*\"turkish\" + 0.005*\"said\" + 0.005*\"nasa\" + 0.005*\"know\" + 0.004*\"armenia\" + 0.004*\"year\" + 0.004*\"like\"\n", + "2019-01-17 14:48:07,840 : INFO : topic diff=0.436104, rho=0.455535\n", + "2019-01-17 14:48:08,814 : INFO : -7.846 per-word bound, 230.1 perplexity estimate based on a held-out corpus of 819 documents with 113268 words\n", + "2019-01-17 14:48:08,815 : INFO : PROGRESS: pass 1, at document #2819/2819\n", + "2019-01-17 14:48:09,364 : INFO : merging changes from 819 documents into a model of 2819 documents\n", + "2019-01-17 14:48:09,368 : INFO : topic #0 (0.200): 0.008*\"space\" + 0.007*\"com\" + 0.006*\"bike\" + 0.006*\"new\" + 0.005*\"univers\" + 0.005*\"year\" + 0.004*\"like\" + 0.004*\"orbit\" + 0.004*\"dod\" + 0.004*\"host\"\n", + "2019-01-17 14:48:09,370 : INFO : topic #1 (0.200): 0.010*\"com\" + 0.008*\"god\" + 0.007*\"peopl\" + 0.007*\"like\" + 0.007*\"think\" + 0.006*\"know\" + 0.005*\"thing\" + 0.005*\"moral\" + 0.005*\"time\" + 0.004*\"said\"\n", + "2019-01-17 14:48:09,371 : INFO : topic #2 (0.200): 0.012*\"israel\" + 0.009*\"isra\" + 0.008*\"jew\" + 0.007*\"peopl\" + 0.006*\"arab\" + 0.005*\"state\" + 0.005*\"islam\" + 0.005*\"right\" + 0.005*\"think\" + 0.004*\"univers\"\n", + "2019-01-17 14:48:09,374 : INFO : topic #3 (0.200): 0.011*\"imag\" + 0.010*\"com\" + 0.010*\"graphic\" + 0.008*\"file\" + 0.007*\"program\" + 0.006*\"softwar\" + 0.005*\"host\" + 0.005*\"us\" + 0.005*\"nntp\" + 0.005*\"univers\"\n", + "2019-01-17 14:48:09,374 : INFO : topic #4 (0.200): 0.017*\"armenian\" + 0.009*\"turkish\" + 0.009*\"space\" + 0.008*\"peopl\" + 0.005*\"said\" + 0.005*\"launch\" + 0.005*\"armenia\" + 0.005*\"year\" + 0.005*\"nasa\" + 0.004*\"turkei\"\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2019-01-17 14:48:09,377 : INFO : topic diff=0.423402, rho=0.455535\n", + "2019-01-17 14:48:09,378 : INFO : PROGRESS: pass 2, at document #1000/2819\n", + "2019-01-17 14:48:09,997 : INFO : merging changes from 1000 documents into a model of 2819 documents\n", + "2019-01-17 14:48:10,002 : INFO : topic #0 (0.200): 0.009*\"space\" + 0.007*\"com\" + 0.006*\"bike\" + 0.006*\"new\" + 0.005*\"univers\" + 0.005*\"orbit\" + 0.004*\"nasa\" + 0.004*\"year\" + 0.004*\"like\" + 0.004*\"time\"\n", + "2019-01-17 14:48:10,003 : INFO : topic #1 (0.200): 0.010*\"com\" + 0.009*\"god\" + 0.007*\"peopl\" + 0.007*\"like\" + 0.007*\"think\" + 0.006*\"know\" + 0.006*\"thing\" + 0.006*\"moral\" + 0.005*\"time\" + 0.005*\"atheist\"\n", + "2019-01-17 14:48:10,006 : INFO : topic #2 (0.200): 0.012*\"israel\" + 0.010*\"isra\" + 0.007*\"jew\" + 0.007*\"peopl\" + 0.006*\"arab\" + 0.006*\"islam\" + 0.005*\"right\" + 0.005*\"think\" + 0.005*\"state\" + 0.004*\"univers\"\n", + "2019-01-17 14:48:10,007 : INFO : topic #3 (0.200): 0.013*\"imag\" + 0.009*\"file\" + 0.009*\"graphic\" + 0.009*\"com\" + 0.007*\"program\" + 0.006*\"us\" + 0.006*\"host\" + 0.005*\"univers\" + 0.005*\"jpeg\" + 0.005*\"nntp\"\n", + "2019-01-17 14:48:10,008 : INFO : topic #4 (0.200): 0.017*\"armenian\" + 0.009*\"turkish\" + 0.008*\"peopl\" + 0.008*\"space\" + 0.005*\"said\" + 0.005*\"nasa\" + 0.005*\"armenia\" + 0.005*\"year\" + 0.004*\"launch\" + 0.004*\"turkei\"\n", + "2019-01-17 14:48:10,008 : INFO : topic diff=0.333963, rho=0.414549\n", + "2019-01-17 14:48:10,010 : INFO : PROGRESS: pass 2, at document #2000/2819\n", + "2019-01-17 14:48:10,635 : INFO : merging changes from 1000 documents into a model of 2819 documents\n", + "2019-01-17 14:48:10,640 : INFO : topic #0 (0.200): 0.011*\"space\" + 0.008*\"com\" + 0.006*\"bike\" + 0.006*\"new\" + 0.005*\"nasa\" + 0.005*\"univers\" + 0.005*\"orbit\" + 0.004*\"year\" + 0.004*\"like\" + 0.004*\"host\"\n", + "2019-01-17 14:48:10,640 : INFO : topic #1 (0.200): 0.010*\"com\" + 0.010*\"god\" + 0.007*\"peopl\" + 0.007*\"like\" + 0.007*\"think\" + 0.006*\"know\" + 0.006*\"thing\" + 0.005*\"moral\" + 0.005*\"time\" + 0.004*\"atheist\"\n", + "2019-01-17 14:48:10,643 : INFO : topic #2 (0.200): 0.012*\"israel\" + 0.010*\"isra\" + 0.008*\"jew\" + 0.007*\"arab\" + 0.007*\"peopl\" + 0.006*\"islam\" + 0.006*\"state\" + 0.005*\"right\" + 0.005*\"think\" + 0.004*\"univers\"\n", + "2019-01-17 14:48:10,646 : INFO : topic #3 (0.200): 0.014*\"imag\" + 0.009*\"file\" + 0.009*\"graphic\" + 0.009*\"com\" + 0.007*\"program\" + 0.006*\"us\" + 0.006*\"univers\" + 0.005*\"softwar\" + 0.005*\"host\" + 0.005*\"nntp\"\n", + "2019-01-17 14:48:10,647 : INFO : topic #4 (0.200): 0.018*\"armenian\" + 0.010*\"peopl\" + 0.008*\"turkish\" + 0.007*\"space\" + 0.006*\"said\" + 0.005*\"know\" + 0.005*\"armenia\" + 0.004*\"like\" + 0.004*\"year\" + 0.004*\"nasa\"\n", + "2019-01-17 14:48:10,647 : INFO : topic diff=0.334135, rho=0.414549\n", + "2019-01-17 14:48:11,575 : INFO : -7.786 per-word bound, 220.6 perplexity estimate based on a held-out corpus of 819 documents with 113268 words\n", + "2019-01-17 14:48:11,576 : INFO : PROGRESS: pass 2, at document #2819/2819\n", + "2019-01-17 14:48:12,086 : INFO : merging changes from 819 documents into a model of 2819 documents\n", + "2019-01-17 14:48:12,092 : INFO : topic #0 (0.200): 0.011*\"space\" + 0.008*\"com\" + 0.007*\"bike\" + 0.006*\"new\" + 0.005*\"univers\" + 0.005*\"orbit\" + 0.005*\"nasa\" + 0.005*\"year\" + 0.004*\"like\" + 0.004*\"satellit\"\n", + "2019-01-17 14:48:12,093 : INFO : topic #1 (0.200): 0.011*\"com\" + 0.010*\"god\" + 0.008*\"peopl\" + 0.007*\"think\" + 0.007*\"like\" + 0.006*\"thing\" + 0.006*\"know\" + 0.005*\"moral\" + 0.005*\"time\" + 0.004*\"believ\"\n", + "2019-01-17 14:48:12,094 : INFO : topic #2 (0.200): 0.012*\"israel\" + 0.010*\"isra\" + 0.009*\"jew\" + 0.007*\"peopl\" + 0.007*\"arab\" + 0.006*\"state\" + 0.005*\"islam\" + 0.005*\"right\" + 0.005*\"think\" + 0.004*\"univers\"\n", + "2019-01-17 14:48:12,095 : INFO : topic #3 (0.200): 0.012*\"imag\" + 0.010*\"graphic\" + 0.009*\"com\" + 0.009*\"file\" + 0.007*\"program\" + 0.006*\"softwar\" + 0.006*\"us\" + 0.005*\"univers\" + 0.005*\"host\" + 0.005*\"mail\"\n", + "2019-01-17 14:48:12,096 : INFO : topic #4 (0.200): 0.018*\"armenian\" + 0.011*\"turkish\" + 0.009*\"peopl\" + 0.006*\"said\" + 0.006*\"space\" + 0.005*\"turkei\" + 0.005*\"armenia\" + 0.005*\"turk\" + 0.005*\"year\" + 0.005*\"know\"\n", + "2019-01-17 14:48:12,099 : INFO : topic diff=0.321527, rho=0.414549\n", + "2019-01-17 14:48:12,100 : INFO : PROGRESS: pass 3, at document #1000/2819\n", + "2019-01-17 14:48:12,722 : INFO : merging changes from 1000 documents into a model of 2819 documents\n", + "2019-01-17 14:48:12,727 : INFO : topic #0 (0.200): 0.012*\"space\" + 0.008*\"com\" + 0.007*\"bike\" + 0.006*\"orbit\" + 0.006*\"nasa\" + 0.006*\"new\" + 0.005*\"univers\" + 0.005*\"year\" + 0.004*\"like\" + 0.004*\"host\"\n", + "2019-01-17 14:48:12,728 : INFO : topic #1 (0.200): 0.011*\"com\" + 0.010*\"god\" + 0.008*\"peopl\" + 0.007*\"like\" + 0.007*\"think\" + 0.006*\"thing\" + 0.006*\"know\" + 0.006*\"moral\" + 0.005*\"time\" + 0.005*\"atheist\"\n", + "2019-01-17 14:48:12,729 : INFO : topic #2 (0.200): 0.012*\"israel\" + 0.011*\"isra\" + 0.008*\"jew\" + 0.007*\"arab\" + 0.007*\"peopl\" + 0.006*\"islam\" + 0.006*\"right\" + 0.005*\"state\" + 0.005*\"think\" + 0.004*\"univers\"\n", + "2019-01-17 14:48:12,730 : INFO : topic #3 (0.200): 0.013*\"imag\" + 0.010*\"file\" + 0.009*\"graphic\" + 0.008*\"com\" + 0.007*\"program\" + 0.006*\"us\" + 0.006*\"univers\" + 0.005*\"host\" + 0.005*\"jpeg\" + 0.005*\"softwar\"\n", + "2019-01-17 14:48:12,731 : INFO : topic #4 (0.200): 0.018*\"armenian\" + 0.010*\"turkish\" + 0.009*\"peopl\" + 0.006*\"said\" + 0.005*\"armenia\" + 0.005*\"space\" + 0.005*\"turk\" + 0.005*\"turkei\" + 0.004*\"year\" + 0.004*\"know\"\n", + "2019-01-17 14:48:12,731 : INFO : topic diff=0.255652, rho=0.382948\n", + "2019-01-17 14:48:12,732 : INFO : PROGRESS: pass 3, at document #2000/2819\n", + "2019-01-17 14:48:13,320 : INFO : merging changes from 1000 documents into a model of 2819 documents\n", + "2019-01-17 14:48:13,325 : INFO : topic #0 (0.200): 0.013*\"space\" + 0.008*\"com\" + 0.007*\"nasa\" + 0.006*\"bike\" + 0.006*\"new\" + 0.006*\"orbit\" + 0.005*\"univers\" + 0.004*\"year\" + 0.004*\"host\" + 0.004*\"nntp\"\n", + "2019-01-17 14:48:13,326 : INFO : topic #1 (0.200): 0.011*\"god\" + 0.010*\"com\" + 0.008*\"peopl\" + 0.007*\"think\" + 0.007*\"like\" + 0.006*\"know\" + 0.006*\"thing\" + 0.005*\"moral\" + 0.005*\"time\" + 0.005*\"believ\"\n", + "2019-01-17 14:48:13,326 : INFO : topic #2 (0.200): 0.012*\"israel\" + 0.011*\"isra\" + 0.008*\"jew\" + 0.007*\"arab\" + 0.007*\"peopl\" + 0.006*\"islam\" + 0.006*\"state\" + 0.006*\"right\" + 0.005*\"think\" + 0.004*\"jewish\"\n", + "2019-01-17 14:48:13,327 : INFO : topic #3 (0.200): 0.014*\"imag\" + 0.009*\"file\" + 0.009*\"graphic\" + 0.008*\"com\" + 0.007*\"program\" + 0.006*\"us\" + 0.006*\"univers\" + 0.006*\"softwar\" + 0.005*\"host\" + 0.005*\"nntp\"\n", + "2019-01-17 14:48:13,328 : INFO : topic #4 (0.200): 0.019*\"armenian\" + 0.011*\"peopl\" + 0.009*\"turkish\" + 0.007*\"said\" + 0.006*\"know\" + 0.005*\"armenia\" + 0.005*\"turk\" + 0.005*\"like\" + 0.004*\"year\" + 0.004*\"turkei\"\n", + "2019-01-17 14:48:13,328 : INFO : topic diff=0.256253, rho=0.382948\n", + "2019-01-17 14:48:14,249 : INFO : -7.754 per-word bound, 215.8 perplexity estimate based on a held-out corpus of 819 documents with 113268 words\n", + "2019-01-17 14:48:14,250 : INFO : PROGRESS: pass 3, at document #2819/2819\n", + "2019-01-17 14:48:14,719 : INFO : merging changes from 819 documents into a model of 2819 documents\n", + "2019-01-17 14:48:14,724 : INFO : topic #0 (0.200): 0.013*\"space\" + 0.008*\"com\" + 0.007*\"bike\" + 0.006*\"nasa\" + 0.006*\"new\" + 0.005*\"orbit\" + 0.005*\"year\" + 0.005*\"univers\" + 0.005*\"launch\" + 0.004*\"like\"\n", + "2019-01-17 14:48:14,724 : INFO : topic #1 (0.200): 0.011*\"com\" + 0.010*\"god\" + 0.008*\"peopl\" + 0.007*\"think\" + 0.007*\"like\" + 0.006*\"thing\" + 0.006*\"know\" + 0.005*\"moral\" + 0.005*\"believ\" + 0.005*\"time\"\n", + "2019-01-17 14:48:14,725 : INFO : topic #2 (0.200): 0.013*\"israel\" + 0.010*\"isra\" + 0.009*\"jew\" + 0.007*\"arab\" + 0.007*\"peopl\" + 0.006*\"state\" + 0.006*\"islam\" + 0.006*\"right\" + 0.005*\"think\" + 0.004*\"war\"\n", + "2019-01-17 14:48:14,726 : INFO : topic #3 (0.200): 0.012*\"imag\" + 0.010*\"graphic\" + 0.009*\"file\" + 0.008*\"com\" + 0.008*\"program\" + 0.006*\"softwar\" + 0.006*\"us\" + 0.006*\"univers\" + 0.005*\"host\" + 0.005*\"mail\"\n", + "2019-01-17 14:48:14,727 : INFO : topic #4 (0.200): 0.019*\"armenian\" + 0.012*\"turkish\" + 0.010*\"peopl\" + 0.007*\"said\" + 0.006*\"turkei\" + 0.005*\"armenia\" + 0.005*\"turk\" + 0.005*\"know\" + 0.004*\"year\" + 0.004*\"like\"\n", + "2019-01-17 14:48:14,727 : INFO : topic diff=0.249831, rho=0.382948\n", + "2019-01-17 14:48:14,728 : INFO : PROGRESS: pass 4, at document #1000/2819\n", + "2019-01-17 14:48:15,289 : INFO : merging changes from 1000 documents into a model of 2819 documents\n", + "2019-01-17 14:48:15,294 : INFO : topic #0 (0.200): 0.013*\"space\" + 0.008*\"com\" + 0.007*\"bike\" + 0.007*\"nasa\" + 0.006*\"orbit\" + 0.005*\"new\" + 0.005*\"year\" + 0.005*\"univers\" + 0.005*\"launch\" + 0.004*\"host\"\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2019-01-17 14:48:15,295 : INFO : topic #1 (0.200): 0.011*\"com\" + 0.011*\"god\" + 0.008*\"peopl\" + 0.007*\"think\" + 0.007*\"like\" + 0.006*\"thing\" + 0.006*\"know\" + 0.006*\"moral\" + 0.005*\"atheist\" + 0.005*\"time\"\n", + "2019-01-17 14:48:15,296 : INFO : topic #2 (0.200): 0.013*\"israel\" + 0.011*\"isra\" + 0.009*\"jew\" + 0.007*\"arab\" + 0.007*\"peopl\" + 0.006*\"islam\" + 0.006*\"right\" + 0.005*\"state\" + 0.005*\"think\" + 0.004*\"peac\"\n", + "2019-01-17 14:48:15,296 : INFO : topic #3 (0.200): 0.014*\"imag\" + 0.010*\"file\" + 0.010*\"graphic\" + 0.008*\"com\" + 0.008*\"program\" + 0.006*\"us\" + 0.006*\"univers\" + 0.005*\"softwar\" + 0.005*\"host\" + 0.005*\"jpeg\"\n", + "2019-01-17 14:48:15,297 : INFO : topic #4 (0.200): 0.019*\"armenian\" + 0.011*\"turkish\" + 0.010*\"peopl\" + 0.006*\"said\" + 0.006*\"armenia\" + 0.006*\"turk\" + 0.005*\"turkei\" + 0.005*\"know\" + 0.004*\"greek\" + 0.004*\"year\"\n", + "2019-01-17 14:48:15,297 : INFO : topic diff=0.204473, rho=0.357622\n", + "2019-01-17 14:48:15,298 : INFO : PROGRESS: pass 4, at document #2000/2819\n", + "2019-01-17 14:48:15,860 : INFO : merging changes from 1000 documents into a model of 2819 documents\n", + "2019-01-17 14:48:15,865 : INFO : topic #0 (0.200): 0.014*\"space\" + 0.008*\"com\" + 0.008*\"nasa\" + 0.007*\"bike\" + 0.006*\"orbit\" + 0.006*\"new\" + 0.005*\"univers\" + 0.005*\"year\" + 0.004*\"host\" + 0.004*\"nntp\"\n", + "2019-01-17 14:48:15,865 : INFO : topic #1 (0.200): 0.011*\"god\" + 0.010*\"com\" + 0.008*\"peopl\" + 0.007*\"think\" + 0.007*\"like\" + 0.006*\"thing\" + 0.006*\"know\" + 0.005*\"moral\" + 0.005*\"believ\" + 0.005*\"atheist\"\n", + "2019-01-17 14:48:15,868 : INFO : topic #2 (0.200): 0.012*\"israel\" + 0.011*\"isra\" + 0.009*\"jew\" + 0.008*\"arab\" + 0.007*\"peopl\" + 0.006*\"islam\" + 0.006*\"right\" + 0.006*\"state\" + 0.005*\"think\" + 0.004*\"jewish\"\n", + "2019-01-17 14:48:15,869 : INFO : topic #3 (0.200): 0.014*\"imag\" + 0.010*\"file\" + 0.009*\"graphic\" + 0.008*\"program\" + 0.007*\"com\" + 0.006*\"univers\" + 0.006*\"us\" + 0.006*\"softwar\" + 0.005*\"host\" + 0.005*\"need\"\n", + "2019-01-17 14:48:15,870 : INFO : topic #4 (0.200): 0.019*\"armenian\" + 0.011*\"peopl\" + 0.010*\"turkish\" + 0.007*\"said\" + 0.006*\"know\" + 0.006*\"armenia\" + 0.005*\"turk\" + 0.005*\"like\" + 0.005*\"turkei\" + 0.004*\"time\"\n", + "2019-01-17 14:48:15,870 : INFO : topic diff=0.206188, rho=0.357622\n", + "2019-01-17 14:48:16,764 : INFO : -7.735 per-word bound, 213.0 perplexity estimate based on a held-out corpus of 819 documents with 113268 words\n", + "2019-01-17 14:48:16,765 : INFO : PROGRESS: pass 4, at document #2819/2819\n", + "2019-01-17 14:48:17,216 : INFO : merging changes from 819 documents into a model of 2819 documents\n", + "2019-01-17 14:48:17,221 : INFO : topic #0 (0.200): 0.014*\"space\" + 0.008*\"com\" + 0.007*\"bike\" + 0.007*\"nasa\" + 0.005*\"new\" + 0.005*\"orbit\" + 0.005*\"launch\" + 0.005*\"year\" + 0.005*\"univers\" + 0.004*\"like\"\n", + "2019-01-17 14:48:17,222 : INFO : topic #1 (0.200): 0.011*\"god\" + 0.011*\"com\" + 0.008*\"peopl\" + 0.008*\"think\" + 0.007*\"like\" + 0.006*\"thing\" + 0.006*\"know\" + 0.005*\"moral\" + 0.005*\"believ\" + 0.005*\"time\"\n", + "2019-01-17 14:48:17,223 : INFO : topic #2 (0.200): 0.013*\"israel\" + 0.011*\"isra\" + 0.010*\"jew\" + 0.007*\"arab\" + 0.007*\"peopl\" + 0.006*\"state\" + 0.006*\"islam\" + 0.006*\"right\" + 0.005*\"think\" + 0.004*\"jewish\"\n", + "2019-01-17 14:48:17,224 : INFO : topic #3 (0.200): 0.012*\"imag\" + 0.010*\"graphic\" + 0.010*\"file\" + 0.008*\"com\" + 0.008*\"program\" + 0.006*\"softwar\" + 0.006*\"univers\" + 0.006*\"us\" + 0.005*\"mail\" + 0.005*\"host\"\n", + "2019-01-17 14:48:17,224 : INFO : topic #4 (0.200): 0.020*\"armenian\" + 0.012*\"turkish\" + 0.010*\"peopl\" + 0.007*\"said\" + 0.006*\"turkei\" + 0.006*\"armenia\" + 0.006*\"turk\" + 0.005*\"know\" + 0.004*\"greek\" + 0.004*\"year\"\n", + "2019-01-17 14:48:17,225 : INFO : topic diff=0.203500, rho=0.357622\n", + "2019-01-17 14:48:21,544 : INFO : CorpusAccumulator accumulated stats from 1000 documents\n", + "2019-01-17 14:48:31,057 : INFO : Loss (no outliers): 543.9085511209285\tLoss (with outliers): 543.9085511209285\n", + "2019-01-17 14:48:31,780 : INFO : Loss (no outliers): 629.7446210861123\tLoss (with outliers): 629.7446210861123\n", + "2019-01-17 14:48:50,245 : INFO : CorpusAccumulator accumulated stats from 1000 documents\n", + "2019-01-17 14:49:03,569 : INFO : Loss (no outliers): 677.513414250545\tLoss (with outliers): 279.46611421992964\n", + "2019-01-17 14:49:10,097 : INFO : Loss (no outliers): 669.590857352226\tLoss (with outliers): 259.2467646189499\n", + "2019-01-17 14:49:39,601 : INFO : CorpusAccumulator accumulated stats from 1000 documents\n", + "2019-01-17 14:49:40,561 : INFO : Loss (no outliers): 547.4249457586467\tLoss (with outliers): 547.4249457586467\n", + "2019-01-17 14:49:40,838 : INFO : Loss (no outliers): 638.2126742605573\tLoss (with outliers): 638.2126742605573\n", + "2019-01-17 14:49:54,607 : INFO : CorpusAccumulator accumulated stats from 1000 documents\n", + "2019-01-17 14:49:57,634 : INFO : Loss (no outliers): 692.6547711302494\tLoss (with outliers): 287.76899186681857\n", + "2019-01-17 14:49:58,233 : INFO : Loss (no outliers): 695.4958681211045\tLoss (with outliers): 268.2945499450434\n", + "2019-01-17 14:50:21,411 : INFO : CorpusAccumulator accumulated stats from 1000 documents\n", + "2019-01-17 14:50:22,980 : INFO : Loss (no outliers): 543.9085511209285\tLoss (with outliers): 543.9085511209285\n", + "2019-01-17 14:50:23,716 : INFO : Loss (no outliers): 629.7446210861123\tLoss (with outliers): 629.7446210861123\n", + "2019-01-17 14:50:42,308 : INFO : CorpusAccumulator accumulated stats from 1000 documents\n", + "2019-01-17 14:50:56,452 : INFO : Loss (no outliers): 639.6176167237056\tLoss (with outliers): 511.0048240200623\n", + "2019-01-17 14:51:03,333 : INFO : Loss (no outliers): 637.4050783690045\tLoss (with outliers): 498.7006582634081\n", + "2019-01-17 14:51:33,575 : INFO : CorpusAccumulator accumulated stats from 1000 documents\n", + "2019-01-17 14:51:34,425 : INFO : Loss (no outliers): 547.4249457586467\tLoss (with outliers): 547.4249457586467\n", + "2019-01-17 14:51:34,696 : INFO : Loss (no outliers): 638.2126742605573\tLoss (with outliers): 638.2126742605573\n", + "2019-01-17 14:51:48,503 : INFO : CorpusAccumulator accumulated stats from 1000 documents\n", + "2019-01-17 14:51:51,998 : INFO : Loss (no outliers): 651.3812921172465\tLoss (with outliers): 518.2309924866902\n", + "2019-01-17 14:51:53,008 : INFO : Loss (no outliers): 647.9339449245117\tLoss (with outliers): 509.82049860049364\n", + "2019-01-17 14:52:14,849 : INFO : CorpusAccumulator accumulated stats from 1000 documents\n", + "2019-01-17 14:52:16,415 : INFO : Loss (no outliers): 543.9085511209285\tLoss (with outliers): 543.9085511209285\n", + "2019-01-17 14:52:17,127 : INFO : Loss (no outliers): 629.7446210861123\tLoss (with outliers): 629.7446210861123\n", + "2019-01-17 14:52:35,545 : INFO : CorpusAccumulator accumulated stats from 1000 documents\n", + "2019-01-17 14:52:54,059 : INFO : Loss (no outliers): 542.2256187627806\tLoss (with outliers): 542.2256187627806\n", + "2019-01-17 14:53:03,433 : INFO : Loss (no outliers): 624.7035238321835\tLoss (with outliers): 624.6056240734391\n", + "2019-01-17 14:53:30,678 : INFO : CorpusAccumulator accumulated stats from 1000 documents\n", + "2019-01-17 14:53:31,653 : INFO : Loss (no outliers): 547.4249457586467\tLoss (with outliers): 547.4249457586467\n", + "2019-01-17 14:53:31,927 : INFO : Loss (no outliers): 638.2126742605573\tLoss (with outliers): 638.2126742605573\n", + "2019-01-17 14:53:45,702 : INFO : CorpusAccumulator accumulated stats from 1000 documents\n", + "2019-01-17 14:53:50,458 : INFO : Loss (no outliers): 547.1203901181682\tLoss (with outliers): 547.1203901181682\n", + "2019-01-17 14:53:51,589 : INFO : Loss (no outliers): 633.6243596382214\tLoss (with outliers): 633.3634284766107\n", + "2019-01-17 14:54:12,967 : INFO : CorpusAccumulator accumulated stats from 1000 documents\n" + ] + } + ], + "source": [ + "tm_metrics = pd.DataFrame()\n", + "\n", + "train_dense_corpus = matutils.corpus2dense(train_corpus, len(dictionary))\n", + "test_dense_corpus = matutils.corpus2dense(test_corpus, len(dictionary))\n", + "\n", + "trainset_target = [doc['target'] for doc in trainset]\n", + "testset_target = [doc['target'] for doc in testset]\n", + "\n", + "# LDA metrics\n", + "row = dict()\n", + "row['model'] = 'lda'\n", + "row['train_time'], lda = get_execution_time(\n", + " lambda: LdaModel(**fixed_params)\n", + ")\n", + "row.update(get_tm_metrics(\n", + " lda, train_corpus, test_corpus, test_dense_corpus, trainset_target, testset_target,\n", + "))\n", + "tm_metrics = tm_metrics.append(pd.Series(row), ignore_index=True)\n", + "\n", + "# Sklearn NMF metrics\n", + "row = dict()\n", + "row['model'] = 'sklearn_nmf'\n", + "sklearn_nmf = SklearnNmf(n_components=5, tol=1e-5, max_iter=int(1e9), random_state=42)\n", + "row['train_time'], sklearn_nmf = get_execution_time(\n", + " lambda: sklearn_nmf.fit((train_dense_corpus / train_dense_corpus.sum(axis=0)).T)\n", + ")\n", + "row.update(get_sklearn_metrics(\n", + " sklearn_nmf, train_dense_corpus, test_dense_corpus, trainset_target, testset_target,\n", + "))\n", + "tm_metrics = tm_metrics.append(pd.Series(row), ignore_index=True)\n", + "\n", + "for variable_params in variable_params_grid:\n", + " row = dict()\n", + " row['model'] = 'gensim_nmf'\n", + " row.update(variable_params)\n", + " row['train_time'], model = get_execution_time(\n", + " lambda: GensimNmf(\n", + " normalize=False,\n", + " **fixed_params,\n", + " **variable_params,\n", + " )\n", + " )\n", + " row.update(get_tm_metrics(\n", + " model, train_corpus, test_corpus, test_dense_corpus, trainset_target, testset_target,\n", + " ))\n", + " tm_metrics = tm_metrics.append(pd.Series(row), ignore_index=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Result table" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
coherencef1l2_normmodelperplexitytopicstrain_timelambda_sparse_coefuse_r
5-1.6751620.5277197.167809gensim_nmf24.738142[(0, 0.035*\"com\" + 0.030*\"world\" + 0.030*\"like...3.5974971.03.01.0
3-1.6930740.6252677.035608gensim_nmf2479.600679[(0, 0.012*\"com\" + 0.012*\"armenian\" + 0.011*\"w...19.8206501.00.01.0
13-1.6953790.6753737.183766gensim_nmf48.768942[(0, 0.025*\"armenian\" + 0.023*\"peopl\" + 0.021*...5.856175100.03.01.0
9-1.6709030.6940307.131330gensim_nmf46.644018[(0, 0.031*\"armenian\" + 0.021*\"peopl\" + 0.020*...4.47631410.03.01.0
1NaN0.6988276.929583sklearn_nmf2404.189918NaN5.676373NaNNaNNaN
11-1.7114110.6988277.059604gensim_nmf2460.213716[(0, 0.017*\"armenian\" + 0.016*\"peopl\" + 0.015*...27.860318100.00.01.0
4-1.7121030.7009597.174119gensim_nmf55.361718[(0, 0.021*\"armenian\" + 0.020*\"peopl\" + 0.019*...1.2052771.03.00.0
8-1.7121030.7009597.174119gensim_nmf55.361718[(0, 0.021*\"armenian\" + 0.020*\"peopl\" + 0.019*...1.09123910.03.00.0
12-1.7121030.7009597.174119gensim_nmf55.361718[(0, 0.021*\"armenian\" + 0.020*\"peopl\" + 0.019*...1.219200100.03.00.0
2-1.7025420.7110877.060992gensim_nmf2473.714343[(0, 0.017*\"armenian\" + 0.015*\"peopl\" + 0.014*...2.2534921.00.00.0
6-1.7025420.7110877.060992gensim_nmf2473.714343[(0, 0.017*\"armenian\" + 0.015*\"peopl\" + 0.014*...2.27124010.00.00.0
10-1.7025420.7110877.060992gensim_nmf2473.714343[(0, 0.017*\"armenian\" + 0.015*\"peopl\" + 0.014*...2.247909100.00.00.0
7-1.6637870.7500007.040535gensim_nmf2287.018000[(0, 0.022*\"armenian\" + 0.015*\"peopl\" + 0.014*...20.99710410.00.01.0
0-1.7556500.7654587.002725lda1939.575701[(0, 0.014*\"space\" + 0.008*\"com\" + 0.007*\"bike...14.540969NaNNaNNaN
\n", + "
" + ], + "text/plain": [ + " coherence f1 l2_norm model perplexity \\\n", + "5 -1.675162 0.527719 7.167809 gensim_nmf 24.738142 \n", + "3 -1.693074 0.625267 7.035608 gensim_nmf 2479.600679 \n", + "13 -1.695379 0.675373 7.183766 gensim_nmf 48.768942 \n", + "9 -1.670903 0.694030 7.131330 gensim_nmf 46.644018 \n", + "1 NaN 0.698827 6.929583 sklearn_nmf 2404.189918 \n", + "11 -1.711411 0.698827 7.059604 gensim_nmf 2460.213716 \n", + "4 -1.712103 0.700959 7.174119 gensim_nmf 55.361718 \n", + "8 -1.712103 0.700959 7.174119 gensim_nmf 55.361718 \n", + "12 -1.712103 0.700959 7.174119 gensim_nmf 55.361718 \n", + "2 -1.702542 0.711087 7.060992 gensim_nmf 2473.714343 \n", + "6 -1.702542 0.711087 7.060992 gensim_nmf 2473.714343 \n", + "10 -1.702542 0.711087 7.060992 gensim_nmf 2473.714343 \n", + "7 -1.663787 0.750000 7.040535 gensim_nmf 2287.018000 \n", + "0 -1.755650 0.765458 7.002725 lda 1939.575701 \n", + "\n", + " topics train_time lambda_ \\\n", + "5 [(0, 0.035*\"com\" + 0.030*\"world\" + 0.030*\"like... 3.597497 1.0 \n", + "3 [(0, 0.012*\"com\" + 0.012*\"armenian\" + 0.011*\"w... 19.820650 1.0 \n", + "13 [(0, 0.025*\"armenian\" + 0.023*\"peopl\" + 0.021*... 5.856175 100.0 \n", + "9 [(0, 0.031*\"armenian\" + 0.021*\"peopl\" + 0.020*... 4.476314 10.0 \n", + "1 NaN 5.676373 NaN \n", + "11 [(0, 0.017*\"armenian\" + 0.016*\"peopl\" + 0.015*... 27.860318 100.0 \n", + "4 [(0, 0.021*\"armenian\" + 0.020*\"peopl\" + 0.019*... 1.205277 1.0 \n", + "8 [(0, 0.021*\"armenian\" + 0.020*\"peopl\" + 0.019*... 1.091239 10.0 \n", + "12 [(0, 0.021*\"armenian\" + 0.020*\"peopl\" + 0.019*... 1.219200 100.0 \n", + "2 [(0, 0.017*\"armenian\" + 0.015*\"peopl\" + 0.014*... 2.253492 1.0 \n", + "6 [(0, 0.017*\"armenian\" + 0.015*\"peopl\" + 0.014*... 2.271240 10.0 \n", + "10 [(0, 0.017*\"armenian\" + 0.015*\"peopl\" + 0.014*... 2.247909 100.0 \n", + "7 [(0, 0.022*\"armenian\" + 0.015*\"peopl\" + 0.014*... 20.997104 10.0 \n", + "0 [(0, 0.014*\"space\" + 0.008*\"com\" + 0.007*\"bike... 14.540969 NaN \n", + "\n", + " sparse_coef use_r \n", + "5 3.0 1.0 \n", + "3 0.0 1.0 \n", + "13 3.0 1.0 \n", + "9 3.0 1.0 \n", + "1 NaN NaN \n", + "11 0.0 1.0 \n", + "4 3.0 0.0 \n", + "8 3.0 0.0 \n", + "12 3.0 0.0 \n", + "2 0.0 0.0 \n", + "6 0.0 0.0 \n", + "10 0.0 0.0 \n", + "7 0.0 1.0 \n", + "0 NaN NaN " + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tm_metrics.sort_values('f1')" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best NMF's topics\n" + ] + }, + { + "data": { + "text/plain": [ + "[(0,\n", + " '0.017*\"armenian\" + 0.015*\"peopl\" + 0.014*\"said\" + 0.013*\"know\" + 0.008*\"went\" + 0.008*\"sai\" + 0.007*\"like\" + 0.007*\"apart\" + 0.007*\"come\" + 0.007*\"azerbaijani\"'),\n", + " (1,\n", + " '0.074*\"jpeg\" + 0.032*\"file\" + 0.031*\"gif\" + 0.028*\"imag\" + 0.024*\"color\" + 0.017*\"format\" + 0.014*\"qualiti\" + 0.013*\"convert\" + 0.013*\"compress\" + 0.013*\"version\"'),\n", + " (2,\n", + " '0.030*\"imag\" + 0.014*\"graphic\" + 0.012*\"data\" + 0.010*\"file\" + 0.010*\"pub\" + 0.010*\"ftp\" + 0.010*\"avail\" + 0.008*\"format\" + 0.008*\"program\" + 0.008*\"packag\"'),\n", + " (3,\n", + " '0.015*\"god\" + 0.012*\"atheist\" + 0.009*\"believ\" + 0.009*\"exist\" + 0.008*\"atheism\" + 0.007*\"peopl\" + 0.007*\"religion\" + 0.006*\"christian\" + 0.006*\"israel\" + 0.006*\"religi\"'),\n", + " (4,\n", + " '0.028*\"space\" + 0.019*\"launch\" + 0.013*\"satellit\" + 0.009*\"orbit\" + 0.008*\"nasa\" + 0.007*\"year\" + 0.006*\"mission\" + 0.006*\"new\" + 0.006*\"commerci\" + 0.005*\"market\"')]" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(\"Best NMF's topics\")\n", + "tm_metrics.iloc[2].topics" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LDA topics\n" + ] + }, + { + "data": { + "text/plain": [ + "[(0,\n", + " '0.014*\"space\" + 0.008*\"com\" + 0.007*\"bike\" + 0.007*\"nasa\" + 0.005*\"new\" + 0.005*\"orbit\" + 0.005*\"launch\" + 0.005*\"year\" + 0.005*\"univers\" + 0.004*\"like\"'),\n", + " (1,\n", + " '0.011*\"god\" + 0.011*\"com\" + 0.008*\"peopl\" + 0.008*\"think\" + 0.007*\"like\" + 0.006*\"thing\" + 0.006*\"know\" + 0.005*\"moral\" + 0.005*\"believ\" + 0.005*\"time\"'),\n", + " (2,\n", + " '0.013*\"israel\" + 0.011*\"isra\" + 0.010*\"jew\" + 0.007*\"arab\" + 0.007*\"peopl\" + 0.006*\"state\" + 0.006*\"islam\" + 0.006*\"right\" + 0.005*\"think\" + 0.004*\"jewish\"'),\n", + " (3,\n", + " '0.012*\"imag\" + 0.010*\"graphic\" + 0.010*\"file\" + 0.008*\"com\" + 0.008*\"program\" + 0.006*\"softwar\" + 0.006*\"univers\" + 0.006*\"us\" + 0.005*\"mail\" + 0.005*\"host\"'),\n", + " (4,\n", + " '0.020*\"armenian\" + 0.012*\"turkish\" + 0.010*\"peopl\" + 0.007*\"said\" + 0.006*\"turkei\" + 0.006*\"armenia\" + 0.006*\"turk\" + 0.005*\"know\" + 0.004*\"greek\" + 0.004*\"year\"')]" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print('LDA topics')\n", + "tm_metrics.iloc[0].topics" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Gensim NMF clearly beats sklearn implementation both in terms of speed and quality\n", + "- LDA is still significantly better in terms of quality, though interpretabiliy of topics and speed are clearly worse then NMF's" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Olivietti faces + Gensim NMF\n", + "NMF algorithm works not only with texts, but with all kinds of stuff!\n", + "\n", + "Let's run our model with other factorization algorithms and check out the results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Sklearn wrapper\n", + "We need that wrapper to compare Gensim NMF with other factorizations on images" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "from sklearn.base import BaseEstimator, TransformerMixin\n", + "\n", + "\n", + "class NmfWrapper(BaseEstimator, TransformerMixin):\n", + " def __init__(self, **kwargs):\n", + " self.nmf = GensimNmf(**kwargs)\n", + " self.corpus = None\n", + "\n", + " def fit_transform(self, X):\n", + " self.fit(X)\n", + " return self.transform(X)\n", + "\n", + " def fit(self, X):\n", + " self.corpus = [\n", + " [\n", + " (feature_idx, value)\n", + " for feature_idx, value\n", + " in enumerate(sample)\n", + " ]\n", + " for sample\n", + " in X\n", + " ]\n", + "\n", + " self.nmf.update(self.corpus)\n", + "\n", + " def transform(self, X):\n", + " H = np.zeros((len(self.corpus), self.nmf.num_topics))\n", + " for bow_id, bow in enumerate(self.corpus):\n", + " for topic_id, proba in self.nmf[bow]:\n", + " H[bow_id, topic_id] = proba\n", + "\n", + " return H\n", + "\n", + " @property\n", + " def components_(self):\n", + " return self.nmf.get_topics()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "============================\n", + "Faces dataset decompositions\n", + "============================\n", + "\n", + "This example applies to :ref:`olivetti_faces` different unsupervised\n", + "matrix decomposition (dimension reduction) methods from the module\n", + ":py:mod:`sklearn.decomposition` (see the documentation chapter\n", + ":ref:`decompositions`) .\n", + "\n", + "\n", + "Dataset consists of 400 faces\n", + "Extracting the top 6 Eigenfaces - PCA using randomized SVD...\n", + "done in 0.195s\n", + "Extracting the top 6 Non-negative components - NMF (Sklearn)...\n", + "done in 1.069s\n", + "Extracting the top 6 Non-negative components - NMF (Gensim)...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2019-01-17 14:54:20,785 : INFO : Loss (no outliers): 5.486415140971889\tLoss (with outliers): 5.486415140971889\n", + "2019-01-17 14:54:20,788 : INFO : Loss (no outliers): 5.486415140971889\tLoss (with outliers): 5.486415140971889\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "done in 6.041s\n", + "Extracting the top 6 Independent components - FastICA...\n", + "done in 0.197s\n", + "Extracting the top 6 Sparse comp. - MiniBatchSparsePCA...\n", + "done in 0.862s\n", + "Extracting the top 6 MiniBatchDictionaryLearning...\n", + "done in 0.660s\n", + "Extracting the top 6 Cluster centers - MiniBatchKMeans...\n", + "done in 0.064s\n", + "Extracting the top 6 Factor Analysis components - FA...\n", + "done in 0.113s\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anotherbugmaster/.virtualenvs/gensim/lib/python3.7/site-packages/sklearn/decomposition/factor_analysis.py:228: ConvergenceWarning: FactorAnalysis did not converge. You might want to increase the number of iterations.\n", + " ConvergenceWarning)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\"\"\"\n", + "============================\n", + "Faces dataset decompositions\n", + "============================\n", + "\n", + "This example applies to :ref:`olivetti_faces` different unsupervised\n", + "matrix decomposition (dimension reduction) methods from the module\n", + ":py:mod:`sklearn.decomposition` (see the documentation chapter\n", + ":ref:`decompositions`) .\n", + "\n", + "\"\"\"\n", + "print(__doc__)\n", + "\n", + "# Authors: Vlad Niculae, Alexandre Gramfort\n", + "# License: BSD 3 claus\n", + "\n", + "n_row, n_col = 2, 3\n", + "n_components = n_row * n_col\n", + "image_shape = (64, 64)\n", + "rng = RandomState(0)\n", + "\n", + "# #############################################################################\n", + "# Load faces data\n", + "dataset = fetch_olivetti_faces(shuffle=True, random_state=rng)\n", + "faces = dataset.data\n", + "\n", + "n_samples, n_features = faces.shape\n", + "\n", + "# global centering\n", + "faces_centered = faces - faces.mean(axis=0)\n", + "\n", + "# local centering\n", + "faces_centered -= faces_centered.mean(axis=1).reshape(n_samples, -1)\n", + "\n", + "print(\"Dataset consists of %d faces\" % n_samples)\n", + "\n", + "\n", + "def plot_gallery(title, images, n_col=n_col, n_row=n_row):\n", + " plt.figure(figsize=(2. * n_col, 2.26 * n_row))\n", + " plt.suptitle(title, size=16)\n", + " for i, comp in enumerate(images):\n", + " plt.subplot(n_row, n_col, i + 1)\n", + " vmax = max(comp.max(), -comp.min())\n", + " plt.imshow(comp.reshape(image_shape), cmap=plt.cm.gray,\n", + " interpolation='nearest',\n", + " vmin=-vmax, vmax=vmax)\n", + " plt.xticks(())\n", + " plt.yticks(())\n", + " plt.subplots_adjust(0.01, 0.05, 0.99, 0.93, 0.04, 0.)\n", + "\n", + "\n", + "# #############################################################################\n", + "# List of the different estimators, whether to center and transpose the\n", + "# problem, and whether the transformer uses the clustering API.\n", + "estimators = [\n", + " ('Eigenfaces - PCA using randomized SVD',\n", + " decomposition.PCA(n_components=n_components, svd_solver='randomized',\n", + " whiten=True),\n", + " True),\n", + "\n", + " ('Non-negative components - NMF (Sklearn)',\n", + " decomposition.NMF(n_components=n_components, init='nndsvda', tol=5e-3),\n", + " False),\n", + "\n", + " ('Non-negative components - NMF (Gensim)',\n", + " NmfWrapper(\n", + " chunksize=1,\n", + " eval_every=400,\n", + " passes=1,\n", + " sparse_coef=0,\n", + " id2word={idx: idx for idx in range(faces.shape[1])},\n", + " num_topics=n_components,\n", + " minimum_probability=0\n", + " ),\n", + " False),\n", + "\n", + " ('Independent components - FastICA',\n", + " decomposition.FastICA(n_components=n_components, whiten=True),\n", + " True),\n", + "\n", + " ('Sparse comp. - MiniBatchSparsePCA',\n", + " decomposition.MiniBatchSparsePCA(n_components=n_components, alpha=0.8,\n", + " n_iter=100, batch_size=3,\n", + " random_state=rng),\n", + " True),\n", + "\n", + " ('MiniBatchDictionaryLearning',\n", + " decomposition.MiniBatchDictionaryLearning(n_components=15, alpha=0.1,\n", + " n_iter=50, batch_size=3,\n", + " random_state=rng),\n", + " True),\n", + "\n", + " ('Cluster centers - MiniBatchKMeans',\n", + " MiniBatchKMeans(n_clusters=n_components, tol=1e-3, batch_size=20,\n", + " max_iter=50, random_state=rng),\n", + " True),\n", + "\n", + " ('Factor Analysis components - FA',\n", + " decomposition.FactorAnalysis(n_components=n_components, max_iter=2),\n", + " True),\n", + "]\n", + "\n", + "# #############################################################################\n", + "# Plot a sample of the input data\n", + "\n", + "plot_gallery(\"First centered Olivetti faces\", faces_centered[:n_components])\n", + "\n", + "# #############################################################################\n", + "# Do the estimation and plot it\n", + "\n", + "for name, estimator, center in estimators:\n", + " print(\"Extracting the top %d %s...\" % (n_components, name))\n", + " t0 = time.time()\n", + " data = faces\n", + " if center:\n", + " data = faces_centered\n", + " estimator.fit(data)\n", + " train_time = (time.time() - t0)\n", + " print(\"done in %0.3fs\" % train_time)\n", + " if hasattr(estimator, 'cluster_centers_'):\n", + " components_ = estimator.cluster_centers_\n", + " else:\n", + " components_ = estimator.components_\n", + "\n", + " # Plot an image representing the pixelwise variance provided by the\n", + " # estimator e.g its noise_variance_ attribute. The Eigenfaces estimator,\n", + " # via the PCA decomposition, also provides a scalar noise_variance_\n", + " # (the mean of pixelwise variance) that cannot be displayed as an image\n", + " # so we skip it.\n", + " if (hasattr(estimator, 'noise_variance_') and\n", + " estimator.noise_variance_.ndim > 0): # Skip the Eigenfaces case\n", + " plot_gallery(\"Pixelwise variance\",\n", + " estimator.noise_variance_.reshape(1, -1), n_col=1,\n", + " n_row=1)\n", + " plot_gallery('%s - Train time %.1fs' % (name, train_time),\n", + " components_[:n_components])\n", + "\n", + "plt.show()" + ] + } + ], + "metadata": { + "jupytext": { + "text_representation": { + "extension": ".py", + "format_name": "percent", + "format_version": "1.2", + "jupytext_version": "0.8.6" + } + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/notebooks/nmf_wikipedia.ipynb b/docs/notebooks/nmf_wikipedia.ipynb new file mode 100644 index 0000000000..eaa3c656c7 --- /dev/null +++ b/docs/notebooks/nmf_wikipedia.ipynb @@ -0,0 +1,1312 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Wikipedia training\n", + "\n", + "In this tutorial we will:\n", + " - Learn how to train the NMF topic model on English Wikipedia corpus\n", + " - Compare it with LDA model\n", + " - Evaluate results" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import itertools\n", + "import json\n", + "import logging\n", + "import numpy as np\n", + "import pandas as pd\n", + "import scipy.sparse\n", + "import smart_open\n", + "import time\n", + "from tqdm import tqdm, tqdm_notebook\n", + "\n", + "import gensim.downloader as api\n", + "from gensim import matutils\n", + "from gensim.corpora import MmCorpus, Dictionary\n", + "from gensim.models import LdaModel, CoherenceModel\n", + "from gensim.models.nmf import Nmf\n", + "from gensim.parsing.preprocessing import preprocess_string\n", + "\n", + "tqdm.pandas()\n", + "\n", + "logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s',\n", + " level=logging.INFO)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Preprocessing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load wikipedia dump\n", + "Let's use `gensim.downloader.api` for that" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Section title: Introduction\n", + "Section text: \n", + "\n", + "\n", + "\n", + "\n", + "'''Anarchism''' is a political philosophy that advocates self-governed societies based on volun\n", + "Section title: Etymology and terminology\n", + "Section text: \n", + "\n", + "The word ''anarchism'' is composed from the word ''anarchy'' and the suffix ''-ism'', themselves d\n", + "Section title: History\n", + "Section text: \n", + "\n", + "===Origins===\n", + "Woodcut from a Diggers document by William Everard\n", + "\n", + "The earliest anarchist themes ca\n", + "Section title: Anarchist schools of thought\n", + "Section text: \n", + "Portrait of philosopher Pierre-Joseph Proudhon (1809–1865) by Gustave Courbet. Proudhon was the pri\n", + "Section title: Internal issues and debates\n", + "Section text: \n", + "consistent with anarchist values is a controversial subject among anarchists.\n", + "\n", + "Anarchism is a philo\n", + "Section title: Topics of interest\n", + "Section text: Intersecting and overlapping between various schools of thought, certain topics of interest and inte\n", + "Section title: Criticisms\n", + "Section text: \n", + "Criticisms of anarchism include moral criticisms and pragmatic criticisms. Anarchism is often evalu\n", + "Section title: See also\n", + "Section text: * Anarchism by country\n", + "\n", + "Section title: References\n", + "Section text: \n", + "\n", + "Section title: Further reading\n", + "Section text: * Barclay, Harold, ''People Without Government: An Anthropology of Anarchy'' (2nd ed.), Left Bank Bo\n", + "Section title: External links\n", + "Section text: \n", + "* \n", + "* \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + } + ], + "source": [ + "data = api.load(\"wiki-english-20171001\")\n", + "article = next(iter(data))\n", + "\n", + "for section_title, section_text in zip(\n", + " article['section_titles'],\n", + " article['section_texts']\n", + "):\n", + " print(\"Section title: %s\" % section_title)\n", + " print(\"Section text: %s\" % section_text[:100])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Preprocess and save articles" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "def save_preprocessed_articles(filename, articles):\n", + " with smart_open(filename, 'w+', encoding=\"utf8\") as writer:\n", + " for article in tqdm_notebook(articles):\n", + " article_text = \" \".join(\n", + " \" \".join(section)\n", + " for section\n", + " in zip(\n", + " article['section_titles'],\n", + " article['section_texts']\n", + " )\n", + " )\n", + " article_text = preprocess_string(article_text)\n", + "\n", + " writer.write(json.dumps(article_text) + '\\n')\n", + "\n", + "\n", + "def get_preprocessed_articles(filename):\n", + " with smart_open(filename, 'r', encoding=\"utf8\") as reader:\n", + " for line in tqdm_notebook(reader):\n", + " yield json.loads(\n", + " line\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "SAVE_ARTICLES = False\n", + "\n", + "if SAVE_ARTICLES:\n", + " save_preprocessed_articles('wiki_articles.jsonlines', data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create and save dictionary" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "lines_to_next_cell": 2, + "scrolled": true + }, + "outputs": [], + "source": [ + "SAVE_DICTIONARY = False\n", + "\n", + "if SAVE_DICTIONARY:\n", + " dictionary = Dictionary(get_preprocessed_articles('wiki_articles.jsonlines'))\n", + " dictionary.save('wiki.dict')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load and filter dictionary" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2019-01-15 19:31:03,151 : INFO : loading Dictionary object from wiki.dict\n", + "2019-01-15 19:31:04,024 : INFO : loaded wiki.dict\n", + "2019-01-15 19:31:06,292 : INFO : discarding 1910258 tokens: [('abdelrahim', 49), ('abstention', 120), ('anarcha', 101), ('anarchica', 40), ('anarchosyndicalist', 20), ('antimilitar', 68), ('arbet', 194), ('archo', 100), ('arkhē', 5), ('autonomedia', 118)]...\n", + "2019-01-15 19:31:06,293 : INFO : keeping 100000 tokens which were in no less than 5 and no more than 2462447 (=50.0%) documents\n", + "2019-01-15 19:31:06,645 : INFO : resulting dictionary: Dictionary(100000 unique tokens: ['abandon', 'abil', 'abl', 'abolit', 'abstent']...)\n" + ] + } + ], + "source": [ + "dictionary = Dictionary.load('wiki.dict')\n", + "dictionary.filter_extremes()\n", + "dictionary.compactify()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### MmCorpus wrapper\n", + "In this way we'll:\n", + "\n", + "- Make sure that documents are shuffled\n", + "- Be able to train-test split corpus without rewriting it" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "class RandomCorpus(MmCorpus):\n", + " def __init__(self, random_seed=42, testset=False, testsize=1000, *args,\n", + " **kwargs):\n", + " super().__init__(*args, **kwargs)\n", + "\n", + " random_state = np.random.RandomState(random_seed)\n", + " self.indices = random_state.permutation(range(self.num_docs))\n", + " if testset:\n", + " self.indices = self.indices[:testsize]\n", + " else:\n", + " self.indices = self.indices[testsize:]\n", + "\n", + " def __iter__(self):\n", + " for doc_id in self.indices:\n", + " yield self[doc_id]\n", + " \n", + " def __len__(self):\n", + " return len(self.indices)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create and save corpus" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "SAVE_CORPUS = False\n", + "\n", + "if SAVE_CORPUS:\n", + " corpus = (\n", + " dictionary.doc2bow(article)\n", + " for article\n", + " in get_preprocessed_articles('wiki_articles.jsonlines')\n", + " )\n", + " \n", + " RandomCorpus.serialize('wiki.mm', corpus)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load train and test corpus\n", + "Using `RandomCorpus` wrapper" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2019-01-15 19:31:07,323 : INFO : loaded corpus index from wiki.mm.index\n", + "2019-01-15 19:31:07,324 : INFO : initializing cython corpus reader from wiki.mm\n", + "2019-01-15 19:31:07,325 : INFO : accepted corpus with 4924894 documents, 100000 features, 683375728 non-zero entries\n", + "2019-01-15 19:31:08,544 : INFO : loaded corpus index from wiki.mm.index\n", + "2019-01-15 19:31:08,544 : INFO : initializing cython corpus reader from wiki.mm\n", + "2019-01-15 19:31:08,545 : INFO : accepted corpus with 4924894 documents, 100000 features, 683375728 non-zero entries\n" + ] + } + ], + "source": [ + "train_corpus = RandomCorpus(\n", + " random_seed=42, testset=False, testsize=2000, fname='wiki.mm'\n", + ")\n", + "test_corpus = RandomCorpus(\n", + " random_seed=42, testset=True, testsize=2000, fname='wiki.mm'\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def get_execution_time(func):\n", + " start = time.time()\n", + "\n", + " result = func()\n", + "\n", + " return (time.time() - start), result\n", + "\n", + "\n", + "def get_tm_metrics(model, test_corpus):\n", + " W = model.get_topics().T\n", + " H = np.zeros((model.num_topics, len(test_corpus)))\n", + " for bow_id, bow in enumerate(test_corpus):\n", + " for topic_id, word_count in model.get_document_topics(bow):\n", + " H[topic_id, bow_id] = word_count\n", + "\n", + " pred_factors = W.dot(H)\n", + " pred_factors /= pred_factors.sum(axis=0)\n", + " \n", + " dense_corpus = matutils.corpus2dense(test_corpus, pred_factors.shape[0])\n", + "\n", + " perplexity = get_tm_perplexity(pred_factors, dense_corpus)\n", + "\n", + " l2_norm = get_tm_l2_norm(pred_factors, dense_corpus)\n", + "\n", + " model.normalize = True\n", + "\n", + " coherence = CoherenceModel(\n", + " model=model,\n", + " corpus=test_corpus,\n", + " coherence='u_mass'\n", + " ).get_coherence()\n", + "\n", + " topics = model.show_topics()\n", + "\n", + " model.normalize = False\n", + "\n", + " return dict(\n", + " perplexity=perplexity,\n", + " coherence=coherence,\n", + " topics=topics,\n", + " l2_norm=l2_norm,\n", + " )\n", + "\n", + "\n", + "def get_tm_perplexity(pred_factors, dense_corpus):\n", + " return np.exp(-(np.log(pred_factors, where=pred_factors > 0) * dense_corpus).sum() / dense_corpus.sum())\n", + "\n", + "\n", + "def get_tm_l2_norm(pred_factors, dense_corpus):\n", + " return np.linalg.norm(dense_corpus / dense_corpus.sum(axis=0) - pred_factors)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define dataframe in which we'll store metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "tm_metrics = pd.DataFrame()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define common params for models" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "params = dict(\n", + " corpus=train_corpus,\n", + " chunksize=2000,\n", + " num_topics=50,\n", + " id2word=dictionary,\n", + " passes=1,\n", + " eval_every=10,\n", + " minimum_probability=0,\n", + " random_state=42,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Train NMF and save it\n", + "Normalization is turned off to compute metrics correctly" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2019-01-15 19:33:21,875 : INFO : Loss (no outliers): 2186.768444126956\tLoss (with outliers): 2186.768444126956\n", + "2019-01-15 19:34:49,514 : INFO : Loss (no outliers): 2298.434152045061\tLoss (with outliers): 2298.434152045061\n", + "==Truncated==\n", + "2019-01-15 20:44:23,913 : INFO : Loss (no outliers): 1322.9664709183141\tLoss (with outliers): 1322.9664709183141\n", + "2019-01-15 20:44:23,928 : INFO : saving Nmf object under nmf.model, separately None\n", + "2019-01-15 20:44:24,625 : INFO : saved nmf.model\n" + ] + } + ], + "source": [ + "row = dict()\n", + "row['model'] = 'nmf'\n", + "row['train_time'], nmf = get_execution_time(\n", + " lambda: Nmf(\n", + " use_r=False,\n", + " normalize=False,\n", + " **params\n", + " )\n", + ")\n", + "nmf.save('nmf.model')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load NMF and store metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2019-01-15 20:44:24,872 : INFO : loading Nmf object from nmf.model\n", + "2019-01-15 20:44:25,150 : INFO : loading id2word recursively from nmf.model.id2word.* with mmap=None\n", + "2019-01-15 20:44:25,151 : INFO : loaded nmf.model\n", + "2019-01-15 20:44:54,148 : INFO : CorpusAccumulator accumulated stats from 1000 documents\n", + "2019-01-15 20:44:54,336 : INFO : CorpusAccumulator accumulated stats from 2000 documents\n" + ] + }, + { + "data": { + "text/plain": [ + "[(0,\n", + " '0.075*\"parti\" + 0.071*\"elect\" + 0.042*\"democrat\" + 0.029*\"republican\" + 0.022*\"vote\" + 0.018*\"conserv\" + 0.017*\"liber\" + 0.014*\"candid\" + 0.013*\"seat\" + 0.013*\"labour\"'),\n", + " (1,\n", + " '0.039*\"book\" + 0.038*\"centuri\" + 0.032*\"histori\" + 0.032*\"languag\" + 0.032*\"publish\" + 0.024*\"english\" + 0.023*\"world\" + 0.022*\"law\" + 0.022*\"govern\" + 0.021*\"nation\"'),\n", + " (2,\n", + " '0.050*\"war\" + 0.036*\"forc\" + 0.026*\"armi\" + 0.023*\"battl\" + 0.021*\"attack\" + 0.019*\"militari\" + 0.018*\"german\" + 0.016*\"british\" + 0.015*\"command\" + 0.014*\"kill\"'),\n", + " (3,\n", + " '0.119*\"race\" + 0.106*\"car\" + 0.073*\"engin\" + 0.035*\"model\" + 0.030*\"driver\" + 0.029*\"vehicl\" + 0.029*\"ford\" + 0.028*\"lap\" + 0.023*\"electr\" + 0.020*\"power\"'),\n", + " (4,\n", + " '0.102*\"leagu\" + 0.092*\"club\" + 0.049*\"footbal\" + 0.047*\"cup\" + 0.029*\"plai\" + 0.028*\"season\" + 0.028*\"divis\" + 0.028*\"goal\" + 0.022*\"team\" + 0.021*\"unit\"'),\n", + " (5,\n", + " '0.055*\"award\" + 0.041*\"best\" + 0.008*\"nomin\" + 0.008*\"year\" + 0.006*\"actress\" + 0.006*\"actor\" + 0.005*\"perform\" + 0.005*\"artist\" + 0.005*\"won\" + 0.005*\"outstand\"'),\n", + " (6,\n", + " '0.115*\"citi\" + 0.014*\"airport\" + 0.013*\"area\" + 0.011*\"popul\" + 0.010*\"san\" + 0.009*\"region\" + 0.008*\"center\" + 0.007*\"municip\" + 0.007*\"intern\" + 0.007*\"ukrainian\"'),\n", + " (7,\n", + " '0.316*\"act\" + 0.046*\"amend\" + 0.020*\"order\" + 0.018*\"ireland\" + 0.016*\"law\" + 0.015*\"regul\" + 0.013*\"court\" + 0.011*\"scotland\" + 0.011*\"road\" + 0.009*\"public\"'),\n", + " (8,\n", + " '0.102*\"align\" + 0.084*\"left\" + 0.022*\"right\" + 0.012*\"text\" + 0.011*\"style\" + 0.007*\"center\" + 0.004*\"bar\" + 0.003*\"till\" + 0.003*\"bgcolor\" + 0.003*\"color\"'),\n", + " (9,\n", + " '0.092*\"team\" + 0.027*\"race\" + 0.025*\"ret\" + 0.014*\"championship\" + 0.007*\"nation\" + 0.006*\"time\" + 0.006*\"sport\" + 0.005*\"stage\" + 0.005*\"coach\" + 0.005*\"finish\"'),\n", + " (10,\n", + " '0.135*\"compani\" + 0.089*\"ship\" + 0.035*\"product\" + 0.028*\"oper\" + 0.024*\"navi\" + 0.022*\"corpor\" + 0.021*\"oil\" + 0.021*\"launch\" + 0.021*\"bank\" + 0.021*\"built\"'),\n", + " (11,\n", + " '0.053*\"new\" + 0.019*\"york\" + 0.004*\"zealand\" + 0.003*\"jersei\" + 0.003*\"american\" + 0.002*\"time\" + 0.002*\"australia\" + 0.002*\"radio\" + 0.002*\"press\" + 0.002*\"washington\"'),\n", + " (12,\n", + " '0.036*\"world\" + 0.034*\"championship\" + 0.032*\"final\" + 0.029*\"match\" + 0.026*\"win\" + 0.026*\"round\" + 0.019*\"open\" + 0.018*\"won\" + 0.015*\"defeat\" + 0.015*\"cup\"'),\n", + " (13,\n", + " '0.019*\"album\" + 0.017*\"record\" + 0.014*\"band\" + 0.008*\"releas\" + 0.005*\"tour\" + 0.005*\"guitar\" + 0.005*\"vocal\" + 0.004*\"rock\" + 0.004*\"track\" + 0.004*\"music\"'),\n", + " (14,\n", + " '0.100*\"church\" + 0.017*\"cathol\" + 0.014*\"christian\" + 0.012*\"centuri\" + 0.012*\"saint\" + 0.011*\"bishop\" + 0.011*\"built\" + 0.009*\"list\" + 0.009*\"build\" + 0.008*\"roman\"'),\n", + " (15,\n", + " '0.088*\"presid\" + 0.072*\"minist\" + 0.046*\"prime\" + 0.015*\"govern\" + 0.014*\"gener\" + 0.011*\"met\" + 0.011*\"governor\" + 0.010*\"foreign\" + 0.010*\"visit\" + 0.009*\"council\"'),\n", + " (16,\n", + " '0.182*\"speci\" + 0.112*\"famili\" + 0.101*\"nov\" + 0.092*\"valid\" + 0.066*\"genu\" + 0.045*\"format\" + 0.040*\"member\" + 0.037*\"gen\" + 0.036*\"bird\" + 0.034*\"type\"'),\n", + " (17,\n", + " '0.029*\"season\" + 0.013*\"yard\" + 0.013*\"game\" + 0.011*\"plai\" + 0.008*\"team\" + 0.007*\"score\" + 0.007*\"win\" + 0.007*\"record\" + 0.006*\"run\" + 0.006*\"coach\"'),\n", + " (18,\n", + " '0.214*\"counti\" + 0.064*\"township\" + 0.017*\"area\" + 0.016*\"statist\" + 0.007*\"ohio\" + 0.006*\"metropolitan\" + 0.006*\"combin\" + 0.005*\"pennsylvania\" + 0.005*\"texa\" + 0.005*\"washington\"'),\n", + " (19,\n", + " '0.017*\"area\" + 0.016*\"river\" + 0.015*\"water\" + 0.006*\"larg\" + 0.006*\"region\" + 0.006*\"lake\" + 0.006*\"power\" + 0.006*\"high\" + 0.005*\"bar\" + 0.005*\"form\"'),\n", + " (20,\n", + " '0.031*\"us\" + 0.025*\"gener\" + 0.024*\"model\" + 0.022*\"data\" + 0.021*\"design\" + 0.020*\"time\" + 0.019*\"function\" + 0.019*\"number\" + 0.018*\"process\" + 0.017*\"exampl\"'),\n", + " (21,\n", + " '0.202*\"order\" + 0.098*\"group\" + 0.098*\"regul\" + 0.076*\"amend\" + 0.041*\"road\" + 0.034*\"traffic\" + 0.033*\"temporari\" + 0.032*\"prohibit\" + 0.027*\"trunk\" + 0.021*\"junction\"'),\n", + " (22,\n", + " '0.096*\"film\" + 0.010*\"product\" + 0.010*\"director\" + 0.010*\"festiv\" + 0.009*\"star\" + 0.009*\"produc\" + 0.009*\"movi\" + 0.008*\"direct\" + 0.007*\"releas\" + 0.007*\"actor\"'),\n", + " (23,\n", + " '0.163*\"music\" + 0.046*\"viola\" + 0.045*\"radio\" + 0.042*\"piano\" + 0.029*\"perform\" + 0.028*\"station\" + 0.027*\"orchestra\" + 0.026*\"compos\" + 0.025*\"song\" + 0.015*\"rock\"'),\n", + " (24,\n", + " '0.052*\"mount\" + 0.051*\"lemmon\" + 0.051*\"peak\" + 0.051*\"kitt\" + 0.051*\"spacewatch\" + 0.026*\"survei\" + 0.015*\"octob\" + 0.012*\"septemb\" + 0.009*\"css\" + 0.009*\"catalina\"'),\n", + " (25,\n", + " '0.075*\"air\" + 0.035*\"forc\" + 0.030*\"squadron\" + 0.029*\"aircraft\" + 0.028*\"oper\" + 0.023*\"unit\" + 0.018*\"flight\" + 0.017*\"airport\" + 0.017*\"wing\" + 0.017*\"base\"'),\n", + " (26,\n", + " '0.105*\"hous\" + 0.038*\"term\" + 0.020*\"march\" + 0.019*\"build\" + 0.019*\"member\" + 0.017*\"serv\" + 0.014*\"congress\" + 0.014*\"hall\" + 0.012*\"januari\" + 0.010*\"window\"'),\n", + " (27,\n", + " '0.129*\"district\" + 0.019*\"pennsylvania\" + 0.016*\"grade\" + 0.012*\"fund\" + 0.012*\"educ\" + 0.012*\"basic\" + 0.011*\"level\" + 0.010*\"oblast\" + 0.010*\"rural\" + 0.009*\"tax\"'),\n", + " (28,\n", + " '0.042*\"year\" + 0.012*\"dai\" + 0.007*\"time\" + 0.005*\"ag\" + 0.004*\"month\" + 0.003*\"includ\" + 0.003*\"follow\" + 0.003*\"later\" + 0.003*\"old\" + 0.003*\"student\"'),\n", + " (29,\n", + " '0.113*\"station\" + 0.109*\"line\" + 0.076*\"road\" + 0.072*\"railwai\" + 0.048*\"rout\" + 0.035*\"oper\" + 0.034*\"train\" + 0.023*\"street\" + 0.020*\"cross\" + 0.020*\"railroad\"'),\n", + " (30,\n", + " '0.036*\"park\" + 0.029*\"town\" + 0.025*\"north\" + 0.020*\"south\" + 0.018*\"west\" + 0.017*\"east\" + 0.017*\"street\" + 0.015*\"nation\" + 0.014*\"build\" + 0.013*\"river\"'),\n", + " (31,\n", + " '0.066*\"women\" + 0.044*\"men\" + 0.030*\"nation\" + 0.024*\"right\" + 0.014*\"athlet\" + 0.013*\"intern\" + 0.013*\"rank\" + 0.013*\"countri\" + 0.012*\"advanc\" + 0.011*\"event\"'),\n", + " (32,\n", + " '0.127*\"linear\" + 0.126*\"socorro\" + 0.029*\"septemb\" + 0.026*\"neat\" + 0.023*\"palomar\" + 0.021*\"octob\" + 0.016*\"kitt\" + 0.016*\"peak\" + 0.015*\"spacewatch\" + 0.015*\"anderson\"'),\n", + " (33,\n", + " '0.152*\"univers\" + 0.055*\"colleg\" + 0.019*\"institut\" + 0.018*\"student\" + 0.018*\"scienc\" + 0.015*\"professor\" + 0.012*\"research\" + 0.011*\"campu\" + 0.011*\"educ\" + 0.011*\"technolog\"'),\n", + " (34,\n", + " '0.072*\"state\" + 0.032*\"unit\" + 0.005*\"court\" + 0.005*\"law\" + 0.004*\"feder\" + 0.004*\"american\" + 0.003*\"nation\" + 0.003*\"govern\" + 0.003*\"kingdom\" + 0.003*\"senat\"'),\n", + " (35,\n", + " '0.074*\"game\" + 0.017*\"player\" + 0.007*\"plai\" + 0.006*\"releas\" + 0.005*\"develop\" + 0.005*\"video\" + 0.005*\"charact\" + 0.004*\"playstat\" + 0.004*\"version\" + 0.004*\"world\"'),\n", + " (36,\n", + " '0.141*\"south\" + 0.098*\"american\" + 0.081*\"india\" + 0.059*\"commun\" + 0.053*\"west\" + 0.053*\"director\" + 0.053*\"africa\" + 0.049*\"usa\" + 0.049*\"indian\" + 0.041*\"servic\"'),\n", + " (37,\n", + " '0.111*\"servic\" + 0.025*\"commun\" + 0.021*\"offic\" + 0.012*\"polic\" + 0.011*\"educ\" + 0.011*\"public\" + 0.010*\"chief\" + 0.009*\"late\" + 0.009*\"manag\" + 0.008*\"mr\"'),\n", + " (38,\n", + " '0.112*\"royal\" + 0.085*\"john\" + 0.083*\"william\" + 0.054*\"lieuten\" + 0.044*\"georg\" + 0.041*\"offic\" + 0.041*\"jame\" + 0.038*\"sergeant\" + 0.037*\"major\" + 0.035*\"charl\"'),\n", + " (39,\n", + " '0.051*\"song\" + 0.043*\"releas\" + 0.042*\"singl\" + 0.027*\"chart\" + 0.025*\"album\" + 0.017*\"number\" + 0.014*\"video\" + 0.013*\"version\" + 0.012*\"love\" + 0.011*\"featur\"'),\n", + " (40,\n", + " '0.031*\"time\" + 0.028*\"later\" + 0.026*\"appear\" + 0.025*\"man\" + 0.024*\"kill\" + 0.020*\"charact\" + 0.019*\"work\" + 0.018*\"father\" + 0.018*\"death\" + 0.018*\"famili\"'),\n", + " (41,\n", + " '0.126*\"seri\" + 0.064*\"episod\" + 0.026*\"season\" + 0.021*\"televis\" + 0.015*\"comic\" + 0.013*\"charact\" + 0.012*\"dvd\" + 0.012*\"anim\" + 0.012*\"star\" + 0.011*\"appear\"'),\n", + " (42,\n", + " '0.143*\"born\" + 0.073*\"american\" + 0.027*\"footbal\" + 0.024*\"player\" + 0.024*\"william\" + 0.023*\"singer\" + 0.019*\"actor\" + 0.017*\"politician\" + 0.015*\"actress\" + 0.013*\"english\"'),\n", + " (43,\n", + " '0.044*\"march\" + 0.042*\"septemb\" + 0.036*\"octob\" + 0.033*\"januari\" + 0.032*\"april\" + 0.031*\"august\" + 0.031*\"juli\" + 0.029*\"novemb\" + 0.029*\"june\" + 0.028*\"decemb\"'),\n", + " (44,\n", + " '0.149*\"island\" + 0.013*\"south\" + 0.013*\"australia\" + 0.009*\"sea\" + 0.008*\"north\" + 0.008*\"bai\" + 0.008*\"western\" + 0.008*\"airport\" + 0.007*\"coast\" + 0.006*\"pacif\"'),\n", + " (45,\n", + " '0.028*\"studi\" + 0.026*\"research\" + 0.023*\"health\" + 0.019*\"human\" + 0.019*\"term\" + 0.019*\"develop\" + 0.018*\"includ\" + 0.018*\"peopl\" + 0.017*\"report\" + 0.017*\"cell\"'),\n", + " (46,\n", + " '0.112*\"school\" + 0.028*\"high\" + 0.016*\"student\" + 0.012*\"educ\" + 0.009*\"grade\" + 0.008*\"primari\" + 0.007*\"public\" + 0.006*\"colleg\" + 0.006*\"elementari\" + 0.006*\"pennsylvania\"'),\n", + " (47,\n", + " '0.137*\"royal\" + 0.121*\"capt\" + 0.103*\"armi\" + 0.090*\"maj\" + 0.089*\"corp\" + 0.075*\"col\" + 0.074*\"temp\" + 0.048*\"servic\" + 0.040*\"engin\" + 0.033*\"reg\"'),\n", + " (48,\n", + " '0.183*\"art\" + 0.117*\"museum\" + 0.071*\"paint\" + 0.062*\"work\" + 0.046*\"artist\" + 0.043*\"galleri\" + 0.040*\"exhibit\" + 0.034*\"collect\" + 0.027*\"histori\" + 0.022*\"jpg\"'),\n", + " (49,\n", + " '0.068*\"regiment\" + 0.062*\"divis\" + 0.049*\"battalion\" + 0.045*\"infantri\" + 0.036*\"brigad\" + 0.024*\"armi\" + 0.023*\"artilleri\" + 0.019*\"compani\" + 0.018*\"gener\" + 0.018*\"colonel\"')]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nmf = Nmf.load('nmf.model')\n", + "row.update(get_tm_metrics(nmf, test_corpus))\n", + "tm_metrics = tm_metrics.append(pd.Series(row), ignore_index=True)\n", + "\n", + "nmf.show_topics(50)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Train NMF with residuals and save it\n", + "Residuals add regularization to the model thus increasing quality, but slows down training" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2019-01-15 20:54:05,363 : INFO : Loss (no outliers): 2179.9524465227146\tLoss (with outliers): 2102.354108449905\n", + "2019-01-15 20:57:12,821 : INFO : Loss (no outliers): 2268.3200929871823\tLoss (with outliers): 2110.928651253909\n", + "==Truncated==\n", + "2019-01-16 04:05:46,589 : INFO : Loss (no outliers): 1321.521323758918\tLoss (with outliers): 1282.9364495345592\n", + "2019-01-16 04:05:46,599 : INFO : saving Nmf object under nmf_with_r.model, separately None\n", + "2019-01-16 04:05:46,601 : INFO : storing scipy.sparse array '_r' under nmf_with_r.model._r.npy\n", + "2019-01-16 04:05:47,781 : INFO : saved nmf_with_r.model\n" + ] + } + ], + "source": [ + "row = dict()\n", + "row['model'] = 'nmf_with_r'\n", + "row['train_time'], nmf_with_r = get_execution_time(\n", + " lambda: Nmf(\n", + " use_r=True,\n", + " lambda_=200,\n", + " normalize=False,\n", + " **params\n", + " )\n", + ")\n", + "nmf_with_r.save('nmf_with_r.model')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load NMF with residuals and store metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2019-01-16 04:05:48,017 : INFO : loading Nmf object from nmf_with_r.model\n", + "2019-01-16 04:05:48,272 : INFO : loading id2word recursively from nmf_with_r.model.id2word.* with mmap=None\n", + "2019-01-16 04:05:48,273 : INFO : loading _r from nmf_with_r.model._r.npy with mmap=None\n", + "2019-01-16 04:05:48,304 : INFO : loaded nmf_with_r.model\n", + "2019-01-16 04:06:27,119 : INFO : CorpusAccumulator accumulated stats from 1000 documents\n", + "2019-01-16 04:06:27,253 : INFO : CorpusAccumulator accumulated stats from 2000 documents\n" + ] + }, + { + "data": { + "text/plain": [ + "[(0,\n", + " '0.062*\"parti\" + 0.061*\"elect\" + 0.031*\"democrat\" + 0.020*\"republican\" + 0.020*\"vote\" + 0.013*\"liber\" + 0.012*\"candid\" + 0.012*\"conserv\" + 0.011*\"seat\" + 0.010*\"member\"'),\n", + " (1,\n", + " '0.052*\"book\" + 0.040*\"centuri\" + 0.039*\"publish\" + 0.031*\"languag\" + 0.027*\"histori\" + 0.025*\"work\" + 0.023*\"english\" + 0.022*\"king\" + 0.019*\"polit\" + 0.019*\"author\"'),\n", + " (2,\n", + " '0.031*\"armi\" + 0.028*\"divis\" + 0.025*\"regiment\" + 0.022*\"forc\" + 0.020*\"battalion\" + 0.019*\"infantri\" + 0.019*\"command\" + 0.017*\"brigad\" + 0.016*\"gener\" + 0.012*\"corp\"'),\n", + " (3,\n", + " '0.110*\"race\" + 0.059*\"car\" + 0.033*\"engin\" + 0.025*\"lap\" + 0.023*\"driver\" + 0.021*\"ret\" + 0.020*\"ford\" + 0.015*\"finish\" + 0.015*\"motorsport\" + 0.015*\"chevrolet\"'),\n", + " (4,\n", + " '0.130*\"club\" + 0.068*\"cup\" + 0.046*\"footbal\" + 0.044*\"goal\" + 0.032*\"leagu\" + 0.031*\"unit\" + 0.031*\"plai\" + 0.030*\"match\" + 0.026*\"score\" + 0.021*\"player\"'),\n", + " (5,\n", + " '0.041*\"award\" + 0.030*\"best\" + 0.006*\"nomin\" + 0.005*\"actress\" + 0.005*\"year\" + 0.004*\"actor\" + 0.004*\"won\" + 0.004*\"perform\" + 0.003*\"outstand\" + 0.003*\"artist\"'),\n", + " (6,\n", + " '0.087*\"citi\" + 0.013*\"town\" + 0.009*\"popul\" + 0.008*\"area\" + 0.007*\"san\" + 0.006*\"center\" + 0.006*\"airport\" + 0.006*\"unit\" + 0.006*\"locat\" + 0.005*\"municip\"'),\n", + " (7,\n", + " '0.171*\"act\" + 0.021*\"amend\" + 0.018*\"order\" + 0.010*\"ireland\" + 0.009*\"law\" + 0.007*\"court\" + 0.007*\"regul\" + 0.006*\"road\" + 0.006*\"scotland\" + 0.006*\"nation\"'),\n", + " (8,\n", + " '0.064*\"leagu\" + 0.014*\"divis\" + 0.012*\"left\" + 0.011*\"align\" + 0.009*\"basebal\" + 0.008*\"footbal\" + 0.007*\"run\" + 0.007*\"major\" + 0.005*\"home\" + 0.005*\"hit\"'),\n", + " (9,\n", + " '0.086*\"team\" + 0.013*\"championship\" + 0.007*\"nation\" + 0.007*\"race\" + 0.007*\"coach\" + 0.005*\"time\" + 0.004*\"sport\" + 0.004*\"ret\" + 0.004*\"player\" + 0.004*\"match\"'),\n", + " (10,\n", + " '0.100*\"episod\" + 0.055*\"compani\" + 0.021*\"product\" + 0.011*\"produc\" + 0.011*\"televis\" + 0.009*\"role\" + 0.009*\"busi\" + 0.008*\"market\" + 0.008*\"corpor\" + 0.007*\"bank\"'),\n", + " (11,\n", + " '0.050*\"new\" + 0.017*\"york\" + 0.003*\"zealand\" + 0.003*\"jersei\" + 0.002*\"time\" + 0.002*\"radio\" + 0.002*\"broadcast\" + 0.002*\"station\" + 0.002*\"washington\" + 0.002*\"australia\"'),\n", + " (12,\n", + " '0.035*\"final\" + 0.033*\"world\" + 0.030*\"round\" + 0.030*\"championship\" + 0.025*\"win\" + 0.025*\"match\" + 0.021*\"open\" + 0.017*\"won\" + 0.016*\"tournament\" + 0.015*\"event\"'),\n", + " (13,\n", + " '0.020*\"record\" + 0.019*\"band\" + 0.015*\"album\" + 0.007*\"releas\" + 0.007*\"guitar\" + 0.006*\"tour\" + 0.005*\"rock\" + 0.005*\"vocal\" + 0.004*\"plai\" + 0.004*\"live\"'),\n", + " (14,\n", + " '0.096*\"church\" + 0.015*\"cathol\" + 0.012*\"christian\" + 0.010*\"saint\" + 0.010*\"bishop\" + 0.009*\"centuri\" + 0.008*\"build\" + 0.007*\"parish\" + 0.007*\"built\" + 0.007*\"roman\"'),\n", + " (15,\n", + " '0.084*\"presid\" + 0.055*\"minist\" + 0.037*\"prime\" + 0.014*\"govern\" + 0.012*\"gener\" + 0.010*\"governor\" + 0.010*\"nation\" + 0.008*\"council\" + 0.008*\"secretari\" + 0.008*\"visit\"'),\n", + " (16,\n", + " '0.089*\"yard\" + 0.035*\"pass\" + 0.035*\"touchdown\" + 0.028*\"field\" + 0.025*\"run\" + 0.023*\"win\" + 0.022*\"score\" + 0.021*\"quarter\" + 0.017*\"record\" + 0.016*\"second\"'),\n", + " (17,\n", + " '0.042*\"season\" + 0.006*\"plai\" + 0.004*\"coach\" + 0.004*\"final\" + 0.004*\"second\" + 0.004*\"win\" + 0.004*\"record\" + 0.003*\"career\" + 0.003*\"finish\" + 0.003*\"point\"'),\n", + " (18,\n", + " '0.174*\"counti\" + 0.034*\"township\" + 0.014*\"area\" + 0.013*\"statist\" + 0.004*\"texa\" + 0.004*\"ohio\" + 0.004*\"virginia\" + 0.004*\"washington\" + 0.003*\"metropolitan\" + 0.003*\"pennsylvania\"'),\n", + " (19,\n", + " '0.012*\"water\" + 0.010*\"area\" + 0.010*\"speci\" + 0.007*\"larg\" + 0.006*\"order\" + 0.006*\"region\" + 0.006*\"includ\" + 0.005*\"black\" + 0.005*\"famili\" + 0.005*\"popul\"'),\n", + " (20,\n", + " '0.020*\"us\" + 0.015*\"gener\" + 0.014*\"design\" + 0.014*\"model\" + 0.012*\"develop\" + 0.012*\"time\" + 0.012*\"data\" + 0.011*\"number\" + 0.011*\"function\" + 0.011*\"process\"'),\n", + " (21,\n", + " '0.165*\"group\" + 0.023*\"left\" + 0.022*\"align\" + 0.021*\"member\" + 0.017*\"text\" + 0.015*\"bar\" + 0.011*\"order\" + 0.011*\"point\" + 0.010*\"till\" + 0.009*\"stage\"'),\n", + " (22,\n", + " '0.095*\"film\" + 0.009*\"director\" + 0.008*\"star\" + 0.008*\"movi\" + 0.008*\"product\" + 0.008*\"festiv\" + 0.008*\"releas\" + 0.008*\"produc\" + 0.007*\"direct\" + 0.006*\"featur\"'),\n", + " (23,\n", + " '0.107*\"music\" + 0.024*\"perform\" + 0.019*\"piano\" + 0.018*\"song\" + 0.017*\"compos\" + 0.017*\"orchestra\" + 0.017*\"viola\" + 0.012*\"plai\" + 0.011*\"radio\" + 0.011*\"danc\"'),\n", + " (24,\n", + " '0.023*\"septemb\" + 0.023*\"march\" + 0.020*\"octob\" + 0.020*\"juli\" + 0.019*\"june\" + 0.019*\"april\" + 0.019*\"august\" + 0.018*\"januari\" + 0.018*\"novemb\" + 0.017*\"decemb\"'),\n", + " (25,\n", + " '0.078*\"air\" + 0.041*\"forc\" + 0.031*\"aircraft\" + 0.027*\"squadron\" + 0.026*\"oper\" + 0.021*\"unit\" + 0.016*\"base\" + 0.016*\"wing\" + 0.016*\"flight\" + 0.015*\"fighter\"'),\n", + " (26,\n", + " '0.101*\"hous\" + 0.023*\"build\" + 0.021*\"term\" + 0.015*\"member\" + 0.014*\"serv\" + 0.014*\"march\" + 0.014*\"left\" + 0.012*\"congress\" + 0.011*\"hall\" + 0.010*\"street\"'),\n", + " (27,\n", + " '0.123*\"district\" + 0.024*\"pennsylvania\" + 0.019*\"grade\" + 0.016*\"educ\" + 0.015*\"fund\" + 0.014*\"basic\" + 0.013*\"level\" + 0.011*\"student\" + 0.011*\"receiv\" + 0.010*\"tax\"'),\n", + " (28,\n", + " '0.048*\"year\" + 0.007*\"dai\" + 0.005*\"time\" + 0.005*\"ag\" + 0.003*\"month\" + 0.003*\"old\" + 0.003*\"student\" + 0.003*\"includ\" + 0.003*\"later\" + 0.002*\"million\"'),\n", + " (29,\n", + " '0.090*\"line\" + 0.083*\"station\" + 0.054*\"road\" + 0.053*\"railwai\" + 0.036*\"rout\" + 0.030*\"train\" + 0.027*\"oper\" + 0.020*\"street\" + 0.016*\"servic\" + 0.016*\"open\"'),\n", + " (30,\n", + " '0.031*\"park\" + 0.030*\"south\" + 0.030*\"north\" + 0.023*\"west\" + 0.020*\"river\" + 0.020*\"east\" + 0.015*\"area\" + 0.014*\"town\" + 0.013*\"lake\" + 0.013*\"nation\"'),\n", + " (31,\n", + " '0.071*\"women\" + 0.041*\"men\" + 0.027*\"nation\" + 0.023*\"right\" + 0.012*\"countri\" + 0.012*\"intern\" + 0.012*\"athlet\" + 0.011*\"advanc\" + 0.011*\"rank\" + 0.010*\"law\"'),\n", + " (32,\n", + " '0.104*\"linear\" + 0.104*\"socorro\" + 0.025*\"septemb\" + 0.020*\"neat\" + 0.018*\"palomar\" + 0.018*\"octob\" + 0.013*\"decemb\" + 0.013*\"august\" + 0.012*\"anderson\" + 0.012*\"mesa\"'),\n", + " (33,\n", + " '0.089*\"univers\" + 0.011*\"scienc\" + 0.009*\"institut\" + 0.008*\"research\" + 0.008*\"professor\" + 0.006*\"student\" + 0.005*\"technolog\" + 0.005*\"faculti\" + 0.005*\"studi\" + 0.005*\"engin\"'),\n", + " (34,\n", + " '0.064*\"state\" + 0.024*\"unit\" + 0.005*\"court\" + 0.005*\"law\" + 0.004*\"feder\" + 0.003*\"nation\" + 0.003*\"govern\" + 0.002*\"senat\" + 0.002*\"california\" + 0.002*\"constitut\"'),\n", + " (35,\n", + " '0.085*\"colleg\" + 0.019*\"univers\" + 0.014*\"student\" + 0.008*\"campu\" + 0.007*\"institut\" + 0.006*\"educ\" + 0.005*\"hall\" + 0.005*\"program\" + 0.005*\"commun\" + 0.005*\"state\"'),\n", + " (36,\n", + " '0.118*\"class\" + 0.079*\"director\" + 0.053*\"rifl\" + 0.050*\"south\" + 0.048*\"×mm\" + 0.046*\"action\" + 0.045*\"san\" + 0.044*\"actor\" + 0.041*\"angel\" + 0.037*\"lo\"'),\n", + " (37,\n", + " '0.092*\"servic\" + 0.025*\"offic\" + 0.023*\"commun\" + 0.013*\"john\" + 0.012*\"chief\" + 0.011*\"polic\" + 0.011*\"public\" + 0.011*\"british\" + 0.010*\"late\" + 0.010*\"director\"'),\n", + " (38,\n", + " '0.156*\"royal\" + 0.072*\"william\" + 0.068*\"john\" + 0.058*\"corp\" + 0.051*\"lieuten\" + 0.046*\"capt\" + 0.041*\"engin\" + 0.041*\"armi\" + 0.039*\"georg\" + 0.039*\"temp\"'),\n", + " (39,\n", + " '0.042*\"song\" + 0.039*\"album\" + 0.034*\"releas\" + 0.029*\"singl\" + 0.024*\"chart\" + 0.013*\"number\" + 0.011*\"video\" + 0.010*\"love\" + 0.010*\"featur\" + 0.010*\"track\"'),\n", + " (40,\n", + " '0.028*\"time\" + 0.025*\"later\" + 0.023*\"kill\" + 0.019*\"appear\" + 0.018*\"man\" + 0.016*\"death\" + 0.016*\"father\" + 0.015*\"return\" + 0.015*\"son\" + 0.014*\"charact\"'),\n", + " (41,\n", + " '0.110*\"seri\" + 0.016*\"charact\" + 0.016*\"episod\" + 0.015*\"comic\" + 0.013*\"televis\" + 0.012*\"anim\" + 0.011*\"appear\" + 0.009*\"stori\" + 0.009*\"origin\" + 0.009*\"featur\"'),\n", + " (42,\n", + " '0.091*\"born\" + 0.070*\"american\" + 0.022*\"player\" + 0.021*\"footbal\" + 0.020*\"william\" + 0.016*\"actor\" + 0.014*\"politician\" + 0.014*\"singer\" + 0.013*\"john\" + 0.012*\"actress\"'),\n", + " (43,\n", + " '0.072*\"game\" + 0.017*\"player\" + 0.011*\"plai\" + 0.004*\"releas\" + 0.004*\"point\" + 0.004*\"develop\" + 0.004*\"score\" + 0.003*\"video\" + 0.003*\"time\" + 0.003*\"card\"'),\n", + " (44,\n", + " '0.110*\"island\" + 0.007*\"australia\" + 0.007*\"ship\" + 0.007*\"south\" + 0.007*\"sea\" + 0.006*\"bai\" + 0.005*\"coast\" + 0.004*\"pacif\" + 0.004*\"western\" + 0.004*\"british\"'),\n", + " (45,\n", + " '0.029*\"health\" + 0.028*\"studi\" + 0.027*\"research\" + 0.022*\"peopl\" + 0.020*\"human\" + 0.019*\"medic\" + 0.019*\"cell\" + 0.018*\"report\" + 0.018*\"ag\" + 0.017*\"includ\"'),\n", + " (46,\n", + " '0.113*\"school\" + 0.025*\"high\" + 0.014*\"student\" + 0.011*\"educ\" + 0.007*\"grade\" + 0.006*\"public\" + 0.005*\"elementari\" + 0.005*\"primari\" + 0.004*\"pennsylvania\" + 0.004*\"teacher\"'),\n", + " (47,\n", + " '0.050*\"war\" + 0.021*\"german\" + 0.017*\"american\" + 0.016*\"british\" + 0.016*\"world\" + 0.012*\"french\" + 0.010*\"battl\" + 0.010*\"germani\" + 0.009*\"ship\" + 0.009*\"soviet\"'),\n", + " (48,\n", + " '0.174*\"art\" + 0.099*\"museum\" + 0.058*\"paint\" + 0.057*\"work\" + 0.044*\"artist\" + 0.041*\"galleri\" + 0.038*\"exhibit\" + 0.031*\"collect\" + 0.023*\"histori\" + 0.021*\"design\"'),\n", + " (49,\n", + " '0.067*\"peak\" + 0.066*\"kitt\" + 0.066*\"mount\" + 0.066*\"spacewatch\" + 0.065*\"lemmon\" + 0.033*\"survei\" + 0.026*\"octob\" + 0.024*\"septemb\" + 0.015*\"novemb\" + 0.012*\"march\"')]" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nmf_with_r = Nmf.load('nmf_with_r.model')\n", + "row.update(get_tm_metrics(nmf_with_r, test_corpus))\n", + "tm_metrics = tm_metrics.append(pd.Series(row), ignore_index=True)\n", + "\n", + "nmf_with_r.show_topics(50)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Train LDA and save it\n", + "That's a common model to do Topic Modeling" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2019-01-16 04:06:27,576 : INFO : using symmetric alpha at 0.02\n", + "2019-01-16 04:06:27,576 : INFO : using symmetric eta at 0.02\n", + "2019-01-16 04:06:27,589 : INFO : using serial LDA version on this node\n", + "2019-01-16 04:06:28,185 : INFO : running online (single-pass) LDA training, 50 topics, 1 passes over the supplied corpus of 4922894 documents, updating model once every 2000 documents, evaluating perplexity every 20000 documents, iterating 50x with a convergence threshold of 0.001000\n", + "2019-01-16 04:06:28,910 : INFO : PROGRESS: pass 0, at document #2000/4922894\n", + "==Truncated==\n", + "2019-01-16 06:24:26,456 : INFO : topic diff=0.003897, rho=0.020154\n", + "2019-01-16 06:24:26,465 : INFO : saving LdaState object under lda.model.state, separately None\n", + "2019-01-16 06:24:26,680 : INFO : saved lda.model.state\n", + "2019-01-16 06:24:26,732 : INFO : saving LdaModel object under lda.model, separately ['expElogbeta', 'sstats']\n", + "2019-01-16 06:24:26,732 : INFO : storing np array 'expElogbeta' to lda.model.expElogbeta.npy\n", + "2019-01-16 06:24:26,812 : INFO : not storing attribute dispatcher\n", + "2019-01-16 06:24:26,814 : INFO : not storing attribute id2word\n", + "2019-01-16 06:24:26,815 : INFO : not storing attribute state\n", + "2019-01-16 06:24:26,828 : INFO : saved lda.model\n" + ] + } + ], + "source": [ + "row = dict()\n", + "row['model'] = 'lda'\n", + "row['train_time'], lda = get_execution_time(\n", + " lambda: LdaModel(**params)\n", + ")\n", + "lda.save('lda.model')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load LDA and store metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2019-01-16 06:24:27,064 : INFO : loading LdaModel object from lda.model\n", + "2019-01-16 06:24:27,070 : INFO : loading expElogbeta from lda.model.expElogbeta.npy with mmap=None\n", + "2019-01-16 06:24:27,077 : INFO : setting ignored attribute dispatcher to None\n", + "2019-01-16 06:24:27,078 : INFO : setting ignored attribute id2word to None\n", + "2019-01-16 06:24:27,078 : INFO : setting ignored attribute state to None\n", + "2019-01-16 06:24:27,079 : INFO : loaded lda.model\n", + "2019-01-16 06:24:27,079 : INFO : loading LdaState object from lda.model.state\n", + "2019-01-16 06:24:27,173 : INFO : loaded lda.model.state\n", + "2019-01-16 06:24:41,257 : INFO : CorpusAccumulator accumulated stats from 1000 documents\n", + "2019-01-16 06:24:41,452 : INFO : CorpusAccumulator accumulated stats from 2000 documents\n" + ] + }, + { + "data": { + "text/plain": [ + "[(0,\n", + " '0.033*\"war\" + 0.028*\"armi\" + 0.021*\"forc\" + 0.020*\"command\" + 0.015*\"militari\" + 0.015*\"battl\" + 0.013*\"gener\" + 0.012*\"offic\" + 0.011*\"divis\" + 0.011*\"regiment\"'),\n", + " (1,\n", + " '0.038*\"album\" + 0.028*\"song\" + 0.026*\"releas\" + 0.026*\"record\" + 0.021*\"band\" + 0.016*\"singl\" + 0.015*\"music\" + 0.014*\"chart\" + 0.013*\"track\" + 0.010*\"guitar\"'),\n", + " (2,\n", + " '0.062*\"german\" + 0.039*\"germani\" + 0.025*\"van\" + 0.023*\"von\" + 0.020*\"der\" + 0.019*\"dutch\" + 0.019*\"berlin\" + 0.015*\"swedish\" + 0.014*\"netherland\" + 0.014*\"sweden\"'),\n", + " (3,\n", + " '0.032*\"john\" + 0.027*\"william\" + 0.019*\"british\" + 0.015*\"georg\" + 0.015*\"london\" + 0.014*\"thoma\" + 0.014*\"sir\" + 0.014*\"jame\" + 0.013*\"royal\" + 0.013*\"henri\"'),\n", + " (4,\n", + " '0.137*\"school\" + 0.040*\"colleg\" + 0.039*\"student\" + 0.033*\"univers\" + 0.030*\"high\" + 0.028*\"educ\" + 0.016*\"year\" + 0.011*\"graduat\" + 0.010*\"state\" + 0.009*\"campu\"'),\n", + " (5,\n", + " '0.030*\"game\" + 0.009*\"develop\" + 0.009*\"player\" + 0.008*\"releas\" + 0.008*\"us\" + 0.008*\"softwar\" + 0.008*\"version\" + 0.008*\"user\" + 0.007*\"data\" + 0.007*\"includ\"'),\n", + " (6,\n", + " '0.061*\"music\" + 0.030*\"perform\" + 0.019*\"theatr\" + 0.018*\"compos\" + 0.016*\"plai\" + 0.016*\"festiv\" + 0.015*\"danc\" + 0.014*\"orchestra\" + 0.012*\"opera\" + 0.011*\"piano\"'),\n", + " (7,\n", + " '0.013*\"number\" + 0.011*\"function\" + 0.010*\"model\" + 0.009*\"valu\" + 0.008*\"set\" + 0.008*\"exampl\" + 0.007*\"gener\" + 0.007*\"theori\" + 0.007*\"point\" + 0.006*\"method\"'),\n", + " (8,\n", + " '0.048*\"india\" + 0.037*\"indian\" + 0.020*\"http\" + 0.016*\"www\" + 0.015*\"pakistan\" + 0.015*\"iran\" + 0.013*\"sri\" + 0.012*\"khan\" + 0.012*\"islam\" + 0.012*\"tamil\"'),\n", + " (9,\n", + " '0.067*\"film\" + 0.025*\"award\" + 0.022*\"seri\" + 0.021*\"episod\" + 0.021*\"best\" + 0.015*\"star\" + 0.012*\"role\" + 0.012*\"actor\" + 0.011*\"televis\" + 0.011*\"produc\"'),\n", + " (10,\n", + " '0.020*\"engin\" + 0.013*\"power\" + 0.011*\"product\" + 0.011*\"design\" + 0.010*\"model\" + 0.009*\"produc\" + 0.008*\"us\" + 0.008*\"electr\" + 0.008*\"type\" + 0.007*\"vehicl\"'),\n", + " (11,\n", + " '0.024*\"law\" + 0.021*\"court\" + 0.016*\"state\" + 0.016*\"act\" + 0.011*\"polic\" + 0.010*\"case\" + 0.009*\"offic\" + 0.009*\"report\" + 0.009*\"right\" + 0.007*\"legal\"'),\n", + " (12,\n", + " '0.056*\"elect\" + 0.041*\"parti\" + 0.023*\"member\" + 0.020*\"vote\" + 0.020*\"presid\" + 0.017*\"democrat\" + 0.017*\"minist\" + 0.013*\"council\" + 0.013*\"repres\" + 0.012*\"polit\"'),\n", + " (13,\n", + " '0.057*\"state\" + 0.035*\"new\" + 0.029*\"american\" + 0.024*\"unit\" + 0.024*\"york\" + 0.020*\"counti\" + 0.015*\"citi\" + 0.014*\"california\" + 0.012*\"washington\" + 0.010*\"texa\"'),\n", + " (14,\n", + " '0.027*\"univers\" + 0.015*\"research\" + 0.014*\"institut\" + 0.012*\"nation\" + 0.012*\"scienc\" + 0.012*\"work\" + 0.012*\"intern\" + 0.011*\"award\" + 0.011*\"develop\" + 0.010*\"organ\"'),\n", + " (15,\n", + " '0.034*\"england\" + 0.024*\"unit\" + 0.021*\"london\" + 0.019*\"cricket\" + 0.019*\"town\" + 0.016*\"citi\" + 0.015*\"scotland\" + 0.013*\"manchest\" + 0.013*\"west\" + 0.012*\"scottish\"'),\n", + " (16,\n", + " '0.031*\"church\" + 0.017*\"famili\" + 0.017*\"di\" + 0.016*\"son\" + 0.015*\"marri\" + 0.014*\"year\" + 0.013*\"father\" + 0.013*\"life\" + 0.013*\"born\" + 0.012*\"daughter\"'),\n", + " (17,\n", + " '0.060*\"race\" + 0.020*\"car\" + 0.017*\"team\" + 0.012*\"finish\" + 0.012*\"tour\" + 0.012*\"driver\" + 0.011*\"ford\" + 0.011*\"time\" + 0.011*\"championship\" + 0.011*\"year\"'),\n", + " (18,\n", + " '0.010*\"water\" + 0.007*\"light\" + 0.007*\"energi\" + 0.007*\"high\" + 0.006*\"surfac\" + 0.006*\"earth\" + 0.006*\"time\" + 0.005*\"effect\" + 0.005*\"temperatur\" + 0.005*\"materi\"'),\n", + " (19,\n", + " '0.022*\"radio\" + 0.020*\"new\" + 0.019*\"broadcast\" + 0.018*\"station\" + 0.014*\"televis\" + 0.013*\"channel\" + 0.013*\"dai\" + 0.011*\"program\" + 0.011*\"host\" + 0.011*\"air\"'),\n", + " (20,\n", + " '0.035*\"win\" + 0.018*\"contest\" + 0.017*\"wrestl\" + 0.017*\"fight\" + 0.016*\"match\" + 0.016*\"titl\" + 0.015*\"championship\" + 0.014*\"team\" + 0.012*\"world\" + 0.011*\"defeat\"'),\n", + " (21,\n", + " '0.011*\"languag\" + 0.007*\"word\" + 0.007*\"form\" + 0.006*\"peopl\" + 0.006*\"differ\" + 0.006*\"cultur\" + 0.006*\"us\" + 0.006*\"mean\" + 0.005*\"tradit\" + 0.005*\"term\"'),\n", + " (22,\n", + " '0.051*\"popul\" + 0.033*\"ag\" + 0.030*\"citi\" + 0.029*\"town\" + 0.027*\"famili\" + 0.026*\"censu\" + 0.023*\"household\" + 0.023*\"commun\" + 0.021*\"peopl\" + 0.021*\"counti\"'),\n", + " (23,\n", + " '0.016*\"medic\" + 0.014*\"health\" + 0.014*\"hospit\" + 0.013*\"cell\" + 0.011*\"diseas\" + 0.010*\"patient\" + 0.009*\"ret\" + 0.009*\"caus\" + 0.008*\"human\" + 0.008*\"treatment\"'),\n", + " (24,\n", + " '0.037*\"ship\" + 0.017*\"navi\" + 0.015*\"sea\" + 0.012*\"island\" + 0.012*\"boat\" + 0.011*\"port\" + 0.010*\"naval\" + 0.010*\"coast\" + 0.010*\"gun\" + 0.009*\"fleet\"'),\n", + " (25,\n", + " '0.044*\"round\" + 0.044*\"final\" + 0.025*\"tournament\" + 0.023*\"group\" + 0.020*\"point\" + 0.020*\"winner\" + 0.018*\"open\" + 0.015*\"place\" + 0.013*\"qualifi\" + 0.012*\"won\"'),\n", + " (26,\n", + " '0.032*\"world\" + 0.030*\"women\" + 0.028*\"championship\" + 0.026*\"olymp\" + 0.023*\"men\" + 0.022*\"event\" + 0.022*\"medal\" + 0.018*\"athlet\" + 0.017*\"gold\" + 0.017*\"nation\"'),\n", + " (27,\n", + " '0.056*\"born\" + 0.034*\"russian\" + 0.026*\"american\" + 0.020*\"russia\" + 0.020*\"soviet\" + 0.017*\"polish\" + 0.015*\"jewish\" + 0.014*\"poland\" + 0.014*\"republ\" + 0.013*\"moscow\"'),\n", + " (28,\n", + " '0.029*\"build\" + 0.025*\"hous\" + 0.014*\"built\" + 0.012*\"locat\" + 0.012*\"street\" + 0.012*\"site\" + 0.011*\"histor\" + 0.009*\"park\" + 0.009*\"citi\" + 0.009*\"place\"'),\n", + " (29,\n", + " '0.039*\"leagu\" + 0.036*\"club\" + 0.035*\"plai\" + 0.031*\"team\" + 0.026*\"footbal\" + 0.026*\"season\" + 0.023*\"cup\" + 0.018*\"goal\" + 0.016*\"player\" + 0.016*\"match\"'),\n", + " (30,\n", + " '0.053*\"french\" + 0.041*\"franc\" + 0.027*\"italian\" + 0.025*\"pari\" + 0.022*\"saint\" + 0.020*\"itali\" + 0.018*\"jean\" + 0.014*\"de\" + 0.011*\"loui\" + 0.011*\"le\"'),\n", + " (31,\n", + " '0.067*\"australia\" + 0.058*\"australian\" + 0.051*\"new\" + 0.040*\"china\" + 0.033*\"zealand\" + 0.032*\"south\" + 0.027*\"chines\" + 0.021*\"sydnei\" + 0.015*\"melbourn\" + 0.013*\"queensland\"'),\n", + " (32,\n", + " '0.026*\"speci\" + 0.011*\"famili\" + 0.009*\"plant\" + 0.008*\"white\" + 0.008*\"bird\" + 0.007*\"genu\" + 0.007*\"red\" + 0.007*\"forest\" + 0.007*\"fish\" + 0.006*\"tree\"'),\n", + " (33,\n", + " '0.033*\"compani\" + 0.013*\"million\" + 0.012*\"busi\" + 0.012*\"market\" + 0.011*\"product\" + 0.010*\"bank\" + 0.010*\"year\" + 0.009*\"industri\" + 0.008*\"oper\" + 0.008*\"new\"'),\n", + " (34,\n", + " '0.085*\"island\" + 0.073*\"canada\" + 0.065*\"canadian\" + 0.026*\"toronto\" + 0.025*\"ontario\" + 0.017*\"korean\" + 0.017*\"korea\" + 0.016*\"quebec\" + 0.016*\"montreal\" + 0.016*\"british\"'),\n", + " (35,\n", + " '0.034*\"kong\" + 0.034*\"japanes\" + 0.033*\"hong\" + 0.023*\"lee\" + 0.021*\"singapor\" + 0.019*\"chines\" + 0.018*\"kim\" + 0.015*\"japan\" + 0.014*\"indonesia\" + 0.014*\"thailand\"'),\n", + " (36,\n", + " '0.054*\"art\" + 0.034*\"museum\" + 0.030*\"jpg\" + 0.027*\"file\" + 0.024*\"work\" + 0.022*\"paint\" + 0.020*\"artist\" + 0.019*\"design\" + 0.017*\"imag\" + 0.017*\"exhibit\"'),\n", + " (37,\n", + " '0.008*\"time\" + 0.007*\"man\" + 0.005*\"later\" + 0.005*\"appear\" + 0.005*\"charact\" + 0.005*\"kill\" + 0.004*\"like\" + 0.004*\"friend\" + 0.004*\"return\" + 0.004*\"end\"'),\n", + " (38,\n", + " '0.014*\"govern\" + 0.012*\"state\" + 0.012*\"nation\" + 0.010*\"war\" + 0.009*\"polit\" + 0.008*\"countri\" + 0.008*\"peopl\" + 0.007*\"group\" + 0.007*\"unit\" + 0.007*\"support\"'),\n", + " (39,\n", + " '0.050*\"air\" + 0.026*\"aircraft\" + 0.026*\"oper\" + 0.025*\"airport\" + 0.017*\"forc\" + 0.017*\"flight\" + 0.015*\"squadron\" + 0.014*\"unit\" + 0.012*\"base\" + 0.011*\"wing\"'),\n", + " (40,\n", + " '0.052*\"bar\" + 0.038*\"africa\" + 0.033*\"text\" + 0.033*\"african\" + 0.031*\"till\" + 0.029*\"color\" + 0.026*\"south\" + 0.023*\"black\" + 0.013*\"tropic\" + 0.013*\"storm\"'),\n", + " (41,\n", + " '0.039*\"book\" + 0.033*\"publish\" + 0.021*\"work\" + 0.015*\"new\" + 0.013*\"press\" + 0.013*\"univers\" + 0.013*\"edit\" + 0.011*\"stori\" + 0.011*\"novel\" + 0.011*\"author\"'),\n", + " (42,\n", + " '0.026*\"king\" + 0.019*\"centuri\" + 0.010*\"princ\" + 0.009*\"empir\" + 0.009*\"kingdom\" + 0.009*\"emperor\" + 0.009*\"greek\" + 0.008*\"roman\" + 0.007*\"ancient\" + 0.006*\"year\"'),\n", + " (43,\n", + " '0.033*\"san\" + 0.022*\"spanish\" + 0.017*\"mexico\" + 0.016*\"del\" + 0.013*\"spain\" + 0.012*\"santa\" + 0.011*\"brazil\" + 0.011*\"juan\" + 0.010*\"josé\" + 0.009*\"francisco\"'),\n", + " (44,\n", + " '0.029*\"game\" + 0.027*\"season\" + 0.023*\"team\" + 0.015*\"plai\" + 0.014*\"coach\" + 0.014*\"player\" + 0.011*\"footbal\" + 0.010*\"year\" + 0.010*\"leagu\" + 0.009*\"record\"'),\n", + " (45,\n", + " '0.015*\"john\" + 0.011*\"david\" + 0.010*\"michael\" + 0.008*\"paul\" + 0.008*\"smith\" + 0.007*\"robert\" + 0.007*\"jame\" + 0.006*\"peter\" + 0.006*\"jack\" + 0.006*\"jone\"'),\n", + " (46,\n", + " '0.133*\"class\" + 0.062*\"align\" + 0.060*\"left\" + 0.056*\"wikit\" + 0.046*\"style\" + 0.043*\"center\" + 0.035*\"right\" + 0.032*\"philippin\" + 0.032*\"list\" + 0.026*\"text\"'),\n", + " (47,\n", + " '0.025*\"river\" + 0.024*\"station\" + 0.021*\"line\" + 0.020*\"road\" + 0.017*\"railwai\" + 0.015*\"rout\" + 0.013*\"lake\" + 0.012*\"park\" + 0.011*\"bridg\" + 0.011*\"area\"'),\n", + " (48,\n", + " '0.072*\"octob\" + 0.070*\"septemb\" + 0.069*\"march\" + 0.062*\"decemb\" + 0.062*\"januari\" + 0.062*\"novemb\" + 0.061*\"juli\" + 0.061*\"august\" + 0.060*\"april\" + 0.058*\"june\"'),\n", + " (49,\n", + " '0.093*\"district\" + 0.066*\"villag\" + 0.047*\"region\" + 0.039*\"east\" + 0.039*\"west\" + 0.038*\"north\" + 0.036*\"counti\" + 0.033*\"south\" + 0.032*\"municip\" + 0.029*\"provinc\"')]" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lda = LdaModel.load('lda.model')\n", + "row.update(get_tm_metrics(lda, test_corpus))\n", + "tm_metrics = tm_metrics.append(pd.Series(row), ignore_index=True)\n", + "\n", + "lda.show_topics(50)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Results" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
coherencel2_normmodelperplexitytopicstrain_time
0-2.8141357.265412nmf975.740399[(24, 0.131*\"mount\" + 0.129*\"lemmon\" + 0.129*\"...4394.560518
1-2.4366507.268837nmf_with_r985.570926[(49, 0.112*\"peak\" + 0.111*\"kitt\" + 0.111*\"mou...26451.927848
2-2.5144697.371544lda4727.075546[(35, 0.034*\"kong\" + 0.034*\"japanes\" + 0.033*\"...8278.891060
\n", + "
" + ], + "text/plain": [ + " coherence l2_norm model perplexity \\\n", + "0 -2.814135 7.265412 nmf 975.740399 \n", + "1 -2.436650 7.268837 nmf_with_r 985.570926 \n", + "2 -2.514469 7.371544 lda 4727.075546 \n", + "\n", + " topics train_time \n", + "0 [(24, 0.131*\"mount\" + 0.129*\"lemmon\" + 0.129*\"... 4394.560518 \n", + "1 [(49, 0.112*\"peak\" + 0.111*\"kitt\" + 0.111*\"mou... 26451.927848 \n", + "2 [(35, 0.034*\"kong\" + 0.034*\"japanes\" + 0.033*\"... 8278.891060 " + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tm_metrics" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### RAM Usage:\n", + "- nmf: 100-150Mb\n", + "- nmf_with_r: 3-9Gb\n", + "- lda: 100Mb" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "====================\n", + "nmf\n", + "====================\n", + "\n", + "Topic: 24\n", + "0.131*\"mount\" + 0.129*\"lemmon\" + 0.129*\"peak\" + 0.127*\"kitt\" + 0.127*\"spacewatch\" + 0.065*\"survei\" + 0.037*\"octob\" + 0.031*\"septemb\" + 0.023*\"css\" + 0.023*\"catalina\"\n", + "\n", + "Topic: 32\n", + "0.196*\"linear\" + 0.195*\"socorro\" + 0.045*\"septemb\" + 0.039*\"neat\" + 0.035*\"palomar\" + 0.032*\"octob\" + 0.024*\"kitt\" + 0.024*\"peak\" + 0.024*\"spacewatch\" + 0.023*\"anderson\"\n", + "\n", + "Topic: 8\n", + "0.331*\"align\" + 0.270*\"left\" + 0.071*\"right\" + 0.040*\"text\" + 0.035*\"style\" + 0.022*\"center\" + 0.013*\"bar\" + 0.009*\"till\" + 0.008*\"bgcolor\" + 0.008*\"color\"\n", + "\n", + "Topic: 27\n", + "0.186*\"district\" + 0.027*\"pennsylvania\" + 0.022*\"grade\" + 0.017*\"fund\" + 0.017*\"educ\" + 0.017*\"basic\" + 0.016*\"level\" + 0.014*\"oblast\" + 0.014*\"rural\" + 0.013*\"tax\"\n", + "\n", + "Topic: 48\n", + "0.103*\"art\" + 0.066*\"museum\" + 0.040*\"paint\" + 0.035*\"work\" + 0.026*\"artist\" + 0.024*\"galleri\" + 0.022*\"exhibit\" + 0.019*\"collect\" + 0.015*\"histori\" + 0.013*\"jpg\"\n", + "\n", + "Topic: 11\n", + "0.122*\"new\" + 0.043*\"york\" + 0.009*\"zealand\" + 0.007*\"jersei\" + 0.006*\"american\" + 0.006*\"time\" + 0.006*\"australia\" + 0.005*\"radio\" + 0.005*\"press\" + 0.005*\"washington\"\n", + "\n", + "Topic: 20\n", + "0.008*\"us\" + 0.006*\"gener\" + 0.006*\"model\" + 0.006*\"data\" + 0.006*\"design\" + 0.005*\"time\" + 0.005*\"function\" + 0.005*\"number\" + 0.005*\"process\" + 0.005*\"exampl\"\n", + "\n", + "Topic: 28\n", + "0.074*\"year\" + 0.022*\"dai\" + 0.012*\"time\" + 0.008*\"ag\" + 0.006*\"month\" + 0.006*\"includ\" + 0.006*\"follow\" + 0.005*\"later\" + 0.005*\"old\" + 0.005*\"student\"\n", + "\n", + "Topic: 38\n", + "0.033*\"royal\" + 0.025*\"john\" + 0.025*\"william\" + 0.016*\"lieuten\" + 0.013*\"georg\" + 0.012*\"offic\" + 0.012*\"jame\" + 0.011*\"sergeant\" + 0.011*\"major\" + 0.010*\"charl\"\n", + "\n", + "Topic: 19\n", + "0.012*\"area\" + 0.011*\"river\" + 0.010*\"water\" + 0.004*\"larg\" + 0.004*\"region\" + 0.004*\"lake\" + 0.004*\"power\" + 0.004*\"high\" + 0.004*\"bar\" + 0.004*\"form\"\n", + "\n", + "\n", + "====================\n", + "nmf_with_r\n", + "====================\n", + "\n", + "Topic: 49\n", + "0.112*\"peak\" + 0.111*\"kitt\" + 0.111*\"mount\" + 0.111*\"spacewatch\" + 0.109*\"lemmon\" + 0.055*\"survei\" + 0.044*\"octob\" + 0.041*\"septemb\" + 0.026*\"novemb\" + 0.021*\"march\"\n", + "\n", + "Topic: 32\n", + "0.194*\"linear\" + 0.193*\"socorro\" + 0.047*\"septemb\" + 0.038*\"neat\" + 0.034*\"palomar\" + 0.034*\"octob\" + 0.025*\"decemb\" + 0.024*\"august\" + 0.023*\"anderson\" + 0.023*\"mesa\"\n", + "\n", + "Topic: 48\n", + "0.112*\"art\" + 0.063*\"museum\" + 0.037*\"paint\" + 0.036*\"work\" + 0.028*\"artist\" + 0.026*\"galleri\" + 0.025*\"exhibit\" + 0.020*\"collect\" + 0.015*\"histori\" + 0.014*\"design\"\n", + "\n", + "Topic: 4\n", + "0.093*\"club\" + 0.049*\"cup\" + 0.033*\"footbal\" + 0.031*\"goal\" + 0.022*\"leagu\" + 0.022*\"unit\" + 0.022*\"plai\" + 0.022*\"match\" + 0.018*\"score\" + 0.015*\"player\"\n", + "\n", + "Topic: 27\n", + "0.159*\"district\" + 0.031*\"pennsylvania\" + 0.025*\"grade\" + 0.021*\"educ\" + 0.019*\"fund\" + 0.018*\"basic\" + 0.017*\"level\" + 0.015*\"student\" + 0.014*\"receiv\" + 0.014*\"tax\"\n", + "\n", + "Topic: 17\n", + "0.095*\"season\" + 0.014*\"plai\" + 0.010*\"coach\" + 0.009*\"final\" + 0.009*\"second\" + 0.008*\"win\" + 0.008*\"record\" + 0.008*\"career\" + 0.008*\"finish\" + 0.007*\"point\"\n", + "\n", + "Topic: 40\n", + "0.009*\"time\" + 0.008*\"later\" + 0.007*\"kill\" + 0.006*\"appear\" + 0.005*\"man\" + 0.005*\"death\" + 0.005*\"father\" + 0.005*\"return\" + 0.005*\"son\" + 0.004*\"charact\"\n", + "\n", + "Topic: 20\n", + "0.008*\"us\" + 0.006*\"gener\" + 0.005*\"design\" + 0.005*\"model\" + 0.005*\"develop\" + 0.005*\"time\" + 0.004*\"data\" + 0.004*\"number\" + 0.004*\"function\" + 0.004*\"process\"\n", + "\n", + "Topic: 19\n", + "0.009*\"water\" + 0.008*\"area\" + 0.008*\"speci\" + 0.005*\"larg\" + 0.004*\"order\" + 0.004*\"region\" + 0.004*\"includ\" + 0.004*\"black\" + 0.004*\"famili\" + 0.004*\"popul\"\n", + "\n", + "Topic: 38\n", + "0.044*\"royal\" + 0.020*\"william\" + 0.019*\"john\" + 0.016*\"corp\" + 0.014*\"lieuten\" + 0.013*\"capt\" + 0.012*\"engin\" + 0.011*\"armi\" + 0.011*\"georg\" + 0.011*\"temp\"\n", + "\n", + "\n", + "====================\n", + "lda\n", + "====================\n", + "\n", + "Topic: 35\n", + "0.034*\"kong\" + 0.034*\"japanes\" + 0.033*\"hong\" + 0.023*\"lee\" + 0.021*\"singapor\" + 0.019*\"chines\" + 0.018*\"kim\" + 0.015*\"japan\" + 0.014*\"indonesia\" + 0.014*\"thailand\"\n", + "\n", + "Topic: 23\n", + "0.016*\"medic\" + 0.014*\"health\" + 0.014*\"hospit\" + 0.013*\"cell\" + 0.011*\"diseas\" + 0.010*\"patient\" + 0.009*\"ret\" + 0.009*\"caus\" + 0.008*\"human\" + 0.008*\"treatment\"\n", + "\n", + "Topic: 47\n", + "0.025*\"river\" + 0.024*\"station\" + 0.021*\"line\" + 0.020*\"road\" + 0.017*\"railwai\" + 0.015*\"rout\" + 0.013*\"lake\" + 0.012*\"park\" + 0.011*\"bridg\" + 0.011*\"area\"\n", + "\n", + "Topic: 14\n", + "0.027*\"univers\" + 0.015*\"research\" + 0.014*\"institut\" + 0.012*\"nation\" + 0.012*\"scienc\" + 0.012*\"work\" + 0.012*\"intern\" + 0.011*\"award\" + 0.011*\"develop\" + 0.010*\"organ\"\n", + "\n", + "Topic: 39\n", + "0.050*\"air\" + 0.026*\"aircraft\" + 0.026*\"oper\" + 0.025*\"airport\" + 0.017*\"forc\" + 0.017*\"flight\" + 0.015*\"squadron\" + 0.014*\"unit\" + 0.012*\"base\" + 0.011*\"wing\"\n", + "\n", + "Topic: 17\n", + "0.060*\"race\" + 0.020*\"car\" + 0.017*\"team\" + 0.012*\"finish\" + 0.012*\"tour\" + 0.012*\"driver\" + 0.011*\"ford\" + 0.011*\"time\" + 0.011*\"championship\" + 0.011*\"year\"\n", + "\n", + "Topic: 4\n", + "0.137*\"school\" + 0.040*\"colleg\" + 0.039*\"student\" + 0.033*\"univers\" + 0.030*\"high\" + 0.028*\"educ\" + 0.016*\"year\" + 0.011*\"graduat\" + 0.010*\"state\" + 0.009*\"campu\"\n", + "\n", + "Topic: 8\n", + "0.048*\"india\" + 0.037*\"indian\" + 0.020*\"http\" + 0.016*\"www\" + 0.015*\"pakistan\" + 0.015*\"iran\" + 0.013*\"sri\" + 0.012*\"khan\" + 0.012*\"islam\" + 0.012*\"tamil\"\n", + "\n", + "Topic: 2\n", + "0.062*\"german\" + 0.039*\"germani\" + 0.025*\"van\" + 0.023*\"von\" + 0.020*\"der\" + 0.019*\"dutch\" + 0.019*\"berlin\" + 0.015*\"swedish\" + 0.014*\"netherland\" + 0.014*\"sweden\"\n", + "\n", + "Topic: 11\n", + "0.024*\"law\" + 0.021*\"court\" + 0.016*\"state\" + 0.016*\"act\" + 0.011*\"polic\" + 0.010*\"case\" + 0.009*\"offic\" + 0.009*\"report\" + 0.009*\"right\" + 0.007*\"legal\"\n", + "\n", + "\n" + ] + } + ], + "source": [ + "for row_idx, row in tm_metrics.iterrows():\n", + " print('='*20)\n", + " print(row['model'])\n", + " print('='*20)\n", + " print()\n", + " for topic_idx, tokens in row['topics']:\n", + " print('Topic: {}'.format(topic_idx))\n", + " print(tokens)\n", + " print()\n", + " print()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we can see, NMF can be significantly faster than LDA without sacrificing quality of topics too much (or not sacrificing at all)\n", + "\n", + "Moreover, NMF can be very flexible on RAM usage due to sparsity option, which leaves only small amount of elements in inner matrices." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "jupytext": { + "text_representation": { + "extension": ".py", + "format_name": "percent", + "format_version": "1.2", + "jupytext_version": "0.8.6" + } + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/src/apiref.rst b/docs/src/apiref.rst index 29f91d9f47..c4f31f7f28 100644 --- a/docs/src/apiref.rst +++ b/docs/src/apiref.rst @@ -29,6 +29,7 @@ Modules: corpora/wikicorpus models/ldamodel models/ldamulticore + models/nmf models/lsimodel models/ldaseqmodel models/tfidfmodel diff --git a/docs/src/models/nmf.rst b/docs/src/models/nmf.rst new file mode 100644 index 0000000000..4a89607a4c --- /dev/null +++ b/docs/src/models/nmf.rst @@ -0,0 +1,9 @@ +:mod:`models.nmf` -- Non-Negative Matrix factorization +====================================================== + +.. automodule:: gensim.models.nmf + :synopsis: Non-Negative Matrix Factorization + :members: + :inherited-members: + :undoc-members: + :show-inheritance: diff --git a/gensim/models/nmf.py b/gensim/models/nmf.py new file mode 100644 index 0000000000..0a33660d00 --- /dev/null +++ b/gensim/models/nmf.py @@ -0,0 +1,656 @@ +"""Online Non-Negative Matrix Factorization.""" + +import itertools + +import logging +import numpy as np +import scipy.sparse +from scipy.stats import halfnorm + +from gensim import interfaces +from gensim import matutils +from gensim import utils +from gensim.interfaces import TransformedCorpus +from gensim.models import basemodel, CoherenceModel +from gensim.models.nmf_pgd import solve_h, solve_r + +logger = logging.getLogger(__name__) + + +class Nmf(interfaces.TransformationABC, basemodel.BaseTopicModel): + """Online Non-Negative Matrix Factorization. + + `Renbo Zhao et al :"Online Nonnegative Matrix Factorization with Outliers" `_ + + """ + + def __init__( + self, + corpus=None, + num_topics=100, + id2word=None, + chunksize=2000, + passes=1, + lambda_=1.0, + kappa=1.0, + minimum_probability=0.01, + use_r=False, + w_max_iter=200, + w_stop_condition=1e-4, + h_r_max_iter=50, + h_r_stop_condition=1e-3, + eval_every=10, + v_max=None, + normalize=True, + sparse_coef=3, + random_state=None, + ): + """ + + Parameters + ---------- + corpus : iterable of list of (int, float), optional + Training corpus. If not given, model is left untrained. + num_topics : int, optional + Number of topics to extract. + id2word: gensim.corpora.Dictionary, optional + Mapping from token id to token. If not set words get replaced with word ids. + chunksize: int, optional + Number of documents to be used in each training chunk. + passes: int, optioanl + Number of full passes over the training corpus. + lambda_ : float, optional + Residuals regularizer coefficient. Increasing it helps prevent ovefitting. Has no effect if `use_r` is set + to False. + kappa : float, optional + Optimizer step coefficient. Increaing it makes model train faster, but adds a risk that it won't converge. + w_max_iter: int, optional + Maximum number of iterations to train W matrix per each batch. + w_stop_condition: float, optional + If error difference gets less than that, training of matrix ``W`` stops for current batch. + h_r_max_iter: int, optional + Maximum number of iterations to train h and r matrices per each batch. + h_r_stop_condition: float + If error difference gets less than that, training of matrices ``h`` and ``r`` stops for current batch. + eval_every: int, optional + Number of batches after which model will be evaluated. + v_max: int, optional + Maximum number of word occurrences in the corpora. Inferred if not set. Rarely needs to be set explicitly. + normalize: bool, optional + Whether to normalize results. Offers "kind-of-probabilistic" result. + sparse_coef: float, optional + The more it is, the more sparse are matrices. Significantly increases performance. + random_state: {np.random.RandomState, int}, optional + Seed for random generator. Useful for reproducibility. + + """ + self._w_error = None + self.num_tokens = None + self.num_topics = num_topics + self.id2word = id2word + self.chunksize = chunksize + self.passes = passes + self._lambda_ = lambda_ + self._kappa = kappa + self.minimum_probability = minimum_probability + self.use_r = use_r + self._w_max_iter = w_max_iter + self._w_stop_condition = w_stop_condition + self._h_r_max_iter = h_r_max_iter + self._h_r_stop_condition = h_r_stop_condition + self.v_max = v_max + self.eval_every = eval_every + self.normalize = normalize + self.sparse_coef = sparse_coef + self.random_state = utils.get_random_state(random_state) + + if self.id2word is None: + self.id2word = utils.dict_from_corpus(corpus) + + self.num_tokens = len(self.id2word) + + self.A = None + self.B = None + + self._W = None + self.w_std = None + + self._h = None + self._r = None + + if corpus is not None: + self.update(corpus) + + def get_topics(self, normalize=None): + """Get the term-topic matrix learned during inference. + + Parameters + ---------- + normalize : bool, optional + Whether to normalize an output vector. + + Returns + ------- + numpy.ndarray + The probability for each word in each topic, shape (`num_topics`, `vocabulary_size`). + + """ + dense_topics = self._W.T.toarray() + if normalize is None: + normalize = self.normalize + if normalize: + return dense_topics / dense_topics.sum(axis=1).reshape(-1, 1) + + return dense_topics + + def __getitem__(self, bow, eps=None): + return self.get_document_topics(bow, eps) + + def show_topics(self, num_topics=10, num_words=10, log=False, + formatted=True, normalize=None): + """Get a representation for selected topics. + + Parameters + ---------- + num_topics : int, optional + Number of topics to be returned. Unlike LSA, there is no natural ordering between the topics in NMF. + The returned topics subset of all topics is therefore arbitrary and may change between two NMF + training runs. + num_words : int, optional + Number of words to be presented for each topic. These will be the most relevant words (assigned the highest + probability for each topic). + log : bool, optional + Whether the output is also logged, besides being returned. + formatted : bool, optional + Whether the topic representations should be formatted as strings. If False, they are returned as + 2 tuples of (word, probability). + normalize : bool, optional + Whether to normalize an output vector. + + Returns + ------- + list of {str, tuple of (str, float)} + a list of topics, each represented either as a string (when `formatted` == True) or word-probability + pairs. + + """ + if normalize is None: + normalize = self.normalize + + sparsity = self._W.getnnz(axis=0) + + if num_topics < 0 or num_topics >= self.num_topics: + num_topics = self.num_topics + chosen_topics = range(num_topics) + else: + num_topics = min(num_topics, self.num_topics) + + sorted_topics = list(matutils.argsort(sparsity)) + chosen_topics = ( + sorted_topics[: num_topics // 2] + sorted_topics[-num_topics // 2:] + ) + + shown = [] + + topics = self.get_topics(normalize=normalize) + + for i in chosen_topics: + topic = topics[i] + bestn = matutils.argsort(topic, num_words, reverse=True).ravel() + topic = [(self.id2word[id], topic[id]) for id in bestn] + if formatted: + topic = " + ".join(['%.3f*"%s"' % (v, k) for k, v in topic]) + + shown.append((i, topic)) + if log: + logger.info("topic #%i (%.3f): %s", i, sparsity[i], topic) + + return shown + + def show_topic(self, topicid, topn=10, normalize=None): + """Get the representation for a single topic. Words here are the actual strings, in constrast to + :meth:`~gensim.models.nmf.Nmf.get_topic_terms` that represents words by their vocabulary ID. + + Parameters + ---------- + topicid : int + The ID of the topic to be returned + topn : int, optional + Number of the most significant words that are associated with the topic. + normalize : bool, optional + Whether to normalize an output vector. + + Returns + ------- + list of (str, float) + Word - probability pairs for the most relevant words generated by the topic. + + """ + if normalize is None: + normalize = self.normalize + + return [ + (self.id2word[id], value) + for id, value in self.get_topic_terms(topicid, topn, + normalize=normalize) + ] + + def get_topic_terms(self, topicid, topn=10, normalize=None): + """Get the representation for a single topic. Words the integer IDs, in constrast to + :meth:`~gensim.models.nmf.Nmf.show_topic` that represents words by the actual strings. + + Parameters + ---------- + topicid : int + The ID of the topic to be returned + topn : int, optional + Number of the most significant words that are associated with the topic. + normalize : bool, optional + Whether to normalize an output vector. + + Returns + ------- + list of (int, float) + Word ID - probability pairs for the most relevant words generated by the topic. + + """ + topic = self._W.getcol(topicid).toarray()[0] + + if normalize is None: + normalize = self.normalize + if normalize: + topic /= topic.sum() + + bestn = matutils.argsort(topic, topn, reverse=True) + return [(idx, topic[idx]) for idx in bestn] + + def top_topics(self, corpus=None, texts=None, dictionary=None, window_size=None, + coherence='u_mass', topn=20, processes=-1): + """Get the topics with the highest coherence score the coherence for each topic. + + Parameters + ---------- + corpus : iterable of list of (int, float), optional + Corpus in BoW format. + texts : list of list of str, optional + Tokenized texts, needed for coherence models that use sliding window based (i.e. coherence=`c_something`) + probability estimator . + dictionary : :class:`~gensim.corpora.dictionary.Dictionary`, optional + Gensim dictionary mapping of id word to create corpus. + If `model.id2word` is present, this is not needed. If both are provided, passed `dictionary` will be used. + window_size : int, optional + Is the size of the window to be used for coherence measures using boolean sliding window as their + probability estimator. For 'u_mass' this doesn't matter. + If None - the default window sizes are used which are: 'c_v' - 110, 'c_uci' - 10, 'c_npmi' - 10. + coherence : {'u_mass', 'c_v', 'c_uci', 'c_npmi'}, optional + Coherence measure to be used. + Fastest method - 'u_mass', 'c_uci' also known as `c_pmi`. + For 'u_mass' corpus should be provided, if texts is provided, it will be converted to corpus + using the dictionary. For 'c_v', 'c_uci' and 'c_npmi' `texts` should be provided (`corpus` isn't needed) + topn : int, optional + Integer corresponding to the number of top words to be extracted from each topic. + processes : int, optional + Number of processes to use for probability estimation phase, any value less than 1 will be interpreted as + num_cpus - 1. + + Returns + ------- + list of (list of (int, str), float) + Each element in the list is a pair of a topic representation and its coherence score. Topic representations + are distributions of words, represented as a list of pairs of word IDs and their probabilities. + + """ + cm = CoherenceModel( + model=self, corpus=corpus, texts=texts, dictionary=dictionary, + window_size=window_size, coherence=coherence, topn=topn, + processes=processes + ) + coherence_scores = cm.get_coherence_per_topic() + + str_topics = [] + for topic in self.get_topics(): # topic = array of vocab_size floats, one per term + bestn = matutils.argsort(topic, topn=topn, reverse=True) # top terms for topic + beststr = [(topic[_id], self.id2word[_id]) for _id in bestn] # membership, token + str_topics.append(beststr) # list of topn (float membership, token) tuples + + scored_topics = zip(str_topics, coherence_scores) + return sorted(scored_topics, key=lambda tup: tup[1], reverse=True) + + def log_perplexity(self, corpus): + """Calculate perplexity bound on the specified corpus. + + Perplexity = e^(-bound). + + Parameters + ---------- + corpus : list of list of (int, float) + The corpus on which the perplexity is computed. + + Returns + ------- + float + The perplexity bound. + + """ + W = self.get_topics().T + + H = np.zeros((W.shape[1], len(corpus))) + for bow_id, bow in enumerate(corpus): + for topic_id, factor in self[bow]: + H[topic_id, bow_id] = factor + + dense_corpus = matutils.corpus2dense(corpus, W.shape[0]) + + pred_factors = W.dot(H) + pred_factors /= pred_factors.sum(axis=0) + + return (np.log(pred_factors, where=pred_factors > 0) * dense_corpus).sum() / dense_corpus.sum() + + def get_term_topics(self, word_id, minimum_probability=None, + normalize=None): + """Get the most relevant topics to the given word. + + Parameters + ---------- + word_id : int + The word for which the topic distribution will be computed. + minimum_probability : float, optional + Topics with an assigned probability below this threshold will be discarded. + normalize : bool, optional + Whether to normalize an output vector. + + Returns + ------- + list of (int, float) + The relevant topics represented as pairs of their ID and their assigned probability, sorted + by relevance to the given word. + + """ + if minimum_probability is None: + minimum_probability = self.minimum_probability + minimum_probability = max(minimum_probability, 1e-8) + + # if user enters word instead of id in vocab, change to get id + if isinstance(word_id, str): + word_id = self.id2word.doc2bow([word_id])[0][0] + + values = [] + + word_topics = self._W.getrow(word_id) + + if normalize is None: + normalize = self.normalize + if normalize and word_topics.sum() > 0: + word_topics /= word_topics.sum() + + for topic_id in range(0, self.num_topics): + word_coef = word_topics[0, topic_id] + + if word_coef >= minimum_probability: + values.append((topic_id, word_coef)) + + return values + + def get_document_topics(self, bow, minimum_probability=None, + normalize=None): + """Get the topic distribution for the given document. + + Parameters + ---------- + bow : list of (int, float) + The document in BOW format. + minimum_probability : float + Topics with an assigned probability lower than this threshold will be discarded. + normalize : bool, optional + Whether to normalize an output vector. + + Returns + ------- + list of (int, float) + Topic distribution for the whole document. Each element in the list is a pair of a topic's id, and + the probability that was assigned to it. + + """ + if minimum_probability is None: + minimum_probability = self.minimum_probability + minimum_probability = max(minimum_probability, 1e-8) + + # if the input vector is a corpus, return a transformed corpus + is_corpus, corpus = utils.is_corpus(bow) + + if is_corpus: + kwargs = dict(minimum_probability=minimum_probability) + return self._apply(corpus, **kwargs) + + v = matutils.corpus2csc([bow], len(self.id2word)).tocsr() + h, _ = self._solveproj(v, self._W, v_max=np.inf) + + if normalize is None: + normalize = self.normalize + if normalize: + h.data /= h.sum() + + return [ + (idx, proba.toarray()[0, 0]) + for idx, proba in enumerate(h[:, 0]) + if not minimum_probability or proba.toarray()[0, 0] > minimum_probability + ] + + def _setup(self, corpus): + """Infer info from the first document and initialize matrices. + + Parameters + ---------- + corpus : iterable of list(int, float) + Training corpus. + + """ + self._h, self._r = None, None + first_doc_it = itertools.tee(corpus, 1) + first_doc = next(first_doc_it[0]) + first_doc = matutils.corpus2csc([first_doc], len(self.id2word)) + self.w_std = np.sqrt(first_doc.mean() / (self.num_tokens * self.num_topics)) + + self._W = np.abs( + self.w_std + * halfnorm.rvs( + size=(self.num_tokens, self.num_topics), random_state=self.random_state + ) + ) + + is_great_enough = self._W > self.w_std * self.sparse_coef + + self._W *= is_great_enough | ~is_great_enough.all(axis=0) + + self._W = scipy.sparse.csc_matrix(self._W) + + self.A = scipy.sparse.csr_matrix((self.num_topics, self.num_topics)) + self.B = scipy.sparse.csc_matrix((self.num_tokens, self.num_topics)) + + def update(self, corpus, chunks_as_numpy=False): + """Train the model with new documents. + + Parameters + ---------- + corpus : iterable of list(int, float) + Training corpus. + chunks_as_numpy : bool, optional + Whether each chunk passed to the inference step should be a numpy.ndarray or not. Numpy can in some settings + turn the term IDs into floats, these will be converted back into integers in inference, which incurs a + performance hit. For distributed computing it may be desirable to keep the chunks as `numpy.ndarray`. + + """ + + if self._W is None: + self._setup(corpus) + + chunk_idx = 1 + + for _ in range(self.passes): + for chunk in utils.grouper( + corpus, self.chunksize, as_numpy=chunks_as_numpy + ): + self.random_state.shuffle(chunk) + v = matutils.corpus2csc(chunk, len(self.id2word)).tocsr() + self._h, self._r = self._solveproj( + v, self._W, r=self._r, h=self._h, v_max=self.v_max + ) + h, r = self._h, self._r + + self.A *= chunk_idx - 1 + self.A += h.dot(h.T) + self.A /= chunk_idx + + self.B *= chunk_idx - 1 + self.B += (v - r).dot(h.T) + self.B /= chunk_idx + + self._solve_w() + + if chunk_idx % self.eval_every == 0: + logger.info( + "Loss (no outliers): {}\tLoss (with outliers): {}".format( + scipy.sparse.linalg.norm(v - self._W.dot(h)), + scipy.sparse.linalg.norm(v - self._W.dot(h) - r), + ) + ) + + chunk_idx += 1 + + logger.info( + "Loss (no outliers): {}\tLoss (with outliers): {}".format( + scipy.sparse.linalg.norm(v - self._W.dot(h)), + scipy.sparse.linalg.norm(v - self._W.dot(h) - r), + ) + ) + + def _solve_w(self): + """Update W matrix.""" + + def error(): + return ( + 0.5 * self._W.T.dot(self._W).dot(self.A).diagonal().sum() + - self._W.T.dot(self.B).diagonal().sum() + ) + + eta = self._kappa / scipy.sparse.linalg.norm(self.A) + + for iter_number in range(self._w_max_iter): + logger.debug("w_error: %s" % self._w_error) + + error_ = error() + + if ( + self._w_error + and np.abs((error_ - self._w_error) / self._w_error) < self._w_stop_condition + ): + break + + self._w_error = error_ + + self._W -= eta * (self._W.dot(self.A) - self.B) + self._transform() + + def _apply(self, corpus, chunksize=None, **kwargs): + """Apply the transformation to a whole corpus and get the result as another corpus. + + Parameters + ---------- + corpus : iterable of list of (int, number) + Corpus in sparse Gensim bag-of-words format. + chunksize : int, optional + If provided, a more effective processing will performed. + + Returns + ------- + :class:`~gensim.interfaces.TransformedCorpus` + Transformed corpus. + + """ + return TransformedCorpus(self, corpus, chunksize, **kwargs) + + def _transform(self): + """Apply boundaries on W.""" + np.clip(self._W.data, 0, self.v_max, out=self._W.data) + self._W.eliminate_zeros() + sumsq = scipy.sparse.linalg.norm(self._W, axis=0) + np.maximum(sumsq, 1, out=sumsq) + sumsq = np.repeat(sumsq, self._W.getnnz(axis=0)) + self._W.data /= sumsq + + is_great_enough_data = self._W.data > self.w_std * self.sparse_coef + is_great_enough = self._W.toarray() > self.w_std * self.sparse_coef + is_all_too_small = is_great_enough.sum(axis=0) == 0 + is_all_too_small = np.repeat(is_all_too_small, self._W.getnnz(axis=0)) + + is_great_enough_data |= is_all_too_small + + self._W.data *= is_great_enough_data + self._W.eliminate_zeros() + + def _solveproj(self, v, W, h=None, r=None, v_max=None): + """Update residuals and representation(h) matrices. + + Parameters + ---------- + v : iterable of list(int, float) + Subset of training corpus. + W : scipy.sparse.csc_matrix + Dictionary matrix. + h : scipy.sparse.csr_matrix + Representation matrix. + r : scipy.sparse.csr_matrix + Residuals matrix. + v_max : float + Maximum possible value in matrices. + + """ + m, n = W.shape + if v_max is not None: + self.v_max = v_max + elif self.v_max is None: + self.v_max = v.max() + + batch_size = v.shape[1] + rshape = (m, batch_size) + hshape = (n, batch_size) + + if h is None or h.shape != hshape: + h = scipy.sparse.csr_matrix(hshape) + + if r is None or r.shape != rshape: + r = scipy.sparse.csr_matrix(rshape) + + WtW = W.T.dot(W) + + _h_r_error = None + + for iter_number in range(self._h_r_max_iter): + logger.debug("h_r_error: %s" % _h_r_error) + + error_ = 0. + + Wt_v_minus_r = W.T.dot(v - r) + + h_ = h.toarray() + error_ = max( + error_, solve_h(h_, Wt_v_minus_r.toarray(), WtW.toarray(), self._kappa) + ) + h = scipy.sparse.csr_matrix(h_) + + if self.use_r: + r_actual = v - W.dot(h) + error_ = max( + error_, + solve_r(r, r_actual, self._lambda_, self.v_max) + ) + r = r_actual + + error_ /= m + + if _h_r_error and np.abs(_h_r_error - error_) < self._h_r_stop_condition: + break + + _h_r_error = error_ + + return h, r diff --git a/gensim/models/nmf_pgd.c b/gensim/models/nmf_pgd.c new file mode 100644 index 0000000000..e552aaf9da --- /dev/null +++ b/gensim/models/nmf_pgd.c @@ -0,0 +1,21786 @@ +/* Generated by Cython 0.28.6 */ + +#define PY_SSIZE_T_CLEAN +#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 < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.6+ or Python 3.3+. +#else +#define CYTHON_ABI "0_28_6" +#define CYTHON_FUTURE_DIVISION 0 +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !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 + #if PY_VERSION_HEX >= 0x02070000 + #define HAVE_LONG_LONG + #endif +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 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_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 +#elif defined(PYSTON_VERSION) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #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 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 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_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #elif !defined(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 + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #elif !defined(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 + #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_PYCALL + #define CYTHON_FAST_PYCALL 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT (0 && PY_VERSION_HEX >= 0x03050000) + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #endif +#endif +#if !defined(CYTHON_FAST_PYCCALL) +#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #include "longintrepr.h" + #undef SHIFT + #undef BASE + #undef MASK + #ifdef SIZEOF_VOID_P + enum { __pyx_check_sizeof_voidp = 1/(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(__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_MAYBE_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# 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 int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int32 uint32_t; + #endif + #endif +#else + #include +#endif +#ifndef CYTHON_FALLTHROUGH + #if defined(__cplusplus) && __cplusplus >= 201103L + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #elif __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #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 + +#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 + +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) + #define Py_OptimizeFlag 0 +#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_PyCode_New(a, 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) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_PyCode_New(a, 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) + #define __Pyx_DefaultClassType PyType_Type +#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 +#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 + #define __Pyx_PyCFunctionFast _PyCFunctionFast + #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords +#endif +#if CYTHON_FAST_PYCCALL +#define __Pyx_PyFastCFunction_Check(func)\ + ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS))))) +#else +#define __Pyx_PyFastCFunction_Check(func) 0 +#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_PYSTON + #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) 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_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#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 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; // PyThread_create_key reports success always +} +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 // TSS (Thread Specific Storage) API +#if CYTHON_COMPILING_IN_CPYTHON || 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 >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#else +#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #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) 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, ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) +#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) ? 65535 : 1114111) + #define __Pyx_PyUnicode_KIND(u) (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] = 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 && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? 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 + #define PyObject_Unicode PyObject_Str +#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 +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) +#else + #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) +#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 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 +#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 PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : (Py_INCREF(func), func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#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(MS_WINDOWS) + #define _USE_MATH_DEFINES +#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_ERR(f_index, lineno, Ln_error) \ +{ \ + __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \ +} + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__gensim__models__nmf_pgd +#define __PYX_HAVE_API__gensim__models__nmf_pgd +/* Early includes */ +#include +#include "pythread.h" +#include +#include +#include +#include "pystate.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_DEFAULT 0 +#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))) ) +#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 const char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#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_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __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) +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#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 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); +#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 +#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +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] = 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 +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)); + 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; } + +static PyObject *__pyx_m = NULL; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_cython_runtime = NULL; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static PyObject *__pyx_empty_unicode; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + + +static const char *__pyx_f[] = { + "nmf_pgd.pyx", + "stringsource", +}; +/* 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() + +/* 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]) + +/* Atomics.proto */ +#include +#ifndef CYTHON_ATOMICS + #define CYTHON_ATOMICS 1 +#endif +#define __pyx_atomic_int_type int +#if CYTHON_ATOMICS && __GNUC__ >= 4 && (__GNUC_MINOR__ > 1 ||\ + (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL >= 2)) &&\ + !defined(__i386__) + #define __pyx_atomic_incr_aligned(value, lock) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_decr_aligned(value, lock) __sync_fetch_and_sub(value, 1) + #ifdef __PYX_DEBUG_ATOMICS + #warning "Using GNU atomics" + #endif +#elif CYTHON_ATOMICS && defined(_MSC_VER) && 0 + #include + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type LONG + #define __pyx_atomic_incr_aligned(value, lock) InterlockedIncrement(value) + #define __pyx_atomic_decr_aligned(value, lock) InterlockedDecrement(value) + #ifdef __PYX_DEBUG_ATOMICS + #pragma message ("Using MSVC atomics") + #endif +#elif CYTHON_ATOMICS && (defined(__ICC) || defined(__INTEL_COMPILER)) && 0 + #define __pyx_atomic_incr_aligned(value, lock) _InterlockedIncrement(value) + #define __pyx_atomic_decr_aligned(value, lock) _InterlockedDecrement(value) + #ifdef __PYX_DEBUG_ATOMICS + #warning "Using Intel atomics" + #endif +#else + #undef CYTHON_ATOMICS + #define CYTHON_ATOMICS 0 + #ifdef __PYX_DEBUG_ATOMICS + #warning "Not using atomics" + #endif +#endif +typedef volatile __pyx_atomic_int_type __pyx_atomic_int; +#if CYTHON_ATOMICS + #define __pyx_add_acquisition_count(memview)\ + __pyx_atomic_incr_aligned(__pyx_get_slice_count_pointer(memview), memview->lock) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_atomic_decr_aligned(__pyx_get_slice_count_pointer(memview), memview->lock) +#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 + +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + +/* BufferFormatStructs.proto */ +#define IS_UNSIGNED(type) (((type) -1) > 0) +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; + + +/*--- Type declarations ---*/ +struct __pyx_array_obj; +struct __pyx_MemviewEnum_obj; +struct __pyx_memoryview_obj; +struct __pyx_memoryviewslice_obj; + +/* "View.MemoryView":104 + * + * @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":278 + * + * @cname('__pyx_MemviewEnum') + * cdef class Enum(object): # <<<<<<<<<<<<<< + * cdef object name + * def __init__(self, name): + */ +struct __pyx_MemviewEnum_obj { + PyObject_HEAD + PyObject *name; +}; + + +/* "View.MemoryView":329 + * + * @cname('__pyx_memoryview') + * cdef class memoryview(object): # <<<<<<<<<<<<<< + * + * 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 acquisition_count[2]; + __pyx_atomic_int *acquisition_count_aligned_p; + Py_buffer view; + int flags; + int dtype_is_object; + __Pyx_TypeInfo *typeinfo; +}; + + +/* "View.MemoryView":960 + * + * @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":104 + * + * @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":329 + * + * @cname('__pyx_memoryview') + * cdef class memoryview(object): # <<<<<<<<<<<<<< + * + * 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 *); +}; +static struct __pyx_vtabstruct_memoryview *__pyx_vtabptr_memoryview; + + +/* "View.MemoryView":960 + * + * @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; + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, 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__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #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) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #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_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) + +/* 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 + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* 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 **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +/* 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 *acquisition_count, PyThread_type_lock lock); +static CYTHON_INLINE int __pyx_sub_acquisition_count_locked( + __pyx_atomic_int *acquisition_count, PyThread_type_lock lock); +#define __pyx_get_slice_count_pointer(memview) (memview->acquisition_count_aligned_p) +#define __pyx_get_slice_count(memview) (*__pyx_get_slice_count_pointer(memview)) +#define __PYX_INC_MEMVIEW(slice, have_gil) __Pyx_INC_MEMVIEW(slice, have_gil, __LINE__) +#define __PYX_XDEC_MEMVIEW(slice, have_gil) __Pyx_XDEC_MEMVIEW(slice, have_gil, __LINE__) +static CYTHON_INLINE void __Pyx_INC_MEMVIEW(__Pyx_memviewslice *, int, int); +static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW(__Pyx_memviewslice *, int, int); + +/* ArgTypeTest.proto */ +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ + ((likely((Py_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); + +/* 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 + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() 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 +#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 + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* PyCFunctionFastCall.proto */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); +#else +#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +#endif + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs); +#else +#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) +#endif +#endif + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* 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); + +/* StrEquals.proto */ +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals +#else +#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals +#endif + +/* UnaryNegOverflows.proto */ +#define UNARY_NEG_WOULD_OVERFLOW(x)\ + (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x))) + +static CYTHON_UNUSED 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); + +/* 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 + +/* decode_c_string_utf16.proto */ +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = 0; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16LE(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = -1; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16BE(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = 1; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} + +/* decode_c_string.proto */ +static CYTHON_INLINE PyObject* __Pyx_decode_c_string( + const char* cstring, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); + +/* 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 + +/* GetAttr3.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); + +/* GetModuleGlobalName.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); + +/* 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); + +/* 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); + +/* FastTypeChecks.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +static CYTHON_INLINE int __Pyx_IsSubtype(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_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_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) + +static CYTHON_UNUSED 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); + PyList_SET_ITEM(list, len, x); + Py_SIZE(list) = len+1; + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) +#endif + +/* PyIntBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace); +#else +#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace)\ + (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) +#endif + +/* ListExtend.proto */ +static CYTHON_INLINE int __Pyx_PyList_Extend(PyObject* L, PyObject* v) { +#if CYTHON_COMPILING_IN_CPYTHON + PyObject* none = _PyList_Extend((PyListObject*)L, v); + if (unlikely(!none)) + return -1; + Py_DECREF(none); + return 0; +#else + return PyList_SetSlice(L, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, v); +#endif +} + +/* ListAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { + Py_INCREF(x); + PyList_SET_ITEM(list, len, x); + Py_SIZE(list) = len+1; + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_PyList_Append(L,x) PyList_Append(L,x) +#endif + +/* None.proto */ +static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); + +/* WriteUnraisableException.proto */ +static void __Pyx_WriteUnraisable(const char *name, int clineno, + int lineno, const char *filename, + int full_traceback, int nogil); + +/* ImportFrom.proto */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); + +/* HasAttr.proto */ +static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); + +/* 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 + +/* SetVTable.proto */ +static int __Pyx_SetVtable(PyObject *dict, void *vtable); + +/* SetupReduce.proto */ +static int __Pyx_setup_reduce(PyObject* type_obj); + +/* 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 */ +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); + +/* 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); + +/* Capsule.proto */ +static CYTHON_INLINE PyObject *__pyx_capsule_create(void *p, const char *sig); + +/* IsLittleEndian.proto */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); + +/* BufferFormatCheck.proto */ +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type); + +/* TypeInfoCompare.proto */ +static int __pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b); + +/* 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_dc_double(PyObject *, int writable_flag); + +/* ObjectToMemviewSlice.proto */ +static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dsds_double(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); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(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 char __Pyx_PyInt_As_char(PyObject *); + +/* ObjectToMemviewSlice.proto */ +static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_int(PyObject *, int writable_flag); + +/* ObjectToMemviewSlice.proto */ +static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_double(PyObject *, int writable_flag); + +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(void); + +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + +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_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*/ + +/* Module declarations from 'libc.math' */ + +/* Module declarations from 'gensim.models.nmf_pgd' */ +static PyTypeObject *__pyx_array_type = 0; +static PyTypeObject *__pyx_MemviewEnum_type = 0; +static PyTypeObject *__pyx_memoryview_type = 0; +static PyTypeObject *__pyx_memoryviewslice_type = 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 double __pyx_f_6gensim_6models_7nmf_pgd_fmin(double, double); /*proto*/ +static double __pyx_f_6gensim_6models_7nmf_pgd_fmax(double, double); /*proto*/ +static double __pyx_f_6gensim_6models_7nmf_pgd_clip(double, double, double); /*proto*/ +static struct __pyx_array_obj *__pyx_array_new(PyObject *, Py_ssize_t, char *, char *, char *); /*proto*/ +static void *__pyx_align_pointer(void *, size_t); /*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 PyObject *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 *, char *, int); /*proto*/ +static int __pyx_memoryview_err(PyObject *, char *); /*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*/ +static __Pyx_TypeInfo __Pyx_TypeInfo_double = { "double", NULL, sizeof(double), { 0 }, 0, 'R', 0, 0 }; +static __Pyx_TypeInfo __Pyx_TypeInfo_int = { "int", NULL, sizeof(int), { 0 }, 0, IS_UNSIGNED(int) ? 'U' : 'I', IS_UNSIGNED(int), 0 }; +#define __Pyx_MODULE_NAME "gensim.models.nmf_pgd" +extern int __pyx_module_is_main_gensim__models__nmf_pgd; +int __pyx_module_is_main_gensim__models__nmf_pgd = 0; + +/* Implementation of 'gensim.models.nmf_pgd' */ +static PyObject *__pyx_builtin_range; +static PyObject *__pyx_builtin_ValueError; +static PyObject *__pyx_builtin_MemoryError; +static PyObject *__pyx_builtin_enumerate; +static PyObject *__pyx_builtin_TypeError; +static PyObject *__pyx_builtin_Ellipsis; +static PyObject *__pyx_builtin_id; +static PyObject *__pyx_builtin_IndexError; +static const char __pyx_k_O[] = "O"; +static const char __pyx_k_c[] = "c"; +static const char __pyx_k_h[] = "h"; +static const char __pyx_k_r[] = "r"; +static const char __pyx_k_id[] = "id"; +static const char __pyx_k_WtW[] = "WtW"; +static const char __pyx_k_new[] = "__new__"; +static const char __pyx_k_obj[] = "obj"; +static const char __pyx_k_base[] = "base"; +static const char __pyx_k_data[] = "data"; +static const char __pyx_k_dict[] = "__dict__"; +static const char __pyx_k_grad[] = "grad"; +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_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_error[] = "error"; +static const char __pyx_k_flags[] = "flags"; +static const char __pyx_k_kappa[] = "kappa"; +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_v_max[] = "v_max"; +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_indptr[] = "indptr"; +static const char __pyx_k_lambda[] = "lambda_"; +static const char __pyx_k_name_2[] = "__name__"; +static const char __pyx_k_pickle[] = "pickle"; +static const char __pyx_k_r_data[] = "r_data"; +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_fortran[] = "fortran"; +static const char __pyx_k_hessian[] = "hessian"; +static const char __pyx_k_indices[] = "indices"; +static const char __pyx_k_memview[] = "memview"; +static const char __pyx_k_solve_h[] = "solve_h"; +static const char __pyx_k_solve_r[] = "solve_r"; +static const char __pyx_k_Ellipsis[] = "Ellipsis"; +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_r_actual[] = "r_actual"; +static const char __pyx_k_r_indptr[] = "r_indptr"; +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_n_samples[] = "n_samples"; +static const char __pyx_k_pyx_state[] = "__pyx_state"; +static const char __pyx_k_r_col_idx[] = "r_col_idx"; +static const char __pyx_k_r_element[] = "r_element"; +static const char __pyx_k_r_indices[] = "r_indices"; +static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; +static const char __pyx_k_violation[] = "violation"; +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_r_col_size[] = "r_col_size"; +static const char __pyx_k_sample_idx[] = "sample_idx"; +static const char __pyx_k_MemoryError[] = "MemoryError"; +static const char __pyx_k_PickleError[] = "PickleError"; +static const char __pyx_k_nmf_pgd_pyx[] = "nmf_pgd.pyx"; +static const char __pyx_k_Wt_v_minus_r[] = "Wt_v_minus_r"; +static const char __pyx_k_n_components[] = "n_components"; +static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; +static const char __pyx_k_r_col_indptr[] = "r_col_indptr"; +static const char __pyx_k_stringsource[] = "stringsource"; +static const char __pyx_k_pyx_getbuffer[] = "__pyx_getbuffer"; +static const char __pyx_k_r_actual_data[] = "r_actual_data"; +static const char __pyx_k_r_actual_sign[] = "r_actual_sign"; +static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; +static const char __pyx_k_projected_grad[] = "projected_grad"; +static const char __pyx_k_View_MemoryView[] = "View.MemoryView"; +static const char __pyx_k_allocate_buffer[] = "allocate_buffer"; +static const char __pyx_k_component_idx_1[] = "component_idx_1"; +static const char __pyx_k_component_idx_2[] = "component_idx_2"; +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_r_actual_indptr[] = "r_actual_indptr"; +static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; +static const char __pyx_k_r_actual_col_idx[] = "r_actual_col_idx"; +static const char __pyx_k_r_actual_element[] = "r_actual_element"; +static const char __pyx_k_r_actual_indices[] = "r_actual_indices"; +static const char __pyx_k_pyx_unpickle_Enum[] = "__pyx_unpickle_Enum"; +static const char __pyx_k_r_actual_col_size[] = "r_actual_col_size"; +static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; +static const char __pyx_k_strided_and_direct[] = ""; +static const char __pyx_k_r_actual_col_indptr[] = "r_actual_col_indptr"; +static const char __pyx_k_strided_and_indirect[] = ""; +static const char __pyx_k_contiguous_and_direct[] = ""; +static const char __pyx_k_gensim_models_nmf_pgd[] = "gensim.models.nmf_pgd"; +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_Cannot_index_with_type_s[] = "Cannot index with type '%s'"; +static const char __pyx_k_Invalid_shape_in_axis_d_d[] = "Invalid shape in axis %d: %d."; +static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cython.array"; +static const char __pyx_k_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_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_Empty_shape_tuple_for_cython_arr[] = "Empty shape tuple for cython.array"; +static const char __pyx_k_Incompatible_checksums_s_vs_0xb0[] = "Incompatible checksums (%s vs 0xb068931 = (name))"; +static const char __pyx_k_Indirect_dimensions_not_supporte[] = "Indirect dimensions not supported"; +static const char __pyx_k_Invalid_mode_expected_c_or_fortr[] = "Invalid mode, expected 'c' or 'fortran', got %s"; +static const char __pyx_k_Out_of_bounds_on_buffer_access_a[] = "Out of bounds on buffer access (axis %d)"; +static const char __pyx_k_Unable_to_convert_item_to_object[] = "Unable to convert item to object"; +static const char __pyx_k_got_differing_extents_in_dimensi[] = "got differing extents in dimension %d (got %d and %d)"; +static const char __pyx_k_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."; +static PyObject *__pyx_n_s_ASCII; +static PyObject *__pyx_kp_s_Buffer_view_does_not_expose_stri; +static PyObject *__pyx_kp_s_Can_only_create_a_buffer_that_is; +static PyObject *__pyx_kp_s_Cannot_assign_to_read_only_memor; +static PyObject *__pyx_kp_s_Cannot_create_writable_memory_vi; +static PyObject *__pyx_kp_s_Cannot_index_with_type_s; +static PyObject *__pyx_n_s_Ellipsis; +static PyObject *__pyx_kp_s_Empty_shape_tuple_for_cython_arr; +static PyObject *__pyx_kp_s_Incompatible_checksums_s_vs_0xb0; +static PyObject *__pyx_n_s_IndexError; +static PyObject *__pyx_kp_s_Indirect_dimensions_not_supporte; +static PyObject *__pyx_kp_s_Invalid_mode_expected_c_or_fortr; +static PyObject *__pyx_kp_s_Invalid_shape_in_axis_d_d; +static PyObject *__pyx_n_s_MemoryError; +static PyObject *__pyx_kp_s_MemoryView_of_r_at_0x_x; +static PyObject *__pyx_kp_s_MemoryView_of_r_object; +static PyObject *__pyx_n_b_O; +static PyObject *__pyx_kp_s_Out_of_bounds_on_buffer_access_a; +static PyObject *__pyx_n_s_PickleError; +static PyObject *__pyx_n_s_TypeError; +static PyObject *__pyx_kp_s_Unable_to_convert_item_to_object; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_n_s_View_MemoryView; +static PyObject *__pyx_n_s_WtW; +static PyObject *__pyx_n_s_Wt_v_minus_r; +static PyObject *__pyx_n_s_allocate_buffer; +static PyObject *__pyx_n_s_base; +static PyObject *__pyx_n_s_c; +static PyObject *__pyx_n_u_c; +static PyObject *__pyx_n_s_class; +static PyObject *__pyx_n_s_cline_in_traceback; +static PyObject *__pyx_n_s_component_idx_1; +static PyObject *__pyx_n_s_component_idx_2; +static PyObject *__pyx_kp_s_contiguous_and_direct; +static PyObject *__pyx_kp_s_contiguous_and_indirect; +static PyObject *__pyx_n_s_data; +static PyObject *__pyx_n_s_dict; +static PyObject *__pyx_n_s_dtype_is_object; +static PyObject *__pyx_n_s_encode; +static PyObject *__pyx_n_s_enumerate; +static PyObject *__pyx_n_s_error; +static PyObject *__pyx_n_s_flags; +static PyObject *__pyx_n_s_format; +static PyObject *__pyx_n_s_fortran; +static PyObject *__pyx_n_u_fortran; +static PyObject *__pyx_n_s_gensim_models_nmf_pgd; +static PyObject *__pyx_n_s_getstate; +static PyObject *__pyx_kp_s_got_differing_extents_in_dimensi; +static PyObject *__pyx_n_s_grad; +static PyObject *__pyx_n_s_h; +static PyObject *__pyx_n_s_hessian; +static PyObject *__pyx_n_s_id; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_indices; +static PyObject *__pyx_n_s_indptr; +static PyObject *__pyx_n_s_itemsize; +static PyObject *__pyx_kp_s_itemsize_0_for_cython_array; +static PyObject *__pyx_n_s_kappa; +static PyObject *__pyx_n_s_lambda; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_memview; +static PyObject *__pyx_n_s_mode; +static PyObject *__pyx_n_s_n_components; +static PyObject *__pyx_n_s_n_samples; +static PyObject *__pyx_n_s_name; +static PyObject *__pyx_n_s_name_2; +static PyObject *__pyx_n_s_ndim; +static PyObject *__pyx_n_s_new; +static PyObject *__pyx_kp_s_nmf_pgd_pyx; +static PyObject *__pyx_kp_s_no_default___reduce___due_to_non; +static PyObject *__pyx_n_s_obj; +static PyObject *__pyx_n_s_pack; +static PyObject *__pyx_n_s_pickle; +static PyObject *__pyx_n_s_projected_grad; +static PyObject *__pyx_n_s_pyx_PickleError; +static PyObject *__pyx_n_s_pyx_checksum; +static PyObject *__pyx_n_s_pyx_getbuffer; +static PyObject *__pyx_n_s_pyx_result; +static PyObject *__pyx_n_s_pyx_state; +static PyObject *__pyx_n_s_pyx_type; +static PyObject *__pyx_n_s_pyx_unpickle_Enum; +static PyObject *__pyx_n_s_pyx_vtable; +static PyObject *__pyx_n_s_r; +static PyObject *__pyx_n_s_r_actual; +static PyObject *__pyx_n_s_r_actual_col_idx; +static PyObject *__pyx_n_s_r_actual_col_indptr; +static PyObject *__pyx_n_s_r_actual_col_size; +static PyObject *__pyx_n_s_r_actual_data; +static PyObject *__pyx_n_s_r_actual_element; +static PyObject *__pyx_n_s_r_actual_indices; +static PyObject *__pyx_n_s_r_actual_indptr; +static PyObject *__pyx_n_s_r_actual_sign; +static PyObject *__pyx_n_s_r_col_idx; +static PyObject *__pyx_n_s_r_col_indptr; +static PyObject *__pyx_n_s_r_col_size; +static PyObject *__pyx_n_s_r_data; +static PyObject *__pyx_n_s_r_element; +static PyObject *__pyx_n_s_r_indices; +static PyObject *__pyx_n_s_r_indptr; +static PyObject *__pyx_n_s_range; +static PyObject *__pyx_n_s_reduce; +static PyObject *__pyx_n_s_reduce_cython; +static PyObject *__pyx_n_s_reduce_ex; +static PyObject *__pyx_n_s_sample_idx; +static PyObject *__pyx_n_s_setstate; +static PyObject *__pyx_n_s_setstate_cython; +static PyObject *__pyx_n_s_shape; +static PyObject *__pyx_n_s_size; +static PyObject *__pyx_n_s_solve_h; +static PyObject *__pyx_n_s_solve_r; +static PyObject *__pyx_n_s_start; +static PyObject *__pyx_n_s_step; +static PyObject *__pyx_n_s_stop; +static PyObject *__pyx_kp_s_strided_and_direct; +static PyObject *__pyx_kp_s_strided_and_direct_or_indirect; +static PyObject *__pyx_kp_s_strided_and_indirect; +static PyObject *__pyx_kp_s_stringsource; +static PyObject *__pyx_n_s_struct; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_kp_s_unable_to_allocate_array_data; +static PyObject *__pyx_kp_s_unable_to_allocate_shape_and_str; +static PyObject *__pyx_n_s_unpack; +static PyObject *__pyx_n_s_update; +static PyObject *__pyx_n_s_v_max; +static PyObject *__pyx_n_s_violation; +static PyObject *__pyx_pf_6gensim_6models_7nmf_pgd_solve_h(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_h, __Pyx_memviewslice __pyx_v_Wt_v_minus_r, __Pyx_memviewslice __pyx_v_WtW, double __pyx_v_kappa); /* proto */ +static PyObject *__pyx_pf_6gensim_6models_7nmf_pgd_2solve_r(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_r, PyObject *__pyx_v_r_actual, double __pyx_v_lambda_, double __pyx_v_v_max); /* proto */ +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer); /* proto */ +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self); /* proto */ +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_15View_dot_MemoryView_16_memoryviewslice_4base___get__(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_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*/ +static PyObject *__pyx_int_0; +static PyObject *__pyx_int_1; +static PyObject *__pyx_int_184977713; +static PyObject *__pyx_int_neg_1; +static PyObject *__pyx_tuple_; +static PyObject *__pyx_tuple__2; +static PyObject *__pyx_tuple__3; +static PyObject *__pyx_tuple__4; +static PyObject *__pyx_tuple__5; +static PyObject *__pyx_tuple__6; +static PyObject *__pyx_tuple__7; +static PyObject *__pyx_tuple__8; +static PyObject *__pyx_tuple__9; +static PyObject *__pyx_slice__16; +static PyObject *__pyx_slice__17; +static PyObject *__pyx_slice__18; +static PyObject *__pyx_tuple__10; +static PyObject *__pyx_tuple__11; +static PyObject *__pyx_tuple__12; +static PyObject *__pyx_tuple__13; +static PyObject *__pyx_tuple__14; +static PyObject *__pyx_tuple__15; +static PyObject *__pyx_tuple__19; +static PyObject *__pyx_tuple__20; +static PyObject *__pyx_tuple__21; +static PyObject *__pyx_tuple__22; +static PyObject *__pyx_tuple__24; +static PyObject *__pyx_tuple__26; +static PyObject *__pyx_tuple__27; +static PyObject *__pyx_tuple__28; +static PyObject *__pyx_tuple__29; +static PyObject *__pyx_tuple__30; +static PyObject *__pyx_tuple__31; +static PyObject *__pyx_codeobj__23; +static PyObject *__pyx_codeobj__25; +static PyObject *__pyx_codeobj__32; +/* Late includes */ + +/* "gensim/models/nmf_pgd.pyx":12 + * from cython.parallel import prange + * + * cdef double fmin(double x, double y) nogil: # <<<<<<<<<<<<<< + * return x if x < y else y + * + */ + +static double __pyx_f_6gensim_6models_7nmf_pgd_fmin(double __pyx_v_x, double __pyx_v_y) { + double __pyx_r; + double __pyx_t_1; + + /* "gensim/models/nmf_pgd.pyx":13 + * + * cdef double fmin(double x, double y) nogil: + * return x if x < y else y # <<<<<<<<<<<<<< + * + * cdef double fmax(double x, double y) nogil: + */ + if (((__pyx_v_x < __pyx_v_y) != 0)) { + __pyx_t_1 = __pyx_v_x; + } else { + __pyx_t_1 = __pyx_v_y; + } + __pyx_r = __pyx_t_1; + goto __pyx_L0; + + /* "gensim/models/nmf_pgd.pyx":12 + * from cython.parallel import prange + * + * cdef double fmin(double x, double y) nogil: # <<<<<<<<<<<<<< + * return x if x < y else y + * + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "gensim/models/nmf_pgd.pyx":15 + * return x if x < y else y + * + * cdef double fmax(double x, double y) nogil: # <<<<<<<<<<<<<< + * return x if x > y else y + * + */ + +static double __pyx_f_6gensim_6models_7nmf_pgd_fmax(double __pyx_v_x, double __pyx_v_y) { + double __pyx_r; + double __pyx_t_1; + + /* "gensim/models/nmf_pgd.pyx":16 + * + * cdef double fmax(double x, double y) nogil: + * return x if x > y else y # <<<<<<<<<<<<<< + * + * cdef double clip(double a, double a_min, double a_max) nogil: + */ + if (((__pyx_v_x > __pyx_v_y) != 0)) { + __pyx_t_1 = __pyx_v_x; + } else { + __pyx_t_1 = __pyx_v_y; + } + __pyx_r = __pyx_t_1; + goto __pyx_L0; + + /* "gensim/models/nmf_pgd.pyx":15 + * return x if x < y else y + * + * cdef double fmax(double x, double y) nogil: # <<<<<<<<<<<<<< + * return x if x > y else y + * + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "gensim/models/nmf_pgd.pyx":18 + * return x if x > y else y + * + * cdef double clip(double a, double a_min, double a_max) nogil: # <<<<<<<<<<<<<< + * a = fmin(a, a_max) + * a = fmax(a, a_min) + */ + +static double __pyx_f_6gensim_6models_7nmf_pgd_clip(double __pyx_v_a, double __pyx_v_a_min, double __pyx_v_a_max) { + double __pyx_r; + + /* "gensim/models/nmf_pgd.pyx":19 + * + * cdef double clip(double a, double a_min, double a_max) nogil: + * a = fmin(a, a_max) # <<<<<<<<<<<<<< + * a = fmax(a, a_min) + * return a + */ + __pyx_v_a = __pyx_f_6gensim_6models_7nmf_pgd_fmin(__pyx_v_a, __pyx_v_a_max); + + /* "gensim/models/nmf_pgd.pyx":20 + * cdef double clip(double a, double a_min, double a_max) nogil: + * a = fmin(a, a_max) + * a = fmax(a, a_min) # <<<<<<<<<<<<<< + * return a + * + */ + __pyx_v_a = __pyx_f_6gensim_6models_7nmf_pgd_fmax(__pyx_v_a, __pyx_v_a_min); + + /* "gensim/models/nmf_pgd.pyx":21 + * a = fmin(a, a_max) + * a = fmax(a, a_min) + * return a # <<<<<<<<<<<<<< + * + * def solve_h(double[:, ::1] h, double[:, :] Wt_v_minus_r, double[:, ::1] WtW, double kappa): + */ + __pyx_r = __pyx_v_a; + goto __pyx_L0; + + /* "gensim/models/nmf_pgd.pyx":18 + * return x if x > y else y + * + * cdef double clip(double a, double a_min, double a_max) nogil: # <<<<<<<<<<<<<< + * a = fmin(a, a_max) + * a = fmax(a, a_min) + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "gensim/models/nmf_pgd.pyx":23 + * return a + * + * def solve_h(double[:, ::1] h, double[:, :] Wt_v_minus_r, double[:, ::1] WtW, double kappa): # <<<<<<<<<<<<<< + * """Find optimal dense vector representation for current W and r matrices. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gensim_6models_7nmf_pgd_1solve_h(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_6gensim_6models_7nmf_pgd_solve_h[] = "solve_h(__Pyx_memviewslice h, __Pyx_memviewslice Wt_v_minus_r, __Pyx_memviewslice WtW, double kappa)\nFind optimal dense vector representation for current W and r matrices.\n\n Parameters\n ----------\n h : matrix\n Dense representation of documents in current batch.\n Wt_v_minus_r : matrix\n WtW : matrix\n\n Returns\n -------\n float\n Cumulative difference between previous and current h vectors.\n\n "; +static PyMethodDef __pyx_mdef_6gensim_6models_7nmf_pgd_1solve_h = {"solve_h", (PyCFunction)__pyx_pw_6gensim_6models_7nmf_pgd_1solve_h, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6gensim_6models_7nmf_pgd_solve_h}; +static PyObject *__pyx_pw_6gensim_6models_7nmf_pgd_1solve_h(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + __Pyx_memviewslice __pyx_v_h = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_Wt_v_minus_r = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_WtW = { 0, 0, { 0 }, { 0 }, { 0 } }; + double __pyx_v_kappa; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("solve_h (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_h,&__pyx_n_s_Wt_v_minus_r,&__pyx_n_s_WtW,&__pyx_n_s_kappa,0}; + PyObject* values[4] = {0,0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_h)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Wt_v_minus_r)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("solve_h", 1, 4, 4, 1); __PYX_ERR(0, 23, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_WtW)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("solve_h", 1, 4, 4, 2); __PYX_ERR(0, 23, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kappa)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("solve_h", 1, 4, 4, 3); __PYX_ERR(0, 23, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "solve_h") < 0)) __PYX_ERR(0, 23, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + } + __pyx_v_h = __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_h.memview)) __PYX_ERR(0, 23, __pyx_L3_error) + __pyx_v_Wt_v_minus_r = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_Wt_v_minus_r.memview)) __PYX_ERR(0, 23, __pyx_L3_error) + __pyx_v_WtW = __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(values[2], PyBUF_WRITABLE); if (unlikely(!__pyx_v_WtW.memview)) __PYX_ERR(0, 23, __pyx_L3_error) + __pyx_v_kappa = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_kappa == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 23, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("solve_h", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 23, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gensim.models.nmf_pgd.solve_h", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gensim_6models_7nmf_pgd_solve_h(__pyx_self, __pyx_v_h, __pyx_v_Wt_v_minus_r, __pyx_v_WtW, __pyx_v_kappa); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gensim_6models_7nmf_pgd_solve_h(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_h, __Pyx_memviewslice __pyx_v_Wt_v_minus_r, __Pyx_memviewslice __pyx_v_WtW, double __pyx_v_kappa) { + Py_ssize_t __pyx_v_n_components; + CYTHON_UNUSED Py_ssize_t __pyx_v_n_samples; + double __pyx_v_violation; + double __pyx_v_grad; + double __pyx_v_projected_grad; + double __pyx_v_hessian; + Py_ssize_t __pyx_v_sample_idx; + Py_ssize_t __pyx_v_component_idx_1; + Py_ssize_t __pyx_v_component_idx_2; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + Py_ssize_t __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; + Py_ssize_t __pyx_t_10; + Py_ssize_t __pyx_t_11; + Py_ssize_t __pyx_t_12; + Py_ssize_t __pyx_t_13; + Py_ssize_t __pyx_t_14; + Py_ssize_t __pyx_t_15; + Py_ssize_t __pyx_t_16; + Py_ssize_t __pyx_t_17; + double __pyx_t_18; + Py_ssize_t __pyx_t_19; + Py_ssize_t __pyx_t_20; + Py_ssize_t __pyx_t_21; + Py_ssize_t __pyx_t_22; + Py_ssize_t __pyx_t_23; + Py_ssize_t __pyx_t_24; + PyObject *__pyx_t_25 = NULL; + __Pyx_RefNannySetupContext("solve_h", 0); + + /* "gensim/models/nmf_pgd.pyx":40 + * """ + * + * cdef Py_ssize_t n_components = h.shape[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t n_samples = h.shape[1] + * cdef double violation = 0 + */ + __pyx_v_n_components = (__pyx_v_h.shape[0]); + + /* "gensim/models/nmf_pgd.pyx":41 + * + * cdef Py_ssize_t n_components = h.shape[0] + * cdef Py_ssize_t n_samples = h.shape[1] # <<<<<<<<<<<<<< + * cdef double violation = 0 + * cdef double grad, projected_grad, hessian + */ + __pyx_v_n_samples = (__pyx_v_h.shape[1]); + + /* "gensim/models/nmf_pgd.pyx":42 + * cdef Py_ssize_t n_components = h.shape[0] + * cdef Py_ssize_t n_samples = h.shape[1] + * cdef double violation = 0 # <<<<<<<<<<<<<< + * cdef double grad, projected_grad, hessian + * cdef Py_ssize_t sample_idx = 0 + */ + __pyx_v_violation = 0.0; + + /* "gensim/models/nmf_pgd.pyx":44 + * cdef double violation = 0 + * cdef double grad, projected_grad, hessian + * cdef Py_ssize_t sample_idx = 0 # <<<<<<<<<<<<<< + * cdef Py_ssize_t component_idx_1 = 0 + * cdef Py_ssize_t component_idx_2 = 0 + */ + __pyx_v_sample_idx = 0; + + /* "gensim/models/nmf_pgd.pyx":45 + * cdef double grad, projected_grad, hessian + * cdef Py_ssize_t sample_idx = 0 + * cdef Py_ssize_t component_idx_1 = 0 # <<<<<<<<<<<<<< + * cdef Py_ssize_t component_idx_2 = 0 + * + */ + __pyx_v_component_idx_1 = 0; + + /* "gensim/models/nmf_pgd.pyx":46 + * cdef Py_ssize_t sample_idx = 0 + * cdef Py_ssize_t component_idx_1 = 0 + * cdef Py_ssize_t component_idx_2 = 0 # <<<<<<<<<<<<<< + * + * for sample_idx in prange(n_samples, nogil=True): + */ + __pyx_v_component_idx_2 = 0; + + /* "gensim/models/nmf_pgd.pyx":48 + * cdef Py_ssize_t component_idx_2 = 0 + * + * for sample_idx in prange(n_samples, nogil=True): # <<<<<<<<<<<<<< + * for component_idx_1 in range(n_components): + * + */ + { + #ifdef WITH_THREAD + PyThreadState *_save; + Py_UNBLOCK_THREADS + __Pyx_FastGIL_Remember(); + #endif + /*try:*/ { + __pyx_t_1 = __pyx_v_n_samples; + if (1 == 0) abort(); + { + #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) + #undef likely + #undef unlikely + #define likely(x) (x) + #define unlikely(x) (x) + #endif + __pyx_t_3 = (__pyx_t_1 - 0 + 1 - 1/abs(1)) / 1; + if (__pyx_t_3 > 0) + { + #ifdef _OPENMP + #pragma omp parallel reduction(+:__pyx_v_violation) private(__pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_t_18, __pyx_t_19, __pyx_t_20, __pyx_t_21, __pyx_t_22, __pyx_t_23, __pyx_t_24, __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9) + #endif /* _OPENMP */ + { + #ifdef _OPENMP + #pragma omp for lastprivate(__pyx_v_component_idx_1) lastprivate(__pyx_v_component_idx_2) lastprivate(__pyx_v_grad) lastprivate(__pyx_v_hessian) lastprivate(__pyx_v_projected_grad) firstprivate(__pyx_v_sample_idx) lastprivate(__pyx_v_sample_idx) + #endif /* _OPENMP */ + for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_3; __pyx_t_2++){ + { + __pyx_v_sample_idx = (Py_ssize_t)(0 + 1 * __pyx_t_2); + /* Initialize private variables to invalid values */ + __pyx_v_component_idx_1 = ((Py_ssize_t)0xbad0bad0); + __pyx_v_component_idx_2 = ((Py_ssize_t)0xbad0bad0); + __pyx_v_grad = ((double)__PYX_NAN()); + __pyx_v_hessian = ((double)__PYX_NAN()); + __pyx_v_projected_grad = ((double)__PYX_NAN()); + + /* "gensim/models/nmf_pgd.pyx":49 + * + * for sample_idx in prange(n_samples, nogil=True): + * for component_idx_1 in range(n_components): # <<<<<<<<<<<<<< + * + * grad = -Wt_v_minus_r[component_idx_1, sample_idx] + */ + __pyx_t_4 = __pyx_v_n_components; + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_component_idx_1 = __pyx_t_6; + + /* "gensim/models/nmf_pgd.pyx":51 + * for component_idx_1 in range(n_components): + * + * grad = -Wt_v_minus_r[component_idx_1, sample_idx] # <<<<<<<<<<<<<< + * + * for component_idx_2 in range(n_components): + */ + __pyx_t_7 = __pyx_v_component_idx_1; + __pyx_t_8 = __pyx_v_sample_idx; + __pyx_v_grad = (-(*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_Wt_v_minus_r.data + __pyx_t_7 * __pyx_v_Wt_v_minus_r.strides[0]) ) + __pyx_t_8 * __pyx_v_Wt_v_minus_r.strides[1]) )))); + + /* "gensim/models/nmf_pgd.pyx":53 + * grad = -Wt_v_minus_r[component_idx_1, sample_idx] + * + * for component_idx_2 in range(n_components): # <<<<<<<<<<<<<< + * grad += WtW[component_idx_1, component_idx_2] * h[component_idx_2, sample_idx] + * + */ + __pyx_t_9 = __pyx_v_n_components; + __pyx_t_10 = __pyx_t_9; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { + __pyx_v_component_idx_2 = __pyx_t_11; + + /* "gensim/models/nmf_pgd.pyx":54 + * + * for component_idx_2 in range(n_components): + * grad += WtW[component_idx_1, component_idx_2] * h[component_idx_2, sample_idx] # <<<<<<<<<<<<<< + * + * hessian = WtW[component_idx_1, component_idx_1] + */ + __pyx_t_12 = __pyx_v_component_idx_1; + __pyx_t_13 = __pyx_v_component_idx_2; + __pyx_t_14 = __pyx_v_component_idx_2; + __pyx_t_15 = __pyx_v_sample_idx; + __pyx_v_grad = (__pyx_v_grad + ((*((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_WtW.data + __pyx_t_12 * __pyx_v_WtW.strides[0]) )) + __pyx_t_13)) ))) * (*((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_h.data + __pyx_t_14 * __pyx_v_h.strides[0]) )) + __pyx_t_15)) ))))); + } + + /* "gensim/models/nmf_pgd.pyx":56 + * grad += WtW[component_idx_1, component_idx_2] * h[component_idx_2, sample_idx] + * + * hessian = WtW[component_idx_1, component_idx_1] # <<<<<<<<<<<<<< + * + * grad = grad * kappa / hessian + */ + __pyx_t_16 = __pyx_v_component_idx_1; + __pyx_t_17 = __pyx_v_component_idx_1; + __pyx_v_hessian = (*((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_WtW.data + __pyx_t_16 * __pyx_v_WtW.strides[0]) )) + __pyx_t_17)) ))); + + /* "gensim/models/nmf_pgd.pyx":58 + * hessian = WtW[component_idx_1, component_idx_1] + * + * grad = grad * kappa / hessian # <<<<<<<<<<<<<< + * + * projected_grad = fmin(0, grad) if h[component_idx_1, sample_idx] == 0 else grad + */ + __pyx_v_grad = ((__pyx_v_grad * __pyx_v_kappa) / __pyx_v_hessian); + + /* "gensim/models/nmf_pgd.pyx":60 + * grad = grad * kappa / hessian + * + * projected_grad = fmin(0, grad) if h[component_idx_1, sample_idx] == 0 else grad # <<<<<<<<<<<<<< + * + * violation += projected_grad * projected_grad + */ + __pyx_t_19 = __pyx_v_component_idx_1; + __pyx_t_20 = __pyx_v_sample_idx; + if ((((*((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_h.data + __pyx_t_19 * __pyx_v_h.strides[0]) )) + __pyx_t_20)) ))) == 0.0) != 0)) { + __pyx_t_18 = __pyx_f_6gensim_6models_7nmf_pgd_fmin(0.0, __pyx_v_grad); + } else { + __pyx_t_18 = __pyx_v_grad; + } + __pyx_v_projected_grad = __pyx_t_18; + + /* "gensim/models/nmf_pgd.pyx":62 + * projected_grad = fmin(0, grad) if h[component_idx_1, sample_idx] == 0 else grad + * + * violation += projected_grad * projected_grad # <<<<<<<<<<<<<< + * + * h[component_idx_1, sample_idx] = fmax(h[component_idx_1, sample_idx] - grad, 0.) + */ + __pyx_v_violation = (__pyx_v_violation + (__pyx_v_projected_grad * __pyx_v_projected_grad)); + + /* "gensim/models/nmf_pgd.pyx":64 + * violation += projected_grad * projected_grad + * + * h[component_idx_1, sample_idx] = fmax(h[component_idx_1, sample_idx] - grad, 0.) # <<<<<<<<<<<<<< + * + * return sqrt(violation) + */ + __pyx_t_21 = __pyx_v_component_idx_1; + __pyx_t_22 = __pyx_v_sample_idx; + __pyx_t_23 = __pyx_v_component_idx_1; + __pyx_t_24 = __pyx_v_sample_idx; + *((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_h.data + __pyx_t_23 * __pyx_v_h.strides[0]) )) + __pyx_t_24)) )) = __pyx_f_6gensim_6models_7nmf_pgd_fmax(((*((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_h.data + __pyx_t_21 * __pyx_v_h.strides[0]) )) + __pyx_t_22)) ))) - __pyx_v_grad), 0.); + } + } + } + } + } + } + #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 + } + + /* "gensim/models/nmf_pgd.pyx":48 + * cdef Py_ssize_t component_idx_2 = 0 + * + * for sample_idx in prange(n_samples, nogil=True): # <<<<<<<<<<<<<< + * for component_idx_1 in range(n_components): + * + */ + /*finally:*/ { + /*normal exit:*/{ + #ifdef WITH_THREAD + __Pyx_FastGIL_Forget(); + Py_BLOCK_THREADS + #endif + goto __pyx_L5; + } + __pyx_L5:; + } + } + + /* "gensim/models/nmf_pgd.pyx":66 + * h[component_idx_1, sample_idx] = fmax(h[component_idx_1, sample_idx] - grad, 0.) + * + * return sqrt(violation) # <<<<<<<<<<<<<< + * + * def solve_r( + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_25 = PyFloat_FromDouble(sqrt(__pyx_v_violation)); if (unlikely(!__pyx_t_25)) __PYX_ERR(0, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_25); + __pyx_r = __pyx_t_25; + __pyx_t_25 = 0; + goto __pyx_L0; + + /* "gensim/models/nmf_pgd.pyx":23 + * return a + * + * def solve_h(double[:, ::1] h, double[:, :] Wt_v_minus_r, double[:, ::1] WtW, double kappa): # <<<<<<<<<<<<<< + * """Find optimal dense vector representation for current W and r matrices. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_25); + __Pyx_AddTraceback("gensim.models.nmf_pgd.solve_h", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __PYX_XDEC_MEMVIEW(&__pyx_v_h, 1); + __PYX_XDEC_MEMVIEW(&__pyx_v_Wt_v_minus_r, 1); + __PYX_XDEC_MEMVIEW(&__pyx_v_WtW, 1); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "gensim/models/nmf_pgd.pyx":68 + * return sqrt(violation) + * + * def solve_r( # <<<<<<<<<<<<<< + * r, + * r_actual, + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_6gensim_6models_7nmf_pgd_3solve_r(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_6gensim_6models_7nmf_pgd_2solve_r[] = "solve_r(r, r_actual, double lambda_, double v_max)\nBound new residuals.\n\n Parameters\n ----------\n r: sparse matrix\n r_actual: sparse matrix\n lambda_ : double\n v_max : double\n\n Returns\n -------\n float\n Cumulative difference between previous and current residuals vectors.\n\n "; +static PyMethodDef __pyx_mdef_6gensim_6models_7nmf_pgd_3solve_r = {"solve_r", (PyCFunction)__pyx_pw_6gensim_6models_7nmf_pgd_3solve_r, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6gensim_6models_7nmf_pgd_2solve_r}; +static PyObject *__pyx_pw_6gensim_6models_7nmf_pgd_3solve_r(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_r = 0; + PyObject *__pyx_v_r_actual = 0; + double __pyx_v_lambda_; + double __pyx_v_v_max; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("solve_r (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_r,&__pyx_n_s_r_actual,&__pyx_n_s_lambda,&__pyx_n_s_v_max,0}; + PyObject* values[4] = {0,0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_r)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_r_actual)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("solve_r", 1, 4, 4, 1); __PYX_ERR(0, 68, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lambda)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("solve_r", 1, 4, 4, 2); __PYX_ERR(0, 68, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_v_max)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("solve_r", 1, 4, 4, 3); __PYX_ERR(0, 68, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "solve_r") < 0)) __PYX_ERR(0, 68, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + } + __pyx_v_r = values[0]; + __pyx_v_r_actual = values[1]; + __pyx_v_lambda_ = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_lambda_ == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error) + __pyx_v_v_max = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_v_max == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 72, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("solve_r", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 68, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("gensim.models.nmf_pgd.solve_r", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_6gensim_6models_7nmf_pgd_2solve_r(__pyx_self, __pyx_v_r, __pyx_v_r_actual, __pyx_v_lambda_, __pyx_v_v_max); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_6gensim_6models_7nmf_pgd_2solve_r(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_r, PyObject *__pyx_v_r_actual, double __pyx_v_lambda_, double __pyx_v_v_max) { + __Pyx_memviewslice __pyx_v_r_indptr = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_r_indices = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_r_data = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_r_actual_indptr = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_r_actual_indices = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_r_actual_data = { 0, 0, { 0 }, { 0 }, { 0 } }; + Py_ssize_t __pyx_v_r_col_size; + Py_ssize_t __pyx_v_r_actual_col_size; + Py_ssize_t __pyx_v_r_col_indptr; + Py_ssize_t __pyx_v_r_actual_col_indptr; + Py_ssize_t __pyx_v_r_col_idx; + Py_ssize_t __pyx_v_r_actual_col_idx; + double *__pyx_v_r_element; + double *__pyx_v_r_actual_element; + double __pyx_v_r_actual_sign; + CYTHON_UNUSED Py_ssize_t __pyx_v_n_samples; + Py_ssize_t __pyx_v_sample_idx; + double __pyx_v_violation; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_3 = { 0, 0, { 0 }, { 0 }, { 0 } }; + Py_ssize_t __pyx_t_4; + Py_ssize_t __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; + Py_ssize_t __pyx_t_10; + int __pyx_t_11; + int __pyx_t_12; + Py_ssize_t __pyx_t_13; + Py_ssize_t __pyx_t_14; + Py_ssize_t __pyx_t_15; + Py_ssize_t __pyx_t_16; + Py_ssize_t __pyx_t_17; + Py_ssize_t __pyx_t_18; + Py_ssize_t __pyx_t_19; + Py_ssize_t __pyx_t_20; + __Pyx_RefNannySetupContext("solve_r", 0); + + /* "gensim/models/nmf_pgd.pyx":90 + * """ + * + * cdef int[::1] r_indptr = r.indptr # <<<<<<<<<<<<<< + * cdef int[::1] r_indices = r.indices + * cdef double[::1] r_data = r.data + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_r, __pyx_n_s_indptr); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dc_int(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 90, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_r_indptr = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "gensim/models/nmf_pgd.pyx":91 + * + * cdef int[::1] r_indptr = r.indptr + * cdef int[::1] r_indices = r.indices # <<<<<<<<<<<<<< + * cdef double[::1] r_data = r.data + * cdef int[::1] r_actual_indptr = r_actual.indptr + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_r, __pyx_n_s_indices); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dc_int(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 91, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_r_indices = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "gensim/models/nmf_pgd.pyx":92 + * cdef int[::1] r_indptr = r.indptr + * cdef int[::1] r_indices = r.indices + * cdef double[::1] r_data = r.data # <<<<<<<<<<<<<< + * cdef int[::1] r_actual_indptr = r_actual.indptr + * cdef int[::1] r_actual_indices = r_actual.indices + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_r, __pyx_n_s_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 92, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_to_MemoryviewSlice_dc_double(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 92, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_r_data = __pyx_t_3; + __pyx_t_3.memview = NULL; + __pyx_t_3.data = NULL; + + /* "gensim/models/nmf_pgd.pyx":93 + * cdef int[::1] r_indices = r.indices + * cdef double[::1] r_data = r.data + * cdef int[::1] r_actual_indptr = r_actual.indptr # <<<<<<<<<<<<<< + * cdef int[::1] r_actual_indices = r_actual.indices + * cdef double[::1] r_actual_data = r_actual.data + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_r_actual, __pyx_n_s_indptr); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dc_int(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 93, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_r_actual_indptr = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "gensim/models/nmf_pgd.pyx":94 + * cdef double[::1] r_data = r.data + * cdef int[::1] r_actual_indptr = r_actual.indptr + * cdef int[::1] r_actual_indices = r_actual.indices # <<<<<<<<<<<<<< + * cdef double[::1] r_actual_data = r_actual.data + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_r_actual, __pyx_n_s_indices); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dc_int(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_r_actual_indices = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "gensim/models/nmf_pgd.pyx":95 + * cdef int[::1] r_actual_indptr = r_actual.indptr + * cdef int[::1] r_actual_indices = r_actual.indices + * cdef double[::1] r_actual_data = r_actual.data # <<<<<<<<<<<<<< + * + * cdef Py_ssize_t r_col_size = 0 + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_r_actual, __pyx_n_s_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_to_MemoryviewSlice_dc_double(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 95, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_r_actual_data = __pyx_t_3; + __pyx_t_3.memview = NULL; + __pyx_t_3.data = NULL; + + /* "gensim/models/nmf_pgd.pyx":97 + * cdef double[::1] r_actual_data = r_actual.data + * + * cdef Py_ssize_t r_col_size = 0 # <<<<<<<<<<<<<< + * cdef Py_ssize_t r_actual_col_size = 0 + * cdef Py_ssize_t r_col_indptr + */ + __pyx_v_r_col_size = 0; + + /* "gensim/models/nmf_pgd.pyx":98 + * + * cdef Py_ssize_t r_col_size = 0 + * cdef Py_ssize_t r_actual_col_size = 0 # <<<<<<<<<<<<<< + * cdef Py_ssize_t r_col_indptr + * cdef Py_ssize_t r_actual_col_indptr + */ + __pyx_v_r_actual_col_size = 0; + + /* "gensim/models/nmf_pgd.pyx":106 + * cdef double* r_actual_element + * + * cdef double r_actual_sign = 1.0 # <<<<<<<<<<<<<< + * + * cdef Py_ssize_t n_samples = r_actual_indptr.shape[0] - 1 + */ + __pyx_v_r_actual_sign = 1.0; + + /* "gensim/models/nmf_pgd.pyx":108 + * cdef double r_actual_sign = 1.0 + * + * cdef Py_ssize_t n_samples = r_actual_indptr.shape[0] - 1 # <<<<<<<<<<<<<< + * cdef Py_ssize_t sample_idx + * + */ + __pyx_v_n_samples = ((__pyx_v_r_actual_indptr.shape[0]) - 1); + + /* "gensim/models/nmf_pgd.pyx":111 + * cdef Py_ssize_t sample_idx + * + * cdef double violation = 0 # <<<<<<<<<<<<<< + * + * for sample_idx in prange(n_samples, nogil=True): + */ + __pyx_v_violation = 0.0; + + /* "gensim/models/nmf_pgd.pyx":113 + * cdef double violation = 0 + * + * for sample_idx in prange(n_samples, nogil=True): # <<<<<<<<<<<<<< + * r_col_size = r_indptr[sample_idx + 1] - r_indptr[sample_idx] + * r_actual_col_size = r_actual_indptr[sample_idx + 1] - r_actual_indptr[sample_idx] + */ + { + #ifdef WITH_THREAD + PyThreadState *_save; + Py_UNBLOCK_THREADS + __Pyx_FastGIL_Remember(); + #endif + /*try:*/ { + __pyx_t_4 = __pyx_v_n_samples; + if (1 == 0) abort(); + { + #if ((defined(__APPLE__) || defined(__OSX__)) && (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))) + #undef likely + #undef unlikely + #define likely(x) (x) + #define unlikely(x) (x) + #endif + __pyx_t_6 = (__pyx_t_4 - 0 + 1 - 1/abs(1)) / 1; + if (__pyx_t_6 > 0) + { + #ifdef _OPENMP + #pragma omp parallel reduction(+:__pyx_v_violation) private(__pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_t_18, __pyx_t_19, __pyx_t_20, __pyx_t_7, __pyx_t_8, __pyx_t_9) + #endif /* _OPENMP */ + { + #ifdef _OPENMP + #pragma omp for lastprivate(__pyx_v_r_actual_col_idx) lastprivate(__pyx_v_r_actual_col_indptr) lastprivate(__pyx_v_r_actual_col_size) lastprivate(__pyx_v_r_actual_element) lastprivate(__pyx_v_r_actual_sign) lastprivate(__pyx_v_r_col_idx) lastprivate(__pyx_v_r_col_indptr) lastprivate(__pyx_v_r_col_size) lastprivate(__pyx_v_r_element) firstprivate(__pyx_v_sample_idx) lastprivate(__pyx_v_sample_idx) + #endif /* _OPENMP */ + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_6; __pyx_t_5++){ + { + __pyx_v_sample_idx = (Py_ssize_t)(0 + 1 * __pyx_t_5); + /* Initialize private variables to invalid values */ + __pyx_v_r_actual_col_idx = ((Py_ssize_t)0xbad0bad0); + __pyx_v_r_actual_col_indptr = ((Py_ssize_t)0xbad0bad0); + __pyx_v_r_actual_col_size = ((Py_ssize_t)0xbad0bad0); + __pyx_v_r_actual_element = ((double *)1); + __pyx_v_r_actual_sign = ((double)__PYX_NAN()); + __pyx_v_r_col_idx = ((Py_ssize_t)0xbad0bad0); + __pyx_v_r_col_indptr = ((Py_ssize_t)0xbad0bad0); + __pyx_v_r_col_size = ((Py_ssize_t)0xbad0bad0); + __pyx_v_r_element = ((double *)1); + + /* "gensim/models/nmf_pgd.pyx":114 + * + * for sample_idx in prange(n_samples, nogil=True): + * r_col_size = r_indptr[sample_idx + 1] - r_indptr[sample_idx] # <<<<<<<<<<<<<< + * r_actual_col_size = r_actual_indptr[sample_idx + 1] - r_actual_indptr[sample_idx] + * + */ + __pyx_t_7 = (__pyx_v_sample_idx + 1); + __pyx_t_8 = __pyx_v_sample_idx; + __pyx_v_r_col_size = ((*((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_r_indptr.data) + __pyx_t_7)) ))) - (*((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_r_indptr.data) + __pyx_t_8)) )))); + + /* "gensim/models/nmf_pgd.pyx":115 + * for sample_idx in prange(n_samples, nogil=True): + * r_col_size = r_indptr[sample_idx + 1] - r_indptr[sample_idx] + * r_actual_col_size = r_actual_indptr[sample_idx + 1] - r_actual_indptr[sample_idx] # <<<<<<<<<<<<<< + * + * r_col_idx = 0 + */ + __pyx_t_9 = (__pyx_v_sample_idx + 1); + __pyx_t_10 = __pyx_v_sample_idx; + __pyx_v_r_actual_col_size = ((*((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_r_actual_indptr.data) + __pyx_t_9)) ))) - (*((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_r_actual_indptr.data) + __pyx_t_10)) )))); + + /* "gensim/models/nmf_pgd.pyx":117 + * r_actual_col_size = r_actual_indptr[sample_idx + 1] - r_actual_indptr[sample_idx] + * + * r_col_idx = 0 # <<<<<<<<<<<<<< + * r_actual_col_idx = 0 + * + */ + __pyx_v_r_col_idx = 0; + + /* "gensim/models/nmf_pgd.pyx":118 + * + * r_col_idx = 0 + * r_actual_col_idx = 0 # <<<<<<<<<<<<<< + * + * while r_col_idx < r_col_size or r_actual_col_idx < r_actual_col_size: + */ + __pyx_v_r_actual_col_idx = 0; + + /* "gensim/models/nmf_pgd.pyx":120 + * r_actual_col_idx = 0 + * + * while r_col_idx < r_col_size or r_actual_col_idx < r_actual_col_size: # <<<<<<<<<<<<<< + * r_col_indptr = r_indices[ + * r_indptr[sample_idx] + */ + while (1) { + __pyx_t_12 = ((__pyx_v_r_col_idx < __pyx_v_r_col_size) != 0); + if (!__pyx_t_12) { + } else { + __pyx_t_11 = __pyx_t_12; + goto __pyx_L12_bool_binop_done; + } + __pyx_t_12 = ((__pyx_v_r_actual_col_idx < __pyx_v_r_actual_col_size) != 0); + __pyx_t_11 = __pyx_t_12; + __pyx_L12_bool_binop_done:; + if (!__pyx_t_11) break; + + /* "gensim/models/nmf_pgd.pyx":122 + * while r_col_idx < r_col_size or r_actual_col_idx < r_actual_col_size: + * r_col_indptr = r_indices[ + * r_indptr[sample_idx] # <<<<<<<<<<<<<< + * + r_col_idx + * ] + */ + __pyx_t_13 = __pyx_v_sample_idx; + + /* "gensim/models/nmf_pgd.pyx":121 + * + * while r_col_idx < r_col_size or r_actual_col_idx < r_actual_col_size: + * r_col_indptr = r_indices[ # <<<<<<<<<<<<<< + * r_indptr[sample_idx] + * + r_col_idx + */ + __pyx_t_14 = ((*((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_r_indptr.data) + __pyx_t_13)) ))) + __pyx_v_r_col_idx); + __pyx_v_r_col_indptr = (*((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_r_indices.data) + __pyx_t_14)) ))); + + /* "gensim/models/nmf_pgd.pyx":126 + * ] + * r_actual_col_indptr = r_actual_indices[ + * r_actual_indptr[sample_idx] # <<<<<<<<<<<<<< + * + r_actual_col_idx + * ] + */ + __pyx_t_15 = __pyx_v_sample_idx; + + /* "gensim/models/nmf_pgd.pyx":125 + * + r_col_idx + * ] + * r_actual_col_indptr = r_actual_indices[ # <<<<<<<<<<<<<< + * r_actual_indptr[sample_idx] + * + r_actual_col_idx + */ + __pyx_t_16 = ((*((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_r_actual_indptr.data) + __pyx_t_15)) ))) + __pyx_v_r_actual_col_idx); + __pyx_v_r_actual_col_indptr = (*((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_r_actual_indices.data) + __pyx_t_16)) ))); + + /* "gensim/models/nmf_pgd.pyx":131 + * + * r_element = &r_data[ + * r_indptr[sample_idx] # <<<<<<<<<<<<<< + * + r_col_idx + * ] + */ + __pyx_t_17 = __pyx_v_sample_idx; + + /* "gensim/models/nmf_pgd.pyx":130 + * ] + * + * r_element = &r_data[ # <<<<<<<<<<<<<< + * r_indptr[sample_idx] + * + r_col_idx + */ + __pyx_t_18 = ((*((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_r_indptr.data) + __pyx_t_17)) ))) + __pyx_v_r_col_idx); + __pyx_v_r_element = (&(*((double *) ( /* dim=0 */ ((char *) (((double *) __pyx_v_r_data.data) + __pyx_t_18)) )))); + + /* "gensim/models/nmf_pgd.pyx":135 + * ] + * r_actual_element = &r_actual_data[ + * r_actual_indptr[sample_idx] # <<<<<<<<<<<<<< + * + r_actual_col_idx + * ] + */ + __pyx_t_19 = __pyx_v_sample_idx; + + /* "gensim/models/nmf_pgd.pyx":134 + * + r_col_idx + * ] + * r_actual_element = &r_actual_data[ # <<<<<<<<<<<<<< + * r_actual_indptr[sample_idx] + * + r_actual_col_idx + */ + __pyx_t_20 = ((*((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_r_actual_indptr.data) + __pyx_t_19)) ))) + __pyx_v_r_actual_col_idx); + __pyx_v_r_actual_element = (&(*((double *) ( /* dim=0 */ ((char *) (((double *) __pyx_v_r_actual_data.data) + __pyx_t_20)) )))); + + /* "gensim/models/nmf_pgd.pyx":139 + * ] + * + * if r_col_indptr >= r_actual_col_indptr: # <<<<<<<<<<<<<< + * r_actual_sign = copysign(r_actual_sign, r_actual_element[0]) + * + */ + __pyx_t_11 = ((__pyx_v_r_col_indptr >= __pyx_v_r_actual_col_indptr) != 0); + if (__pyx_t_11) { + + /* "gensim/models/nmf_pgd.pyx":140 + * + * if r_col_indptr >= r_actual_col_indptr: + * r_actual_sign = copysign(r_actual_sign, r_actual_element[0]) # <<<<<<<<<<<<<< + * + * r_actual_element[0] = fabs(r_actual_element[0]) - lambda_ + */ + __pyx_v_r_actual_sign = copysign(__pyx_v_r_actual_sign, (__pyx_v_r_actual_element[0])); + + /* "gensim/models/nmf_pgd.pyx":142 + * r_actual_sign = copysign(r_actual_sign, r_actual_element[0]) + * + * r_actual_element[0] = fabs(r_actual_element[0]) - lambda_ # <<<<<<<<<<<<<< + * r_actual_element[0] = fmax(r_actual_element[0], 0) + * + */ + (__pyx_v_r_actual_element[0]) = (fabs((__pyx_v_r_actual_element[0])) - __pyx_v_lambda_); + + /* "gensim/models/nmf_pgd.pyx":143 + * + * r_actual_element[0] = fabs(r_actual_element[0]) - lambda_ + * r_actual_element[0] = fmax(r_actual_element[0], 0) # <<<<<<<<<<<<<< + * + * if r_actual_element[0] != 0: + */ + (__pyx_v_r_actual_element[0]) = __pyx_f_6gensim_6models_7nmf_pgd_fmax((__pyx_v_r_actual_element[0]), 0.0); + + /* "gensim/models/nmf_pgd.pyx":145 + * r_actual_element[0] = fmax(r_actual_element[0], 0) + * + * if r_actual_element[0] != 0: # <<<<<<<<<<<<<< + * r_actual_element[0] = copysign(r_actual_element[0], r_actual_sign) + * r_actual_element[0] = clip(r_actual_element[0], -v_max, v_max) + */ + __pyx_t_11 = (((__pyx_v_r_actual_element[0]) != 0.0) != 0); + if (__pyx_t_11) { + + /* "gensim/models/nmf_pgd.pyx":146 + * + * if r_actual_element[0] != 0: + * r_actual_element[0] = copysign(r_actual_element[0], r_actual_sign) # <<<<<<<<<<<<<< + * r_actual_element[0] = clip(r_actual_element[0], -v_max, v_max) + * + */ + (__pyx_v_r_actual_element[0]) = copysign((__pyx_v_r_actual_element[0]), __pyx_v_r_actual_sign); + + /* "gensim/models/nmf_pgd.pyx":147 + * if r_actual_element[0] != 0: + * r_actual_element[0] = copysign(r_actual_element[0], r_actual_sign) + * r_actual_element[0] = clip(r_actual_element[0], -v_max, v_max) # <<<<<<<<<<<<<< + * + * if r_col_indptr == r_actual_col_indptr: + */ + (__pyx_v_r_actual_element[0]) = __pyx_f_6gensim_6models_7nmf_pgd_clip((__pyx_v_r_actual_element[0]), (-__pyx_v_v_max), __pyx_v_v_max); + + /* "gensim/models/nmf_pgd.pyx":145 + * r_actual_element[0] = fmax(r_actual_element[0], 0) + * + * if r_actual_element[0] != 0: # <<<<<<<<<<<<<< + * r_actual_element[0] = copysign(r_actual_element[0], r_actual_sign) + * r_actual_element[0] = clip(r_actual_element[0], -v_max, v_max) + */ + } + + /* "gensim/models/nmf_pgd.pyx":149 + * r_actual_element[0] = clip(r_actual_element[0], -v_max, v_max) + * + * if r_col_indptr == r_actual_col_indptr: # <<<<<<<<<<<<<< + * violation += (r_element[0] - r_actual_element[0]) ** 2 + * else: + */ + __pyx_t_11 = ((__pyx_v_r_col_indptr == __pyx_v_r_actual_col_indptr) != 0); + if (__pyx_t_11) { + + /* "gensim/models/nmf_pgd.pyx":150 + * + * if r_col_indptr == r_actual_col_indptr: + * violation += (r_element[0] - r_actual_element[0]) ** 2 # <<<<<<<<<<<<<< + * else: + * violation += r_actual_element[0] ** 2 + */ + __pyx_v_violation = (__pyx_v_violation + pow(((__pyx_v_r_element[0]) - (__pyx_v_r_actual_element[0])), 2.0)); + + /* "gensim/models/nmf_pgd.pyx":149 + * r_actual_element[0] = clip(r_actual_element[0], -v_max, v_max) + * + * if r_col_indptr == r_actual_col_indptr: # <<<<<<<<<<<<<< + * violation += (r_element[0] - r_actual_element[0]) ** 2 + * else: + */ + goto __pyx_L16; + } + + /* "gensim/models/nmf_pgd.pyx":152 + * violation += (r_element[0] - r_actual_element[0]) ** 2 + * else: + * violation += r_actual_element[0] ** 2 # <<<<<<<<<<<<<< + * + * if r_actual_col_idx < r_actual_col_size: + */ + /*else*/ { + __pyx_v_violation = (__pyx_v_violation + pow((__pyx_v_r_actual_element[0]), 2.0)); + } + __pyx_L16:; + + /* "gensim/models/nmf_pgd.pyx":154 + * violation += r_actual_element[0] ** 2 + * + * if r_actual_col_idx < r_actual_col_size: # <<<<<<<<<<<<<< + * r_actual_col_idx = r_actual_col_idx + 1 + * else: + */ + __pyx_t_11 = ((__pyx_v_r_actual_col_idx < __pyx_v_r_actual_col_size) != 0); + if (__pyx_t_11) { + + /* "gensim/models/nmf_pgd.pyx":155 + * + * if r_actual_col_idx < r_actual_col_size: + * r_actual_col_idx = r_actual_col_idx + 1 # <<<<<<<<<<<<<< + * else: + * r_col_idx = r_col_idx + 1 + */ + __pyx_v_r_actual_col_idx = (__pyx_v_r_actual_col_idx + 1); + + /* "gensim/models/nmf_pgd.pyx":154 + * violation += r_actual_element[0] ** 2 + * + * if r_actual_col_idx < r_actual_col_size: # <<<<<<<<<<<<<< + * r_actual_col_idx = r_actual_col_idx + 1 + * else: + */ + goto __pyx_L17; + } + + /* "gensim/models/nmf_pgd.pyx":157 + * r_actual_col_idx = r_actual_col_idx + 1 + * else: + * r_col_idx = r_col_idx + 1 # <<<<<<<<<<<<<< + * else: + * violation += r_element[0] ** 2 + */ + /*else*/ { + __pyx_v_r_col_idx = (__pyx_v_r_col_idx + 1); + } + __pyx_L17:; + + /* "gensim/models/nmf_pgd.pyx":139 + * ] + * + * if r_col_indptr >= r_actual_col_indptr: # <<<<<<<<<<<<<< + * r_actual_sign = copysign(r_actual_sign, r_actual_element[0]) + * + */ + goto __pyx_L14; + } + + /* "gensim/models/nmf_pgd.pyx":159 + * r_col_idx = r_col_idx + 1 + * else: + * violation += r_element[0] ** 2 # <<<<<<<<<<<<<< + * + * if r_col_idx < r_col_size: + */ + /*else*/ { + __pyx_v_violation = (__pyx_v_violation + pow((__pyx_v_r_element[0]), 2.0)); + + /* "gensim/models/nmf_pgd.pyx":161 + * violation += r_element[0] ** 2 + * + * if r_col_idx < r_col_size: # <<<<<<<<<<<<<< + * r_col_idx = r_col_idx + 1 + * else: + */ + __pyx_t_11 = ((__pyx_v_r_col_idx < __pyx_v_r_col_size) != 0); + if (__pyx_t_11) { + + /* "gensim/models/nmf_pgd.pyx":162 + * + * if r_col_idx < r_col_size: + * r_col_idx = r_col_idx + 1 # <<<<<<<<<<<<<< + * else: + * r_actual_col_idx = r_actual_col_idx + 1 + */ + __pyx_v_r_col_idx = (__pyx_v_r_col_idx + 1); + + /* "gensim/models/nmf_pgd.pyx":161 + * violation += r_element[0] ** 2 + * + * if r_col_idx < r_col_size: # <<<<<<<<<<<<<< + * r_col_idx = r_col_idx + 1 + * else: + */ + goto __pyx_L18; + } + + /* "gensim/models/nmf_pgd.pyx":164 + * r_col_idx = r_col_idx + 1 + * else: + * r_actual_col_idx = r_actual_col_idx + 1 # <<<<<<<<<<<<<< + * + * return sqrt(violation) + */ + /*else*/ { + __pyx_v_r_actual_col_idx = (__pyx_v_r_actual_col_idx + 1); + } + __pyx_L18:; + } + __pyx_L14:; + } + } + } + } + } + } + #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 + } + + /* "gensim/models/nmf_pgd.pyx":113 + * cdef double violation = 0 + * + * for sample_idx in prange(n_samples, nogil=True): # <<<<<<<<<<<<<< + * r_col_size = r_indptr[sample_idx + 1] - r_indptr[sample_idx] + * r_actual_col_size = r_actual_indptr[sample_idx + 1] - r_actual_indptr[sample_idx] + */ + /*finally:*/ { + /*normal exit:*/{ + #ifdef WITH_THREAD + __Pyx_FastGIL_Forget(); + Py_BLOCK_THREADS + #endif + goto __pyx_L5; + } + __pyx_L5:; + } + } + + /* "gensim/models/nmf_pgd.pyx":166 + * r_actual_col_idx = r_actual_col_idx + 1 + * + * return sqrt(violation) # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(sqrt(__pyx_v_violation)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 166, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "gensim/models/nmf_pgd.pyx":68 + * return sqrt(violation) + * + * def solve_r( # <<<<<<<<<<<<<< + * r, + * r_actual, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __PYX_XDEC_MEMVIEW(&__pyx_t_2, 1); + __PYX_XDEC_MEMVIEW(&__pyx_t_3, 1); + __Pyx_AddTraceback("gensim.models.nmf_pgd.solve_r", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __PYX_XDEC_MEMVIEW(&__pyx_v_r_indptr, 1); + __PYX_XDEC_MEMVIEW(&__pyx_v_r_indices, 1); + __PYX_XDEC_MEMVIEW(&__pyx_v_r_data, 1); + __PYX_XDEC_MEMVIEW(&__pyx_v_r_actual_indptr, 1); + __PYX_XDEC_MEMVIEW(&__pyx_v_r_actual_indices, 1); + __PYX_XDEC_MEMVIEW(&__pyx_v_r_actual_data, 1); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":121 + * 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; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_shape,&__pyx_n_s_itemsize,&__pyx_n_s_format,&__pyx_n_s_mode,&__pyx_n_s_allocate_buffer,0}; + PyObject* values[5] = {0,0,0,0,0}; + values[3] = ((PyObject *)__pyx_n_s_c); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_shape)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_itemsize)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 1); __PYX_ERR(1, 121, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_format)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 2); __PYX_ERR(1, 121, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mode); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_allocate_buffer); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 121, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_shape = ((PyObject*)values[0]); + __pyx_v_itemsize = __Pyx_PyIndex_AsSsize_t(values[1]); if (unlikely((__pyx_v_itemsize == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 121, __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, 122, __pyx_L3_error) + } else { + + /* "View.MemoryView":122 + * + * 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_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 121, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_shape), (&PyTuple_Type), 1, "shape", 1))) __PYX_ERR(1, 121, __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, 121, __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":121 + * 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:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer) { + int __pyx_v_idx; + Py_ssize_t __pyx_v_i; + Py_ssize_t __pyx_v_dim; + PyObject **__pyx_v_p; + char __pyx_v_order; + int __pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + char *__pyx_t_6; + int __pyx_t_7; + Py_ssize_t __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + Py_ssize_t __pyx_t_11; + __Pyx_RefNannySetupContext("__cinit__", 0); + __Pyx_INCREF(__pyx_v_format); + + /* "View.MemoryView":128 + * cdef PyObject **p + * + * 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, 128, __pyx_L1_error) + } + __pyx_t_1 = PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 128, __pyx_L1_error) + __pyx_v_self->ndim = ((int)__pyx_t_1); + + /* "View.MemoryView":129 + * + * self.ndim = len(shape) + * self.itemsize = itemsize # <<<<<<<<<<<<<< + * + * if not self.ndim: + */ + __pyx_v_self->itemsize = __pyx_v_itemsize; + + /* "View.MemoryView":131 + * self.itemsize = itemsize + * + * if not self.ndim: # <<<<<<<<<<<<<< + * raise ValueError("Empty shape tuple for cython.array") + * + */ + __pyx_t_2 = ((!(__pyx_v_self->ndim != 0)) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":132 + * + * if not self.ndim: + * raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<< + * + * if itemsize <= 0: + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 132, __pyx_L1_error) + + /* "View.MemoryView":131 + * self.itemsize = itemsize + * + * if not self.ndim: # <<<<<<<<<<<<<< + * raise ValueError("Empty shape tuple for cython.array") + * + */ + } + + /* "View.MemoryView":134 + * 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) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":135 + * + * if itemsize <= 0: + * raise ValueError("itemsize <= 0 for cython.array") # <<<<<<<<<<<<<< + * + * if not isinstance(format, bytes): + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 135, __pyx_L1_error) + + /* "View.MemoryView":134 + * raise ValueError("Empty shape tuple for cython.array") + * + * if itemsize <= 0: # <<<<<<<<<<<<<< + * raise ValueError("itemsize <= 0 for cython.array") + * + */ + } + + /* "View.MemoryView":137 + * 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_4 = ((!(__pyx_t_2 != 0)) != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":138 + * + * 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_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_format, __pyx_t_5); + __pyx_t_5 = 0; + + /* "View.MemoryView":137 + * 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":139 + * 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)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_v_format)->tp_name), 0))) __PYX_ERR(1, 139, __pyx_L1_error) + __pyx_t_5 = __pyx_v_format; + __Pyx_INCREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_v_self->_format); + __Pyx_DECREF(__pyx_v_self->_format); + __pyx_v_self->_format = ((PyObject*)__pyx_t_5); + __pyx_t_5 = 0; + + /* "View.MemoryView":140 + * 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, 140, __pyx_L1_error) + } + __pyx_t_6 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(1, 140, __pyx_L1_error) + __pyx_v_self->format = __pyx_t_6; + + /* "View.MemoryView":143 + * + * + * 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":144 + * + * 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":146 + * self._strides = self._shape + self.ndim + * + * if not self._shape: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate shape and strides.") + * + */ + __pyx_t_4 = ((!(__pyx_v_self->_shape != 0)) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":147 + * + * if not self._shape: + * raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(1, 147, __pyx_L1_error) + + /* "View.MemoryView":146 + * self._strides = self._shape + self.ndim + * + * if not self._shape: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate shape and strides.") + * + */ + } + + /* "View.MemoryView":150 + * + * + * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + */ + __pyx_t_7 = 0; + __pyx_t_5 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_5); __pyx_t_1 = 0; + for (;;) { + if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_5)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_1); __Pyx_INCREF(__pyx_t_3); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(1, 150, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_5, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __pyx_t_8 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_8 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 150, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_dim = __pyx_t_8; + __pyx_v_idx = __pyx_t_7; + __pyx_t_7 = (__pyx_t_7 + 1); + + /* "View.MemoryView":151 + * + * for idx, dim in enumerate(shape): + * if dim <= 0: # <<<<<<<<<<<<<< + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * self._shape[idx] = dim + */ + __pyx_t_4 = ((__pyx_v_dim <= 0) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":152 + * for idx, dim in enumerate(shape): + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) # <<<<<<<<<<<<<< + * self._shape[idx] = dim + * + */ + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_idx); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_9 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_9); + __pyx_t_3 = 0; + __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(1, 152, __pyx_L1_error) + + /* "View.MemoryView":151 + * + * for idx, dim in enumerate(shape): + * if dim <= 0: # <<<<<<<<<<<<<< + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * self._shape[idx] = dim + */ + } + + /* "View.MemoryView":153 + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * self._shape[idx] = dim # <<<<<<<<<<<<<< + * + * cdef char order + */ + (__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim; + + /* "View.MemoryView":150 + * + * + * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + */ + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "View.MemoryView":156 + * + * cdef char order + * if mode == 'fortran': # <<<<<<<<<<<<<< + * order = b'F' + * self.mode = u'fortran' + */ + __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_fortran, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 156, __pyx_L1_error) + if (__pyx_t_4) { + + /* "View.MemoryView":157 + * cdef char order + * if mode == 'fortran': + * order = b'F' # <<<<<<<<<<<<<< + * self.mode = u'fortran' + * elif mode == 'c': + */ + __pyx_v_order = 'F'; + + /* "View.MemoryView":158 + * if mode == 'fortran': + * order = b'F' + * self.mode = u'fortran' # <<<<<<<<<<<<<< + * elif mode == 'c': + * order = b'C' + */ + __Pyx_INCREF(__pyx_n_u_fortran); + __Pyx_GIVEREF(__pyx_n_u_fortran); + __Pyx_GOTREF(__pyx_v_self->mode); + __Pyx_DECREF(__pyx_v_self->mode); + __pyx_v_self->mode = __pyx_n_u_fortran; + + /* "View.MemoryView":156 + * + * cdef char order + * if mode == 'fortran': # <<<<<<<<<<<<<< + * order = b'F' + * self.mode = u'fortran' + */ + goto __pyx_L10; + } + + /* "View.MemoryView":159 + * order = b'F' + * self.mode = u'fortran' + * elif mode == 'c': # <<<<<<<<<<<<<< + * order = b'C' + * self.mode = u'c' + */ + __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_c, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 159, __pyx_L1_error) + if (likely(__pyx_t_4)) { + + /* "View.MemoryView":160 + * self.mode = u'fortran' + * elif mode == 'c': + * order = b'C' # <<<<<<<<<<<<<< + * self.mode = u'c' + * else: + */ + __pyx_v_order = 'C'; + + /* "View.MemoryView":161 + * elif mode == 'c': + * order = b'C' + * self.mode = u'c' # <<<<<<<<<<<<<< + * else: + * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) + */ + __Pyx_INCREF(__pyx_n_u_c); + __Pyx_GIVEREF(__pyx_n_u_c); + __Pyx_GOTREF(__pyx_v_self->mode); + __Pyx_DECREF(__pyx_v_self->mode); + __pyx_v_self->mode = __pyx_n_u_c; + + /* "View.MemoryView":159 + * order = b'F' + * self.mode = u'fortran' + * elif mode == 'c': # <<<<<<<<<<<<<< + * order = b'C' + * self.mode = u'c' + */ + goto __pyx_L10; + } + + /* "View.MemoryView":163 + * self.mode = u'c' + * else: + * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) # <<<<<<<<<<<<<< + * + * self.len = fill_contig_strides_array(self._shape, self._strides, + */ + /*else*/ { + __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_v_mode); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_5); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(1, 163, __pyx_L1_error) + } + __pyx_L10:; + + /* "View.MemoryView":165 + * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) + * + * self.len = fill_contig_strides_array(self._shape, self._strides, # <<<<<<<<<<<<<< + * itemsize, self.ndim, order) + * + */ + __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":168 + * itemsize, self.ndim, order) + * + * self.free_data = allocate_buffer # <<<<<<<<<<<<<< + * self.dtype_is_object = format == b'O' + * if allocate_buffer: + */ + __pyx_v_self->free_data = __pyx_v_allocate_buffer; + + /* "View.MemoryView":169 + * + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' # <<<<<<<<<<<<<< + * if allocate_buffer: + * + */ + __pyx_t_10 = PyObject_RichCompare(__pyx_v_format, __pyx_n_b_O, Py_EQ); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 169, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 169, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_v_self->dtype_is_object = __pyx_t_4; + + /* "View.MemoryView":170 + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' + * if allocate_buffer: # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_4 = (__pyx_v_allocate_buffer != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":173 + * + * + * 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":174 + * + * self.data = malloc(self.len) + * if not self.data: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate array data.") + * + */ + __pyx_t_4 = ((!(__pyx_v_self->data != 0)) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":175 + * self.data = malloc(self.len) + * if not self.data: + * raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<< + * + * if self.dtype_is_object: + */ + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(1, 175, __pyx_L1_error) + + /* "View.MemoryView":174 + * + * self.data = malloc(self.len) + * if not self.data: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate array data.") + * + */ + } + + /* "View.MemoryView":177 + * raise MemoryError("unable to allocate array data.") + * + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * p = self.data + * for i in range(self.len / itemsize): + */ + __pyx_t_4 = (__pyx_v_self->dtype_is_object != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":178 + * + * if self.dtype_is_object: + * p = self.data # <<<<<<<<<<<<<< + * for i in range(self.len / itemsize): + * p[i] = Py_None + */ + __pyx_v_p = ((PyObject **)__pyx_v_self->data); + + /* "View.MemoryView":179 + * if self.dtype_is_object: + * p = self.data + * for i in range(self.len / itemsize): # <<<<<<<<<<<<<< + * p[i] = Py_None + * Py_INCREF(Py_None) + */ + if (unlikely(__pyx_v_itemsize == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); + __PYX_ERR(1, 179, __pyx_L1_error) + } + else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_self->len))) { + PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); + __PYX_ERR(1, 179, __pyx_L1_error) + } + __pyx_t_1 = (__pyx_v_self->len / __pyx_v_itemsize); + __pyx_t_8 = __pyx_t_1; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_8; __pyx_t_11+=1) { + __pyx_v_i = __pyx_t_11; + + /* "View.MemoryView":180 + * p = self.data + * for i in range(self.len / itemsize): + * p[i] = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) + * + */ + (__pyx_v_p[__pyx_v_i]) = Py_None; + + /* "View.MemoryView":181 + * for i in range(self.len / itemsize): + * p[i] = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * + * @cname('getbuffer') + */ + Py_INCREF(Py_None); + } + + /* "View.MemoryView":177 + * raise MemoryError("unable to allocate array data.") + * + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * p = self.data + * for i in range(self.len / itemsize): + */ + } + + /* "View.MemoryView":170 + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' + * if allocate_buffer: # <<<<<<<<<<<<<< + * + * + */ + } + + /* "View.MemoryView":121 + * 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_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_format); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":184 + * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * cdef int bufmode = -1 + * if self.mode == u"c": + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(((struct __pyx_array_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_v_bufmode; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + char *__pyx_t_4; + Py_ssize_t __pyx_t_5; + int __pyx_t_6; + Py_ssize_t *__pyx_t_7; + if (__pyx_v_info == NULL) { + PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); + return -1; + } + __Pyx_RefNannySetupContext("__getbuffer__", 0); + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + + /* "View.MemoryView":185 + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 # <<<<<<<<<<<<<< + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + */ + __pyx_v_bufmode = -1; + + /* "View.MemoryView":186 + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 + * if self.mode == u"c": # <<<<<<<<<<<<<< + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": + */ + __pyx_t_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) + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":187 + * cdef int bufmode = -1 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + */ + __pyx_v_bufmode = (PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); + + /* "View.MemoryView":186 + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 + * if self.mode == u"c": # <<<<<<<<<<<<<< + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": + */ + goto __pyx_L3; + } + + /* "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_2 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_fortran, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 188, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_2 != 0); + 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_L3:; + + /* "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)) != 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_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 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":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 + * info.ndim = self.ndim + */ + __pyx_t_4 = __pyx_v_self->data; + __pyx_v_info->buf = __pyx_t_4; + + /* "View.MemoryView":193 + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data + * info.len = self.len # <<<<<<<<<<<<<< + * info.ndim = self.ndim + * info.shape = self._shape + */ + __pyx_t_5 = __pyx_v_self->len; + __pyx_v_info->len = __pyx_t_5; + + /* "View.MemoryView":194 + * info.buf = self.data + * info.len = self.len + * info.ndim = self.ndim # <<<<<<<<<<<<<< + * info.shape = self._shape + * info.strides = self._strides + */ + __pyx_t_6 = __pyx_v_self->ndim; + __pyx_v_info->ndim = __pyx_t_6; + + /* "View.MemoryView":195 + * info.len = self.len + * info.ndim = self.ndim + * info.shape = self._shape # <<<<<<<<<<<<<< + * info.strides = self._strides + * info.suboffsets = NULL + */ + __pyx_t_7 = __pyx_v_self->_shape; + __pyx_v_info->shape = __pyx_t_7; + + /* "View.MemoryView":196 + * info.ndim = self.ndim + * info.shape = self._shape + * info.strides = self._strides # <<<<<<<<<<<<<< + * info.suboffsets = NULL + * info.itemsize = self.itemsize + */ + __pyx_t_7 = __pyx_v_self->_strides; + __pyx_v_info->strides = __pyx_t_7; + + /* "View.MemoryView":197 + * info.shape = self._shape + * info.strides = self._strides + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * info.itemsize = self.itemsize + * info.readonly = 0 + */ + __pyx_v_info->suboffsets = NULL; + + /* "View.MemoryView":198 + * info.strides = self._strides + * info.suboffsets = NULL + * info.itemsize = self.itemsize # <<<<<<<<<<<<<< + * info.readonly = 0 + * + */ + __pyx_t_5 = __pyx_v_self->itemsize; + __pyx_v_info->itemsize = __pyx_t_5; + + /* "View.MemoryView":199 + * info.suboffsets = NULL + * info.itemsize = self.itemsize + * info.readonly = 0 # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: + */ + __pyx_v_info->readonly = 0; + + /* "View.MemoryView":201 + * info.readonly = 0 + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.format + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":202 + * + * if flags & PyBUF_FORMAT: + * info.format = self.format # <<<<<<<<<<<<<< + * else: + * info.format = NULL + */ + __pyx_t_4 = __pyx_v_self->format; + __pyx_v_info->format = __pyx_t_4; + + /* "View.MemoryView":201 + * info.readonly = 0 + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.format + * else: + */ + goto __pyx_L5; + } + + /* "View.MemoryView":204 + * info.format = self.format + * else: + * info.format = NULL # <<<<<<<<<<<<<< + * + * info.obj = self + */ + /*else*/ { + __pyx_v_info->format = NULL; + } + __pyx_L5:; + + /* "View.MemoryView":206 + * info.format = NULL + * + * info.obj = self # <<<<<<<<<<<<<< + * + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") + */ + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + + /* "View.MemoryView":184 + * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * cdef int bufmode = -1 + * if self.mode == u"c": + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.array.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + __pyx_L2:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":210 + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") + * + * def __dealloc__(array self): # <<<<<<<<<<<<<< + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + */ + +/* Python wrapper */ +static void __pyx_array___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_array___dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "View.MemoryView":211 + * + * def __dealloc__(array self): + * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< + * self.callback_free_data(self.data) + * elif self.free_data: + */ + __pyx_t_1 = ((__pyx_v_self->callback_free_data != NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":212 + * def __dealloc__(array self): + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) # <<<<<<<<<<<<<< + * elif self.free_data: + * if self.dtype_is_object: + */ + __pyx_v_self->callback_free_data(__pyx_v_self->data); + + /* "View.MemoryView":211 + * + * def __dealloc__(array self): + * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< + * self.callback_free_data(self.data) + * elif self.free_data: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":213 + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + * elif self.free_data: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, + */ + __pyx_t_1 = (__pyx_v_self->free_data != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":214 + * self.callback_free_data(self.data) + * elif self.free_data: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice(self.data, self._shape, + * self._strides, self.ndim, False) + */ + __pyx_t_1 = (__pyx_v_self->dtype_is_object != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":215 + * elif self.free_data: + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, # <<<<<<<<<<<<<< + * self._strides, self.ndim, False) + * free(self.data) + */ + __pyx_memoryview_refcount_objects_in_slice(__pyx_v_self->data, __pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_self->ndim, 0); + + /* "View.MemoryView":214 + * self.callback_free_data(self.data) + * elif self.free_data: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice(self.data, self._shape, + * self._strides, self.ndim, False) + */ + } + + /* "View.MemoryView":217 + * refcount_objects_in_slice(self.data, self._shape, + * self._strides, self.ndim, False) + * free(self.data) # <<<<<<<<<<<<<< + * PyObject_Free(self._shape) + * + */ + free(__pyx_v_self->data); + + /* "View.MemoryView":213 + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + * elif self.free_data: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, + */ + } + __pyx_L3:; + + /* "View.MemoryView":218 + * self._strides, self.ndim, False) + * free(self.data) + * PyObject_Free(self._shape) # <<<<<<<<<<<<<< + * + * @property + */ + PyObject_Free(__pyx_v_self->_shape); + + /* "View.MemoryView":210 + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") + * + * def __dealloc__(array self): # <<<<<<<<<<<<<< + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":221 + * + * @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) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_5array_7memview___get__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":222 + * @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, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":221 + * + * @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":225 + * + * @cname('get_memview') + * cdef get_memview(self): # <<<<<<<<<<<<<< + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE + * return memoryview(self, flags, self.dtype_is_object) + */ + +static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) { + int __pyx_v_flags; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("get_memview", 0); + + /* "View.MemoryView":226 + * @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":227 + * 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, 227, __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, 227, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 227, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 227, __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":225 + * + * @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":229 + * return memoryview(self, flags, self.dtype_is_object) + * + * def __len__(self): # <<<<<<<<<<<<<< + * return self._shape[0] + * + */ + +/* Python wrapper */ +static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self); /*proto*/ +static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__", 0); + + /* "View.MemoryView":230 + * + * def __len__(self): + * return self._shape[0] # <<<<<<<<<<<<<< + * + * def __getattr__(self, attr): + */ + __pyx_r = (__pyx_v_self->_shape[0]); + goto __pyx_L0; + + /* "View.MemoryView":229 + * return memoryview(self, flags, self.dtype_is_object) + * + * def __len__(self): # <<<<<<<<<<<<<< + * return self._shape[0] + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":232 + * 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) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_attr)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__getattr__", 0); + + /* "View.MemoryView":233 + * + * 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, 233, __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, 233, __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":232 + * 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":235 + * 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) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "View.MemoryView":236 + * + * 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, 236, __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, 236, __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":235 + * 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":238 + * 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) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__setitem__", 0); + + /* "View.MemoryView":239 + * + * 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, 239, __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, 239, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "View.MemoryView":238 + * 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, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_array___reduce_cython__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* 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 + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(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_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_array_2__setstate_cython__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(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_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":243 + * + * @cname("__pyx_array_new") + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< + * char *mode, char *buf): + * cdef array result + */ + +static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, char *__pyx_v_format, char *__pyx_v_mode, char *__pyx_v_buf) { + struct __pyx_array_obj *__pyx_v_result = 0; + struct __pyx_array_obj *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("array_cwrapper", 0); + + /* "View.MemoryView":247 + * cdef array result + * + * if buf == NULL: # <<<<<<<<<<<<<< + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + */ + __pyx_t_1 = ((__pyx_v_buf == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":248 + * + * if buf == NULL: + * result = array(shape, itemsize, format, mode.decode('ASCII')) # <<<<<<<<<<<<<< + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), + */ + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v_shape); + __Pyx_GIVEREF(__pyx_v_shape); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_shape); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4); + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":247 + * cdef array result + * + * if buf == NULL: # <<<<<<<<<<<<<< + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":250 + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< + * allocate_buffer=False) + * result.data = buf + */ + /*else*/ { + __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_shape); + __Pyx_GIVEREF(__pyx_v_shape); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_shape); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_3); + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_3 = 0; + + /* "View.MemoryView":251 + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), + * allocate_buffer=False) # <<<<<<<<<<<<<< + * result.data = buf + * + */ + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_allocate_buffer, Py_False) < 0) __PYX_ERR(1, 251, __pyx_L1_error) + + /* "View.MemoryView":250 + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< + * allocate_buffer=False) + * result.data = buf + */ + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_5); + __pyx_t_5 = 0; + + /* "View.MemoryView":252 + * result = array(shape, itemsize, format, mode.decode('ASCII'), + * allocate_buffer=False) + * result.data = buf # <<<<<<<<<<<<<< + * + * return result + */ + __pyx_v_result->data = __pyx_v_buf; + } + __pyx_L3:; + + /* "View.MemoryView":254 + * 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":243 + * + * @cname("__pyx_array_new") + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< + * char *mode, char *buf): + * cdef array result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.array_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":280 + * 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; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 280, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_name = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 280, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("View.MemoryView.Enum.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v_name); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static 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__", 0); + + /* "View.MemoryView":281 + * 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":280 + * 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":282 + * 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) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "View.MemoryView":283 + * 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":282 + * 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 bint use_setstate + * state = (self.name,) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_MemviewEnum___reduce_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { + int __pyx_v_use_setstate; + PyObject *__pyx_v_state = NULL; + PyObject *__pyx_v__dict = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * 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, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self->name); + __Pyx_GIVEREF(__pyx_v_self->name); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->name); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":4 + * 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, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":5 + * state = (self.name,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "(tree fragment)":6 + * _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, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict); + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "(tree fragment)":7 + * 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)":5 + * state = (self.name,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":9 + * use_setstate = True + * else: + * use_setstate = self.name is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + */ + /*else*/ { + __pyx_t_3 = (__pyx_v_self->name != Py_None); + __pyx_v_use_setstate = __pyx_t_3; + } + __pyx_L3:; + + /* "(tree fragment)":10 + * else: + * use_setstate = self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * else: + */ + __pyx_t_3 = (__pyx_v_use_setstate != 0); + if (__pyx_t_3) { + + /* "(tree fragment)":11 + * use_setstate = self.name is not None + * if use_setstate: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 11, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 11, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_INCREF(__pyx_int_184977713); + __Pyx_GIVEREF(__pyx_int_184977713); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 11, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":10 + * else: + * use_setstate = self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * else: + */ + } + + /* "(tree fragment)":13 + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Enum__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __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)))); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_INCREF(__pyx_int_184977713); + __Pyx_GIVEREF(__pyx_int_184977713); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef bint use_setstate + * state = (self.name,) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.Enum.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":14 + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":15 + * return __pyx_unpickle_Enum, (type(self), 0xb068931, 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)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 15, __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, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":14 + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.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":297 + * + * @cname('__pyx_align_pointer') + * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< + * "Align pointer memory on a given boundary" + * cdef Py_intptr_t aligned_p = memory + */ + +static void *__pyx_align_pointer(void *__pyx_v_memory, size_t __pyx_v_alignment) { + Py_intptr_t __pyx_v_aligned_p; + size_t __pyx_v_offset; + void *__pyx_r; + int __pyx_t_1; + + /* "View.MemoryView":299 + * cdef void *align_pointer(void *memory, size_t alignment) nogil: + * "Align pointer memory on a given boundary" + * cdef Py_intptr_t aligned_p = memory # <<<<<<<<<<<<<< + * cdef size_t offset + * + */ + __pyx_v_aligned_p = ((Py_intptr_t)__pyx_v_memory); + + /* "View.MemoryView":303 + * + * with cython.cdivision(True): + * offset = aligned_p % alignment # <<<<<<<<<<<<<< + * + * if offset > 0: + */ + __pyx_v_offset = (__pyx_v_aligned_p % __pyx_v_alignment); + + /* "View.MemoryView":305 + * offset = aligned_p % alignment + * + * if offset > 0: # <<<<<<<<<<<<<< + * aligned_p += alignment - offset + * + */ + __pyx_t_1 = ((__pyx_v_offset > 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":306 + * + * if offset > 0: + * aligned_p += alignment - offset # <<<<<<<<<<<<<< + * + * return aligned_p + */ + __pyx_v_aligned_p = (__pyx_v_aligned_p + (__pyx_v_alignment - __pyx_v_offset)); + + /* "View.MemoryView":305 + * offset = aligned_p % alignment + * + * if offset > 0: # <<<<<<<<<<<<<< + * aligned_p += alignment - offset + * + */ + } + + /* "View.MemoryView":308 + * aligned_p += alignment - offset + * + * return aligned_p # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((void *)__pyx_v_aligned_p); + goto __pyx_L0; + + /* "View.MemoryView":297 + * + * @cname('__pyx_align_pointer') + * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< + * "Align pointer memory on a given boundary" + * cdef Py_intptr_t aligned_p = memory + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":344 + * 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; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_obj,&__pyx_n_s_flags,&__pyx_n_s_dtype_is_object,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_obj)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, 1); __PYX_ERR(1, 344, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dtype_is_object); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 344, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __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, 344, __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, 344, __pyx_L3_error) + } else { + __pyx_v_dtype_is_object = ((int)0); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 344, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_obj, __pyx_v_flags, __pyx_v_dtype_is_object); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* "View.MemoryView":345 + * + * 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":346 + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): + * self.obj = obj + * self.flags = flags # <<<<<<<<<<<<<< + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) + */ + __pyx_v_self->flags = __pyx_v_flags; + + /* "View.MemoryView":347 + * self.obj = obj + * self.flags = flags + * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: + */ + __pyx_t_2 = (((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))) == ((PyObject *)__pyx_memoryview_type)); + __pyx_t_3 = (__pyx_t_2 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = (__pyx_v_obj != Py_None); + __pyx_t_2 = (__pyx_t_3 != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "View.MemoryView":348 + * self.flags = flags + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) # <<<<<<<<<<<<<< + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None + */ + __pyx_t_4 = __Pyx_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 348, __pyx_L1_error) + + /* "View.MemoryView":349 + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: # <<<<<<<<<<<<<< + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) + */ + __pyx_t_1 = ((((PyObject *)__pyx_v_self->view.obj) == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":350 + * __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":351 + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * + * global __pyx_memoryview_thread_locks_used + */ + Py_INCREF(Py_None); + + /* "View.MemoryView":349 + * 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":347 + * 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":354 + * + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + */ + __pyx_t_1 = ((__pyx_memoryview_thread_locks_used < 8) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":355 + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: + */ + __pyx_v_self->lock = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); + + /* "View.MemoryView":356 + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 # <<<<<<<<<<<<<< + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + */ + __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used + 1); + + /* "View.MemoryView":354 + * + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + */ + } + + /* "View.MemoryView":357 + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: # <<<<<<<<<<<<<< + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: + */ + __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":358 + * __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":359 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * + */ + __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":360 + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: + * raise MemoryError # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: + */ + PyErr_NoMemory(); __PYX_ERR(1, 360, __pyx_L1_error) + + /* "View.MemoryView":359 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * + */ + } + + /* "View.MemoryView":357 + * 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":362 + * 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":363 + * + * if flags & PyBUF_FORMAT: + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') # <<<<<<<<<<<<<< + * else: + * self.dtype_is_object = dtype_is_object + */ + __pyx_t_2 = (((__pyx_v_self->view.format[0]) == 'O') != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_2 = (((__pyx_v_self->view.format[1]) == '\x00') != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L11_bool_binop_done:; + __pyx_v_self->dtype_is_object = __pyx_t_1; + + /* "View.MemoryView":362 + * raise MemoryError + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') + * else: + */ + goto __pyx_L10; + } + + /* "View.MemoryView":365 + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') + * else: + * self.dtype_is_object = dtype_is_object # <<<<<<<<<<<<<< + * + * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( + */ + /*else*/ { + __pyx_v_self->dtype_is_object = __pyx_v_dtype_is_object; + } + __pyx_L10:; + + /* "View.MemoryView":367 + * self.dtype_is_object = dtype_is_object + * + * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( # <<<<<<<<<<<<<< + * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) + * self.typeinfo = NULL + */ + __pyx_v_self->acquisition_count_aligned_p = ((__pyx_atomic_int *)__pyx_align_pointer(((void *)(&(__pyx_v_self->acquisition_count[0]))), (sizeof(__pyx_atomic_int)))); + + /* "View.MemoryView":369 + * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( + * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) + * self.typeinfo = NULL # <<<<<<<<<<<<<< + * + * def __dealloc__(memoryview self): + */ + __pyx_v_self->typeinfo = NULL; + + /* "View.MemoryView":344 + * 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":371 + * 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) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self) { + int __pyx_v_i; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyThread_type_lock __pyx_t_6; + PyThread_type_lock __pyx_t_7; + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "View.MemoryView":372 + * + * def __dealloc__(memoryview self): + * if self.obj is not None: # <<<<<<<<<<<<<< + * __Pyx_ReleaseBuffer(&self.view) + * + */ + __pyx_t_1 = (__pyx_v_self->obj != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":373 + * def __dealloc__(memoryview self): + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) # <<<<<<<<<<<<<< + * + * cdef int i + */ + __Pyx_ReleaseBuffer((&__pyx_v_self->view)); + + /* "View.MemoryView":372 + * + * def __dealloc__(memoryview self): + * if self.obj is not None: # <<<<<<<<<<<<<< + * __Pyx_ReleaseBuffer(&self.view) + * + */ + } + + /* "View.MemoryView":377 + * cdef int i + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: # <<<<<<<<<<<<<< + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: + */ + __pyx_t_2 = ((__pyx_v_self->lock != NULL) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":378 + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: + * for i in range(__pyx_memoryview_thread_locks_used): # <<<<<<<<<<<<<< + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 + */ + __pyx_t_3 = __pyx_memoryview_thread_locks_used; + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "View.MemoryView":379 + * if self.lock != NULL: + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: + */ + __pyx_t_2 = (((__pyx_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":380 + * 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":381 + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + */ + __pyx_t_2 = ((__pyx_v_i != __pyx_memoryview_thread_locks_used) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":383 + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) # <<<<<<<<<<<<<< + * break + * else: + */ + __pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); + __pyx_t_7 = (__pyx_memoryview_thread_locks[__pyx_v_i]); + + /* "View.MemoryView":382 + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + * break + */ + (__pyx_memoryview_thread_locks[__pyx_v_i]) = __pyx_t_6; + (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_7; + + /* "View.MemoryView":381 + * 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":384 + * __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":379 + * 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":386 + * 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":377 + * 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":371 + * self.typeinfo = NULL + * + * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":388 + * 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; + __Pyx_RefNannySetupContext("get_item_pointer", 0); + + /* "View.MemoryView":390 + * 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":392 + * 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, 392, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 392, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 392, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 392, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } else { + if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 392, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 392, __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, 392, __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":393 + * + * 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, 393, __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, 393, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_7; + + /* "View.MemoryView":392 + * 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":395 + * itemp = pybuffer_index(&self.view, itemp, idx, dim) + * + * return itemp # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_itemp; + goto __pyx_L0; + + /* "View.MemoryView":388 + * 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":398 + * + * + * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< + * if index is Ellipsis: + * return self + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index); /*proto*/ +static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index)); + + /* 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; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + char *__pyx_t_6; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "View.MemoryView":399 + * + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: # <<<<<<<<<<<<<< + * return self + * + */ + __pyx_t_1 = (__pyx_v_index == __pyx_builtin_Ellipsis); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":400 + * 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":399 + * + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: # <<<<<<<<<<<<<< + * return self + * + */ + } + + /* "View.MemoryView":402 + * return self + * + * have_slices, indices = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< + * + * cdef char *itemp + */ + __pyx_t_3 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 402, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (likely(__pyx_t_3 != Py_None)) { + PyObject* sequence = __pyx_t_3; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(1, 402, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + #else + __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 402, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 402, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 402, __pyx_L1_error) + } + __pyx_v_have_slices = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_v_indices = __pyx_t_5; + __pyx_t_5 = 0; + + /* "View.MemoryView":405 + * + * cdef char *itemp + * if have_slices: # <<<<<<<<<<<<<< + * return memview_slice(self, indices) + * else: + */ + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 405, __pyx_L1_error) + if (__pyx_t_2) { + + /* "View.MemoryView":406 + * cdef char *itemp + * if have_slices: + * return memview_slice(self, indices) # <<<<<<<<<<<<<< + * else: + * itemp = self.get_item_pointer(indices) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 406, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":405 + * + * cdef char *itemp + * if have_slices: # <<<<<<<<<<<<<< + * return memview_slice(self, indices) + * else: + */ + } + + /* "View.MemoryView":408 + * return memview_slice(self, indices) + * else: + * itemp = self.get_item_pointer(indices) # <<<<<<<<<<<<<< + * return self.convert_item_to_object(itemp) + * + */ + /*else*/ { + __pyx_t_6 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_6 == ((char *)NULL))) __PYX_ERR(1, 408, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_6; + + /* "View.MemoryView":409 + * else: + * itemp = self.get_item_pointer(indices) + * return self.convert_item_to_object(itemp) # <<<<<<<<<<<<<< + * + * def __setitem__(memoryview self, object index, object value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":398 + * + * + * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< + * if index is Ellipsis: + * return self + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_have_slices); + __Pyx_XDECREF(__pyx_v_indices); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":411 + * return self.convert_item_to_object(itemp) + * + * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") + */ + +/* Python wrapper */ +static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { + PyObject *__pyx_v_have_slices = NULL; + PyObject *__pyx_v_obj = NULL; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("__setitem__", 0); + __Pyx_INCREF(__pyx_v_index); + + /* "View.MemoryView":412 + * + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: # <<<<<<<<<<<<<< + * raise TypeError("Cannot assign to read-only memoryview") + * + */ + __pyx_t_1 = (__pyx_v_self->view.readonly != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":413 + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<< + * + * have_slices, index = _unellipsify(index, self.view.ndim) + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 413, __pyx_L1_error) + + /* "View.MemoryView":412 + * + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: # <<<<<<<<<<<<<< + * raise TypeError("Cannot assign to read-only memoryview") + * + */ + } + + /* "View.MemoryView":415 + * raise TypeError("Cannot assign to read-only memoryview") + * + * have_slices, index = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< + * + * if have_slices: + */ + __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 415, __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, 415, __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, 415, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 415, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 415, __pyx_L1_error) + } + __pyx_v_have_slices = __pyx_t_3; + __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":417 + * have_slices, index = _unellipsify(index, self.view.ndim) + * + * if have_slices: # <<<<<<<<<<<<<< + * obj = self.is_slice(value) + * if obj: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 417, __pyx_L1_error) + if (__pyx_t_1) { + + /* "View.MemoryView":418 + * + * if have_slices: + * obj = self.is_slice(value) # <<<<<<<<<<<<<< + * if obj: + * self.setitem_slice_assignment(self[index], obj) + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->is_slice(__pyx_v_self, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 418, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_obj = __pyx_t_2; + __pyx_t_2 = 0; + + /* "View.MemoryView":419 + * if have_slices: + * obj = self.is_slice(value) + * if obj: # <<<<<<<<<<<<<< + * self.setitem_slice_assignment(self[index], obj) + * else: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_obj); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 419, __pyx_L1_error) + if (__pyx_t_1) { + + /* "View.MemoryView":420 + * obj = self.is_slice(value) + * if obj: + * self.setitem_slice_assignment(self[index], obj) # <<<<<<<<<<<<<< + * else: + * self.setitem_slice_assign_scalar(self[index], value) + */ + __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assignment(__pyx_v_self, __pyx_t_2, __pyx_v_obj); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "View.MemoryView":419 + * if have_slices: + * obj = self.is_slice(value) + * if obj: # <<<<<<<<<<<<<< + * self.setitem_slice_assignment(self[index], obj) + * else: + */ + goto __pyx_L5; + } + + /* "View.MemoryView":422 + * 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_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_memoryview_type))))) __PYX_ERR(1, 422, __pyx_L1_error) + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_4), __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L5:; + + /* "View.MemoryView":417 + * have_slices, index = _unellipsify(index, self.view.ndim) + * + * if have_slices: # <<<<<<<<<<<<<< + * obj = self.is_slice(value) + * if obj: + */ + goto __pyx_L4; + } + + /* "View.MemoryView":424 + * self.setitem_slice_assign_scalar(self[index], value) + * else: + * self.setitem_indexed(index, value) # <<<<<<<<<<<<<< + * + * cdef is_slice(self, obj): + */ + /*else*/ { + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L4:; + + /* "View.MemoryView":411 + * 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_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __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":426 + * 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; + __Pyx_RefNannySetupContext("is_slice", 0); + __Pyx_INCREF(__pyx_v_obj); + + /* "View.MemoryView":427 + * + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< + * try: + * obj = memoryview(obj, self.flags|PyBUF_ANY_CONTIGUOUS, + */ + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_obj, __pyx_memoryview_type); + __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":428 + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): + * try: # <<<<<<<<<<<<<< + * obj = memoryview(obj, self.flags|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":429 + * if not isinstance(obj, memoryview): + * try: + * obj = memoryview(obj, self.flags|PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< + * self.dtype_is_object) + * except TypeError: + */ + __pyx_t_6 = __Pyx_PyInt_From_int((__pyx_v_self->flags | PyBUF_ANY_CONTIGUOUS)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 429, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_6); + + /* "View.MemoryView":430 + * try: + * obj = memoryview(obj, self.flags|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, 430, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_7); + + /* "View.MemoryView":429 + * if not isinstance(obj, memoryview): + * try: + * obj = memoryview(obj, self.flags|PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< + * self.dtype_is_object) + * except TypeError: + */ + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 429, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_INCREF(__pyx_v_obj); + __Pyx_GIVEREF(__pyx_v_obj); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_obj); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7); + __pyx_t_6 = 0; + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 429, __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":428 + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): + * try: # <<<<<<<<<<<<<< + * obj = memoryview(obj, self.flags|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_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "View.MemoryView":431 + * obj = memoryview(obj, self.flags|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, 431, __pyx_L6_except_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GOTREF(__pyx_t_6); + + /* "View.MemoryView":432 + * 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; + __pyx_L6_except_error:; + + /* "View.MemoryView":428 + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): + * try: # <<<<<<<<<<<<<< + * obj = memoryview(obj, self.flags|PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) + */ + __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":427 + * + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< + * try: + * obj = memoryview(obj, self.flags|PyBUF_ANY_CONTIGUOUS, + */ + } + + /* "View.MemoryView":434 + * 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":426 + * 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":436 + * 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; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + __Pyx_RefNannySetupContext("setitem_slice_assignment", 0); + + /* "View.MemoryView":440 + * cdef __Pyx_memviewslice src_slice + * + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], # <<<<<<<<<<<<<< + * get_slice_from_memview(dst, &dst_slice)[0], + * src.ndim, dst.ndim, self.dtype_is_object) + */ + if (!(likely(((__pyx_v_src) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_src, __pyx_memoryview_type))))) __PYX_ERR(1, 440, __pyx_L1_error) + + /* "View.MemoryView":441 + * + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], + * get_slice_from_memview(dst, &dst_slice)[0], # <<<<<<<<<<<<<< + * src.ndim, dst.ndim, self.dtype_is_object) + * + */ + if (!(likely(((__pyx_v_dst) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_dst, __pyx_memoryview_type))))) __PYX_ERR(1, 441, __pyx_L1_error) + + /* "View.MemoryView":442 + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], + * get_slice_from_memview(dst, &dst_slice)[0], + * src.ndim, dst.ndim, self.dtype_is_object) # <<<<<<<<<<<<<< + * + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_n_s_ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 442, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dst, __pyx_n_s_ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 442, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "View.MemoryView":440 + * cdef __Pyx_memviewslice src_slice + * + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], # <<<<<<<<<<<<<< + * get_slice_from_memview(dst, &dst_slice)[0], + * src.ndim, dst.ndim, self.dtype_is_object) + */ + __pyx_t_4 = __pyx_memoryview_copy_contents((__pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_src), (&__pyx_v_src_slice))[0]), (__pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice))[0]), __pyx_t_2, __pyx_t_3, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 440, __pyx_L1_error) + + /* "View.MemoryView":436 + * 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_1); + __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":444 + * 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 + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + char const *__pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + __Pyx_RefNannySetupContext("setitem_slice_assign_scalar", 0); + + /* "View.MemoryView":446 + * 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":451 + * 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_v_dst_slice = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_dst, (&__pyx_v_tmp_slice)); + + /* "View.MemoryView":453 + * 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_1 = ((((size_t)__pyx_v_self->view.itemsize) > (sizeof(__pyx_v_array))) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":454 + * + * 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":455 + * if self.view.itemsize > sizeof(array): + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * item = tmp + */ + __pyx_t_1 = ((__pyx_v_tmp == NULL) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":456 + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: + * raise MemoryError # <<<<<<<<<<<<<< + * item = tmp + * else: + */ + PyErr_NoMemory(); __PYX_ERR(1, 456, __pyx_L1_error) + + /* "View.MemoryView":455 + * if self.view.itemsize > sizeof(array): + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * item = tmp + */ + } + + /* "View.MemoryView":457 + * if tmp == NULL: + * raise MemoryError + * item = tmp # <<<<<<<<<<<<<< + * else: + * item = array + */ + __pyx_v_item = __pyx_v_tmp; + + /* "View.MemoryView":453 + * 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":459 + * item = tmp + * else: + * item = array # <<<<<<<<<<<<<< + * + * try: + */ + /*else*/ { + __pyx_v_item = ((void *)__pyx_v_array); + } + __pyx_L3:; + + /* "View.MemoryView":461 + * item = array + * + * try: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * ( item)[0] = value + */ + /*try:*/ { + + /* "View.MemoryView":462 + * + * try: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * ( item)[0] = value + * else: + */ + __pyx_t_1 = (__pyx_v_self->dtype_is_object != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":463 + * 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":462 + * + * try: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * ( item)[0] = value + * else: + */ + goto __pyx_L8; + } + + /* "View.MemoryView":465 + * ( item)[0] = value + * else: + * self.assign_item_from_object( item, value) # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, ((char *)__pyx_v_item), __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 465, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L8:; + + /* "View.MemoryView":469 + * + * + * 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_1 = ((__pyx_v_self->view.suboffsets != NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":470 + * + * if self.view.suboffsets != NULL: + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) # <<<<<<<<<<<<<< + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, + * item, self.dtype_is_object) + */ + __pyx_t_2 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 470, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":469 + * + * + * 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":471 + * if self.view.suboffsets != NULL: + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, # <<<<<<<<<<<<<< + * item, self.dtype_is_object) + * 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":474 + * 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_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8) < 0)) __Pyx_ErrFetch(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_11); + __pyx_t_3 = __pyx_lineno; __pyx_t_4 = __pyx_clineno; __pyx_t_5 = __pyx_filename; + { + PyMem_Free(__pyx_v_tmp); + } + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); + } + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_ErrRestore(__pyx_t_6, __pyx_t_7, __pyx_t_8); + __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; + __pyx_lineno = __pyx_t_3; __pyx_clineno = __pyx_t_4; __pyx_filename = __pyx_t_5; + goto __pyx_L1_error; + } + __pyx_L7:; + } + + /* "View.MemoryView":444 + * 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_2); + __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":476 + * 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; + __Pyx_RefNannySetupContext("setitem_indexed", 0); + + /* "View.MemoryView":477 + * + * 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, 477, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_1; + + /* "View.MemoryView":478 + * 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, 478, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":476 + * 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":480 + * 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; + PyObject *__pyx_t_9 = NULL; + size_t __pyx_t_10; + int __pyx_t_11; + __Pyx_RefNannySetupContext("convert_item_to_object", 0); + + /* "View.MemoryView":483 + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + * import struct # <<<<<<<<<<<<<< + * cdef bytes bytesitem + * + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 483, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_struct = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":486 + * 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, 486, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_bytesitem = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":487 + * + * 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":488 + * 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, 488, __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, 488, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && 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; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 488, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 488, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 488, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_6); + __Pyx_INCREF(__pyx_v_bytesitem); + __Pyx_GIVEREF(__pyx_v_bytesitem); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_bytesitem); + __pyx_t_6 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 488, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":487 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + */ + } + + /* "View.MemoryView":492 + * raise ValueError("Unable to convert item to object") + * else: + * if len(self.view.format) == 1: # <<<<<<<<<<<<<< + * return result[0] + * return result + */ + /*else:*/ { + __pyx_t_10 = strlen(__pyx_v_self->view.format); + __pyx_t_11 = ((__pyx_t_10 == 1) != 0); + if (__pyx_t_11) { + + /* "View.MemoryView":493 + * 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, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 493, __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":492 + * raise ValueError("Unable to convert item to object") + * else: + * if len(self.view.format) == 1: # <<<<<<<<<<<<<< + * return result[0] + * return result + */ + } + + /* "View.MemoryView":494 + * 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_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "View.MemoryView":489 + * 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_9); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 489, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_ErrRestore(__pyx_t_1, __pyx_t_5, __pyx_t_9); + __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_9 = 0; + if (__pyx_t_8) { + __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(1, 489, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_1); + + /* "View.MemoryView":490 + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + * raise ValueError("Unable to convert item to object") # <<<<<<<<<<<<<< + * else: + * if len(self.view.format) == 1: + */ + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 490, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(1, 490, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "View.MemoryView":487 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.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":480 + * 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_XDECREF(__pyx_t_9); + __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":496 + * 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; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + Py_ssize_t __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + char *__pyx_t_11; + char *__pyx_t_12; + char *__pyx_t_13; + char *__pyx_t_14; + __Pyx_RefNannySetupContext("assign_item_from_object", 0); + + /* "View.MemoryView":499 + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + * import struct # <<<<<<<<<<<<<< + * cdef char c + * cdef bytes bytesvalue + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_struct = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":504 + * 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); + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "View.MemoryView":505 + * + * 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, 505, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 505, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 505, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 505, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 505, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 505, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 505, __pyx_L1_error) + __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":504 + * cdef Py_ssize_t i + * + * if isinstance(value, tuple): # <<<<<<<<<<<<<< + * bytesvalue = struct.pack(self.view.format, *value) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":507 + * bytesvalue = struct.pack(self.view.format, *value) + * else: + * bytesvalue = struct.pack(self.view.format, value) # <<<<<<<<<<<<<< + * + * for i, c in enumerate(bytesvalue): + */ + /*else*/ { + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 507, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 507, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 507, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 507, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 507, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_value); + __pyx_t_1 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 507, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 507, __pyx_L1_error) + __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + } + __pyx_L3:; + + /* "View.MemoryView":509 + * bytesvalue = struct.pack(self.view.format, value) + * + * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< + * itemp[i] = c + * + */ + __pyx_t_9 = 0; + if (unlikely(__pyx_v_bytesvalue == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable"); + __PYX_ERR(1, 509, __pyx_L1_error) + } + __Pyx_INCREF(__pyx_v_bytesvalue); + __pyx_t_10 = __pyx_v_bytesvalue; + __pyx_t_12 = PyBytes_AS_STRING(__pyx_t_10); + __pyx_t_13 = (__pyx_t_12 + PyBytes_GET_SIZE(__pyx_t_10)); + for (__pyx_t_14 = __pyx_t_12; __pyx_t_14 < __pyx_t_13; __pyx_t_14++) { + __pyx_t_11 = __pyx_t_14; + __pyx_v_c = (__pyx_t_11[0]); + + /* "View.MemoryView":510 + * + * for i, c in enumerate(bytesvalue): + * itemp[i] = c # <<<<<<<<<<<<<< + * + * @cname('getbuffer') + */ + __pyx_v_i = __pyx_t_9; + + /* "View.MemoryView":509 + * bytesvalue = struct.pack(self.view.format, value) + * + * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< + * itemp[i] = c + * + */ + __pyx_t_9 = (__pyx_t_9 + 1); + + /* "View.MemoryView":510 + * + * for i, c in enumerate(bytesvalue): + * itemp[i] = c # <<<<<<<<<<<<<< + * + * @cname('getbuffer') + */ + (__pyx_v_itemp[__pyx_v_i]) = __pyx_v_c; + } + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "View.MemoryView":496 + * 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_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); + __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":513 + * + * @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") + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __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; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t *__pyx_t_4; + char *__pyx_t_5; + void *__pyx_t_6; + int __pyx_t_7; + Py_ssize_t __pyx_t_8; + if (__pyx_v_info == NULL) { + PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); + return -1; + } + __Pyx_RefNannySetupContext("__getbuffer__", 0); + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + + /* "View.MemoryView":514 + * @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_2 = (__pyx_v_self->view.readonly != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":515 + * 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_STRIDES: + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 515, __pyx_L1_error) + + /* "View.MemoryView":514 + * @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":517 + * raise ValueError("Cannot create writable memory view from read-only memoryview") + * + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< + * info.shape = self.view.shape + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":518 + * + * if flags & PyBUF_STRIDES: + * info.shape = self.view.shape # <<<<<<<<<<<<<< + * else: + * info.shape = NULL + */ + __pyx_t_4 = __pyx_v_self->view.shape; + __pyx_v_info->shape = __pyx_t_4; + + /* "View.MemoryView":517 + * raise ValueError("Cannot create writable memory view from read-only memoryview") + * + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< + * info.shape = self.view.shape + * else: + */ + goto __pyx_L6; + } + + /* "View.MemoryView":520 + * info.shape = self.view.shape + * else: + * info.shape = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_STRIDES: + */ + /*else*/ { + __pyx_v_info->shape = NULL; + } + __pyx_L6:; + + /* "View.MemoryView":522 + * 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":523 + * + * if flags & PyBUF_STRIDES: + * info.strides = self.view.strides # <<<<<<<<<<<<<< + * else: + * info.strides = NULL + */ + __pyx_t_4 = __pyx_v_self->view.strides; + __pyx_v_info->strides = __pyx_t_4; + + /* "View.MemoryView":522 + * info.shape = NULL + * + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< + * info.strides = self.view.strides + * else: + */ + goto __pyx_L7; + } + + /* "View.MemoryView":525 + * info.strides = self.view.strides + * else: + * info.strides = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_INDIRECT: + */ + /*else*/ { + __pyx_v_info->strides = NULL; + } + __pyx_L7:; + + /* "View.MemoryView":527 + * 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":528 + * + * if flags & PyBUF_INDIRECT: + * info.suboffsets = self.view.suboffsets # <<<<<<<<<<<<<< + * else: + * info.suboffsets = NULL + */ + __pyx_t_4 = __pyx_v_self->view.suboffsets; + __pyx_v_info->suboffsets = __pyx_t_4; + + /* "View.MemoryView":527 + * info.strides = NULL + * + * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< + * info.suboffsets = self.view.suboffsets + * else: + */ + goto __pyx_L8; + } + + /* "View.MemoryView":530 + * info.suboffsets = self.view.suboffsets + * else: + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: + */ + /*else*/ { + __pyx_v_info->suboffsets = NULL; + } + __pyx_L8:; + + /* "View.MemoryView":532 + * 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":533 + * + * if flags & PyBUF_FORMAT: + * info.format = self.view.format # <<<<<<<<<<<<<< + * else: + * info.format = NULL + */ + __pyx_t_5 = __pyx_v_self->view.format; + __pyx_v_info->format = __pyx_t_5; + + /* "View.MemoryView":532 + * info.suboffsets = NULL + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.view.format + * else: + */ + goto __pyx_L9; + } + + /* "View.MemoryView":535 + * info.format = self.view.format + * else: + * info.format = NULL # <<<<<<<<<<<<<< + * + * info.buf = self.view.buf + */ + /*else*/ { + __pyx_v_info->format = NULL; + } + __pyx_L9:; + + /* "View.MemoryView":537 + * info.format = NULL + * + * info.buf = self.view.buf # <<<<<<<<<<<<<< + * info.ndim = self.view.ndim + * info.itemsize = self.view.itemsize + */ + __pyx_t_6 = __pyx_v_self->view.buf; + __pyx_v_info->buf = __pyx_t_6; + + /* "View.MemoryView":538 + * + * info.buf = self.view.buf + * info.ndim = self.view.ndim # <<<<<<<<<<<<<< + * info.itemsize = self.view.itemsize + * info.len = self.view.len + */ + __pyx_t_7 = __pyx_v_self->view.ndim; + __pyx_v_info->ndim = __pyx_t_7; + + /* "View.MemoryView":539 + * 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_8 = __pyx_v_self->view.itemsize; + __pyx_v_info->itemsize = __pyx_t_8; + + /* "View.MemoryView":540 + * 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_8 = __pyx_v_self->view.len; + __pyx_v_info->len = __pyx_t_8; + + /* "View.MemoryView":541 + * 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":542 + * info.len = self.view.len + * info.readonly = self.view.readonly + * info.obj = self # <<<<<<<<<<<<<< + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") + */ + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + + /* "View.MemoryView":513 + * + * @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") + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __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":548 + * + * @property + * def T(self): # <<<<<<<<<<<<<< + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) + */ + +/* 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) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __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; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":549 + * @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, 549, __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, 549, __pyx_L1_error) + __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":550 + * def T(self): + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_t_2 = __pyx_memslice_transpose((&__pyx_v_result->from_slice)); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(1, 550, __pyx_L1_error) + + /* "View.MemoryView":551 + * 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":548 + * + * @property + * def T(self): # <<<<<<<<<<<<<< + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) + */ + + /* 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":554 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.obj + * + */ + +/* 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) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __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 + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":555 + * @property + * def 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":554 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.obj + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":558 + * + * @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) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __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_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; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":559 + * @property + * def shape(self): + * return tuple([length for length in self.view.shape[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 559, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); + for (__pyx_t_4 = __pyx_v_self->view.shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { + __pyx_t_2 = __pyx_t_4; + __pyx_v_length = (__pyx_t_2[0]); + __pyx_t_5 = PyInt_FromSsize_t(__pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 559, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(1, 559, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_t_5 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 559, __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":558 + * + * @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":562 + * + * @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) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __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_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; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":563 + * @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) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":565 + * if self.view.strides == NULL: + * + * raise ValueError("Buffer view does not expose strides") # <<<<<<<<<<<<<< + * + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 565, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 565, __pyx_L1_error) + + /* "View.MemoryView":563 + * @property + * def strides(self): + * if self.view.strides == NULL: # <<<<<<<<<<<<<< + * + * raise ValueError("Buffer view does not expose strides") + */ + } + + /* "View.MemoryView":567 + * 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); + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 567, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = (__pyx_v_self->view.strides + __pyx_v_self->view.ndim); + for (__pyx_t_5 = __pyx_v_self->view.strides; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { + __pyx_t_3 = __pyx_t_5; + __pyx_v_stride = (__pyx_t_3[0]); + __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_stride); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 567, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 567, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 567, __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":562 + * + * @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":570 + * + * @property + * def suboffsets(self): # <<<<<<<<<<<<<< + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim + */ + +/* 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) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __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_v_suboffset; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t *__pyx_t_4; + Py_ssize_t *__pyx_t_5; + Py_ssize_t *__pyx_t_6; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":571 + * @property + * def suboffsets(self): + * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< + * return (-1,) * self.view.ndim + * + */ + __pyx_t_1 = ((__pyx_v_self->view.suboffsets == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":572 + * 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_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Multiply(__pyx_tuple__13, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":571 + * @property + * def suboffsets(self): + * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< + * return (-1,) * self.view.ndim + * + */ + } + + /* "View.MemoryView":574 + * return (-1,) * self.view.ndim + * + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = (__pyx_v_self->view.suboffsets + __pyx_v_self->view.ndim); + for (__pyx_t_6 = __pyx_v_self->view.suboffsets; __pyx_t_6 < __pyx_t_5; __pyx_t_6++) { + __pyx_t_4 = __pyx_t_6; + __pyx_v_suboffset = (__pyx_t_4[0]); + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_suboffset); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_2))) __PYX_ERR(1, 574, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_2 = PyList_AsTuple(((PyObject*)__pyx_t_3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 574, __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":570 + * + * @property + * def suboffsets(self): # <<<<<<<<<<<<<< + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __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":577 + * + * @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) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __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; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":578 + * @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, 578, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":577 + * + * @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":581 + * + * @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) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __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; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":582 + * @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, 582, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":581 + * + * @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":585 + * + * @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) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __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; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":586 + * @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, 586, __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, 586, __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, 586, __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":585 + * + * @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":589 + * + * @property + * def size(self): # <<<<<<<<<<<<<< + * if self._size is None: + * result = 1 + */ + +/* 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) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __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; + int __pyx_t_2; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + Py_ssize_t *__pyx_t_5; + PyObject *__pyx_t_6 = NULL; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":590 + * @property + * def size(self): + * if self._size is None: # <<<<<<<<<<<<<< + * result = 1 + * + */ + __pyx_t_1 = (__pyx_v_self->_size == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":591 + * 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":593 + * result = 1 + * + * for length in self.view.shape[:self.view.ndim]: # <<<<<<<<<<<<<< + * result *= length + * + */ + __pyx_t_4 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); + for (__pyx_t_5 = __pyx_v_self->view.shape; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { + __pyx_t_3 = __pyx_t_5; + __pyx_t_6 = PyInt_FromSsize_t((__pyx_t_3[0])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_6); + __pyx_t_6 = 0; + + /* "View.MemoryView":594 + * + * for length in self.view.shape[:self.view.ndim]: + * result *= length # <<<<<<<<<<<<<< + * + * self._size = result + */ + __pyx_t_6 = PyNumber_InPlaceMultiply(__pyx_v_result, __pyx_v_length); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 594, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_6); + __pyx_t_6 = 0; + } + + /* "View.MemoryView":596 + * 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":590 + * @property + * def size(self): + * if self._size is None: # <<<<<<<<<<<<<< + * result = 1 + * + */ + } + + /* "View.MemoryView":598 + * 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":589 + * + * @property + * def size(self): # <<<<<<<<<<<<<< + * if self._size is None: + * result = 1 + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_6); + __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":600 + * 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) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); + __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; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__len__", 0); + + /* "View.MemoryView":601 + * + * def __len__(self): + * if self.view.ndim >= 1: # <<<<<<<<<<<<<< + * return self.view.shape[0] + * + */ + __pyx_t_1 = ((__pyx_v_self->view.ndim >= 1) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":602 + * 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":601 + * + * def __len__(self): + * if self.view.ndim >= 1: # <<<<<<<<<<<<<< + * return self.view.shape[0] + * + */ + } + + /* "View.MemoryView":604 + * return self.view.shape[0] + * + * return 0 # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":600 + * return self._size + * + * def __len__(self): # <<<<<<<<<<<<<< + * if self.view.ndim >= 1: + * return self.view.shape[0] + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":606 + * 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) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __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; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "View.MemoryView":607 + * + * 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, 607, __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, 607, __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, 607, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":608 + * 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, 608, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "View.MemoryView":607 + * + * def __repr__(self): + * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< + * id(self)) + * + */ + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 607, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 607, __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":606 + * 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":610 + * 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) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); + __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; + __Pyx_RefNannySetupContext("__str__", 0); + + /* "View.MemoryView":611 + * + * 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, 611, __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, 611, __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, 611, __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, 611, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_object, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 611, __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":610 + * 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":614 + * + * + * 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, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_c_contig (wrapper)", 0); + __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 + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("is_c_contig", 0); + + /* "View.MemoryView":617 + * 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_v_mslice = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); + + /* "View.MemoryView":618 + * 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_1 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'C', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":614 + * + * + * def is_c_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __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":620 + * 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, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_f_contig (wrapper)", 0); + __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 + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("is_f_contig", 0); + + /* "View.MemoryView":623 + * 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_v_mslice = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); + + /* "View.MemoryView":624 + * 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_1 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'F', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 624, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":620 + * 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_1); + __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":626 + * 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, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("copy (wrapper)", 0); + __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; + __Pyx_RefNannySetupContext("copy", 0); + + /* "View.MemoryView":628 + * 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":630 + * 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":631 + * + * 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, 631, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":636 + * 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, 636, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":626 + * 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":638 + * 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, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("copy_fortran (wrapper)", 0); + __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; + __Pyx_RefNannySetupContext("copy_fortran", 0); + + /* "View.MemoryView":640 + * 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":642 + * 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":643 + * + * 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, 643, __pyx_L1_error) + __pyx_v_dst = __pyx_t_1; + + /* "View.MemoryView":648 + * 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, 648, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":638 + * 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, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_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 + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(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_XDECREF(__pyx_t_1); + __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, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_memoryview_2__setstate_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __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 + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(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_XDECREF(__pyx_t_1); + __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":652 + * + * @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; + __Pyx_RefNannySetupContext("memoryview_cwrapper", 0); + + /* "View.MemoryView":653 + * @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, 653, __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, 653, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 653, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_o); + __Pyx_GIVEREF(__pyx_v_o); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_o); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 653, __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":654 + * 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":655 + * 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":652 + * + * @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":658 + * + * @cname('__pyx_memoryview_check') + * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< + * return isinstance(o, memoryview) + * + */ + +static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("memoryview_check", 0); + + /* "View.MemoryView":659 + * @cname('__pyx_memoryview_check') + * cdef inline bint memoryview_check(object o): + * 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":658 + * + * @cname('__pyx_memoryview_check') + * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< + * return isinstance(o, memoryview) + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":661 + * 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) { + PyObject *__pyx_v_tup = NULL; + PyObject *__pyx_v_result = NULL; + int __pyx_v_have_slices; + int __pyx_v_seen_ellipsis; + CYTHON_UNUSED PyObject *__pyx_v_idx = NULL; + PyObject *__pyx_v_item = NULL; + Py_ssize_t __pyx_v_nslices; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + Py_ssize_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + PyObject *__pyx_t_7 = NULL; + Py_ssize_t __pyx_t_8; + int __pyx_t_9; + int __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + __Pyx_RefNannySetupContext("_unellipsify", 0); + + /* "View.MemoryView":666 + * full slices. + * """ + * if not isinstance(index, tuple): # <<<<<<<<<<<<<< + * tup = (index,) + * else: + */ + __pyx_t_1 = PyTuple_Check(__pyx_v_index); + __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":667 + * """ + * if not isinstance(index, tuple): + * tup = (index,) # <<<<<<<<<<<<<< + * else: + * tup = index + */ + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 667, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_index); + __Pyx_GIVEREF(__pyx_v_index); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_index); + __pyx_v_tup = __pyx_t_3; + __pyx_t_3 = 0; + + /* "View.MemoryView":666 + * full slices. + * """ + * if not isinstance(index, tuple): # <<<<<<<<<<<<<< + * tup = (index,) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":669 + * tup = (index,) + * else: + * tup = index # <<<<<<<<<<<<<< + * + * result = [] + */ + /*else*/ { + __Pyx_INCREF(__pyx_v_index); + __pyx_v_tup = __pyx_v_index; + } + __pyx_L3:; + + /* "View.MemoryView":671 + * tup = index + * + * result = [] # <<<<<<<<<<<<<< + * have_slices = False + * seen_ellipsis = False + */ + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 671, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_result = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":672 + * + * result = [] + * have_slices = False # <<<<<<<<<<<<<< + * seen_ellipsis = False + * for idx, item in enumerate(tup): + */ + __pyx_v_have_slices = 0; + + /* "View.MemoryView":673 + * result = [] + * have_slices = False + * seen_ellipsis = False # <<<<<<<<<<<<<< + * for idx, item in enumerate(tup): + * if item is Ellipsis: + */ + __pyx_v_seen_ellipsis = 0; + + /* "View.MemoryView":674 + * have_slices = False + * seen_ellipsis = False + * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< + * if item is Ellipsis: + * if not seen_ellipsis: + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_3 = __pyx_int_0; + if (likely(PyList_CheckExact(__pyx_v_tup)) || PyTuple_CheckExact(__pyx_v_tup)) { + __pyx_t_4 = __pyx_v_tup; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_v_tup); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 674, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 674, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_4))) { + if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_7 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 674, __pyx_L1_error) + #else + __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 674, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + } else { + if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 674, __pyx_L1_error) + #else + __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 674, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + } + } else { + __pyx_t_7 = __pyx_t_6(__pyx_t_4); + if (unlikely(!__pyx_t_7)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 674, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_7); + } + __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_INCREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_3); + __pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 674, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); + __pyx_t_3 = __pyx_t_7; + __pyx_t_7 = 0; + + /* "View.MemoryView":675 + * seen_ellipsis = False + * for idx, item in enumerate(tup): + * if item is Ellipsis: # <<<<<<<<<<<<<< + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + */ + __pyx_t_2 = (__pyx_v_item == __pyx_builtin_Ellipsis); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":676 + * for idx, item in enumerate(tup): + * if item is Ellipsis: + * if not seen_ellipsis: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * seen_ellipsis = True + */ + __pyx_t_1 = ((!(__pyx_v_seen_ellipsis != 0)) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":677 + * if item is Ellipsis: + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) # <<<<<<<<<<<<<< + * seen_ellipsis = True + * else: + */ + __pyx_t_8 = PyObject_Length(__pyx_v_tup); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(1, 677, __pyx_L1_error) + __pyx_t_7 = PyList_New(1 * ((((__pyx_v_ndim - __pyx_t_8) + 1)<0) ? 0:((__pyx_v_ndim - __pyx_t_8) + 1))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 677, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + { Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < ((__pyx_v_ndim - __pyx_t_8) + 1); __pyx_temp++) { + __Pyx_INCREF(__pyx_slice__16); + __Pyx_GIVEREF(__pyx_slice__16); + PyList_SET_ITEM(__pyx_t_7, __pyx_temp, __pyx_slice__16); + } + } + __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_7); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 677, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "View.MemoryView":678 + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * seen_ellipsis = True # <<<<<<<<<<<<<< + * else: + * result.append(slice(None)) + */ + __pyx_v_seen_ellipsis = 1; + + /* "View.MemoryView":676 + * for idx, item in enumerate(tup): + * if item is Ellipsis: + * if not seen_ellipsis: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * seen_ellipsis = True + */ + goto __pyx_L7; + } + + /* "View.MemoryView":680 + * seen_ellipsis = True + * else: + * result.append(slice(None)) # <<<<<<<<<<<<<< + * have_slices = True + * else: + */ + /*else*/ { + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_slice__17); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 680, __pyx_L1_error) + } + __pyx_L7:; + + /* "View.MemoryView":681 + * else: + * result.append(slice(None)) + * have_slices = True # <<<<<<<<<<<<<< + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): + */ + __pyx_v_have_slices = 1; + + /* "View.MemoryView":675 + * seen_ellipsis = False + * for idx, item in enumerate(tup): + * if item is Ellipsis: # <<<<<<<<<<<<<< + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + */ + goto __pyx_L6; + } + + /* "View.MemoryView":683 + * have_slices = True + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<< + * raise TypeError("Cannot index with type '%s'" % type(item)) + * + */ + /*else*/ { + __pyx_t_2 = PySlice_Check(__pyx_v_item); + __pyx_t_10 = ((!(__pyx_t_2 != 0)) != 0); + if (__pyx_t_10) { + } else { + __pyx_t_1 = __pyx_t_10; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_10 = ((!(PyIndex_Check(__pyx_v_item) != 0)) != 0); + __pyx_t_1 = __pyx_t_10; + __pyx_L9_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":684 + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): + * raise TypeError("Cannot index with type '%s'" % type(item)) # <<<<<<<<<<<<<< + * + * have_slices = have_slices or isinstance(item, slice) + */ + __pyx_t_7 = __Pyx_PyString_Format(__pyx_kp_s_Cannot_index_with_type_s, ((PyObject *)Py_TYPE(__pyx_v_item))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 684, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_7); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 684, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_11, 0, 0, 0); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __PYX_ERR(1, 684, __pyx_L1_error) + + /* "View.MemoryView":683 + * have_slices = True + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<< + * raise TypeError("Cannot index with type '%s'" % type(item)) + * + */ + } + + /* "View.MemoryView":686 + * raise TypeError("Cannot index with type '%s'" % type(item)) + * + * have_slices = have_slices or isinstance(item, slice) # <<<<<<<<<<<<<< + * result.append(item) + * + */ + __pyx_t_10 = (__pyx_v_have_slices != 0); + if (!__pyx_t_10) { + } else { + __pyx_t_1 = __pyx_t_10; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_10 = PySlice_Check(__pyx_v_item); + __pyx_t_2 = (__pyx_t_10 != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L11_bool_binop_done:; + __pyx_v_have_slices = __pyx_t_1; + + /* "View.MemoryView":687 + * + * have_slices = have_slices or isinstance(item, slice) + * result.append(item) # <<<<<<<<<<<<<< + * + * nslices = ndim - len(result) + */ + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_v_item); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 687, __pyx_L1_error) + } + __pyx_L6:; + + /* "View.MemoryView":674 + * have_slices = False + * seen_ellipsis = False + * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< + * if item is Ellipsis: + * if not seen_ellipsis: + */ + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":689 + * result.append(item) + * + * nslices = ndim - len(result) # <<<<<<<<<<<<<< + * if nslices: + * result.extend([slice(None)] * nslices) + */ + __pyx_t_5 = PyList_GET_SIZE(__pyx_v_result); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 689, __pyx_L1_error) + __pyx_v_nslices = (__pyx_v_ndim - __pyx_t_5); + + /* "View.MemoryView":690 + * + * nslices = ndim - len(result) + * if nslices: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * nslices) + * + */ + __pyx_t_1 = (__pyx_v_nslices != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":691 + * nslices = ndim - len(result) + * if nslices: + * result.extend([slice(None)] * nslices) # <<<<<<<<<<<<<< + * + * return have_slices or nslices, tuple(result) + */ + __pyx_t_3 = PyList_New(1 * ((__pyx_v_nslices<0) ? 0:__pyx_v_nslices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + { Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < __pyx_v_nslices; __pyx_temp++) { + __Pyx_INCREF(__pyx_slice__18); + __Pyx_GIVEREF(__pyx_slice__18); + PyList_SET_ITEM(__pyx_t_3, __pyx_temp, __pyx_slice__18); + } + } + __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 691, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":690 + * + * nslices = ndim - len(result) + * if nslices: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * nslices) + * + */ + } + + /* "View.MemoryView":693 + * result.extend([slice(None)] * nslices) + * + * return have_slices or nslices, tuple(result) # <<<<<<<<<<<<<< + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + */ + __Pyx_XDECREF(__pyx_r); + if (!__pyx_v_have_slices) { + } else { + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_have_slices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 693, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L14_bool_binop_done; + } + __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_nslices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 693, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_L14_bool_binop_done:; + __pyx_t_4 = PyList_AsTuple(__pyx_v_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 693, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 693, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_4); + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_r = ((PyObject*)__pyx_t_11); + __pyx_t_11 = 0; + goto __pyx_L0; + + /* "View.MemoryView":661 + * 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_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_11); + __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_idx); + __Pyx_XDECREF(__pyx_v_item); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":695 + * return have_slices or nslices, tuple(result) + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + */ + +static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __pyx_v_ndim) { + Py_ssize_t __pyx_v_suboffset; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + Py_ssize_t *__pyx_t_1; + Py_ssize_t *__pyx_t_2; + Py_ssize_t *__pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("assert_direct_dimensions", 0); + + /* "View.MemoryView":696 + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * 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":697 + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * raise ValueError("Indirect dimensions not supported") + * + */ + __pyx_t_4 = ((__pyx_v_suboffset >= 0) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":698 + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + * raise ValueError("Indirect dimensions not supported") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__19, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 698, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(1, 698, __pyx_L1_error) + + /* "View.MemoryView":697 + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * raise ValueError("Indirect dimensions not supported") + * + */ + } + } + + /* "View.MemoryView":695 + * return have_slices or nslices, tuple(result) + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.assert_direct_dimensions", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":705 + * + * @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; + 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; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + struct __pyx_memoryview_obj *__pyx_t_4; + char *__pyx_t_5; + int __pyx_t_6; + Py_ssize_t __pyx_t_7; + PyObject *(*__pyx_t_8)(PyObject *); + PyObject *__pyx_t_9 = NULL; + Py_ssize_t __pyx_t_10; + int __pyx_t_11; + Py_ssize_t __pyx_t_12; + __Pyx_RefNannySetupContext("memview_slice", 0); + + /* "View.MemoryView":706 + * @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":713 + * + * + * memset(&dst, 0, sizeof(dst)) # <<<<<<<<<<<<<< + * + * cdef _memoryviewslice memviewsliceobj + */ + (void)(memset((&__pyx_v_dst), 0, (sizeof(__pyx_v_dst)))); + + /* "View.MemoryView":717 + * cdef _memoryviewslice memviewsliceobj + * + * assert memview.view.ndim > 0 # <<<<<<<<<<<<<< + * + * if isinstance(memview, _memoryviewslice): + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!((__pyx_v_memview->view.ndim > 0) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + __PYX_ERR(1, 717, __pyx_L1_error) + } + } + #endif + + /* "View.MemoryView":719 + * 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); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":720 + * + * 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, 720, __pyx_L1_error) + __pyx_t_3 = ((PyObject *)__pyx_v_memview); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_memviewsliceobj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":721 + * 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":719 + * assert memview.view.ndim > 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * memviewsliceobj = memview + * p_src = &memviewsliceobj.from_slice + */ + goto __pyx_L3; + } + + /* "View.MemoryView":723 + * 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":724 + * else: + * slice_copy(memview, &src) + * p_src = &src # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_p_src = (&__pyx_v_src); + } + __pyx_L3:; + + /* "View.MemoryView":730 + * + * + * dst.memview = p_src.memview # <<<<<<<<<<<<<< + * dst.data = p_src.data + * + */ + __pyx_t_4 = __pyx_v_p_src->memview; + __pyx_v_dst.memview = __pyx_t_4; + + /* "View.MemoryView":731 + * + * dst.memview = p_src.memview + * dst.data = p_src.data # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = __pyx_v_p_src->data; + __pyx_v_dst.data = __pyx_t_5; + + /* "View.MemoryView":736 + * + * + * cdef __Pyx_memviewslice *p_dst = &dst # <<<<<<<<<<<<<< + * cdef int *p_suboffset_dim = &suboffset_dim + * cdef Py_ssize_t start, stop, step + */ + __pyx_v_p_dst = (&__pyx_v_dst); + + /* "View.MemoryView":737 + * + * cdef __Pyx_memviewslice *p_dst = &dst + * cdef int *p_suboffset_dim = &suboffset_dim # <<<<<<<<<<<<<< + * cdef Py_ssize_t start, stop, step + * cdef bint have_start, have_stop, have_step + */ + __pyx_v_p_suboffset_dim = (&__pyx_v_suboffset_dim); + + /* "View.MemoryView":741 + * cdef bint have_start, have_stop, have_step + * + * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< + * if PyIndex_Check(index): + * slice_memviewslice( + */ + __pyx_t_6 = 0; + if (likely(PyList_CheckExact(__pyx_v_indices)) || PyTuple_CheckExact(__pyx_v_indices)) { + __pyx_t_3 = __pyx_v_indices; __Pyx_INCREF(__pyx_t_3); __pyx_t_7 = 0; + __pyx_t_8 = NULL; + } else { + __pyx_t_7 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_indices); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 741, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 741, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_8)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_9 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(1, 741, __pyx_L1_error) + #else + __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 741, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + } else { + if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_9 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(1, 741, __pyx_L1_error) + #else + __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 741, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + } + } else { + __pyx_t_9 = __pyx_t_8(__pyx_t_3); + if (unlikely(!__pyx_t_9)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 741, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_9); + } + __Pyx_XDECREF_SET(__pyx_v_index, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_v_dim = __pyx_t_6; + __pyx_t_6 = (__pyx_t_6 + 1); + + /* "View.MemoryView":742 + * + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): # <<<<<<<<<<<<<< + * slice_memviewslice( + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + */ + __pyx_t_2 = (PyIndex_Check(__pyx_v_index) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":746 + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + * dim, new_ndim, p_suboffset_dim, + * index, 0, 0, # start, stop, step # <<<<<<<<<<<<<< + * 0, 0, 0, # have_{start,stop,step} + * False) + */ + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_index); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 746, __pyx_L1_error) + + /* "View.MemoryView":743 + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): + * slice_memviewslice( # <<<<<<<<<<<<<< + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + * dim, new_ndim, p_suboffset_dim, + */ + __pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_t_10, 0, 0, 0, 0, 0, 0); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(1, 743, __pyx_L1_error) + + /* "View.MemoryView":742 + * + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): # <<<<<<<<<<<<<< + * slice_memviewslice( + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + */ + goto __pyx_L6; + } + + /* "View.MemoryView":749 + * 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_2 = (__pyx_v_index == Py_None); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":750 + * 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":751 + * 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":752 + * 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":753 + * 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":749 + * 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":755 + * new_ndim += 1 + * else: + * start = index.start or 0 # <<<<<<<<<<<<<< + * stop = index.stop or 0 + * step = index.step or 0 + */ + /*else*/ { + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 755, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 755, __pyx_L1_error) + if (!__pyx_t_1) { + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 755, __pyx_L1_error) + __pyx_t_10 = __pyx_t_12; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_10 = 0; + __pyx_L7_bool_binop_done:; + __pyx_v_start = __pyx_t_10; + + /* "View.MemoryView":756 + * else: + * start = index.start or 0 + * stop = index.stop or 0 # <<<<<<<<<<<<<< + * step = index.step or 0 + * + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 756, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 756, __pyx_L1_error) + if (!__pyx_t_1) { + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 756, __pyx_L1_error) + __pyx_t_10 = __pyx_t_12; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_10 = 0; + __pyx_L9_bool_binop_done:; + __pyx_v_stop = __pyx_t_10; + + /* "View.MemoryView":757 + * start = index.start or 0 + * stop = index.stop or 0 + * step = index.step or 0 # <<<<<<<<<<<<<< + * + * have_start = index.start is not None + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 757, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 757, __pyx_L1_error) + if (!__pyx_t_1) { + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 757, __pyx_L1_error) + __pyx_t_10 = __pyx_t_12; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_10 = 0; + __pyx_L11_bool_binop_done:; + __pyx_v_step = __pyx_t_10; + + /* "View.MemoryView":759 + * step = index.step or 0 + * + * have_start = index.start is not None # <<<<<<<<<<<<<< + * have_stop = index.stop is not None + * have_step = index.step is not None + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 759, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = (__pyx_t_9 != Py_None); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_have_start = __pyx_t_1; + + /* "View.MemoryView":760 + * + * have_start = index.start is not None + * have_stop = index.stop is not None # <<<<<<<<<<<<<< + * have_step = index.step is not None + * + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 760, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = (__pyx_t_9 != Py_None); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_have_stop = __pyx_t_1; + + /* "View.MemoryView":761 + * have_start = index.start is not None + * have_stop = index.stop is not None + * have_step = index.step is not None # <<<<<<<<<<<<<< + * + * slice_memviewslice( + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 761, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = (__pyx_t_9 != Py_None); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_have_step = __pyx_t_1; + + /* "View.MemoryView":763 + * have_step = index.step is not None + * + * slice_memviewslice( # <<<<<<<<<<<<<< + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + * dim, new_ndim, p_suboffset_dim, + */ + __pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_v_start, __pyx_v_stop, __pyx_v_step, __pyx_v_have_start, __pyx_v_have_stop, __pyx_v_have_step, 1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(1, 763, __pyx_L1_error) + + /* "View.MemoryView":769 + * 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":741 + * cdef bint have_start, have_stop, have_step + * + * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< + * if PyIndex_Check(index): + * slice_memviewslice( + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":771 + * 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); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":772 + * + * 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":773 + * 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, 773, __pyx_L1_error) } + + /* "View.MemoryView":774 + * 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, 774, __pyx_L1_error) } + + /* "View.MemoryView":772 + * + * if isinstance(memview, _memoryviewslice): + * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< + * memviewsliceobj.to_object_func, + * memviewsliceobj.to_dtype_func, + */ + __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, __pyx_v_memviewsliceobj->to_object_func, __pyx_v_memviewsliceobj->to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 772, __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, 772, __pyx_L1_error) + __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":771 + * new_ndim += 1 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, + */ + } + + /* "View.MemoryView":777 + * 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":778 + * else: + * return memoryview_fromslice(dst, new_ndim, NULL, NULL, + * memview.dtype_is_object) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, NULL, NULL, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 777, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "View.MemoryView":777 + * memview.dtype_is_object) + * else: + * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< + * memview.dtype_is_object) + * + */ + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(1, 777, __pyx_L1_error) + __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":705 + * + * @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_3); + __Pyx_XDECREF(__pyx_t_9); + __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":802 + * + * @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; + + /* "View.MemoryView":822 + * cdef bint negative_step + * + * if not is_slice: # <<<<<<<<<<<<<< + * + * if start < 0: + */ + __pyx_t_1 = ((!(__pyx_v_is_slice != 0)) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":824 + * if not is_slice: + * + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if not 0 <= start < shape: + */ + __pyx_t_1 = ((__pyx_v_start < 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":825 + * + * if start < 0: + * start += shape # <<<<<<<<<<<<<< + * if not 0 <= start < shape: + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) + */ + __pyx_v_start = (__pyx_v_start + __pyx_v_shape); + + /* "View.MemoryView":824 + * if not is_slice: + * + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if not 0 <= start < shape: + */ + } + + /* "View.MemoryView":826 + * if start < 0: + * start += shape + * if not 0 <= start < shape: # <<<<<<<<<<<<<< + * _err_dim(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 != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":827 + * start += shape + * if not 0 <= start < shape: + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) # <<<<<<<<<<<<<< + * else: + * + */ + __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"Index out of bounds (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 827, __pyx_L1_error) + + /* "View.MemoryView":826 + * if start < 0: + * start += shape + * if not 0 <= start < shape: # <<<<<<<<<<<<<< + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) + * else: + */ + } + + /* "View.MemoryView":822 + * cdef bint negative_step + * + * if not is_slice: # <<<<<<<<<<<<<< + * + * if start < 0: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":830 + * else: + * + * negative_step = have_step != 0 and step < 0 # <<<<<<<<<<<<<< + * + * if have_step and step == 0: + */ + /*else*/ { + __pyx_t_1 = ((__pyx_v_have_step != 0) != 0); + if (__pyx_t_1) { + } else { + __pyx_t_2 = __pyx_t_1; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_1 = ((__pyx_v_step < 0) != 0); + __pyx_t_2 = __pyx_t_1; + __pyx_L6_bool_binop_done:; + __pyx_v_negative_step = __pyx_t_2; + + /* "View.MemoryView":832 + * negative_step = have_step != 0 and step < 0 + * + * if have_step and step == 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) + * + */ + __pyx_t_1 = (__pyx_v_have_step != 0); + if (__pyx_t_1) { + } else { + __pyx_t_2 = __pyx_t_1; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_1 = ((__pyx_v_step == 0) != 0); + __pyx_t_2 = __pyx_t_1; + __pyx_L9_bool_binop_done:; + if (__pyx_t_2) { + + /* "View.MemoryView":833 + * + * if have_step and step == 0: + * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Step may not be zero (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 833, __pyx_L1_error) + + /* "View.MemoryView":832 + * negative_step = have_step != 0 and step < 0 + * + * if have_step and step == 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) + * + */ + } + + /* "View.MemoryView":836 + * + * + * if have_start: # <<<<<<<<<<<<<< + * if start < 0: + * start += shape + */ + __pyx_t_2 = (__pyx_v_have_start != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":837 + * + * if have_start: + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if start < 0: + */ + __pyx_t_2 = ((__pyx_v_start < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":838 + * if have_start: + * if start < 0: + * start += shape # <<<<<<<<<<<<<< + * if start < 0: + * start = 0 + */ + __pyx_v_start = (__pyx_v_start + __pyx_v_shape); + + /* "View.MemoryView":839 + * if start < 0: + * start += shape + * if start < 0: # <<<<<<<<<<<<<< + * start = 0 + * elif start >= shape: + */ + __pyx_t_2 = ((__pyx_v_start < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":840 + * start += shape + * if start < 0: + * start = 0 # <<<<<<<<<<<<<< + * elif start >= shape: + * if negative_step: + */ + __pyx_v_start = 0; + + /* "View.MemoryView":839 + * if start < 0: + * start += shape + * if start < 0: # <<<<<<<<<<<<<< + * start = 0 + * elif start >= shape: + */ + } + + /* "View.MemoryView":837 + * + * if have_start: + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if start < 0: + */ + goto __pyx_L12; + } + + /* "View.MemoryView":841 + * if start < 0: + * start = 0 + * elif start >= shape: # <<<<<<<<<<<<<< + * if negative_step: + * start = shape - 1 + */ + __pyx_t_2 = ((__pyx_v_start >= __pyx_v_shape) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":842 + * start = 0 + * elif start >= shape: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + __pyx_t_2 = (__pyx_v_negative_step != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":843 + * elif start >= shape: + * if negative_step: + * start = shape - 1 # <<<<<<<<<<<<<< + * else: + * start = shape + */ + __pyx_v_start = (__pyx_v_shape - 1); + + /* "View.MemoryView":842 + * start = 0 + * elif start >= shape: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + goto __pyx_L14; + } + + /* "View.MemoryView":845 + * start = shape - 1 + * else: + * start = shape # <<<<<<<<<<<<<< + * else: + * if negative_step: + */ + /*else*/ { + __pyx_v_start = __pyx_v_shape; + } + __pyx_L14:; + + /* "View.MemoryView":841 + * if start < 0: + * start = 0 + * elif start >= shape: # <<<<<<<<<<<<<< + * if negative_step: + * start = shape - 1 + */ + } + __pyx_L12:; + + /* "View.MemoryView":836 + * + * + * if have_start: # <<<<<<<<<<<<<< + * if start < 0: + * start += shape + */ + goto __pyx_L11; + } + + /* "View.MemoryView":847 + * start = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + /*else*/ { + __pyx_t_2 = (__pyx_v_negative_step != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":848 + * else: + * if negative_step: + * start = shape - 1 # <<<<<<<<<<<<<< + * else: + * start = 0 + */ + __pyx_v_start = (__pyx_v_shape - 1); + + /* "View.MemoryView":847 + * start = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + goto __pyx_L15; + } + + /* "View.MemoryView":850 + * start = shape - 1 + * else: + * start = 0 # <<<<<<<<<<<<<< + * + * if have_stop: + */ + /*else*/ { + __pyx_v_start = 0; + } + __pyx_L15:; + } + __pyx_L11:; + + /* "View.MemoryView":852 + * start = 0 + * + * if have_stop: # <<<<<<<<<<<<<< + * if stop < 0: + * stop += shape + */ + __pyx_t_2 = (__pyx_v_have_stop != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":853 + * + * if have_stop: + * if stop < 0: # <<<<<<<<<<<<<< + * stop += shape + * if stop < 0: + */ + __pyx_t_2 = ((__pyx_v_stop < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":854 + * if have_stop: + * if stop < 0: + * stop += shape # <<<<<<<<<<<<<< + * if stop < 0: + * stop = 0 + */ + __pyx_v_stop = (__pyx_v_stop + __pyx_v_shape); + + /* "View.MemoryView":855 + * if stop < 0: + * stop += shape + * if stop < 0: # <<<<<<<<<<<<<< + * stop = 0 + * elif stop > shape: + */ + __pyx_t_2 = ((__pyx_v_stop < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":856 + * stop += shape + * if stop < 0: + * stop = 0 # <<<<<<<<<<<<<< + * elif stop > shape: + * stop = shape + */ + __pyx_v_stop = 0; + + /* "View.MemoryView":855 + * if stop < 0: + * stop += shape + * if stop < 0: # <<<<<<<<<<<<<< + * stop = 0 + * elif stop > shape: + */ + } + + /* "View.MemoryView":853 + * + * if have_stop: + * if stop < 0: # <<<<<<<<<<<<<< + * stop += shape + * if stop < 0: + */ + goto __pyx_L17; + } + + /* "View.MemoryView":857 + * if stop < 0: + * stop = 0 + * elif stop > shape: # <<<<<<<<<<<<<< + * stop = shape + * else: + */ + __pyx_t_2 = ((__pyx_v_stop > __pyx_v_shape) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":858 + * stop = 0 + * elif stop > shape: + * stop = shape # <<<<<<<<<<<<<< + * else: + * if negative_step: + */ + __pyx_v_stop = __pyx_v_shape; + + /* "View.MemoryView":857 + * if stop < 0: + * stop = 0 + * elif stop > shape: # <<<<<<<<<<<<<< + * stop = shape + * else: + */ + } + __pyx_L17:; + + /* "View.MemoryView":852 + * start = 0 + * + * if have_stop: # <<<<<<<<<<<<<< + * if stop < 0: + * stop += shape + */ + goto __pyx_L16; + } + + /* "View.MemoryView":860 + * stop = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * stop = -1 + * else: + */ + /*else*/ { + __pyx_t_2 = (__pyx_v_negative_step != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":861 + * else: + * if negative_step: + * stop = -1 # <<<<<<<<<<<<<< + * else: + * stop = shape + */ + __pyx_v_stop = -1L; + + /* "View.MemoryView":860 + * stop = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * stop = -1 + * else: + */ + goto __pyx_L19; + } + + /* "View.MemoryView":863 + * stop = -1 + * else: + * stop = shape # <<<<<<<<<<<<<< + * + * if not have_step: + */ + /*else*/ { + __pyx_v_stop = __pyx_v_shape; + } + __pyx_L19:; + } + __pyx_L16:; + + /* "View.MemoryView":865 + * stop = shape + * + * if not have_step: # <<<<<<<<<<<<<< + * step = 1 + * + */ + __pyx_t_2 = ((!(__pyx_v_have_step != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":866 + * + * if not have_step: + * step = 1 # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_step = 1; + + /* "View.MemoryView":865 + * stop = shape + * + * if not have_step: # <<<<<<<<<<<<<< + * step = 1 + * + */ + } + + /* "View.MemoryView":870 + * + * 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":872 + * 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":873 + * + * if (stop - start) - step * new_shape: + * new_shape += 1 # <<<<<<<<<<<<<< + * + * if new_shape < 0: + */ + __pyx_v_new_shape = (__pyx_v_new_shape + 1); + + /* "View.MemoryView":872 + * new_shape = (stop - start) // step + * + * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< + * new_shape += 1 + * + */ + } + + /* "View.MemoryView":875 + * new_shape += 1 + * + * if new_shape < 0: # <<<<<<<<<<<<<< + * new_shape = 0 + * + */ + __pyx_t_2 = ((__pyx_v_new_shape < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":876 + * + * if new_shape < 0: + * new_shape = 0 # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_new_shape = 0; + + /* "View.MemoryView":875 + * new_shape += 1 + * + * if new_shape < 0: # <<<<<<<<<<<<<< + * new_shape = 0 + * + */ + } + + /* "View.MemoryView":879 + * + * + * 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":880 + * + * 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":881 + * 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":884 + * + * + * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< + * dst.data += start * stride + * else: + */ + __pyx_t_2 = (((__pyx_v_suboffset_dim[0]) < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":885 + * + * 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":884 + * + * + * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< + * dst.data += start * stride + * else: + */ + goto __pyx_L23; + } + + /* "View.MemoryView":887 + * 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_L23:; + + /* "View.MemoryView":889 + * 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) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":890 + * + * if suboffset >= 0: + * if not is_slice: # <<<<<<<<<<<<<< + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset + */ + __pyx_t_2 = ((!(__pyx_v_is_slice != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":891 + * 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) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":892 + * if not is_slice: + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset # <<<<<<<<<<<<<< + * else: + * _err_dim(IndexError, "All dimensions preceding dimension %d " + */ + __pyx_v_dst->data = ((((char **)__pyx_v_dst->data)[0]) + __pyx_v_suboffset); + + /* "View.MemoryView":891 + * if suboffset >= 0: + * if not is_slice: + * if new_ndim == 0: # <<<<<<<<<<<<<< + * dst.data = ( dst.data)[0] + suboffset + * else: + */ + goto __pyx_L26; + } + + /* "View.MemoryView":894 + * dst.data = ( dst.data)[0] + suboffset + * else: + * _err_dim(IndexError, "All dimensions preceding dimension %d " # <<<<<<<<<<<<<< + * "must be indexed and not sliced", dim) + * else: + */ + /*else*/ { + + /* "View.MemoryView":895 + * else: + * _err_dim(IndexError, "All dimensions preceding dimension %d " + * "must be indexed and not sliced", dim) # <<<<<<<<<<<<<< + * else: + * suboffset_dim[0] = new_ndim + */ + __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"All dimensions preceding dimension %d must be indexed and not sliced"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 894, __pyx_L1_error) + } + __pyx_L26:; + + /* "View.MemoryView":890 + * + * if suboffset >= 0: + * if not is_slice: # <<<<<<<<<<<<<< + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset + */ + goto __pyx_L25; + } + + /* "View.MemoryView":897 + * "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_L25:; + + /* "View.MemoryView":889 + * dst.suboffsets[suboffset_dim[0]] += start * stride + * + * if suboffset >= 0: # <<<<<<<<<<<<<< + * if not is_slice: + * if new_ndim == 0: + */ + } + + /* "View.MemoryView":899 + * suboffset_dim[0] = new_ndim + * + * return 0 # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":802 + * + * @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 + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.slice_memviewslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":905 + * + * @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; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("pybuffer_index", 0); + + /* "View.MemoryView":907 + * 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":908 + * 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":911 + * cdef char *resultp + * + * if view.ndim == 0: # <<<<<<<<<<<<<< + * shape = view.len / itemsize + * stride = itemsize + */ + __pyx_t_2 = ((__pyx_v_view->ndim == 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":912 + * + * 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, 912, __pyx_L1_error) + } + else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_view->len))) { + PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); + __PYX_ERR(1, 912, __pyx_L1_error) + } + __pyx_v_shape = (__pyx_v_view->len / __pyx_v_itemsize); + + /* "View.MemoryView":913 + * if view.ndim == 0: + * shape = view.len / itemsize + * stride = itemsize # <<<<<<<<<<<<<< + * else: + * shape = view.shape[dim] + */ + __pyx_v_stride = __pyx_v_itemsize; + + /* "View.MemoryView":911 + * cdef char *resultp + * + * if view.ndim == 0: # <<<<<<<<<<<<<< + * shape = view.len / itemsize + * stride = itemsize + */ + goto __pyx_L3; + } + + /* "View.MemoryView":915 + * 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":916 + * 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":917 + * shape = view.shape[dim] + * stride = view.strides[dim] + * if view.suboffsets != NULL: # <<<<<<<<<<<<<< + * suboffset = view.suboffsets[dim] + * + */ + __pyx_t_2 = ((__pyx_v_view->suboffsets != NULL) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":918 + * 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":917 + * shape = view.shape[dim] + * stride = view.strides[dim] + * if view.suboffsets != NULL: # <<<<<<<<<<<<<< + * suboffset = view.suboffsets[dim] + * + */ + } + } + __pyx_L3:; + + /* "View.MemoryView":920 + * suboffset = view.suboffsets[dim] + * + * if index < 0: # <<<<<<<<<<<<<< + * index += view.shape[dim] + * if index < 0: + */ + __pyx_t_2 = ((__pyx_v_index < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":921 + * + * if index < 0: + * index += view.shape[dim] # <<<<<<<<<<<<<< + * if index < 0: + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + */ + __pyx_v_index = (__pyx_v_index + (__pyx_v_view->shape[__pyx_v_dim])); + + /* "View.MemoryView":922 + * if index < 0: + * index += view.shape[dim] + * if index < 0: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + __pyx_t_2 = ((__pyx_v_index < 0) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":923 + * index += view.shape[dim] + * if index < 0: + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) # <<<<<<<<<<<<<< + * + * if index >= shape: + */ + __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 923, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 923, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 923, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 923, __pyx_L1_error) + + /* "View.MemoryView":922 + * if index < 0: + * index += view.shape[dim] + * if index < 0: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + } + + /* "View.MemoryView":920 + * suboffset = view.suboffsets[dim] + * + * if index < 0: # <<<<<<<<<<<<<< + * index += view.shape[dim] + * if index < 0: + */ + } + + /* "View.MemoryView":925 + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + * if index >= shape: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + __pyx_t_2 = ((__pyx_v_index >= __pyx_v_shape) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":926 + * + * if index >= shape: + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) # <<<<<<<<<<<<<< + * + * resultp = bufp + index * stride + */ + __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 926, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 926, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 926, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 926, __pyx_L1_error) + + /* "View.MemoryView":925 + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + * if index >= shape: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + } + + /* "View.MemoryView":928 + * raise IndexError("Out of bounds on buffer access (axis %d)" % 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":929 + * + * resultp = bufp + index * stride + * if suboffset >= 0: # <<<<<<<<<<<<<< + * resultp = ( resultp)[0] + suboffset + * + */ + __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":930 + * 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":929 + * + * resultp = bufp + index * stride + * if suboffset >= 0: # <<<<<<<<<<<<<< + * resultp = ( resultp)[0] + suboffset + * + */ + } + + /* "View.MemoryView":932 + * resultp = ( resultp)[0] + suboffset + * + * return resultp # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_resultp; + goto __pyx_L0; + + /* "View.MemoryView":905 + * + * @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_4); + __Pyx_AddTraceback("View.MemoryView.pybuffer_index", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":938 + * + * @cname('__pyx_memslice_transpose') + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< + * 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; + + /* "View.MemoryView":939 + * @cname('__pyx_memslice_transpose') + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: + * 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":941 + * 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":942 + * + * 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":946 + * + * 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_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":947 + * 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":948 + * 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":949 + * 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":951 + * shape[i], shape[j] = shape[j], shape[i] + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") + * + */ + __pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_i]) >= 0) != 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) != 0); + __pyx_t_7 = __pyx_t_8; + __pyx_L6_bool_binop_done:; + if (__pyx_t_7) { + + /* "View.MemoryView":952 + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") # <<<<<<<<<<<<<< + * + * return 1 + */ + __pyx_t_9 = __pyx_memoryview_err(__pyx_builtin_ValueError, ((char *)"Cannot transpose memoryview with indirect dimensions")); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 952, __pyx_L1_error) + + /* "View.MemoryView":951 + * shape[i], shape[j] = shape[j], shape[i] + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") + * + */ + } + } + + /* "View.MemoryView":954 + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") + * + * return 1 # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = 1; + goto __pyx_L0; + + /* "View.MemoryView":938 + * + * @cname('__pyx_memslice_transpose') + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< + * cdef int ndim = memslice.memview.view.ndim + * + */ + + /* function exit code */ + __pyx_L1_error:; + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.transpose_memslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = 0; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":971 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * __PYX_XDEC_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) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __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) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "View.MemoryView":972 + * + * def __dealloc__(self): + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) # <<<<<<<<<<<<<< + * + * cdef convert_item_to_object(self, char *itemp): + */ + __PYX_XDEC_MEMVIEW((&__pyx_v_self->from_slice), 1); + + /* "View.MemoryView":971 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + * + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":974 + * __PYX_XDEC_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; + __Pyx_RefNannySetupContext("convert_item_to_object", 0); + + /* "View.MemoryView":975 + * + * 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) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":976 + * 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, 976, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":975 + * + * cdef convert_item_to_object(self, char *itemp): + * if self.to_object_func != NULL: # <<<<<<<<<<<<<< + * return self.to_object_func(itemp) + * else: + */ + } + + /* "View.MemoryView":978 + * 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, 978, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":974 + * __PYX_XDEC_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":980 + * 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; + __Pyx_RefNannySetupContext("assign_item_from_object", 0); + + /* "View.MemoryView":981 + * + * 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) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":982 + * 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, 982, __pyx_L1_error) + + /* "View.MemoryView":981 + * + * 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":984 + * self.to_dtype_func(itemp, value) + * else: + * memoryview.assign_item_from_object(self, itemp, value) # <<<<<<<<<<<<<< + * + * @property + */ + /*else*/ { + __pyx_t_3 = __pyx_memoryview_assign_item_from_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 984, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_L3:; + + /* "View.MemoryView":980 + * 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":987 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.from_object + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(struct __pyx_memoryviewslice_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":988 + * @property + * def base(self): + * return self.from_object # <<<<<<<<<<<<<< + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->from_object); + __pyx_r = __pyx_v_self->from_object; + goto __pyx_L0; + + /* "View.MemoryView":987 + * + * @property + * def 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, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_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 + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__20, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(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_XDECREF(__pyx_t_1); + __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, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_memoryviewslice_2__setstate_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __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 + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(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_XDECREF(__pyx_t_1); + __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":994 + * + * @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; + __Pyx_RefNannySetupContext("memoryview_fromslice", 0); + + /* "View.MemoryView":1002 + * cdef _memoryviewslice result + * + * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< + * return None + * + */ + __pyx_t_1 = ((((PyObject *)__pyx_v_memviewslice.memview) == Py_None) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1003 + * + * if memviewslice.memview == Py_None: + * return None # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "View.MemoryView":1002 + * cdef _memoryviewslice result + * + * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< + * return None + * + */ + } + + /* "View.MemoryView":1008 + * + * + * result = _memoryviewslice(None, 0, dtype_is_object) # <<<<<<<<<<<<<< + * + * result.from_slice = memviewslice + */ + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1008, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1008, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + PyTuple_SET_ITEM(__pyx_t_3, 0, Py_None); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_0); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryviewslice_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1008, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":1010 + * result = _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":1011 + * + * result.from_slice = memviewslice + * __PYX_INC_MEMVIEW(&memviewslice, 1) # <<<<<<<<<<<<<< + * + * result.from_object = ( memviewslice.memview).base + */ + __PYX_INC_MEMVIEW((&__pyx_v_memviewslice), 1); + + /* "View.MemoryView":1013 + * __PYX_INC_MEMVIEW(&memviewslice, 1) + * + * result.from_object = ( memviewslice.memview).base # <<<<<<<<<<<<<< + * result.typeinfo = memviewslice.memview.typeinfo + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_memviewslice.memview), __pyx_n_s_base); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1013, __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":1014 + * + * result.from_object = ( memviewslice.memview).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":1016 + * 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":1017 + * + * 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":1018 + * 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":1019 + * 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":1020 + * 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":1022 + * 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":1023 + * + * 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":1022 + * Py_INCREF(Py_None) + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< + * result.flags = PyBUF_RECORDS + * else: + */ + goto __pyx_L4; + } + + /* "View.MemoryView":1025 + * 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":1027 + * 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":1028 + * + * 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":1031 + * + * + * 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":1032 + * + * 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":1033 + * 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) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1034 + * 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":1035 + * if suboffset >= 0: + * result.view.suboffsets = result.from_slice.suboffsets + * break # <<<<<<<<<<<<<< + * + * result.view.len = result.view.itemsize + */ + goto __pyx_L6_break; + + /* "View.MemoryView":1033 + * 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":1037 + * 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":1038 + * + * 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, 1038, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":1039 + * 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, 1039, __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, 1039, __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, 1039, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result->__pyx_base.view.len = __pyx_t_9; + } + + /* "View.MemoryView":1041 + * 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":1042 + * + * 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":1044 + * 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":994 + * + * @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":1047 + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') + * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *mslice): + * 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; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + __Pyx_RefNannySetupContext("get_slice_from_memview", 0); + + /* "View.MemoryView":1050 + * __Pyx_memviewslice *mslice): + * 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); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1051 + * 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, 1051, __pyx_L1_error) + __pyx_t_3 = ((PyObject *)__pyx_v_memview); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_obj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":1052 + * 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":1050 + * __Pyx_memviewslice *mslice): + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * obj = memview + * return &obj.from_slice + */ + } + + /* "View.MemoryView":1054 + * return &obj.from_slice + * else: + * slice_copy(memview, mslice) # <<<<<<<<<<<<<< + * return mslice + * + */ + /*else*/ { + __pyx_memoryview_slice_copy(__pyx_v_memview, __pyx_v_mslice); + + /* "View.MemoryView":1055 + * else: + * slice_copy(memview, mslice) + * return mslice # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_slice_copy') + */ + __pyx_r = __pyx_v_mslice; + goto __pyx_L0; + } + + /* "View.MemoryView":1047 + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') + * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *mslice): + * cdef _memoryviewslice obj + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("View.MemoryView.get_slice_from_memview", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_obj); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1058 + * + * @cname('__pyx_memoryview_slice_copy') + * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< + * 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; + __Pyx_RefNannyDeclarations + Py_ssize_t *__pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + Py_ssize_t __pyx_t_5; + __Pyx_RefNannySetupContext("slice_copy", 0); + + /* "View.MemoryView":1062 + * 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":1063 + * + * 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":1064 + * 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":1066 + * 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":1067 + * + * 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":1069 + * 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":1070 + * + * 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":1071 + * 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":1072 + * dst.shape[dim] = shape[dim] + * dst.strides[dim] = strides[dim] + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_object') + */ + if ((__pyx_v_suboffsets != 0)) { + __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":1058 + * + * @cname('__pyx_memoryview_slice_copy') + * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< + * cdef int dim + * cdef (Py_ssize_t*) shape, strides, suboffsets + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":1075 + * + * @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; + __Pyx_RefNannySetupContext("memoryview_copy", 0); + + /* "View.MemoryView":1078 + * "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":1079 + * 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, 1079, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":1075 + * + * @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":1082 + * + * @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; + int __pyx_t_2; + PyObject *(*__pyx_t_3)(char *); + int (*__pyx_t_4)(char *, PyObject *); + PyObject *__pyx_t_5 = NULL; + __Pyx_RefNannySetupContext("memoryview_copy_from_slice", 0); + + /* "View.MemoryView":1089 + * 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); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1090 + * + * if isinstance(memview, _memoryviewslice): + * to_object_func = (<_memoryviewslice> memview).to_object_func # <<<<<<<<<<<<<< + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + * else: + */ + __pyx_t_3 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_object_func; + __pyx_v_to_object_func = __pyx_t_3; + + /* "View.MemoryView":1091 + * 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_4 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_dtype_func; + __pyx_v_to_dtype_func = __pyx_t_4; + + /* "View.MemoryView":1089 + * 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":1093 + * 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":1094 + * 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":1096 + * 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":1098 + * return memoryview_fromslice(memviewslice[0], memview.view.ndim, + * to_object_func, to_dtype_func, + * memview.dtype_is_object) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = __pyx_memoryview_fromslice((__pyx_v_memviewslice[0]), __pyx_v_memview->view.ndim, __pyx_v_to_object_func, __pyx_v_to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1096, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "View.MemoryView":1082 + * + * @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_5); + __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":1104 + * + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< + * if arg < 0: + * return -arg + */ + +static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { + Py_ssize_t __pyx_r; + int __pyx_t_1; + + /* "View.MemoryView":1105 + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: + * if arg < 0: # <<<<<<<<<<<<<< + * return -arg + * else: + */ + __pyx_t_1 = ((__pyx_v_arg < 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1106 + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: + * if arg < 0: + * return -arg # <<<<<<<<<<<<<< + * else: + * return arg + */ + __pyx_r = (-__pyx_v_arg); + goto __pyx_L0; + + /* "View.MemoryView":1105 + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: + * if arg < 0: # <<<<<<<<<<<<<< + * return -arg + * else: + */ + } + + /* "View.MemoryView":1108 + * return -arg + * else: + * return arg # <<<<<<<<<<<<<< + * + * @cname('__pyx_get_best_slice_order') + */ + /*else*/ { + __pyx_r = __pyx_v_arg; + goto __pyx_L0; + } + + /* "View.MemoryView":1104 + * + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< + * if arg < 0: + * return -arg + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1111 + * + * @cname('__pyx_get_best_slice_order') + * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) 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":1116 + * """ + * cdef int i + * cdef Py_ssize_t c_stride = 0 # <<<<<<<<<<<<<< + * cdef Py_ssize_t f_stride = 0 + * + */ + __pyx_v_c_stride = 0; + + /* "View.MemoryView":1117 + * 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":1119 + * 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":1120 + * + * 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) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1121 + * 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":1122 + * if mslice.shape[i] > 1: + * c_stride = mslice.strides[i] + * break # <<<<<<<<<<<<<< + * + * for i in range(ndim): + */ + goto __pyx_L4_break; + + /* "View.MemoryView":1120 + * + * for i in range(ndim - 1, -1, -1): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * c_stride = mslice.strides[i] + * break + */ + } + } + __pyx_L4_break:; + + /* "View.MemoryView":1124 + * 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":1125 + * + * 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) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1126 + * 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":1127 + * 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":1125 + * + * for i in range(ndim): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * f_stride = mslice.strides[i] + * break + */ + } + } + __pyx_L7_break:; + + /* "View.MemoryView":1129 + * 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)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1130 + * + * 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":1129 + * break + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< + * return 'C' + * else: + */ + } + + /* "View.MemoryView":1132 + * return 'C' + * else: + * return 'F' # <<<<<<<<<<<<<< + * + * @cython.cdivision(True) + */ + /*else*/ { + __pyx_r = 'F'; + goto __pyx_L0; + } + + /* "View.MemoryView":1111 + * + * @cname('__pyx_get_best_slice_order') + * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<< + * """ + * Figure out the best memory access order for a given slice. + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1135 + * + * @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; + int __pyx_t_3; + Py_ssize_t __pyx_t_4; + Py_ssize_t __pyx_t_5; + Py_ssize_t __pyx_t_6; + + /* "View.MemoryView":1142 + * + * 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":1143 + * 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":1144 + * 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":1145 + * 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":1147 + * 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) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1148 + * + * 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) != 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) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L5_bool_binop_done; + } + + /* "View.MemoryView":1149 + * 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_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L5_bool_binop_done:; + + /* "View.MemoryView":1148 + * + * 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":1150 + * 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":1148 + * + * 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":1152 + * 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_4 = __pyx_v_dst_extent; + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1153 + * 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":1154 + * 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":1155 + * 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":1147 + * 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":1157 + * 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_4 = __pyx_v_dst_extent; + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1158 + * 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":1162 + * 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":1163 + * 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":1135 + * + * @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":1165 + * dst_data += dst_stride + * + * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) 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":1168 + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) 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":1165 + * dst_data += dst_stride + * + * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) nogil: + */ + + /* function exit code */ +} + +/* "View.MemoryView":1172 + * + * @cname('__pyx_memoryview_slice_get_size') + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<< + * "Return the size of the memory occupied by the slice in number of bytes" + * cdef int i + */ + +static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_src, int __pyx_v_ndim) { + int __pyx_v_i; + Py_ssize_t __pyx_v_size; + Py_ssize_t __pyx_r; + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + + /* "View.MemoryView":1175 + * "Return the size of the memory occupied by the slice in number of bytes" + * cdef int i + * cdef Py_ssize_t size = src.memview.view.itemsize # <<<<<<<<<<<<<< + * + * for i in range(ndim): + */ + __pyx_t_1 = __pyx_v_src->memview->view.itemsize; + __pyx_v_size = __pyx_t_1; + + /* "View.MemoryView":1177 + * cdef Py_ssize_t size = src.memview.view.itemsize + * + * for i in range(ndim): # <<<<<<<<<<<<<< + * size *= src.shape[i] + * + */ + __pyx_t_2 = __pyx_v_ndim; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1178 + * + * for i in range(ndim): + * size *= src.shape[i] # <<<<<<<<<<<<<< + * + * return size + */ + __pyx_v_size = (__pyx_v_size * (__pyx_v_src->shape[__pyx_v_i])); + } + + /* "View.MemoryView":1180 + * size *= src.shape[i] + * + * return size # <<<<<<<<<<<<<< + * + * @cname('__pyx_fill_contig_strides_array') + */ + __pyx_r = __pyx_v_size; + goto __pyx_L0; + + /* "View.MemoryView":1172 + * + * @cname('__pyx_memoryview_slice_get_size') + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<< + * "Return the size of the memory occupied by the slice in number of bytes" + * cdef int i + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1183 + * + * @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) 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":1192 + * cdef int idx + * + * if order == 'F': # <<<<<<<<<<<<<< + * for idx in range(ndim): + * strides[idx] = stride + */ + __pyx_t_1 = ((__pyx_v_order == 'F') != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1193 + * + * if order == 'F': + * for idx in range(ndim): # <<<<<<<<<<<<<< + * strides[idx] = stride + * 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":1194 + * if order == 'F': + * for idx in range(ndim): + * strides[idx] = stride # <<<<<<<<<<<<<< + * stride = stride * shape[idx] + * else: + */ + (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; + + /* "View.MemoryView":1195 + * for idx in range(ndim): + * strides[idx] = stride + * 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":1192 + * cdef int idx + * + * if order == 'F': # <<<<<<<<<<<<<< + * for idx in range(ndim): + * strides[idx] = stride + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1197 + * stride = stride * shape[idx] + * else: + * for idx in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< + * strides[idx] = stride + * 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":1198 + * else: + * for idx in range(ndim - 1, -1, -1): + * strides[idx] = stride # <<<<<<<<<<<<<< + * stride = stride * shape[idx] + * + */ + (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; + + /* "View.MemoryView":1199 + * for idx in range(ndim - 1, -1, -1): + * strides[idx] = stride + * stride = stride * shape[idx] # <<<<<<<<<<<<<< + * + * return stride + */ + __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx])); + } + } + __pyx_L3:; + + /* "View.MemoryView":1201 + * stride = stride * shape[idx] + * + * return stride # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_data_to_temp') + */ + __pyx_r = __pyx_v_stride; + goto __pyx_L0; + + /* "View.MemoryView":1183 + * + * @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) nogil: + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1204 + * + * @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; + + /* "View.MemoryView":1215 + * 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":1216 + * + * 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":1218 + * cdef size_t size = slice_get_size(src, ndim) + * + * result = malloc(size) # <<<<<<<<<<<<<< + * if not result: + * _err(MemoryError, NULL) + */ + __pyx_v_result = malloc(__pyx_v_size); + + /* "View.MemoryView":1219 + * + * result = malloc(size) + * if not result: # <<<<<<<<<<<<<< + * _err(MemoryError, NULL) + * + */ + __pyx_t_2 = ((!(__pyx_v_result != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1220 + * result = malloc(size) + * if not result: + * _err(MemoryError, NULL) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __pyx_memoryview_err(__pyx_builtin_MemoryError, NULL); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 1220, __pyx_L1_error) + + /* "View.MemoryView":1219 + * + * result = malloc(size) + * if not result: # <<<<<<<<<<<<<< + * _err(MemoryError, NULL) + * + */ + } + + /* "View.MemoryView":1223 + * + * + * tmpslice.data = result # <<<<<<<<<<<<<< + * tmpslice.memview = src.memview + * for i in range(ndim): + */ + __pyx_v_tmpslice->data = ((char *)__pyx_v_result); + + /* "View.MemoryView":1224 + * + * 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":1225 + * 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":1226 + * 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":1227 + * 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, + */ + (__pyx_v_tmpslice->suboffsets[__pyx_v_i]) = -1L; + } + + /* "View.MemoryView":1229 + * 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) != 0); + 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) != 0); + 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":1204 + * + * @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 + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.copy_data_to_temp", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = NULL; + __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("got differing extents in dimension %d (got %d and %d)" % + */ + +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; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("_err_extents", 0); + + /* "View.MemoryView":1250 + * Py_ssize_t extent2) except -1 with gil: + * raise ValueError("got differing extents in dimension %d (got %d and %d)" % + * (i, extent1, extent2)) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_err_dim') + */ + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_extent1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_extent2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + + /* "View.MemoryView":1249 + * cdef int _err_extents(int i, Py_ssize_t extent1, + * Py_ssize_t extent2) except -1 with gil: + * raise ValueError("got differing extents in dimension %d (got %d and %d)" % # <<<<<<<<<<<<<< + * (i, extent1, extent2)) + * + */ + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(1, 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("got differing extents in dimension %d (got %d and %d)" % + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_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":1253 + * + * @cname('__pyx_memoryview_err_dim') + * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii') % dim) + * + */ + +static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg, int __pyx_v_dim) { + int __pyx_r; + __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; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("_err_dim", 0); + __Pyx_INCREF(__pyx_v_error); + + /* "View.MemoryView":1254 + * @cname('__pyx_memoryview_err_dim') + * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: + * raise error(msg.decode('ascii') % dim) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_err') + */ + __pyx_t_2 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyUnicode_Format(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_INCREF(__pyx_v_error); + __pyx_t_3 = __pyx_v_error; __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_2) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1254, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1254, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1254, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); __pyx_t_2 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 1254, __pyx_L1_error) + + /* "View.MemoryView":1253 + * + * @cname('__pyx_memoryview_err_dim') + * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii') % dim) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView._err_dim", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_XDECREF(__pyx_v_error); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "View.MemoryView":1257 + * + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< + * if msg != NULL: + * raise error(msg.decode('ascii')) + */ + +static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("_err", 0); + __Pyx_INCREF(__pyx_v_error); + + /* "View.MemoryView":1258 + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: + * if msg != NULL: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii')) + * else: + */ + __pyx_t_1 = ((__pyx_v_msg != NULL) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":1259 + * cdef int _err(object error, char *msg) except -1 with gil: + * if msg != NULL: + * raise error(msg.decode('ascii')) # <<<<<<<<<<<<<< + * else: + * raise error + */ + __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1259, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_error); + __pyx_t_4 = __pyx_v_error; __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1259, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1259, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1259, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1259, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1259, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 1259, __pyx_L1_error) + + /* "View.MemoryView":1258 + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: + * if msg != NULL: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii')) + * else: + */ + } + + /* "View.MemoryView":1261 + * raise error(msg.decode('ascii')) + * else: + * raise error # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_contents') + */ + /*else*/ { + __Pyx_Raise(__pyx_v_error, 0, 0, 0); + __PYX_ERR(1, 1261, __pyx_L1_error) + } + + /* "View.MemoryView":1257 + * + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< + * if msg != NULL: + * raise error(msg.decode('ascii')) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("View.MemoryView._err", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_XDECREF(__pyx_v_error); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "View.MemoryView":1264 + * + * @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_t_8; + + /* "View.MemoryView":1272 + * 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":1273 + * """ + * 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":1275 + * 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":1276 + * 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":1277 + * 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":1280 + * 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) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1281 + * + * 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":1280 + * 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":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_t_2 = ((__pyx_v_dst_ndim < __pyx_v_src_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1283 + * 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":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_L3:; + + /* "View.MemoryView":1285 + * 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; + if (((__pyx_t_3 > __pyx_t_4) != 0)) { + __pyx_t_5 = __pyx_t_3; + } else { + __pyx_t_5 = __pyx_t_4; + } + __pyx_v_ndim = __pyx_t_5; + + /* "View.MemoryView":1287 + * 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":1288 + * + * 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])) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1289 + * 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) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1290 + * 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":1291 + * 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":1289 + * 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":1293 + * 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, 1293, __pyx_L1_error) + } + __pyx_L7:; + + /* "View.MemoryView":1288 + * + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< + * if src.shape[i] == 1: + * broadcasting = True + */ + } + + /* "View.MemoryView":1295 + * _err_extents(i, dst.shape[i], src.shape[i]) + * + * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + */ + __pyx_t_2 = (((__pyx_v_src.suboffsets[__pyx_v_i]) >= 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1296 + * + * if src.suboffsets[i] >= 0: + * _err_dim(ValueError, "Dimension %d is not direct", i) # <<<<<<<<<<<<<< + * + * if slices_overlap(&src, &dst, ndim, itemsize): + */ + __pyx_t_6 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Dimension %d is not direct"), __pyx_v_i); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1296, __pyx_L1_error) + + /* "View.MemoryView":1295 + * _err_extents(i, dst.shape[i], src.shape[i]) + * + * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + */ + } + } + + /* "View.MemoryView":1298 + * _err_dim(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) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1300 + * 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) != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1301 + * + * 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":1300 + * if slices_overlap(&src, &dst, ndim, itemsize): + * + * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< + * order = get_best_order(&dst, ndim) + * + */ + } + + /* "View.MemoryView":1303 + * 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, 1303, __pyx_L1_error) + __pyx_v_tmpdata = __pyx_t_7; + + /* "View.MemoryView":1304 + * + * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) + * src = tmp # <<<<<<<<<<<<<< + * + * if not broadcasting: + */ + __pyx_v_src = __pyx_v_tmp; + + /* "View.MemoryView":1298 + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< + * + * if not slice_is_contig(src, order, ndim): + */ + } + + /* "View.MemoryView":1306 + * src = tmp + * + * if not broadcasting: # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = ((!(__pyx_v_broadcasting != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1309 + * + * + * 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) != 0); + 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): + * 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":1309 + * + * + * 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":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_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'F', __pyx_v_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1312 + * 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":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_L12:; + + /* "View.MemoryView":1314 + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + * if direct_copy: # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + */ + __pyx_t_2 = (__pyx_v_direct_copy != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1316 + * if direct_copy: + * + * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, True) + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1317 + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) # <<<<<<<<<<<<<< + * refcount_copying(&dst, dtype_is_object, ndim, True) + * 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":1318 + * refcount_copying(&dst, dtype_is_object, ndim, False) + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< + * free(tmpdata) + * return 0 + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1319 + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, True) + * free(tmpdata) # <<<<<<<<<<<<<< + * return 0 + * + */ + free(__pyx_v_tmpdata); + + /* "View.MemoryView":1320 + * refcount_copying(&dst, dtype_is_object, ndim, True) + * free(tmpdata) + * return 0 # <<<<<<<<<<<<<< + * + * if order == 'F' == get_best_order(&dst, ndim): + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":1314 + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + * if direct_copy: # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + */ + } + + /* "View.MemoryView":1306 + * src = tmp + * + * if not broadcasting: # <<<<<<<<<<<<<< + * + * + */ + } + + /* "View.MemoryView":1322 + * 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)); + } + __pyx_t_8 = (__pyx_t_2 != 0); + if (__pyx_t_8) { + + /* "View.MemoryView":1325 + * + * + * transpose_memslice(&src) # <<<<<<<<<<<<<< + * transpose_memslice(&dst) + * + */ + __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_src)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(1, 1325, __pyx_L1_error) + + /* "View.MemoryView":1326 + * + * transpose_memslice(&src) + * transpose_memslice(&dst) # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + */ + __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_dst)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(1, 1326, __pyx_L1_error) + + /* "View.MemoryView":1322 + * return 0 + * + * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< + * + * + */ + } + + /* "View.MemoryView":1328 + * transpose_memslice(&dst) + * + * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< + * copy_strided_to_strided(&src, &dst, ndim, itemsize) + * refcount_copying(&dst, dtype_is_object, ndim, True) + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1329 + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + * copy_strided_to_strided(&src, &dst, ndim, itemsize) # <<<<<<<<<<<<<< + * refcount_copying(&dst, dtype_is_object, ndim, True) + * + */ + copy_strided_to_strided((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize); + + /* "View.MemoryView":1330 + * refcount_copying(&dst, dtype_is_object, ndim, False) + * copy_strided_to_strided(&src, &dst, ndim, itemsize) + * refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< + * + * free(tmpdata) + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1332 + * refcount_copying(&dst, dtype_is_object, ndim, True) + * + * free(tmpdata) # <<<<<<<<<<<<<< + * return 0 + * + */ + free(__pyx_v_tmpdata); + + /* "View.MemoryView":1333 + * + * free(tmpdata) + * return 0 # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_broadcast_leading') + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":1264 + * + * @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 + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.memoryview_copy_contents", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1336 + * + * @cname('__pyx_memoryview_broadcast_leading') + * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< + * int ndim, + * int ndim_other) 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":1340 + * int ndim_other) 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":1342 + * 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":1343 + * + * 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":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->strides[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->strides[__pyx_v_i]); + + /* "View.MemoryView":1345 + * 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":1347 + * 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":1348 + * + * 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":1349 + * 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":1350 + * mslice.shape[i] = 1 + * mslice.strides[i] = mslice.strides[0] + * mslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< + * + * + */ + (__pyx_v_mslice->suboffsets[__pyx_v_i]) = -1L; + } + + /* "View.MemoryView":1336 + * + * @cname('__pyx_memoryview_broadcast_leading') + * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< + * int ndim, + * int ndim_other) nogil: + */ + + /* function exit code */ +} + +/* "View.MemoryView":1358 + * + * @cname('__pyx_memoryview_refcount_copying') + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< + * int ndim, bint inc) nogil: + * + */ + +static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_dtype_is_object, int __pyx_v_ndim, int __pyx_v_inc) { + int __pyx_t_1; + + /* "View.MemoryView":1362 + * + * + * if dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, + * dst.strides, ndim, inc) + */ + __pyx_t_1 = (__pyx_v_dtype_is_object != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1363 + * + * if dtype_is_object: + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, # <<<<<<<<<<<<<< + * dst.strides, ndim, inc) + * + */ + __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":1362 + * + * + * if dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, + * dst.strides, ndim, inc) + */ + } + + /* "View.MemoryView":1358 + * + * @cname('__pyx_memoryview_refcount_copying') + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< + * int ndim, bint inc) nogil: + * + */ + + /* function exit code */ +} + +/* "View.MemoryView":1367 + * + * @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) 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) { + __Pyx_RefNannyDeclarations + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("refcount_objects_in_slice_with_gil", 0); + + /* "View.MemoryView":1370 + * Py_ssize_t *strides, int ndim, + * bint inc) 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":1367 + * + * @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) with gil: + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif +} + +/* "View.MemoryView":1373 + * + * @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): + * 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; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + __Pyx_RefNannySetupContext("refcount_objects_in_slice", 0); + + /* "View.MemoryView":1377 + * cdef Py_ssize_t i + * + * 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":1378 + * + * for i in range(shape[0]): + * if ndim == 1: # <<<<<<<<<<<<<< + * if inc: + * Py_INCREF(( data)[0]) + */ + __pyx_t_4 = ((__pyx_v_ndim == 1) != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":1379 + * for i in range(shape[0]): + * if ndim == 1: + * if inc: # <<<<<<<<<<<<<< + * Py_INCREF(( data)[0]) + * else: + */ + __pyx_t_4 = (__pyx_v_inc != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":1380 + * if ndim == 1: + * if inc: + * Py_INCREF(( data)[0]) # <<<<<<<<<<<<<< + * else: + * Py_DECREF(( data)[0]) + */ + Py_INCREF((((PyObject **)__pyx_v_data)[0])); + + /* "View.MemoryView":1379 + * for i in range(shape[0]): + * if ndim == 1: + * if inc: # <<<<<<<<<<<<<< + * Py_INCREF(( data)[0]) + * else: + */ + goto __pyx_L6; + } + + /* "View.MemoryView":1382 + * Py_INCREF(( data)[0]) + * else: + * Py_DECREF(( data)[0]) # <<<<<<<<<<<<<< + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, + */ + /*else*/ { + Py_DECREF((((PyObject **)__pyx_v_data)[0])); + } + __pyx_L6:; + + /* "View.MemoryView":1378 + * + * for i in range(shape[0]): + * if ndim == 1: # <<<<<<<<<<<<<< + * if inc: + * Py_INCREF(( data)[0]) + */ + goto __pyx_L5; + } + + /* "View.MemoryView":1384 + * Py_DECREF(( data)[0]) + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< + * ndim - 1, inc) + * + */ + /*else*/ { + + /* "View.MemoryView":1385 + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, + * ndim - 1, inc) # <<<<<<<<<<<<<< + * + * data += strides[0] + */ + __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":1387 + * ndim - 1, inc) + * + * data += strides[0] # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_data = (__pyx_v_data + (__pyx_v_strides[0])); + } + + /* "View.MemoryView":1373 + * + * @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): + * cdef Py_ssize_t i + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":1393 + * + * @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) 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":1396 + * size_t itemsize, void *item, + * bint dtype_is_object) nogil: + * refcount_copying(dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, + * itemsize, item) + */ + __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1397 + * bint dtype_is_object) nogil: + * refcount_copying(dst, dtype_is_object, ndim, False) + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, # <<<<<<<<<<<<<< + * itemsize, item) + * refcount_copying(dst, dtype_is_object, ndim, 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":1399 + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, + * itemsize, item) + * refcount_copying(dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< + * + * + */ + __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1393 + * + * @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) nogil: + */ + + /* function exit code */ +} + +/* "View.MemoryView":1403 + * + * @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) 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":1407 + * size_t itemsize, void *item) 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":1408 + * 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":1410 + * 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) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1411 + * + * 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":1412 + * 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":1413 + * 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":1410 + * cdef Py_ssize_t extent = shape[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * for i in range(extent): + * memcpy(data, item, itemsize) + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1415 + * data += stride + * else: + * for i in range(extent): # <<<<<<<<<<<<<< + * _slice_assign_scalar(data, shape + 1, strides + 1, + * ndim - 1, itemsize, item) + */ + /*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":1416 + * 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":1418 + * _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":1403 + * + * @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) nogil: + */ + + /* function exit code */ +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * if __pyx_checksum != 0xb068931: + * from pickle import PickleError as __pyx_PickleError + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum = {"__pyx_unpickle_Enum", (PyCFunction)__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--; + 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_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_Enum") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__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_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_L3_error:; + __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 */ + __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 = NULL; + PyObject *__pyx_v___pyx_result = NULL; + 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; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum", 0); + + /* "(tree fragment)":2 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): + * if __pyx_checksum != 0xb068931: # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum) + */ + __pyx_t_1 = ((__pyx_v___pyx_checksum != 0xb068931) != 0); + if (__pyx_t_1) { + + /* "(tree fragment)":3 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): + * if __pyx_checksum != 0xb068931: + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum) + * __pyx_result = Enum.__new__(__pyx_type) + */ + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_PickleError); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_2); + __pyx_v___pyx_PickleError = __pyx_t_2; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":4 + * if __pyx_checksum != 0xb068931: + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum) # <<<<<<<<<<<<<< + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_s_vs_0xb0, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_v___pyx_PickleError); + __pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_5) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else + #endif + { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":2 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): + * if __pyx_checksum != 0xb068931: # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum) + */ + } + + /* "(tree fragment)":5 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (%s vs 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_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_MemviewEnum_type), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (!__pyx_t_6) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v___pyx_type}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v___pyx_type}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_INCREF(__pyx_v___pyx_type); + __Pyx_GIVEREF(__pyx_v___pyx_type); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v___pyx_type); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v___pyx_result = __pyx_t_3; + __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * raise __pyx_PickleError("Incompatible checksums (%s vs 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_1 = (__pyx_v___pyx_state != Py_None); + __pyx_t_7 = (__pyx_t_1 != 0); + if (__pyx_t_7) { + + /* "(tree fragment)":7 + * __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)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 7, __pyx_L1_error) + __pyx_t_3 = __pyx_unpickle_Enum__set_state(((struct __pyx_MemviewEnum_obj *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * raise __pyx_PickleError("Incompatible checksums (%s vs 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)":8 + * 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): # <<<<<<<<<<<<<< + * if __pyx_checksum != 0xb068931: + * from pickle import PickleError as __pyx_PickleError + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __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)":9 + * __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; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum__set_state", 0); + + /* "(tree fragment)":10 + * 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, 10, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 10, __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)":11 + * 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, 11, __pyx_L1_error) + } + __pyx_t_3 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 11, __pyx_L1_error) + __pyx_t_4 = ((__pyx_t_3 > 1) != 0); + 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, 11, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_4 != 0); + __pyx_t_2 = __pyx_t_5; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":12 + * __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_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + 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_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + if (!__pyx_t_8) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL; + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":11 + * 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)":9 + * __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_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __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; +} +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 (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + 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(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + ++Py_REFCNT(o); + __pyx_array___dealloc__(o); + --Py_REFCNT(o); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->mode); + Py_CLEAR(p->_format); + (*Py_TYPE(o)->tp_free)(o); +} +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 { + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_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)__pyx_pw___pyx_array_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_array_3__setstate_cython__, METH_O, 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} +}; + +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) + "gensim.models.nmf_pgd.array", /*tp_name*/ + sizeof(struct __pyx_array_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_array, /*tp_dealloc*/ + 0, /*tp_print*/ + 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, /*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*/ + 0, /*tp_dictoffset*/ + 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 + 0, /*tp_finalize*/ + #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 (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + 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(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->name); + (*Py_TYPE(o)->tp_free)(o); +} + +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 PyMethodDef __pyx_methods_Enum[] = { + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type___pyx_MemviewEnum = { + PyVarObject_HEAD_INIT(0, 0) + "gensim.models.nmf_pgd.Enum", /*tp_name*/ + sizeof(struct __pyx_MemviewEnum_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_Enum, /*tp_dealloc*/ + 0, /*tp_print*/ + 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*/ + 0, /*tp_dictoffset*/ + __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 + 0, /*tp_finalize*/ + #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 (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + 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(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + ++Py_REFCNT(o); + __pyx_memoryview___dealloc__(o); + --Py_REFCNT(o); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->obj); + Py_CLEAR(p->_size); + Py_CLEAR(p->_array_interface); + (*Py_TYPE(o)->tp_free)(o); +} + +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 { + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_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 PyMethodDef __pyx_methods_memoryview[] = { + {"is_c_contig", (PyCFunction)__pyx_memoryview_is_c_contig, METH_NOARGS, 0}, + {"is_f_contig", (PyCFunction)__pyx_memoryview_is_f_contig, METH_NOARGS, 0}, + {"copy", (PyCFunction)__pyx_memoryview_copy, METH_NOARGS, 0}, + {"copy_fortran", (PyCFunction)__pyx_memoryview_copy_fortran, METH_NOARGS, 0}, + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_3__setstate_cython__, METH_O, 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} +}; + +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) + "gensim.models.nmf_pgd.memoryview", /*tp_name*/ + sizeof(struct __pyx_memoryview_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_memoryview, /*tp_dealloc*/ + 0, /*tp_print*/ + 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*/ + 0, /*tp_dictoffset*/ + 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 + 0, /*tp_finalize*/ + #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(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + ++Py_REFCNT(o); + __pyx_memoryviewslice___dealloc__(o); + --Py_REFCNT(o); + 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_XDEC_MEMVIEW(&p->from_slice, 1); + return 0; +} + +static PyObject *__pyx_getprop___pyx_memoryviewslice_base(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(o); +} + +static PyMethodDef __pyx_methods__memoryviewslice[] = { + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets__memoryviewslice[] = { + {(char *)"base", __pyx_getprop___pyx_memoryviewslice_base, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type___pyx_memoryviewslice = { + PyVarObject_HEAD_INIT(0, 0) + "gensim.models.nmf_pgd._memoryviewslice", /*tp_name*/ + sizeof(struct __pyx_memoryviewslice_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc__memoryviewslice, /*tp_dealloc*/ + 0, /*tp_print*/ + 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 + __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 + __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, /*tp_flags*/ + "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*/ + __pyx_getsets__memoryviewslice, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 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 + 0, /*tp_finalize*/ + #endif +}; + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 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_nmf_pgd(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_nmf_pgd}, + {0, NULL} +}; +#endif + +static struct PyModuleDef __pyx_moduledef = { + PyModuleDef_HEAD_INIT, + "nmf_pgd", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* 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 + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_ASCII, __pyx_k_ASCII, sizeof(__pyx_k_ASCII), 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_s_Cannot_index_with_type_s, __pyx_k_Cannot_index_with_type_s, sizeof(__pyx_k_Cannot_index_with_type_s), 0, 0, 1, 0}, + {&__pyx_n_s_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_s_vs_0xb0, __pyx_k_Incompatible_checksums_s_vs_0xb0, sizeof(__pyx_k_Incompatible_checksums_s_vs_0xb0), 0, 0, 1, 0}, + {&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1}, + {&__pyx_kp_s_Indirect_dimensions_not_supporte, __pyx_k_Indirect_dimensions_not_supporte, sizeof(__pyx_k_Indirect_dimensions_not_supporte), 0, 0, 1, 0}, + {&__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_k_Invalid_mode_expected_c_or_fortr, sizeof(__pyx_k_Invalid_mode_expected_c_or_fortr), 0, 0, 1, 0}, + {&__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_k_Invalid_shape_in_axis_d_d, sizeof(__pyx_k_Invalid_shape_in_axis_d_d), 0, 0, 1, 0}, + {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, + {&__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_s_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, 0, 1, 0}, + {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 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_n_s_WtW, __pyx_k_WtW, sizeof(__pyx_k_WtW), 0, 0, 1, 1}, + {&__pyx_n_s_Wt_v_minus_r, __pyx_k_Wt_v_minus_r, sizeof(__pyx_k_Wt_v_minus_r), 0, 0, 1, 1}, + {&__pyx_n_s_allocate_buffer, __pyx_k_allocate_buffer, sizeof(__pyx_k_allocate_buffer), 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_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_component_idx_1, __pyx_k_component_idx_1, sizeof(__pyx_k_component_idx_1), 0, 0, 1, 1}, + {&__pyx_n_s_component_idx_2, __pyx_k_component_idx_2, sizeof(__pyx_k_component_idx_2), 0, 0, 1, 1}, + {&__pyx_kp_s_contiguous_and_direct, __pyx_k_contiguous_and_direct, sizeof(__pyx_k_contiguous_and_direct), 0, 0, 1, 0}, + {&__pyx_kp_s_contiguous_and_indirect, __pyx_k_contiguous_and_indirect, sizeof(__pyx_k_contiguous_and_indirect), 0, 0, 1, 0}, + {&__pyx_n_s_data, __pyx_k_data, sizeof(__pyx_k_data), 0, 0, 1, 1}, + {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, + {&__pyx_n_s_dtype_is_object, __pyx_k_dtype_is_object, sizeof(__pyx_k_dtype_is_object), 0, 0, 1, 1}, + {&__pyx_n_s_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_n_s_gensim_models_nmf_pgd, __pyx_k_gensim_models_nmf_pgd, sizeof(__pyx_k_gensim_models_nmf_pgd), 0, 0, 1, 1}, + {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, + {&__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_k_got_differing_extents_in_dimensi, sizeof(__pyx_k_got_differing_extents_in_dimensi), 0, 0, 1, 0}, + {&__pyx_n_s_grad, __pyx_k_grad, sizeof(__pyx_k_grad), 0, 0, 1, 1}, + {&__pyx_n_s_h, __pyx_k_h, sizeof(__pyx_k_h), 0, 0, 1, 1}, + {&__pyx_n_s_hessian, __pyx_k_hessian, sizeof(__pyx_k_hessian), 0, 0, 1, 1}, + {&__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_indices, __pyx_k_indices, sizeof(__pyx_k_indices), 0, 0, 1, 1}, + {&__pyx_n_s_indptr, __pyx_k_indptr, sizeof(__pyx_k_indptr), 0, 0, 1, 1}, + {&__pyx_n_s_itemsize, __pyx_k_itemsize, sizeof(__pyx_k_itemsize), 0, 0, 1, 1}, + {&__pyx_kp_s_itemsize_0_for_cython_array, __pyx_k_itemsize_0_for_cython_array, sizeof(__pyx_k_itemsize_0_for_cython_array), 0, 0, 1, 0}, + {&__pyx_n_s_kappa, __pyx_k_kappa, sizeof(__pyx_k_kappa), 0, 0, 1, 1}, + {&__pyx_n_s_lambda, __pyx_k_lambda, sizeof(__pyx_k_lambda), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 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_n_components, __pyx_k_n_components, sizeof(__pyx_k_n_components), 0, 0, 1, 1}, + {&__pyx_n_s_n_samples, __pyx_k_n_samples, sizeof(__pyx_k_n_samples), 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_nmf_pgd_pyx, __pyx_k_nmf_pgd_pyx, sizeof(__pyx_k_nmf_pgd_pyx), 0, 0, 1, 0}, + {&__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_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_projected_grad, __pyx_k_projected_grad, sizeof(__pyx_k_projected_grad), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_PickleError, __pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_checksum, __pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_getbuffer, __pyx_k_pyx_getbuffer, sizeof(__pyx_k_pyx_getbuffer), 0, 0, 1, 1}, + {&__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_r, __pyx_k_r, sizeof(__pyx_k_r), 0, 0, 1, 1}, + {&__pyx_n_s_r_actual, __pyx_k_r_actual, sizeof(__pyx_k_r_actual), 0, 0, 1, 1}, + {&__pyx_n_s_r_actual_col_idx, __pyx_k_r_actual_col_idx, sizeof(__pyx_k_r_actual_col_idx), 0, 0, 1, 1}, + {&__pyx_n_s_r_actual_col_indptr, __pyx_k_r_actual_col_indptr, sizeof(__pyx_k_r_actual_col_indptr), 0, 0, 1, 1}, + {&__pyx_n_s_r_actual_col_size, __pyx_k_r_actual_col_size, sizeof(__pyx_k_r_actual_col_size), 0, 0, 1, 1}, + {&__pyx_n_s_r_actual_data, __pyx_k_r_actual_data, sizeof(__pyx_k_r_actual_data), 0, 0, 1, 1}, + {&__pyx_n_s_r_actual_element, __pyx_k_r_actual_element, sizeof(__pyx_k_r_actual_element), 0, 0, 1, 1}, + {&__pyx_n_s_r_actual_indices, __pyx_k_r_actual_indices, sizeof(__pyx_k_r_actual_indices), 0, 0, 1, 1}, + {&__pyx_n_s_r_actual_indptr, __pyx_k_r_actual_indptr, sizeof(__pyx_k_r_actual_indptr), 0, 0, 1, 1}, + {&__pyx_n_s_r_actual_sign, __pyx_k_r_actual_sign, sizeof(__pyx_k_r_actual_sign), 0, 0, 1, 1}, + {&__pyx_n_s_r_col_idx, __pyx_k_r_col_idx, sizeof(__pyx_k_r_col_idx), 0, 0, 1, 1}, + {&__pyx_n_s_r_col_indptr, __pyx_k_r_col_indptr, sizeof(__pyx_k_r_col_indptr), 0, 0, 1, 1}, + {&__pyx_n_s_r_col_size, __pyx_k_r_col_size, sizeof(__pyx_k_r_col_size), 0, 0, 1, 1}, + {&__pyx_n_s_r_data, __pyx_k_r_data, sizeof(__pyx_k_r_data), 0, 0, 1, 1}, + {&__pyx_n_s_r_element, __pyx_k_r_element, sizeof(__pyx_k_r_element), 0, 0, 1, 1}, + {&__pyx_n_s_r_indices, __pyx_k_r_indices, sizeof(__pyx_k_r_indices), 0, 0, 1, 1}, + {&__pyx_n_s_r_indptr, __pyx_k_r_indptr, sizeof(__pyx_k_r_indptr), 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_sample_idx, __pyx_k_sample_idx, sizeof(__pyx_k_sample_idx), 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_solve_h, __pyx_k_solve_h, sizeof(__pyx_k_solve_h), 0, 0, 1, 1}, + {&__pyx_n_s_solve_r, __pyx_k_solve_r, sizeof(__pyx_k_solve_r), 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_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_v_max, __pyx_k_v_max, sizeof(__pyx_k_v_max), 0, 0, 1, 1}, + {&__pyx_n_s_violation, __pyx_k_violation, sizeof(__pyx_k_violation), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 49, __pyx_L1_error) + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 132, __pyx_L1_error) + __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(1, 147, __pyx_L1_error) + __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(1, 150, __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_Ellipsis = __Pyx_GetBuiltinName(__pyx_n_s_Ellipsis); if (!__pyx_builtin_Ellipsis) __PYX_ERR(1, 399, __pyx_L1_error) + __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(1, 608, __pyx_L1_error) + __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(1, 827, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "View.MemoryView":132 + * + * if not self.ndim: + * raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<< + * + * if itemsize <= 0: + */ + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_Empty_shape_tuple_for_cython_arr); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + + /* "View.MemoryView":135 + * + * if itemsize <= 0: + * raise ValueError("itemsize <= 0 for cython.array") # <<<<<<<<<<<<<< + * + * if not isinstance(format, bytes): + */ + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_itemsize_0_for_cython_array); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "View.MemoryView":138 + * + * if not isinstance(format, bytes): + * format = format.encode('ASCII') # <<<<<<<<<<<<<< + * self._format = format # keep a reference to the byte string + * self.format = self._format + */ + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_n_s_ASCII); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "View.MemoryView":147 + * + * if not self._shape: + * raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_shape_and_str); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "View.MemoryView":175 + * self.data = malloc(self.len) + * if not self.data: + * raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<< + * + * if self.dtype_is_object: + */ + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_array_data); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "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_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_Can_only_create_a_buffer_that_is); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + + /* "(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_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + + /* "(tree fragment)":4 + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + */ + __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + + /* "View.MemoryView":413 + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<< + * + * have_slices, index = _unellipsify(index, self.view.ndim) + */ + __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_Cannot_assign_to_read_only_memor); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); + + /* "View.MemoryView":490 + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + * raise ValueError("Unable to convert item to object") # <<<<<<<<<<<<<< + * else: + * if len(self.view.format) == 1: + */ + __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_Unable_to_convert_item_to_object); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 490, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + + /* "View.MemoryView":515 + * 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_STRIDES: + */ + __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_Cannot_create_writable_memory_vi); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + + /* "View.MemoryView":565 + * if self.view.strides == NULL: + * + * raise ValueError("Buffer view does not expose strides") # <<<<<<<<<<<<<< + * + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) + */ + __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_s_Buffer_view_does_not_expose_stri); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 565, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + + /* "View.MemoryView":572 + * 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__13 = PyTuple_New(1); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_INCREF(__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_int_neg_1); + PyTuple_SET_ITEM(__pyx_tuple__13, 0, __pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_tuple__13); + + /* "(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_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__14); + __Pyx_GIVEREF(__pyx_tuple__14); + + /* "(tree fragment)":4 + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + */ + __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__15); + __Pyx_GIVEREF(__pyx_tuple__15); + + /* "View.MemoryView":677 + * if item is Ellipsis: + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) # <<<<<<<<<<<<<< + * seen_ellipsis = True + * else: + */ + __pyx_slice__16 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__16)) __PYX_ERR(1, 677, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice__16); + __Pyx_GIVEREF(__pyx_slice__16); + + /* "View.MemoryView":680 + * seen_ellipsis = True + * else: + * result.append(slice(None)) # <<<<<<<<<<<<<< + * have_slices = True + * else: + */ + __pyx_slice__17 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__17)) __PYX_ERR(1, 680, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice__17); + __Pyx_GIVEREF(__pyx_slice__17); + + /* "View.MemoryView":691 + * nslices = ndim - len(result) + * if nslices: + * result.extend([slice(None)] * nslices) # <<<<<<<<<<<<<< + * + * return have_slices or nslices, tuple(result) + */ + __pyx_slice__18 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__18)) __PYX_ERR(1, 691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice__18); + __Pyx_GIVEREF(__pyx_slice__18); + + /* "View.MemoryView":698 + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + * raise ValueError("Indirect dimensions not supported") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__19 = PyTuple_Pack(1, __pyx_kp_s_Indirect_dimensions_not_supporte); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(1, 698, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__19); + __Pyx_GIVEREF(__pyx_tuple__19); + + /* "(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_tuple__20 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__20); + __Pyx_GIVEREF(__pyx_tuple__20); + + /* "(tree fragment)":4 + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + */ + __pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__21); + __Pyx_GIVEREF(__pyx_tuple__21); + + /* "gensim/models/nmf_pgd.pyx":23 + * return a + * + * def solve_h(double[:, ::1] h, double[:, :] Wt_v_minus_r, double[:, ::1] WtW, double kappa): # <<<<<<<<<<<<<< + * """Find optimal dense vector representation for current W and r matrices. + * + */ + __pyx_tuple__22 = PyTuple_Pack(13, __pyx_n_s_h, __pyx_n_s_Wt_v_minus_r, __pyx_n_s_WtW, __pyx_n_s_kappa, __pyx_n_s_n_components, __pyx_n_s_n_samples, __pyx_n_s_violation, __pyx_n_s_grad, __pyx_n_s_projected_grad, __pyx_n_s_hessian, __pyx_n_s_sample_idx, __pyx_n_s_component_idx_1, __pyx_n_s_component_idx_2); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__22); + __Pyx_GIVEREF(__pyx_tuple__22); + __pyx_codeobj__23 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 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_nmf_pgd_pyx, __pyx_n_s_solve_h, 23, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__23)) __PYX_ERR(0, 23, __pyx_L1_error) + + /* "gensim/models/nmf_pgd.pyx":68 + * return sqrt(violation) + * + * def solve_r( # <<<<<<<<<<<<<< + * r, + * r_actual, + */ + __pyx_tuple__24 = PyTuple_Pack(22, __pyx_n_s_r, __pyx_n_s_r_actual, __pyx_n_s_lambda, __pyx_n_s_v_max, __pyx_n_s_r_indptr, __pyx_n_s_r_indices, __pyx_n_s_r_data, __pyx_n_s_r_actual_indptr, __pyx_n_s_r_actual_indices, __pyx_n_s_r_actual_data, __pyx_n_s_r_col_size, __pyx_n_s_r_actual_col_size, __pyx_n_s_r_col_indptr, __pyx_n_s_r_actual_col_indptr, __pyx_n_s_r_col_idx, __pyx_n_s_r_actual_col_idx, __pyx_n_s_r_element, __pyx_n_s_r_actual_element, __pyx_n_s_r_actual_sign, __pyx_n_s_n_samples, __pyx_n_s_sample_idx, __pyx_n_s_violation); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(0, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__24); + __Pyx_GIVEREF(__pyx_tuple__24); + __pyx_codeobj__25 = (PyObject*)__Pyx_PyCode_New(4, 0, 22, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__24, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_nmf_pgd_pyx, __pyx_n_s_solve_r, 68, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__25)) __PYX_ERR(0, 68, __pyx_L1_error) + + /* "View.MemoryView":285 + * return self.name + * + * cdef generic = Enum("") # <<<<<<<<<<<<<< + * cdef strided = Enum("") # default + * cdef indirect = Enum("") + */ + __pyx_tuple__26 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(1, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__26); + __Pyx_GIVEREF(__pyx_tuple__26); + + /* "View.MemoryView":286 + * + * cdef generic = Enum("") + * cdef strided = Enum("") # default # <<<<<<<<<<<<<< + * cdef indirect = Enum("") + * + */ + __pyx_tuple__27 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(1, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__27); + __Pyx_GIVEREF(__pyx_tuple__27); + + /* "View.MemoryView":287 + * cdef generic = Enum("") + * cdef strided = Enum("") # default + * cdef indirect = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__28 = PyTuple_Pack(1, __pyx_kp_s_strided_and_indirect); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(1, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__28); + __Pyx_GIVEREF(__pyx_tuple__28); + + /* "View.MemoryView":290 + * + * + * cdef contiguous = Enum("") # <<<<<<<<<<<<<< + * cdef indirect_contiguous = Enum("") + * + */ + __pyx_tuple__29 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(1, 290, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__29); + __Pyx_GIVEREF(__pyx_tuple__29); + + /* "View.MemoryView":291 + * + * cdef contiguous = Enum("") + * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__30 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_indirect); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(1, 291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__30); + __Pyx_GIVEREF(__pyx_tuple__30); + + /* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * if __pyx_checksum != 0xb068931: + * from pickle import PickleError as __pyx_PickleError + */ + __pyx_tuple__31 = 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__31)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__31); + __Pyx_GIVEREF(__pyx_tuple__31); + __pyx_codeobj__32 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__31, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__32)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_InitGlobals(void) { + /* InitThreads.init */ + #ifdef WITH_THREAD +PyEval_InitThreads(); +#endif + +if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __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; +} + +static int __Pyx_modinit_global_init_code(void); /*proto*/ +static int __Pyx_modinit_variable_export_code(void); /*proto*/ +static int __Pyx_modinit_function_export_code(void); /*proto*/ +static int __Pyx_modinit_type_init_code(void); /*proto*/ +static int __Pyx_modinit_type_import_code(void); /*proto*/ +static int __Pyx_modinit_variable_import_code(void); /*proto*/ +static 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 ---*/ + 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 + __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 (PyType_Ready(&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 104, __pyx_L1_error) + __pyx_type___pyx_array.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type___pyx_array.tp_dict, __pyx_vtabptr_array) < 0) __PYX_ERR(1, 104, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 104, __pyx_L1_error) + __pyx_array_type = &__pyx_type___pyx_array; + if (PyType_Ready(&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(1, 278, __pyx_L1_error) + __pyx_type___pyx_MemviewEnum.tp_print = 0; + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_MemviewEnum.tp_dictoffset && __pyx_type___pyx_MemviewEnum.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type___pyx_MemviewEnum.tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(1, 278, __pyx_L1_error) + __pyx_MemviewEnum_type = &__pyx_type___pyx_MemviewEnum; + __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; + if (PyType_Ready(&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 329, __pyx_L1_error) + __pyx_type___pyx_memoryview.tp_print = 0; + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryview.tp_dictoffset && __pyx_type___pyx_memoryview.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type___pyx_memoryview.tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + if (__Pyx_SetVtable(__pyx_type___pyx_memoryview.tp_dict, __pyx_vtabptr_memoryview) < 0) __PYX_ERR(1, 329, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 329, __pyx_L1_error) + __pyx_memoryview_type = &__pyx_type___pyx_memoryview; + __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_type___pyx_memoryviewslice.tp_base = __pyx_memoryview_type; + if (PyType_Ready(&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 960, __pyx_L1_error) + __pyx_type___pyx_memoryviewslice.tp_print = 0; + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryviewslice.tp_dictoffset && __pyx_type___pyx_memoryviewslice.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type___pyx_memoryviewslice.tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + if (__Pyx_SetVtable(__pyx_type___pyx_memoryviewslice.tp_dict, __pyx_vtabptr__memoryviewslice) < 0) __PYX_ERR(1, 960, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 960, __pyx_L1_error) + __pyx_memoryviewslice_type = &__pyx_type___pyx_memoryviewslice; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __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 +#ifdef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC void +#else +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#endif +#else +#ifdef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyObject * +#else +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#endif +#endif +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (!(defined(__cplusplus)) || (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 4))) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif + + +#if PY_MAJOR_VERSION < 3 +__Pyx_PyMODINIT_FUNC initnmf_pgd(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC initnmf_pgd(void) +#else +__Pyx_PyMODINIT_FUNC PyInit_nmf_pgd(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_nmf_pgd(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +static int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name) { + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + result = PyDict_SetItemString(moddict, to_name, value); + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} +static PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + 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; + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__") < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__") < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__") < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__") < 0)) goto bad; + return module; +bad: + Py_XDECREF(module); + return NULL; +} + + +static int __pyx_pymod_exec_nmf_pgd(PyObject *__pyx_pyinit_module) +#endif +#endif +{ + PyObject *__pyx_t_1 = NULL; + static PyThread_type_lock __pyx_t_2[8]; + __Pyx_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m && __pyx_m == __pyx_pyinit_module) return 0; + #elif PY_MAJOR_VERSION >= 3 + if (__pyx_m) return __Pyx_NewRef(__pyx_m); + #endif + #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_nmf_pgd(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __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() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #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("nmf_pgd", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + #if CYTHON_COMPILING_IN_PYPY + Py_INCREF(__pyx_b); + #endif + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + /*--- Initialize various global constants etc. ---*/ + 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_gensim__models__nmf_pgd) { + if (PyObject_SetAttrString(__pyx_m, "__name__", __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, "gensim.models.nmf_pgd")) { + if (unlikely(PyDict_SetItemString(modules, "gensim.models.nmf_pgd", __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)) goto __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 + + /* "gensim/models/nmf_pgd.pyx":23 + * return a + * + * def solve_h(double[:, ::1] h, double[:, :] Wt_v_minus_r, double[:, ::1] WtW, double kappa): # <<<<<<<<<<<<<< + * """Find optimal dense vector representation for current W and r matrices. + * + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6gensim_6models_7nmf_pgd_1solve_h, NULL, __pyx_n_s_gensim_models_nmf_pgd); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_solve_h, __pyx_t_1) < 0) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "gensim/models/nmf_pgd.pyx":68 + * return sqrt(violation) + * + * def solve_r( # <<<<<<<<<<<<<< + * r, + * r_actual, + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6gensim_6models_7nmf_pgd_3solve_r, NULL, __pyx_n_s_gensim_models_nmf_pgd); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_solve_r, __pyx_t_1) < 0) __PYX_ERR(0, 68, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "gensim/models/nmf_pgd.pyx":1 + * # Author: Timofey Yefimov # <<<<<<<<<<<<<< + * + * # cython: cdivision=True + */ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "View.MemoryView":208 + * info.obj = self + * + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< + * + * def __dealloc__(array self): + */ + __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_array_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_array_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(1, 208, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_array_type); + + /* "View.MemoryView":285 + * return self.name + * + * cdef generic = Enum("") # <<<<<<<<<<<<<< + * cdef strided = Enum("") # default + * cdef indirect = Enum("") + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(generic); + __Pyx_DECREF_SET(generic, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":286 + * + * cdef generic = Enum("") + * cdef strided = Enum("") # default # <<<<<<<<<<<<<< + * cdef indirect = Enum("") + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__27, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(strided); + __Pyx_DECREF_SET(strided, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":287 + * cdef generic = Enum("") + * cdef strided = Enum("") # default + * cdef indirect = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__28, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(indirect); + __Pyx_DECREF_SET(indirect, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":290 + * + * + * cdef contiguous = Enum("") # <<<<<<<<<<<<<< + * cdef indirect_contiguous = Enum("") + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__29, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 290, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(contiguous); + __Pyx_DECREF_SET(contiguous, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":291 + * + * cdef contiguous = Enum("") + * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__30, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(indirect_contiguous); + __Pyx_DECREF_SET(indirect_contiguous, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":315 + * + * DEF THREAD_LOCKS_PREALLOCATED = 8 + * cdef int __pyx_memoryview_thread_locks_used = 0 # <<<<<<<<<<<<<< + * cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [ + * PyThread_allocate_lock(), + */ + __pyx_memoryview_thread_locks_used = 0; + + /* "View.MemoryView":316 + * DEF THREAD_LOCKS_PREALLOCATED = 8 + * cdef int __pyx_memoryview_thread_locks_used = 0 + * cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [ # <<<<<<<<<<<<<< + * PyThread_allocate_lock(), + * PyThread_allocate_lock(), + */ + __pyx_t_2[0] = PyThread_allocate_lock(); + __pyx_t_2[1] = PyThread_allocate_lock(); + __pyx_t_2[2] = PyThread_allocate_lock(); + __pyx_t_2[3] = PyThread_allocate_lock(); + __pyx_t_2[4] = PyThread_allocate_lock(); + __pyx_t_2[5] = PyThread_allocate_lock(); + __pyx_t_2[6] = PyThread_allocate_lock(); + __pyx_t_2[7] = PyThread_allocate_lock(); + memcpy(&(__pyx_memoryview_thread_locks[0]), __pyx_t_2, sizeof(__pyx_memoryview_thread_locks[0]) * (8)); + + /* "View.MemoryView":544 + * info.obj = self + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 544, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_memoryview_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(1, 544, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_memoryview_type); + + /* "View.MemoryView":990 + * return self.from_object + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 990, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_memoryviewslice_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(1, 990, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_memoryviewslice_type); + + /* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * if __pyx_checksum != 0xb068931: + * from pickle import PickleError as __pyx_PickleError + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum, NULL, __pyx_n_s_View_MemoryView); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Enum, __pyx_t_1) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":9 + * __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__'): + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init gensim.models.nmf_pgd", 0, __pyx_lineno, __pyx_filename); + } + Py_DECREF(__pyx_m); __pyx_m = 0; + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init gensim.models.nmf_pgd"); + } + __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 +} + +/* --- 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((char *)modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#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 + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + 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; +} + +/* RaiseArgTupleInvalid */ +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) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* RaiseDoubleKeywords */ +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 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 **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; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + 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 = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + 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 + (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(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; + } + } + 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: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +/* 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 (!buf) { + PyErr_SetString(PyExc_ValueError, + "buf is NULL."); + goto fail; + } else if (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]; +#ifdef 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 *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 *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) +{ + int first_time; + struct __pyx_memoryview_obj *memview = memslice->memview; + if (!memview || (PyObject *) memview == Py_None) + return; + if (__pyx_get_slice_count(memview) < 0) + __pyx_fatalerror("Acquisition count is %d (line %d)", + __pyx_get_slice_count(memview), lineno); + first_time = __pyx_add_acquisition_count(memview) == 0; + if (first_time) { + if (have_gil) { + Py_INCREF((PyObject *) memview); + } else { + PyGILState_STATE _gilstate = PyGILState_Ensure(); + Py_INCREF((PyObject *) memview); + PyGILState_Release(_gilstate); + } + } +} +static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW(__Pyx_memviewslice *memslice, + int have_gil, int lineno) { + int last_time; + struct __pyx_memoryview_obj *memview = memslice->memview; + if (!memview ) { + return; + } else if ((PyObject *) memview == Py_None) { + memslice->memview = NULL; + return; + } + if (__pyx_get_slice_count(memview) <= 0) + __pyx_fatalerror("Acquisition count is %d (line %d)", + __pyx_get_slice_count(memview), lineno); + last_time = __pyx_sub_acquisition_count(memview) == 1; + memslice->data = NULL; + if (last_time) { + if (have_gil) { + Py_CLEAR(memslice->memview); + } else { + PyGILState_STATE _gilstate = PyGILState_Ensure(); + Py_CLEAR(memslice->memview); + PyGILState_Release(_gilstate); + } + } else { + memslice->memview = NULL; + } +} + +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + else if (exact) { + #if PY_MAJOR_VERSION == 2 + if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; + } + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); + return 0; +} + +/* PyObjectCall */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + 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 + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + 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); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *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 + +/* RaiseException */ +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + __Pyx_PyThreadState_declare + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +/* PyCFunctionFastCall */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { + PyCFunctionObject *func = (PyCFunctionObject*)func_obj; + PyCFunction meth = PyCFunction_GET_FUNCTION(func); + PyObject *self = PyCFunction_GET_SELF(func); + int flags = PyCFunction_GET_FLAGS(func); + assert(PyCFunction_Check(func)); + assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS))); + assert(nargs >= 0); + assert(nargs == 0 || args != NULL); + /* _PyCFunction_FastCallDict() must not be called with an exception set, + because it may clear it (directly or indirectly) and so the + caller loses its exception */ + assert(!PyErr_Occurred()); + if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { + return (*((__Pyx_PyCFunctionFastWithKeywords)meth)) (self, args, nargs, NULL); + } else { + return (*((__Pyx_PyCFunctionFast)meth)) (self, args, nargs); + } +} +#endif + +/* PyFunctionFastCall */ +#if CYTHON_FAST_PYCALL +#include "frameobject.h" +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 = f->f_localsplus; + 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; +} +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int 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_EnterRecursiveCall((char*)" while calling a Python object")) { + return NULL; + } + 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, nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif +#endif + +/* PyObjectCallMethO */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + 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 + +/* PyObjectCallOneArg */ +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, &arg, 1); + } +#endif + if (likely(PyCFunction_Check(func))) { + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); +#if CYTHON_FAST_PYCCALL + } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); +#endif + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +/* BytesEquals */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result; +#if CYTHON_USE_UNICODE_INTERNALS + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + return (equals == Py_NE); + } +#endif + result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +#endif +} + +/* UnicodeEquals */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY + return PyObject_RichCompareBool(s1, s2, equals); +#else +#if PY_MAJOR_VERSION < 3 + PyObject* owned_ref = NULL; +#endif + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + goto return_eq; + } + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); +#if PY_MAJOR_VERSION < 3 + if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { + owned_ref = PyUnicode_FromObject(s2); + if (unlikely(!owned_ref)) + return -1; + s2 = owned_ref; + s2_is_unicode = 1; + } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { + owned_ref = PyUnicode_FromObject(s1); + if (unlikely(!owned_ref)) + return -1; + s1 = owned_ref; + s1_is_unicode = 1; + } else if (((!s2_is_unicode) & (!s1_is_unicode))) { + return __Pyx_PyBytes_Equals(s1, s2, equals); + } +#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 +} + +/* 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 (!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((0 <= wrapped_i) & (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((0 <= wrapped_i) & (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((n >= 0) & (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((n >= 0) & (n < PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return m->sq_item(o, i); + } + } +#else + if (is_list || PySequence_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} + +/* ObjectGetItem */ +#if CYTHON_USE_TYPE_SLOTS +static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) { + PyObject *runerr; + Py_ssize_t key_value; + PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence; + if (unlikely(!(m && m->sq_item))) { + PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name); + return NULL; + } + 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)) { + PyErr_Clear(); + PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name); + } + return NULL; +} +static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) { + PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping; + if (likely(m && m->mp_subscript)) { + return m->mp_subscript(obj, key); + } + return __Pyx_PyObject_GetIndex(obj, key); +} +#endif + +/* decode_c_string */ +static CYTHON_INLINE PyObject* __Pyx_decode_c_string( + const char* cstring, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + Py_ssize_t length; + if (unlikely((start < 0) | (stop < 0))) { + size_t slen = strlen(cstring); + if (unlikely(slen > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, + "c-string too long to convert to Python"); + return NULL; + } + length = (Py_ssize_t) slen; + if (start < 0) { + start += length; + if (start < 0) + start = 0; + } + if (stop < 0) + stop += length; + } + length = stop - start; + if (unlikely(length <= 0)) + return PyUnicode_FromUnicode(NULL, 0); + cstring += start; + if (decode_func) { + return decode_func(cstring, length, errors); + } else { + return PyUnicode_Decode(cstring, length, encoding, errors); + } +} + +/* PyErrExceptionMatches */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; icurexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; + if (unlikely(PyTuple_Check(err))) + return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); +} +#endif + +/* GetAttr3 */ +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; +} +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { + PyObject *r = __Pyx_GetAttr(o, n); + return (likely(r)) ? r : __Pyx_GetAttr3Default(d); +} + +/* GetModuleGlobalName */ +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) { + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 + result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); + if (likely(result)) { + Py_INCREF(result); + } else if (unlikely(PyErr_Occurred())) { + result = NULL; + } else { +#else + result = PyDict_GetItem(__pyx_d, name); + if (likely(result)) { + Py_INCREF(result); + } else { +#endif +#else + result = PyObject_GetItem(__pyx_d, name); + if (!result) { + PyErr_Clear(); +#endif + result = __Pyx_GetBuiltinName(name); + } + return result; +} + +/* 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) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +/* SaveResetException */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + #if PY_VERSION_HEX >= 0x030700A3 + *type = tstate->exc_state.exc_type; + *value = tstate->exc_state.exc_value; + *tb = tstate->exc_state.exc_traceback; + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + #endif + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if PY_VERSION_HEX >= 0x030700A3 + tmp_type = tstate->exc_state.exc_type; + tmp_value = tstate->exc_state.exc_value; + tmp_tb = tstate->exc_state.exc_traceback; + tstate->exc_state.exc_type = type; + tstate->exc_state.exc_value = value; + tstate->exc_state.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 + +/* GetException */ + #if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) { +#endif + PyObject *local_type, *local_value, *local_tb; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + #if PY_MAJOR_VERSION >= 3 + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } + #endif + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if PY_VERSION_HEX >= 0x030700A3 + tmp_type = tstate->exc_state.exc_type; + tmp_value = tstate->exc_state.exc_value; + tmp_tb = tstate->exc_state.exc_traceback; + tstate->exc_state.exc_type = local_type; + tstate->exc_state.exc_value = local_value; + tstate->exc_state.exc_traceback = local_tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +} + +/* 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 PY_VERSION_HEX >= 0x030700A3 + tmp_type = tstate->exc_state.exc_type; + tmp_value = tstate->exc_state.exc_value; + tmp_tb = tstate->exc_state.exc_traceback; + tstate->exc_state.exc_type = *type; + tstate->exc_state.exc_value = *value; + tstate->exc_state.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 *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_MAJOR_VERSION < 3 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.')) { + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + if (!module) { + if (!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 (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +/* FastTypeChecks */ + #if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = a->tp_base; + 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); +} +#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) { + int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; + if (!res) { + res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + } + return res; +} +#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; i= 0 || (x^b) >= 0)) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a, x; +#ifdef HAVE_LONG_LONG + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla, llx; +#endif + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + default: return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + } + x = a + b; + return PyLong_FromLong(x); +#ifdef HAVE_LONG_LONG + long_long: + llx = lla + llb; + return PyLong_FromLongLong(llx); +#endif + + + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + double result; + PyFPE_START_PROTECT("add", return NULL) + result = ((double)a) + (double)b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); + } + return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); +} +#endif + +/* None */ + static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { + PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); +} + +/* WriteUnraisableException */ + static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, + CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, + int full_traceback, CYTHON_UNUSED int nogil) { + PyObject *old_exc, *old_val, *old_tb; + PyObject *ctx; + __Pyx_PyThreadState_declare +#ifdef WITH_THREAD + PyGILState_STATE state; + if (nogil) + state = PyGILState_Ensure(); +#ifdef _MSC_VER + else state = (PyGILState_STATE)-1; +#endif +#endif + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); + if (full_traceback) { + Py_XINCREF(old_exc); + Py_XINCREF(old_val); + Py_XINCREF(old_tb); + __Pyx_ErrRestore(old_exc, old_val, old_tb); + PyErr_PrintEx(1); + } + #if PY_MAJOR_VERSION < 3 + ctx = PyString_FromString(name); + #else + ctx = PyUnicode_FromString(name); + #endif + __Pyx_ErrRestore(old_exc, old_val, old_tb); + if (!ctx) { + PyErr_WriteUnraisable(Py_None); + } else { + PyErr_WriteUnraisable(ctx); + Py_DECREF(ctx); + } +#ifdef WITH_THREAD + if (nogil) + PyGILState_Release(state); +#endif +} + +/* ImportFrom */ + static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Format(PyExc_ImportError, + #if PY_MAJOR_VERSION < 3 + "cannot import name %.230s", PyString_AS_STRING(name)); + #else + "cannot import name %S", name); + #endif + } + return value; +} + +/* HasAttr */ + 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 (unlikely(!r)) { + PyErr_Clear(); + return 0; + } else { + Py_DECREF(r); + return 1; + } +} + +/* PyObject_GenericGetAttrNoDict */ + #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'%.50s' object has no attribute '%U'", + tp->tp_name, attr_name); +#else + "'%.50s' object has no attribute '%.400s'", + tp->tp_name, PyString_AS_STRING(attr_name)); +#endif + 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 + +/* SetVTable */ + static int __Pyx_SetVtable(PyObject *dict, void *vtable) { +#if PY_VERSION_HEX >= 0x02070000 + PyObject *ob = PyCapsule_New(vtable, 0, 0); +#else + PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); +#endif + if (!ob) + goto bad; + if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; +} + +/* SetupReduce */ + static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { + int ret; + PyObject *name_attr; + name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name_2); + 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_reduce_ex = NULL; + PyObject *reduce = NULL; + PyObject *reduce_ex = NULL; + PyObject *reduce_cython = NULL; + PyObject *setstate = NULL; + PyObject *setstate_cython = NULL; +#if CYTHON_USE_PYTYPE_LOOKUP + if (_PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate)) goto GOOD; +#else + if (PyObject_HasAttr(type_obj, __pyx_n_s_getstate)) goto GOOD; +#endif +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto BAD; +#else + object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto BAD; +#endif + reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto 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 BAD; +#else + object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto BAD; +#endif + reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto BAD; + if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { + reduce_cython = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_cython); if (unlikely(!reduce_cython)) goto BAD; + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto BAD; + setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); + if (!setstate) PyErr_Clear(); + if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { + setstate_cython = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate_cython); if (unlikely(!setstate_cython)) goto BAD; + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto BAD; + } + PyType_Modified((PyTypeObject*)type_obj); + } + } + goto GOOD; +BAD: + if (!PyErr_Occurred()) + PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); + ret = -1; +GOOD: +#if !CYTHON_USE_PYTYPE_LOOKUP + Py_XDECREF(object_reduce); + Py_XDECREF(object_reduce_ex); +#endif + Py_XDECREF(reduce); + Py_XDECREF(reduce_ex); + Py_XDECREF(reduce_cython); + Py_XDECREF(setstate); + Py_XDECREF(setstate_cython); + return ret; +} + +/* CLineInTraceback */ + #ifndef CYTHON_CLINE_IN_TRACEBACK +static int __Pyx_CLineForTraceback(CYTHON_UNUSED PyThreadState *tstate, int c_line) { + PyObject *use_cline; + PyObject *ptype, *pvalue, *ptraceback; +#if CYTHON_COMPILING_IN_CPYTHON + PyObject **cython_runtime_dict; +#endif + if (unlikely(!__pyx_cython_runtime)) { + return c_line; + } + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); +#if CYTHON_COMPILING_IN_CPYTHON + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); + if (likely(cython_runtime_dict)) { + use_cline = __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback); + } else +#endif + { + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + if (use_cline_obj) { + use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_DECREF(use_cline_obj); + } else { + PyErr_Clear(); + use_cline = NULL; + } + } + if (!use_cline) { + c_line = 0; + PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); + } + else if (PyObject_Not(use_cline) != 0) { + c_line = 0; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + return c_line; +} +#endif + +/* CodeObjectCache */ + static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static 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); +} + +/* AddTraceback */ + #include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + if (c_line) { + c_line = __Pyx_CLineForTraceback(tstate, c_line); + } + py_code = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); + } + py_frame = PyFrame_New( + tstate, /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +#if PY_MAJOR_VERSION < 3 +static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { + if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); + if (__Pyx_TypeCheck(obj, __pyx_array_type)) return __pyx_array_getbuffer(obj, view, flags); + if (__Pyx_TypeCheck(obj, __pyx_memoryview_type)) return __pyx_memoryview_getbuffer(obj, view, flags); + PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); + return -1; +} +static void __Pyx_ReleaseBuffer(Py_buffer *view) { + PyObject *obj = view->obj; + if (!obj) return; + if (PyObject_CheckBuffer(obj)) { + PyBuffer_Release(view); + return; + } + 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); +} + +/* Capsule */ + static CYTHON_INLINE PyObject * +__pyx_capsule_create(void *p, CYTHON_UNUSED const char *sig) +{ + PyObject *cobj; +#if PY_VERSION_HEX >= 0x02070000 + cobj = PyCapsule_New(p, sig, NULL); +#else + cobj = PyCObject_FromVoidPtr(p, NULL); +#endif + return cobj; +} + +/* 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 'c': return "'char'"; + case 'b': return "'signed char'"; + case 'B': return "'unsigned char'"; + case 'h': return "'short'"; + case 'H': return "'unsigned short'"; + case 'i': return "'int'"; + case 'I': return "'unsigned int'"; + case 'l': return "'long'"; + case 'L': return "'unsigned long'"; + case 'q': return "'long long'"; + case 'Q': return "'unsigned long long'"; + case 'f': return (is_complex ? "'complex float'" : "'float'"); + case 'd': return (is_complex ? "'complex double'" : "'double'"); + case 'g': return (is_complex ? "'complex long double'" : "'long double'"); + case 'T': return "a struct"; + case 'O': return "Python object"; + case 'P': return "a pointer"; + case 's': case 'p': return "a string"; + case 0: return "end"; + default: return "unparseable format string"; + } +} +static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return 2; + case 'i': case 'I': case 'l': case 'L': return 4; + case 'q': case 'Q': return 8; + case 'f': return (is_complex ? 8 : 4); + case 'd': return (is_complex ? 16 : 8); + case 'g': { + PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); + return 0; + } + 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 '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, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_st_float) - sizeof(float); + case 'd': return sizeof(__Pyx_st_double) - sizeof(double); + case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +/* These are for computing the padding at the end of the struct to align + on the first member of the struct. This will probably the same as above, + but we don't have any guarantees. + */ +typedef struct { short x; char c; } __Pyx_pad_short; +typedef struct { int x; char c; } __Pyx_pad_int; +typedef struct { long x; char c; } __Pyx_pad_long; +typedef struct { float x; char c; } __Pyx_pad_float; +typedef struct { double x; char c; } __Pyx_pad_double; +typedef struct { long double x; char c; } __Pyx_pad_longdouble; +typedef struct { void *x; char c; } __Pyx_pad_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); + case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); + case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { + switch (ch) { + case 'c': + return 'H'; + case 'b': case 'h': case 'i': + case 'l': case 'q': case 's': case 'p': + return 'I'; + case 'B': case 'H': case 'I': case 'L': case 'Q': + return 'U'; + case 'f': case 'd': case 'g': + return (is_complex ? 'C' : 'R'); + case 'O': + return 'O'; + case 'P': + return 'P'; + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +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 PyObject * +__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) +{ + const char *ts = *tsp; + int i = 0, number; + int ndim = ctx->head->field->type->ndim; +; + ++ts; + if (ctx->new_count != 1) { + PyErr_SetString(PyExc_ValueError, + "Cannot handle repeated arrays in format string"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + while (*ts && *ts != ')') { + switch (*ts) { + case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; + default: break; + } + number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) + return PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %d", + ctx->head->field->type->arraysize[i], number); + if (*ts != ',' && *ts != ')') + return PyErr_Format(PyExc_ValueError, + "Expected a comma in format string, got '%c'", *ts); + if (*ts == ',') ts++; + i++; + } + if (i != ndim) + return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", + ctx->head->field->type->ndim, i); + if (!*ts) { + PyErr_SetString(PyExc_ValueError, + "Unexpected end of format string, expected ')'"); + return NULL; + } + ctx->is_valid_array = 1; + ctx->new_count = 1; + *tsp = ++ts; + return Py_None; +} +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { + int got_Z = 0; + while (1) { + switch(*ts) { + case 0: + if (ctx->enc_type != 0 && ctx->head == NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + if (ctx->head != NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + return ts; + case ' ': + case '\r': + case '\n': + ++ts; + break; + case '<': + if (!__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '>': + case '!': + if (__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '=': + case '@': + case '^': + ctx->new_packmode = *ts++; + break; + case 'T': + { + const char* ts_after_sub; + size_t i, struct_count = ctx->new_count; + size_t struct_alignment = ctx->struct_alignment; + ctx->new_count = 1; + ++ts; + if (*ts != '{') { + PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + ctx->enc_count = 0; + ctx->struct_alignment = 0; + ++ts; + ts_after_sub = ts; + for (i = 0; i != struct_count; ++i) { + ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); + if (!ts_after_sub) return NULL; + } + ts = ts_after_sub; + if (struct_alignment) ctx->struct_alignment = struct_alignment; + } + break; + case '}': + { + size_t alignment = ctx->struct_alignment; + ++ts; + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + if (alignment && ctx->fmt_offset % alignment) { + ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); + } + } + return ts; + case 'x': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->fmt_offset += ctx->new_count; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->enc_packmode = ctx->new_packmode; + ++ts; + break; + case 'Z': + got_Z = 1; + ++ts; + if (*ts != 'f' && *ts != 'd' && *ts != 'g') { + __Pyx_BufFmt_RaiseUnexpectedChar('Z'); + return NULL; + } + CYTHON_FALLTHROUGH; + case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': + case 'l': case 'L': case 'q': case 'Q': + case 'f': case 'd': case 'g': + case 'O': case 'p': + if (ctx->enc_type == *ts && got_Z == ctx->is_complex && + ctx->enc_packmode == ctx->new_packmode) { + ctx->enc_count += ctx->new_count; + ctx->new_count = 1; + got_Z = 0; + ++ts; + break; + } + CYTHON_FALLTHROUGH; + case 's': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_count = ctx->new_count; + ctx->enc_packmode = ctx->new_packmode; + ctx->enc_type = *ts; + ctx->is_complex = got_Z; + ++ts; + ctx->new_count = 1; + got_Z = 0; + break; + case ':': + ++ts; + while(*ts != ':') ++ts; + ++ts; + break; + case '(': + if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; + break; + default: + { + int number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + ctx->new_count = (size_t)number; + } + } + } +} + +/* 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 (buf->strides[dim] != sizeof(void *)) { + PyErr_Format(PyExc_ValueError, + "Buffer is not indirectly contiguous " + "in dimension %d.", dim); + goto fail; + } + } else if (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 (stride < buf->itemsize) { + PyErr_SetString(PyExc_ValueError, + "Buffer and memoryview are not contiguous " + "in the same dimension."); + goto fail; + } + } + } else { + if (spec & __Pyx_MEMVIEW_CONTIG && dim != ndim - 1) { + PyErr_Format(PyExc_ValueError, + "C-contiguous buffer is not contiguous in " + "dimension %d", dim); + goto fail; + } else if (spec & (__Pyx_MEMVIEW_PTR)) { + PyErr_Format(PyExc_ValueError, + "C-contiguous buffer is not indirect in " + "dimension %d", dim); + goto fail; + } else if (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, CYTHON_UNUSED int ndim, int spec) +{ + if (spec & __Pyx_MEMVIEW_DIRECT) { + if (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 (!buf->suboffsets || (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 (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 (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 (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 (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; + } + if ((unsigned) buf->itemsize != dtype->size) { + PyErr_Format(PyExc_ValueError, + "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "u byte%s) " + "does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "u byte%s)", + buf->itemsize, + (buf->itemsize > 1) ? "s" : "", + dtype->name, + dtype->size, + (dtype->size > 1) ? "s" : ""); + goto fail; + } + for (i = 0; i < ndim; i++) { + spec = axes_specs[i]; + if (!__pyx_check_strides(buf, i, ndim, spec)) + goto fail; + if (!__pyx_check_suboffsets(buf, i, ndim, spec)) + goto fail; + } + if (buf->strides && !__pyx_verify_contig(buf, ndim, c_or_f_flag)) + goto fail; + if (unlikely(__Pyx_init_memviewslice(memview, ndim, memviewslice, + new_memview != NULL) == -1)) { + goto fail; + } + 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_dc_double(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_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, 2, + &__Pyx_TypeInfo_double, 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_double(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_double, stack, + &result, obj); + if (unlikely(retcode == -1)) + goto __pyx_fail; + return result; +__pyx_fail: + result.memview = NULL; + result.data = NULL; + return result; +} + +/* 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 (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; +} + +/* 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;\ + } + +/* CIntFromPy */ + static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) -1, const_zero = (int) 0; + 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 + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + 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 + 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 + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + 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 + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (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; +} + +/* CIntFromPy */ + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) -1, const_zero = (long) 0; + 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 + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + 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 + 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 + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + 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 + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + 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 one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (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; +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { + const int neg_one = (int) -1, const_zero = (int) 0; + 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; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) -1, const_zero = (long) 0; + 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; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) { + const char neg_one = (char) -1, const_zero = (char) 0; + 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 + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (char) 0; + case 1: __PYX_VERIFY_RETURN_INT(char, digit, digits[0]) + 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 + 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 + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (char) 0; + case -1: __PYX_VERIFY_RETURN_INT(char, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(char, digit, +digits[0]) + 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 + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + 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 one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (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; +} + +/* 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; +} + +/* ObjectToMemviewSlice */ + static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_double(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_double, stack, + &result, obj); + if (unlikely(retcode == -1)) + goto __pyx_fail; + return result; +__pyx_fail: + result.memview = NULL; + result.data = NULL; + return result; +} + +/* CheckBinaryVersion */ + static int __Pyx_check_binary_version(void) { + char ctversion[4], rtversion[4]; + PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); + if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + return PyErr_WarnEx(NULL, message, 1); + } + return 0; +} + +/* InitStrings */ + static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + 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); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + if (PyObject_Hash(*t->p) == -1) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +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) || (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 PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { +#if PY_MAJOR_VERSION >= 3 + if (PyLong_Check(result)) { + if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, + "__int__ returned non-int (type %.200s). " + "The ability to return an instance of a strict subclass of int " + "is deprecated, and may be removed in a future version of Python.", + Py_TYPE(result)->tp_name)) { + Py_DECREF(result); + return NULL; + } + return result; + } +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + type_name, type_name, Py_TYPE(result)->tp_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(x); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + 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 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); +} + + +#endif /* Py_PYTHON_H */ diff --git a/gensim/models/nmf_pgd.pyx b/gensim/models/nmf_pgd.pyx new file mode 100644 index 0000000000..01e9075cbc --- /dev/null +++ b/gensim/models/nmf_pgd.pyx @@ -0,0 +1,166 @@ +# Author: Timofey Yefimov + +# cython: cdivision=True +# cython: boundscheck=False +# cython: wraparound=False +# cython: nonecheck=False +# cython: embedsignature=True + +from libc.math cimport sqrt, fabs, copysign +from cython.parallel import prange + +cdef double fmin(double x, double y) nogil: + return x if x < y else y + +cdef double fmax(double x, double y) nogil: + return x if x > y else y + +cdef double clip(double a, double a_min, double a_max) nogil: + a = fmin(a, a_max) + a = fmax(a, a_min) + return a + +def solve_h(double[:, ::1] h, double[:, :] Wt_v_minus_r, double[:, ::1] WtW, double kappa): + """Find optimal dense vector representation for current W and r matrices. + + Parameters + ---------- + h : matrix + Dense representation of documents in current batch. + Wt_v_minus_r : matrix + WtW : matrix + + Returns + ------- + float + Cumulative difference between previous and current h vectors. + + """ + + cdef Py_ssize_t n_components = h.shape[0] + cdef Py_ssize_t n_samples = h.shape[1] + cdef double violation = 0 + cdef double grad, projected_grad, hessian + cdef Py_ssize_t sample_idx = 0 + cdef Py_ssize_t component_idx_1 = 0 + cdef Py_ssize_t component_idx_2 = 0 + + for sample_idx in prange(n_samples, nogil=True): + for component_idx_1 in range(n_components): + + grad = -Wt_v_minus_r[component_idx_1, sample_idx] + + for component_idx_2 in range(n_components): + grad += WtW[component_idx_1, component_idx_2] * h[component_idx_2, sample_idx] + + hessian = WtW[component_idx_1, component_idx_1] + + grad = grad * kappa / hessian + + projected_grad = fmin(0, grad) if h[component_idx_1, sample_idx] == 0 else grad + + violation += projected_grad * projected_grad + + h[component_idx_1, sample_idx] = fmax(h[component_idx_1, sample_idx] - grad, 0.) + + return sqrt(violation) + +def solve_r( + r, + r_actual, + double lambda_, + double v_max + ): + """Bound new residuals. + + Parameters + ---------- + r: sparse matrix + r_actual: sparse matrix + lambda_ : double + v_max : double + + Returns + ------- + float + Cumulative difference between previous and current residuals vectors. + + """ + + cdef int[::1] r_indptr = r.indptr + cdef int[::1] r_indices = r.indices + cdef double[::1] r_data = r.data + cdef int[::1] r_actual_indptr = r_actual.indptr + cdef int[::1] r_actual_indices = r_actual.indices + cdef double[::1] r_actual_data = r_actual.data + + cdef Py_ssize_t r_col_size = 0 + cdef Py_ssize_t r_actual_col_size = 0 + cdef Py_ssize_t r_col_indptr + cdef Py_ssize_t r_actual_col_indptr + cdef Py_ssize_t r_col_idx + cdef Py_ssize_t r_actual_col_idx + cdef double* r_element + cdef double* r_actual_element + + cdef double r_actual_sign = 1.0 + + cdef Py_ssize_t n_samples = r_actual_indptr.shape[0] - 1 + cdef Py_ssize_t sample_idx + + cdef double violation = 0 + + for sample_idx in prange(n_samples, nogil=True): + r_col_size = r_indptr[sample_idx + 1] - r_indptr[sample_idx] + r_actual_col_size = r_actual_indptr[sample_idx + 1] - r_actual_indptr[sample_idx] + + r_col_idx = 0 + r_actual_col_idx = 0 + + while r_col_idx < r_col_size or r_actual_col_idx < r_actual_col_size: + r_col_indptr = r_indices[ + r_indptr[sample_idx] + + r_col_idx + ] + r_actual_col_indptr = r_actual_indices[ + r_actual_indptr[sample_idx] + + r_actual_col_idx + ] + + r_element = &r_data[ + r_indptr[sample_idx] + + r_col_idx + ] + r_actual_element = &r_actual_data[ + r_actual_indptr[sample_idx] + + r_actual_col_idx + ] + + if r_col_indptr >= r_actual_col_indptr: + r_actual_sign = copysign(r_actual_sign, r_actual_element[0]) + + r_actual_element[0] = fabs(r_actual_element[0]) - lambda_ + r_actual_element[0] = fmax(r_actual_element[0], 0) + + if r_actual_element[0] != 0: + r_actual_element[0] = copysign(r_actual_element[0], r_actual_sign) + r_actual_element[0] = clip(r_actual_element[0], -v_max, v_max) + + if r_col_indptr == r_actual_col_indptr: + violation += (r_element[0] - r_actual_element[0]) ** 2 + else: + violation += r_actual_element[0] ** 2 + + if r_actual_col_idx < r_actual_col_size: + r_actual_col_idx = r_actual_col_idx + 1 + else: + r_col_idx = r_col_idx + 1 + else: + violation += r_element[0] ** 2 + + if r_col_idx < r_col_size: + r_col_idx = r_col_idx + 1 + else: + r_actual_col_idx = r_actual_col_idx + 1 + + return sqrt(violation) diff --git a/gensim/test/test_nmf.py b/gensim/test/test_nmf.py new file mode 100644 index 0000000000..c73795c64a --- /dev/null +++ b/gensim/test/test_nmf.py @@ -0,0 +1,159 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# +# Copyright (C) 2018 Timofey Yefimov +# Licensed under the GNU LGPL v2.1 - http://www.gnu.org/licenses/lgpl.html + +""" +Automated tests for checking transformation algorithms (the models package). +""" + +import unittest + +import copy +import logging +import numbers +import numpy as np +import six + +from gensim import matutils +from gensim.models import nmf +from gensim.test import basetmtests +from gensim.test.utils import datapath, get_tmpfile, common_corpus, common_dictionary + + +class TestNmf(unittest.TestCase, basetmtests.TestBaseTopicModel): + def setUp(self): + self.model = nmf.Nmf(common_corpus, id2word=common_dictionary, num_topics=2, passes=100, random_state=42) + + def testUpdate(self): + model = copy.deepcopy(self.model) + model.update(common_corpus) + + self.assertFalse(np.allclose(self.model.get_topics(), model.get_topics())) + + def testRandomState(self): + model_1 = nmf.Nmf(common_corpus, id2word=common_dictionary, num_topics=2, passes=100, random_state=42) + model_2 = nmf.Nmf(common_corpus, id2word=common_dictionary, num_topics=2, passes=100, random_state=0) + + self.assertTrue(np.allclose(self.model.get_topics(), model_1.get_topics())) + self.assertFalse(np.allclose(self.model.get_topics(), model_2.get_topics())) + + def testTransform(self): + # transform one document + doc = list(common_corpus)[0] + transformed = self.model[doc] + + vec = matutils.sparse2full(transformed, 2) # convert to dense vector, for easier equality tests + expected = [0., 1.] + # must contain the same values, up to re-ordering + self.assertTrue(np.allclose(sorted(vec), sorted(expected))) + + # transform one word + word = 5 + transformed = self.model.get_term_topics(word) + + vec = matutils.sparse2full(transformed, 2) + expected = [0., 1.] + # must contain the same values, up to re-ordering + self.assertTrue(np.allclose(sorted(vec), sorted(expected))) + + def testTopTopics(self): + top_topics = self.model.top_topics(common_corpus) + + for topic, score in top_topics: + self.assertTrue(isinstance(topic, list)) + self.assertTrue(isinstance(score, float)) + + for v, k in topic: + self.assertTrue(isinstance(k, six.string_types)) + self.assertTrue(np.issubdtype(v, float)) + + def testGetTopicTerms(self): + topic_terms = self.model.get_topic_terms(1) + + for k, v in topic_terms: + self.assertTrue(isinstance(k, numbers.Integral)) + self.assertTrue(np.issubdtype(v, float)) + + def testGetDocumentTopics(self): + doc_topics = self.model.get_document_topics(common_corpus) + + for topic in doc_topics: + self.assertTrue(isinstance(topic, list)) + for k, v in topic: + self.assertTrue(isinstance(k, numbers.Integral)) + self.assertTrue(np.issubdtype(v, float)) + + # Test case to use the get_document_topic function for the corpus + all_topics = self.model.get_document_topics(common_corpus) + + print(list(all_topics)) + + for topic in all_topics: + self.assertTrue(isinstance(topic, list)) + for k, v in topic: # list of doc_topics + self.assertTrue(isinstance(k, numbers.Integral)) + self.assertTrue(np.issubdtype(v, float)) + + def testTermTopics(self): + # check with word_type + result = self.model.get_term_topics(2) + for topic_no, probability in result: + self.assertTrue(isinstance(topic_no, int)) + self.assertTrue(np.issubdtype(probability, float)) + + # if user has entered word instead, check with word + result = self.model.get_term_topics(str(self.model.id2word[2])) + for topic_no, probability in result: + self.assertTrue(isinstance(topic_no, int)) + self.assertTrue(np.issubdtype(probability, float)) + + def testPersistence(self): + fname = get_tmpfile('gensim_models_nmf.tst') + + self.model.save(fname) + model2 = nmf.Nmf.load(fname) + tstvec = [] + self.assertTrue(np.allclose(self.model[tstvec], model2[tstvec])) # try projecting an empty vector + + def testLargeMmap(self): + fname = get_tmpfile('gensim_models_nmf.tst') + + # simulate storing large arrays separately + self.model.save(fname, sep_limit=0) + + # test loading the large model arrays with mmap + model2 = nmf.Nmf.load(fname, mmap='r') + self.assertEqual(self.model.num_topics, model2.num_topics) + tstvec = [] + self.assertTrue(np.allclose(self.model[tstvec], model2[tstvec])) # try projecting an empty vector + + def testLargeMmapCompressed(self): + fname = get_tmpfile('gensim_models_nmf.tst.gz') + + # simulate storing large arrays separately + self.model.save(fname, sep_limit=0) + + # test loading the large model arrays with mmap + self.assertRaises(IOError, nmf.Nmf.load, fname, mmap='r') + + def testDtypeBackwardCompatibility(self): + nmf_3_6_0_fname = datapath('nmf_3_6_0_model') + test_doc = [(0, 1), (1, 1), (2, 1)] + expected_topics = [(0, 1.0)] + + # save model to use in test + self.model.save(nmf_3_6_0_fname) + + # load a model saved using a 3.0.1 version of Gensim + model = nmf.Nmf.load(nmf_3_6_0_fname) + + # and test it on a predefined document + topics = model[test_doc] + self.assertTrue(np.allclose(expected_topics, topics)) + + +if __name__ == '__main__': + logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO) + unittest.main() diff --git a/setup.py b/setup.py index 4902dc2198..45a7e6e94b 100644 --- a/setup.py +++ b/setup.py @@ -262,6 +262,8 @@ def finalize_options(self): include_dirs=[model_dir]), Extension('gensim._matutils', sources=['./gensim/_matutils.c']), + Extension('gensim.models.nmf_pgd', + sources=['./gensim/models/nmf_pgd.c']) ] if not (os.name == 'nt' and sys.version_info[0] < 3):