diff --git a/docs/notebooks/nmf_tutorial.ipynb b/docs/notebooks/nmf_tutorial.ipynb index 49e5f02bc3..fc9e31f111 100644 --- a/docs/notebooks/nmf_tutorial.ipynb +++ b/docs/notebooks/nmf_tutorial.ipynb @@ -26,7 +26,47 @@ "\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)." + "This particular implementation is based on [this paper](https://arxiv.org/abs/1604.02634).\n", + "\n", + "The main attributes are following:\n", + "\n", + "- W is a word-topic matrix\n", + "- h is a topic-document matrix\n", + "- v is an input word-document matrix\n", + "- A, B - matrices that accumulate information from every consecutive chunk. A = h.dot(ht), B = v.dot(ht).\n", + "\n", + "The idea of the algorithm is as follows:\n", + "\n", + "```\n", + " Initialize W, A and B matrices\n", + "\n", + " Input corpus\n", + " Split corpus to batches\n", + "\n", + " for v in batches:\n", + " infer h:\n", + " do coordinate gradient descent step to find h that minimizes (v - Wh) l2 norm\n", + "\n", + " bound h so that it is non-negative\n", + "\n", + " update A and B:\n", + " A = h.dot(ht)\n", + " B = v.dot(ht)\n", + "\n", + " update W:\n", + " do gradient descent step to find W that minimizes 0.5*trace(WtWA) - trace(WtB) l2 norm\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## What's in this tutorial?\n", + "\n", + "- Basic training example\n", + "- Comparison with alternative models (LDA and Sklearn NMF)\n", + "- Non-standart application (image decomposition)" ] }, { @@ -40,8 +80,22 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anotherbugmaster/.virtualenvs/gensim/lib/python3.6/importlib/_bootstrap.py:219: RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility. Expected 96, got 88\n", + " return f(*args, **kwds)\n" + ] + } + ], "source": [ + "%load_ext autoreload\n", + "%load_ext line_profiler\n", + "\n", + "%autoreload 2\n", + "\n", "import logging\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", @@ -155,11 +209,11 @@ "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" + "2019-01-31 03:18:20,423 : INFO : adding document #0 to Dictionary(0 unique tokens: [])\n", + "2019-01-31 03:18:21,151 : INFO : built Dictionary(25279 unique tokens: ['actual', 'assum', 'babbl', 'batka', 'batkaj']...) from 2819 documents (total 435328 corpus positions)\n", + "2019-01-31 03:18:21,253 : 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-31 03:18:21,255 : INFO : keeping 7081 tokens which were in no less than 5 and no more than 1409 (=50.0%) documents\n", + "2019-01-31 03:18:21,300 : INFO : resulting dictionary: Dictionary(7081 unique tokens: ['actual', 'assum', 'babbl', 'burster', 'caus']...)\n" ] } ], @@ -202,12 +256,33 @@ "\n", "The API works in the way similar to [Gensim.models.LdaModel](https://radimrehurek.com/gensim/models/ldamodel.html).\n", "\n", - "Specific parameters:\n", + "Special parameters:\n", + "\n", + "- `kappa` float, optional\n", + "\n", + " Gradient descent step size.\n", + " \n", + " Larger value makes the model train faster, but could lead to non-convergence if set too large.\n", + " \n", + " \n", + "- `w_max_iter` int, optional\n", + "\n", + " Maximum number of iterations to train W per each batch.\n", + " \n", + " \n", + "- `w_stop_condition` float, optional\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." + " If error difference gets less than that, training of ``W`` stops for the current batch.\n", + " \n", + " \n", + "- `h_r_max_iter` int, optional\n", + "\n", + " Maximum number of iterations to train h per each batch.\n", + " \n", + " \n", + "- `h_r_stop_condition` float\n", + "\n", + " If error difference gets less than that, training of ``h`` stops for the current batch." ] }, { @@ -219,16 +294,16 @@ "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" + "2019-01-31 03:18:22,816 : INFO : Loss: 1.0280021673693736\n", + "2019-01-31 03:18:23,067 : INFO : Loss: 0.9805869534381415\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" + "CPU times: user 795 ms, sys: 20.2 ms, total: 815 ms\n", + "Wall time: 814 ms\n" ] } ], @@ -237,15 +312,13 @@ "\n", "nmf = GensimNmf(\n", " corpus=train_corpus,\n", - " chunksize=1000,\n", " num_topics=5,\n", " id2word=dictionary,\n", + " chunksize=1000,\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", ")" ] @@ -266,15 +339,15 @@ "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", + " '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.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", + " '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.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", + " '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.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", + " '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.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\"')]" + " '0.028*\"space\" + 0.019*\"launch\" + 0.013*\"satellit\" + 0.009*\"orbit\" + 0.008*\"nasa\" + 0.007*\"year\" + 0.007*\"mission\" + 0.006*\"new\" + 0.006*\"commerci\" + 0.005*\"market\"')]" ] }, "execution_count": 8, @@ -290,7 +363,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Coherence" + "### Coherence\n", + "\n", + "Here's a [description of what coherence is](http://qpleple.com/topic-coherence-to-evaluate-topic-models/). Basically it measures how often do most frequent tokens from each topic co-occur in one document." ] }, { @@ -302,13 +377,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "2019-01-17 14:47:56,425 : INFO : CorpusAccumulator accumulated stats from 1000 documents\n" + "2019-01-31 03:18:23,179 : INFO : CorpusAccumulator accumulated stats from 1000 documents\n" ] }, { "data": { "text/plain": [ - "-1.7121027413685233" + "-1.7053902612634844" ] }, "execution_count": 9, @@ -328,7 +403,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Perplexity" + "### Perplexity\n", + "\n", + "[Perplexity](http://qpleple.com/perplexity-to-evaluate-topic-models/) is basically a degree of uncertainty of the model, i.e. how probable it is to observe a particular set of documents." ] }, { @@ -339,7 +416,7 @@ { "data": { "text/plain": [ - "55.22863930899718" + "2501.280703411481" ] }, "execution_count": 10, @@ -357,7 +434,9 @@ "lines_to_next_cell": 2 }, "source": [ - "### Document topics inference" + "### Document topics inference\n", + "\n", + "Let's get some news and infer a topic vector." ] }, { @@ -395,12 +474,14 @@ "\"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" + "====================================================================================================\n", + "Topics: [(0, 0.29903293372372697), (1, 0.007751538808305081), (2, 0.41698421255575224), (3, 0.27623131491221575)]\n" ] } ], "source": [ "print(testset[0]['data'])\n", + "print('=' * 100)\n", "print(\"Topics: {}\".format(nmf[test_corpus[0]]))" ] }, @@ -408,7 +489,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Word topic inference" + "### Word topic inference\n", + "\n", + "Here's an example of topic distribution inference for a token." ] }, { @@ -423,7 +506,7 @@ "output_type": "stream", "text": [ "Word: actual\n", - "Topics: [(1, 0.20201598559144582), (3, 0.7979840144085542)]\n" + "Topics: [(0, 0.04910674896578284), (1, 0.1277766177062051), (2, 0.07803764680331245), (3, 0.6584104509982174), (4, 0.08666853552648228)]\n" ] } ], @@ -440,6 +523,13 @@ "### Internal state" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Density is a fraction of non-zero elements in a matrix." + ] + }, { "cell_type": "code", "execution_count": 13, @@ -448,8 +538,8 @@ }, "outputs": [], "source": [ - "def density(sparse_matrix):\n", - " return sparse_matrix.nnz / np.multiply(*sparse_matrix.shape)" + "def density(matrix):\n", + " return (matrix > 0).mean()" ] }, { @@ -463,33 +553,12 @@ "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" + "Density: 0.6427905663041943\n" ] } ], @@ -506,35 +575,14 @@ }, { "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, + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Density: 0.8774114774114774\n" + "Density: 0.8424908424908425\n" ] } ], @@ -549,44 +597,6 @@ "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": {}, @@ -598,23 +608,27 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Gensim NMF vs Sklearn NMF vs Gensim LDA" + "## Gensim NMF vs Sklearn NMF vs Gensim LDA\n", + "\n", + "We'll run all the models on the [20newsgroups](https://scikit-learn.org/0.19/datasets/twenty_newsgroups.html) dataset, which has texts and labels for them.\n", + "\n", + "### Metrics\n", + "\n", + "- train time: time to train a model in seconds\n", + "- coherence: coherence score (not defined for sklearn NMF). Classic metric for topic models.\n", + "- perplexity: perplexity score. Another usual TM metric\n", + "- f1: f1 on the task of news topic classification\n", + "- l2_norm: l2 matrix norm" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 16, "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", @@ -629,7 +643,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 17, "metadata": { "lines_to_next_cell": 2 }, @@ -637,7 +651,6 @@ "source": [ "def get_execution_time(func):\n", " start = time.time()\n", - "\n", " result = func()\n", "\n", " return (time.time() - start), result\n", @@ -692,14 +705,11 @@ " 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", @@ -735,9 +745,16 @@ " )" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run the models" + ] + }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 18, "metadata": { "scrolled": true }, @@ -746,184 +763,151 @@ "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" + "2019-01-31 03:18:27,010 : INFO : using symmetric alpha at 0.2\n", + "2019-01-31 03:18:27,012 : INFO : using symmetric eta at 0.2\n", + "2019-01-31 03:18:27,018 : INFO : using serial LDA version on this node\n", + "2019-01-31 03:18:27,026 : 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-31 03:18:27,027 : INFO : PROGRESS: pass 0, at document #1000/2819\n", + "2019-01-31 03:18:28,047 : INFO : merging changes from 1000 documents into a model of 2819 documents\n", + "2019-01-31 03:18:28,052 : 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-31 03:18:28,053 : 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-31 03:18:28,054 : 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-31 03:18:28,057 : 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-31 03:18:28,059 : 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-31 03:18:28,060 : INFO : topic diff=1.686979, rho=1.000000\n", + "2019-01-31 03:18:28,062 : INFO : PROGRESS: pass 0, at document #2000/2819\n", + "2019-01-31 03:18:29,018 : INFO : merging changes from 1000 documents into a model of 2819 documents\n", + "2019-01-31 03:18:29,025 : 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-31 03:18:29,027 : 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-31 03:18:29,028 : 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-31 03:18:29,031 : 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-31 03:18:29,034 : 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-31 03:18:29,035 : INFO : topic diff=0.848667, rho=0.707107\n", + "2019-01-31 03:18:30,239 : 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-31 03:18:30,240 : INFO : PROGRESS: pass 0, at document #2819/2819\n", + "2019-01-31 03:18:30,922 : INFO : merging changes from 819 documents into a model of 2819 documents\n", + "2019-01-31 03:18:30,927 : 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-31 03:18:30,929 : 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-31 03:18:30,930 : 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-31 03:18:30,932 : 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-31 03:18:30,934 : 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-31 03:18:30,935 : INFO : topic diff=0.663294, rho=0.577350\n", + "2019-01-31 03:18:30,939 : INFO : PROGRESS: pass 1, at document #1000/2819\n", + "2019-01-31 03:18:31,707 : INFO : merging changes from 1000 documents into a model of 2819 documents\n", + "2019-01-31 03:18:31,711 : 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-31 03:18:31,714 : 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-31 03:18:31,716 : 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-31 03:18:31,717 : 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-31 03:18:31,718 : 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-31 03:18:31,719 : INFO : topic diff=0.431708, rho=0.455535\n", + "2019-01-31 03:18:31,720 : INFO : PROGRESS: pass 1, at document #2000/2819\n", + "2019-01-31 03:18:32,621 : INFO : merging changes from 1000 documents into a model of 2819 documents\n", + "2019-01-31 03:18:32,625 : 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-31 03:18:32,626 : 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-31 03:18:32,628 : 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-31 03:18:32,630 : 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-31 03:18:32,631 : 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-31 03:18:32,632 : INFO : topic diff=0.436104, rho=0.455535\n", + "2019-01-31 03:18:33,790 : 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-31 03:18:33,791 : INFO : PROGRESS: pass 1, at document #2819/2819\n", + "2019-01-31 03:18:34,344 : INFO : merging changes from 819 documents into a model of 2819 documents\n", + "2019-01-31 03:18:34,348 : 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-31 03:18:34,349 : 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-31 03:18:34,351 : 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-31 03:18:34,353 : 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-31 03:18:34,355 : 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" + "2019-01-31 03:18:34,356 : INFO : topic diff=0.423402, rho=0.455535\n", + "2019-01-31 03:18:34,357 : INFO : PROGRESS: pass 2, at document #1000/2819\n", + "2019-01-31 03:18:35,071 : INFO : merging changes from 1000 documents into a model of 2819 documents\n", + "2019-01-31 03:18:35,075 : 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-31 03:18:35,076 : 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-31 03:18:35,079 : 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-31 03:18:35,080 : 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-31 03:18:35,081 : 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-31 03:18:35,082 : INFO : topic diff=0.333964, rho=0.414549\n", + "2019-01-31 03:18:35,083 : INFO : PROGRESS: pass 2, at document #2000/2819\n", + "2019-01-31 03:18:35,848 : INFO : merging changes from 1000 documents into a model of 2819 documents\n", + "2019-01-31 03:18:35,852 : 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-31 03:18:35,854 : 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-31 03:18:35,855 : 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-31 03:18:35,858 : 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-31 03:18:35,859 : 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-31 03:18:35,861 : INFO : topic diff=0.334136, rho=0.414549\n", + "2019-01-31 03:18:36,922 : 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-31 03:18:36,923 : INFO : PROGRESS: pass 2, at document #2819/2819\n", + "2019-01-31 03:18:37,532 : INFO : merging changes from 819 documents into a model of 2819 documents\n", + "2019-01-31 03:18:37,536 : 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-31 03:18:37,537 : 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-31 03:18:37,539 : 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-31 03:18:37,542 : 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-31 03:18:37,544 : 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-31 03:18:37,544 : INFO : topic diff=0.321527, rho=0.414549\n", + "2019-01-31 03:18:37,546 : INFO : PROGRESS: pass 3, at document #1000/2819\n", + "2019-01-31 03:18:38,269 : INFO : merging changes from 1000 documents into a model of 2819 documents\n", + "2019-01-31 03:18:38,274 : 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-31 03:18:38,276 : 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-31 03:18:38,277 : 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-31 03:18:38,279 : 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-31 03:18:38,281 : 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-31 03:18:38,289 : INFO : topic diff=0.255652, rho=0.382948\n", + "2019-01-31 03:18:38,291 : INFO : PROGRESS: pass 3, at document #2000/2819\n", + "2019-01-31 03:18:39,204 : INFO : merging changes from 1000 documents into a model of 2819 documents\n", + "2019-01-31 03:18:39,209 : 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-31 03:18:39,211 : 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-31 03:18:39,213 : 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-31 03:18:39,219 : 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-31 03:18:39,220 : 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-31 03:18:39,222 : INFO : topic diff=0.256253, rho=0.382948\n", + "2019-01-31 03:18:40,239 : 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-31 03:18:40,240 : INFO : PROGRESS: pass 3, at document #2819/2819\n", + "2019-01-31 03:18:40,808 : INFO : merging changes from 819 documents into a model of 2819 documents\n", + "2019-01-31 03:18:40,815 : 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-31 03:18:40,822 : 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-31 03:18:40,831 : 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-31 03:18:40,835 : 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-31 03:18:40,839 : 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-31 03:18:40,841 : INFO : topic diff=0.249832, rho=0.382948\n", + "2019-01-31 03:18:40,846 : INFO : PROGRESS: pass 4, at document #1000/2819\n", + "2019-01-31 03:18:41,534 : INFO : merging changes from 1000 documents into a model of 2819 documents\n", + "2019-01-31 03:18:41,539 : 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" + "2019-01-31 03:18:41,542 : 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-31 03:18:41,543 : 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-31 03:18:41,546 : 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-31 03:18:41,548 : 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-31 03:18:41,549 : INFO : topic diff=0.204471, rho=0.357622\n", + "2019-01-31 03:18:41,551 : INFO : PROGRESS: pass 4, at document #2000/2819\n", + "2019-01-31 03:18:42,187 : INFO : merging changes from 1000 documents into a model of 2819 documents\n", + "2019-01-31 03:18:42,191 : 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-31 03:18:42,195 : 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-31 03:18:42,197 : 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-31 03:18:42,199 : 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-31 03:18:42,201 : 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-31 03:18:42,203 : INFO : topic diff=0.206189, rho=0.357622\n", + "2019-01-31 03:18:43,176 : 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-31 03:18:43,177 : INFO : PROGRESS: pass 4, at document #2819/2819\n", + "2019-01-31 03:18:43,789 : INFO : merging changes from 819 documents into a model of 2819 documents\n", + "2019-01-31 03:18:43,794 : 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-31 03:18:43,795 : 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-31 03:18:43,796 : 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-31 03:18:43,798 : 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-31 03:18:43,799 : 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-31 03:18:43,801 : INFO : topic diff=0.203499, rho=0.357622\n", + "2019-01-31 03:18:49,095 : INFO : CorpusAccumulator accumulated stats from 1000 documents\n", + "2019-01-31 03:19:05,551 : INFO : Loss: 1.0280021673693736\n", + "2019-01-31 03:19:05,749 : INFO : Loss: 0.9805869534381415\n", + "2019-01-31 03:19:11,783 : INFO : CorpusAccumulator accumulated stats from 1000 documents\n" ] } ], @@ -959,21 +943,19 @@ "))\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", + "row = dict()\n", + "row['model'] = 'gensim_nmf'\n", + "row['train_time'], model = get_execution_time(\n", + " lambda: GensimNmf(\n", + " normalize=False,\n", + " **fixed_params\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)" + ")\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)\n", + "tm_metrics.replace(np.nan, '-', inplace=True)" ] }, { @@ -985,7 +967,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -1014,251 +996,49 @@ " l2_norm\n", " model\n", " perplexity\n", - " topics\n", " train_time\n", - " lambda_\n", - " sparse_coef\n", - " use_r\n", " \n", " \n", " \n", " \n", - " 5\n", - " -1.675162\n", - " 0.527719\n", - " 7.167809\n", - " gensim_nmf\n", - " 24.738142\n", - " [(0, 0.035*\"com\" + 0.030*\"world\" + 0.030*\"like...\n", - " 3.597497\n", - " 1.0\n", - " 3.0\n", - " 1.0\n", - " \n", - " \n", - " 3\n", - " -1.693074\n", - " 0.625267\n", - " 7.035608\n", - " gensim_nmf\n", - " 2479.600679\n", - " [(0, 0.012*\"com\" + 0.012*\"armenian\" + 0.011*\"w...\n", - " 19.820650\n", - " 1.0\n", - " 0.0\n", - " 1.0\n", - " \n", - " \n", - " 13\n", - " -1.695379\n", - " 0.675373\n", - " 7.183766\n", - " gensim_nmf\n", - " 48.768942\n", - " [(0, 0.025*\"armenian\" + 0.023*\"peopl\" + 0.021*...\n", - " 5.856175\n", - " 100.0\n", - " 3.0\n", - " 1.0\n", - " \n", - " \n", - " 9\n", - " -1.670903\n", - " 0.694030\n", - " 7.131330\n", - " gensim_nmf\n", - " 46.644018\n", - " [(0, 0.031*\"armenian\" + 0.021*\"peopl\" + 0.020*...\n", - " 4.476314\n", - " 10.0\n", - " 3.0\n", - " 1.0\n", - " \n", - " \n", " 1\n", - " NaN\n", - " 0.698827\n", + " -\n", + " 0.696695\n", " 6.929583\n", " sklearn_nmf\n", " 2404.189918\n", - " NaN\n", - " 5.676373\n", - " NaN\n", - " NaN\n", - " NaN\n", - " \n", - " \n", - " 11\n", - " -1.711411\n", - " 0.698827\n", - " 7.059604\n", - " gensim_nmf\n", - " 2460.213716\n", - " [(0, 0.017*\"armenian\" + 0.016*\"peopl\" + 0.015*...\n", - " 27.860318\n", - " 100.0\n", - " 0.0\n", - " 1.0\n", - " \n", - " \n", - " 4\n", - " -1.712103\n", - " 0.700959\n", - " 7.174119\n", - " gensim_nmf\n", - " 55.361718\n", - " [(0, 0.021*\"armenian\" + 0.020*\"peopl\" + 0.019*...\n", - " 1.205277\n", - " 1.0\n", - " 3.0\n", - " 0.0\n", - " \n", - " \n", - " 8\n", - " -1.712103\n", - " 0.700959\n", - " 7.174119\n", - " gensim_nmf\n", - " 55.361718\n", - " [(0, 0.021*\"armenian\" + 0.020*\"peopl\" + 0.019*...\n", - " 1.091239\n", - " 10.0\n", - " 3.0\n", - " 0.0\n", - " \n", - " \n", - " 12\n", - " -1.712103\n", - " 0.700959\n", - " 7.174119\n", - " gensim_nmf\n", - " 55.361718\n", - " [(0, 0.021*\"armenian\" + 0.020*\"peopl\" + 0.019*...\n", - " 1.219200\n", - " 100.0\n", - " 3.0\n", - " 0.0\n", + " 12.541235\n", " \n", " \n", " 2\n", - " -1.702542\n", - " 0.711087\n", - " 7.060992\n", - " gensim_nmf\n", - " 2473.714343\n", - " [(0, 0.017*\"armenian\" + 0.015*\"peopl\" + 0.014*...\n", - " 2.253492\n", - " 1.0\n", - " 0.0\n", - " 0.0\n", - " \n", - " \n", - " 6\n", - " -1.702542\n", - " 0.711087\n", - " 7.060992\n", - " gensim_nmf\n", - " 2473.714343\n", - " [(0, 0.017*\"armenian\" + 0.015*\"peopl\" + 0.014*...\n", - " 2.271240\n", - " 10.0\n", - " 0.0\n", - " 0.0\n", - " \n", - " \n", - " 10\n", - " -1.702542\n", - " 0.711087\n", - " 7.060992\n", + " -1.70539\n", + " 0.715352\n", + " 7.061342\n", " gensim_nmf\n", - " 2473.714343\n", - " [(0, 0.017*\"armenian\" + 0.015*\"peopl\" + 0.014*...\n", - " 2.247909\n", - " 100.0\n", - " 0.0\n", - " 0.0\n", - " \n", - " \n", - " 7\n", - " -1.663787\n", - " 0.750000\n", - " 7.040535\n", - " gensim_nmf\n", - " 2287.018000\n", - " [(0, 0.022*\"armenian\" + 0.015*\"peopl\" + 0.014*...\n", - " 20.997104\n", - " 10.0\n", - " 0.0\n", - " 1.0\n", + " 2475.979773\n", + " 0.656207\n", " \n", " \n", " 0\n", - " -1.755650\n", + " -1.75565\n", " 0.765458\n", " 7.002725\n", " lda\n", - " 1939.575701\n", - " [(0, 0.014*\"space\" + 0.008*\"com\" + 0.007*\"bike...\n", - " 14.540969\n", - " NaN\n", - " NaN\n", - " NaN\n", + " 1939.575705\n", + " 16.793869\n", " \n", " \n", "\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 " + " coherence f1 l2_norm model perplexity train_time\n", + "1 - 0.696695 6.929583 sklearn_nmf 2404.189918 12.541235\n", + "2 -1.70539 0.715352 7.061342 gensim_nmf 2475.979773 0.656207\n", + "0 -1.75565 0.765458 7.002725 lda 1939.575705 16.793869" ] }, - "execution_count": 23, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -1267,96 +1047,28 @@ "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" + "### Main insights\n", + "\n", + "- Gensim NMF is **ridiculously** fast and leaves LDA and Sklearn far behind in terms of training time\n", + "- Gensim NMF beats sklearn NMF implementation on f1 metric, though not on the l2 norm and perplexity\n", + "- Gensim NMF beats LDA on coherence, but LDA is still better on perplexity and l2 norm" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Olivietti faces + Gensim NMF\n", + "## Faces Dataset Decomposition + Gensim NMF\n", + "\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" + "Let's compare our model with the other factorization algorithms and check out the results!\n", + "\n", + "To do that we'll patch sklearn's [Faces Dataset Decomposition](https://scikit-learn.org/stable/auto_examples/decomposition/plot_faces_decomposition.html)." ] }, { @@ -1364,59 +1076,47 @@ "metadata": {}, "source": [ "### Sklearn wrapper\n", - "We need that wrapper to compare Gensim NMF with other factorizations on images" + "Let's create a wrapper to compare Gensim NMF with the other factorizations on images" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 20, "metadata": { "lines_to_next_cell": 2 }, "outputs": [], "source": [ "from sklearn.base import BaseEstimator, TransformerMixin\n", + "import scipy.sparse as sparse\n", "\n", "\n", "class NmfWrapper(BaseEstimator, TransformerMixin):\n", - " def __init__(self, **kwargs):\n", + " def __init__(self, bow_matrix, **kwargs):\n", + " self.corpus = sparse.csc.csc_matrix(bow_matrix)\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, + "cell_type": "markdown", "metadata": {}, + "source": [ + "### Modified FDD notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "scrolled": false + }, "outputs": [ { "name": "stdout", @@ -1435,9 +1135,9 @@ "\n", "Dataset consists of 400 faces\n", "Extracting the top 6 Eigenfaces - PCA using randomized SVD...\n", - "done in 0.195s\n", + "done in 0.172s\n", "Extracting the top 6 Non-negative components - NMF (Sklearn)...\n", - "done in 1.069s\n", + "done in 0.905s\n", "Extracting the top 6 Non-negative components - NMF (Gensim)...\n" ] }, @@ -1445,35 +1145,40 @@ "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" + "2019-01-31 03:19:14,462 : INFO : Loss: 1.0006496938661258\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "done in 6.041s\n", + "done in 0.818s\n", "Extracting the top 6 Independent components - FastICA...\n", - "done in 0.197s\n", + "done in 0.448s\n", "Extracting the top 6 Sparse comp. - MiniBatchSparsePCA...\n", - "done in 0.862s\n", + "done in 1.343s\n", "Extracting the top 6 MiniBatchDictionaryLearning...\n", - "done in 0.660s\n", + "done in 2.885s\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" + "done in 0.133s\n", + "Extracting the top 6 Factor Analysis components - FA...\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", + "/home/anotherbugmaster/.virtualenvs/gensim/lib/python3.6/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" ] }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "done in 0.304s\n" + ] + }, { "data": { "image/png": "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\n", @@ -1486,7 +1191,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1496,7 +1201,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAe0AAAE9CAYAAAAmijrUAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzsvWm4ZVlVJTrWjSDJnmxAILWelF1ZWir1BMWnBdihhcrThyWgopT1FB5Vir0oliTYop9aWkiJLQKWaNn3dJoC9th3gE0mpZIpSZJdRGQXcff7sfeMO+84c8y1zo0bEefgHN93v3PPbla/91ljtm2aJhQKhUKhUNh87JzvBhQKhUKhUBhD/WgXCoVCobAlqB/tQqFQKBS2BPWjXSgUCoXClqB+tAuFQqFQ2BLUj3ahUCgUCluC7o92a+1prbWptXZba+1KOnd0OXftWWvhlqK19tjW2rWttR06/rBlzJ52nppWOAQsz8Xnnae6p+Vvpf7W2stbazfQsRuW6/+nKO/Xl/NvEPXw38sH2rjTWvvj1tqX0/FPba29rrX29tbaXa21t7bWfra19onuGnvnvM/AOFzba8v5xNK3Fx1ymWpe/N8Nh1TXhUt5zz6k8t5neS/+H8G5m1pr33sY9RwGWmsf3Vr7nWWdvq219q2ttfsP3vu41tpvL/e+o7X2w621Bx5Gu9Zh2g8A8FWHUek/EzwWwHOxOsY3AvgIAL90rhtUOFQ8DcB5+dF2eG5r7YLBa+8E8Kmttcv8wdbaewJ4zHI+wkswr1f/99yB+j4bwEMBnP7Baq19EYCfAfDXAP4TgE8C8A3L6Y8Z7Me24XkAPr+19n6HWCbPx00AXknHPu2Q6rpnKe+lh1Te+2BePys/2gAeD+AFh1TPGaG19ggAvwrgfwP4ZMzz+AwA3zdw78cC+BXM8/JEAF8G4OMBvLq1dr8zbdvRNa59FYAvbK195zRN/3SmFf9zxTRN9wD4nfPdjsLW41UAHgfg6QD++8D1r8b84ngi5h9iw1MB3ADg7wEcCe77x2maDrJevxzAS6dpOkHHfnaapv/kjv0agO9nidSmorV2/+UZHsI0TX/UWvsjAF8M4JmH0Qaej9baPQDeMTpP6/RhmqNvnZP31TRNf3gu6hnE1wP4GwBPmabpFIDXttYmAC9urX3rNE1/kdz7PABvAvDEaZp2AaC19rcAXo/5efuhM2nYOg+K7Yi/tndha+3DWmuvaa0da60db629trX2YXTNS1pr/9Ba+7ettde31k601v66tfaMkcasc39r7V+21n60tXZza+2eRWy3shNtrT2ltfam1trdrbU/a609obV2XWvtOnfNha2172yt/fnSv5taa7/QWnt/d8212GMj95nIajm3TzzeWvuK1tq9rbWrg/b8ZWvt59z3i1trL2itXb/cc31r7TkjL7zW2iWttW9prf3tMgY3tdZ+qrX2YHfNOvP2iNbaby3inze31j5pOf+lbRbH3tFa+7nW2oPo/qm19o1Lu/9huf91rbWH03WttfYlS9n3ttZubK29sLV2eVDeN7TWvmgZjztba7/RWvvAYAz+nzaLu060Wd3zvxqJ6Za2v7y19uTW2l8t4/DG1tpHuWuuw8xOP7LtiSOvW849pLX2I20Wp92ztPsXW2vv1pujNfH7AH4WwHNaaxcPXH8XgJ/E/NLweCqAlwE4tNCIrbUPB/BBAFgcfxVm9rECe7klZT6itfZPrbWfbq1dmFz3Ia21n2+t3bqsrd9srf07uuaRrbWfdOvvza21b2qtXUTXXddae0Nr7VNaa3/U5h/HZy7nhtcdgFcA+Cwu/1ygtfaK1trftNYevaz9uwA8fzn3OUubb17a/wettc+k+1fE48t75GRr7X1ba69cnpHrW2tf3VprSVs+ETMDBYDXu2fnUcv5feLx1tozlvOPbPO7yt63X7ac/5TW2p8s9f9ua+1Dgjqf1Fr7veWZv3UZj3fvjNnFAD4OwCuWH2zDjwE4BeAJyb0NwIcBeJVf09M0vQHAcTgJSGvt3dv8u3Tj8q5427J2r1wt2WGapvQPsxhwwizWeAFmccl7LueOLueuddd/MOYXxB8A+HTMO/vfX459iLvuJQDuAPBXmNnCx2N+yCcAHz3QrqH7AfwLAG8H8OeYRXafgHmnswvgCe66j1+O/SxmMc3nAvg7AG8DcJ277gEAfgDAkzG/uD8NM4u5FcBDlmveY7lmAvCRAB4F4FHLuYctx5+2fH93zAvhmdS/D12ue6Ib69cDuAXzrv1jATwHwN0Avr0zVhcA+C3Mi+a/Ln39dADfD+D9Dzhvf4lZPPyJS7vuBvDtAH4Bs9jz85brfoLaMmFmdb8J4FMBPAnAm5d+XeWu+6bl2hcuc/YlAI4tde1QeTdgFg8+YWn79Zh3yUfddc9Yrv2hZX6fhHntXA/gMnfdDQDeuvT90zGLxv4IwG0Arliu+QAAfwjgT2xuAXzAcu7VAN4C4LMAPBrAfwDwvQAe1lvTo39LP74BwAcua+fZ7tzLAdxA19+wHH/scv17LMcftZT13gCuA/CGoJ5vxLz2Tv8NtO+5y9zv0PFfA3ACwFcAeL+Rd87y/XGYxfffC+AItc+/e/5PzGv8DcvcPR7Az2N+Z32ou+6JmMnHJ2N+hp+JeTPxCmrHdZjfHddjXs+PBfDB66y75dpHLNd/zGGtgWh+xblXLGv3rUs/HwvgkW6e/j/M74OPx/zMncLyblquuXBpu19j37Jc92eY30Ufh1kNMmFmpqqdD1iunwB8AfaenUuX8zcB+N7gmX0zgK9e6vnh5dg3Y37+PmMZ/7dgfl/79fHFmN/pLwbw7wE8BbNq5i0ALk7a+fCljk8Lzv0dgJcl9zbM78wXBOduAXC9+/56zO/Rp2B+V3wG5nfyQ9P5HlgQT8Pej/ZVywL4oeVc9KP9k3AvuOXY5QDeCeCn3bGXYPUH9v5Lx75voF1D9wP4QQA3A7ia7n81gD92338L8w97c8fsh/O6pB1HAFyM+aXyJe74tcu9/AA/DO5H27Xlt+m6/4Z5I3D/5ftTl/seTdc9B8C9AN4taePnLfc+Iblm3Xl7tDv2wdh7uPxD8x0A7sPqi/YdAC6hMbkPwNcv36/C/KJ9CbXxs7kfy/e/BnA/d+zTl+P/1/L9UgC3Y1m37rp/uYzdF7tjNyzjfqU7Zi/dz3THrgP9yC3HjwH4ot76PZO/pS3fsPz/smWOHrB8z3602/L/s5fjLwLwm6o/Sz3R3/t02vcrVi4dfz8Af+rKeQdm9vI4uu5p2HvnfNYyR88T4+DfPa/FvBG7gJ7Pv8Isllcv2aPL2tqFe08sY7IL4OGi7nTdueP3w/wj9zVnaT3cgPxHewLwCZ0ydpZxeBmA33XH1Y/2vh/oZRzfAuDnO/V84nLvRwXn1I/2V7pjF2B+Pu/Gsvlcjn/Gcu2HL9+vwLyBe1GwBk8CeEbSxo9ZynpscO6NAH6p08c/BfAbQb0TgNvdeN0L4AvWne+19EjTNL0TM5v6nNbavxKXPRrAL07TdJu77w7MO97H0LUnpmn6dXfdPZgn/rTIss0W6qf/1r0f8yL5ZQC3UzmvBPAhrbXLW2tHML+Yf2paRnQp7w8w7573obX2GYs45jbMC+A45h8GNSY9vBTAo9piLbu07ymYWarpnj4R8275t6gfr8L8UnhUUv7jANw0TdPPJ9esM2/Hp2l6nfv+puXzNdN+cdKbML8IHkr3//I0TcddPTdg1pt9xHLoUZgfTrZSfgXm8eb2vHqapvvc9z9bPm0dfATmDciP0tj9/dLGR1N5vz1N061JeRl+H8BXtNae1Vr7oExcaGitHaF1vs5z+VzMa+8rehcua/vlAJ7aZgO2J6FvYPRDAB5Jf3/fuecazBtlrv8tAP4t5vn7RgB/jFlS9crWWqR2+2LMm8RnTdP03KzCRfT8GAD/C8Cum+MG4DVwc7w88y9os57xHswbxpct174vFX3DNE1/LKrtrTvr932YN43XdPqQvevOBCemaXplUN/7t9Z+orX2NszP1X2YNy+j77HTxrTL2voLjD0j68JE6pim6V7M7+S/mKbpH9w19g76F8vnv8NMpviZ/7vlj5/5w8R3AXh0a+2/ttYetKhMfgTzxm136ceEWar5Na21/yLUKiEOYvzxnZh39s8X56/CbCHNuAkAy+pvDa67B/PuDq21h2FeSKf/lmND9y94NwCfw+UA+Lbl/NUAHoj5h+/tQXn7jO5aa58C4Mcx794/E8CHY36R3Uz1roOfxvzDb/rGxy3t9i/UdwPwnkE/fs/1Q+FqAP/YacM683ab/7I8SMDqfNhxHpfIkPGfMKsKrC3g9kzTdBKLGJ3ufSd9t42O1Wv65Ndgdfw+CKtjt688t3Eamd8nYd7ofCXmHfc/tta+rvND/Fpq09cN1GNt+zvM0qRnNbIfEHgpZvH+cwFcgnktZ7hxmqY30l/PiOlC7M0Bt/fUNE2vm6bpa6dp+jgA74X5x+65gS7vyZjX7U916gPmNXEEs/qH5/i/ALjSzcEPY2Zx341ZLPxIAP/Ztd0jeiYMvXXncRcAqdMeeNedCVbsCFprV2B+Ht4f84bvozCPw49ibJ2fWjb1HvzuPSxE75Xeu8ae+TdgdT28L/L3pZUd6Zavwuq8M34Isyr5azH/pvwZZqnMa7B/PX0aZgv15wD48zbbWKR2AcB61uMAgGmajrXWvhkz4/624JJ3AnhIcPwhiH9kM7wN80LiY+vgFsy6A+VK4HeZkbHQgzGb/RueDOBvpml6mh1osxk//5AMY5qm4621n8EsCnwu5t3u303T9Jvuslsw7zA/QxRzQ1LFOwD8m04zDnPeeniwOGYbC3soHoJ59w7gtATiavQfGsYty+fTfHkOyt1pbUzT9HbMPwD/eZFGfS5ma9KbAfwPcdvTAXhXrHXX+Ncv9XzNQPve0lr7XQDPxqz2uK13zwFwC+IXXtSet7XWfgAzO3lf7G1CgVn3/H0Armutfcw0TaER24LbMLOY74GQHkzTtNtmI7b/G7NY/bvsXGvtg1QTR/oxgKswP4cKh/GuU4j68O8wb5I/dZqmN9rBdgguSRsCe+Y/E/MPJoM3HB5vxvyb8IGYXRQBAK21SzFLEr4/q3hh0c9urX0DZhXcP03T9PbW2vWYVaF23U2YN4/PaK19AID/iNmu4CbMG8sQBxXBvAjAl2LPotzjNwA8vrV22TRNdwJAm31DPwWzjmgYC4N7Y/fCHL+KWTz6F9M03aUuaq29EcATW2vXmoi8tfahmAfd/2hfjHlCPZ6KVXcZ23VfhLEfhZcC+OzW2idgNtDiDdGvYn6JHZum6U18cwevAvDk1tqnTNP0C+KaQ5u3ATy+tXaJicgXRvEozLoyYBaV34t5g/Rad9+TMK/ZddvzW5jn4H2mafqRA7d6P+7B/h/aFUzT9GbM4q9nINk0LdcdGMsP3/cA+EKMued8K2bp0wvPpN4EkcoBrbWHTtMUMVfzvOAf5X/EbDj16wB+ffnhDpnvsvF9PYAPAfCHk7ZGvz/mZ/U+Ov40cf0Zo7X2EMwMUM7zIb3r1oF5HJwehzZ7ODz+LNfr34tnE6/DLN14r2mafmydG6dpOtFaey3md+Y3O5XfkzGvHfUO5XKOYVGZtNY+FfMP/ovFtX+JWa32THQI1oF+tKdpuqe19nzEjuZfj9kq87WttRdg3uV9FeZFokTqZxNfh3n3/rrW2gsxM9IrMQ/Me03TZAEynov5x+1nWmvfh1lkfi3mF4l/Afwq5iAV3wngFzHrwr8QJDLGbBUIAF/WWvsVzOKk7KF8Lead9Q9iXtAvo/M/inkn9trW2rdjtpy8ALPl7xMw75hPIMbLAXw+gB9bpCS/i/kH5xMA/LdlE3Au5+0uAK9qrX0b5pfo8zDvfL8TmG0nlj5+dWvtOGabhH+NeZP4BqwZmGaapjtaa18B4HsWEfKvYNYxvjtmPeh10zSF0cIS/CWAZ7bWngTgbzFvCm7CLAL7Ucw/XPdhZnVXYl5bZxPfgtki9zGYbR8kpmn6acwqmbOF1wH4j621q6dpusUd//PW2mswz+f1mO0MHo+ZbfzENE3/mwuapunG1tpjMVue2w+3YqBfutT9ytbaD2IWRT4Qs1X5kWmanj1N0+2ttd/B/FzeiJn9fh72VDNnAx++fL4uverc4vWYVXIvXt7ll2N+V/4TZu+Xs4U3YX6f/r/Ls30vgL/yNi6HgeUd8mwA395auwazDdOdmOf5owH8yjRNP5kU8XWY3zX/s7X2YsxGkd+G2eDvz+2i1toXYCaxHzlN0+8uxz4MszHbH2FWQT8GC8ld7KTQZlfbn8Ps8fRmzPruT8f87j/NxiOcSUCDH0Ygdpim6U8x747vwKx8fxlmi9rHTNP0J2dQ34GwvAgegflH7pswD8j/wDyQv+auezVm8fS/xiwS+SrMkWxuwvyCN3w/ZiOaJ2HecT0eMxv11wDzD/qLMLtZ/DZmA6WsnbuYJ/DdMRtC/Q2dvw/zj+z3Y345/zLmH4fPxcwk74XAcu/jln7bvS/C/EJ753LNuZy3l2L+4X3hUtfNAD52MXQ0PAfzQv/3mMfy2ct9n5SwKIlpml6MeXPzrzD37Zcxb8qOYjaIWhcvwLzR+gHMc/tizBatf4h5g/STmNfRRwD4rGmafk6UcyhYfhy/42zWsQZ+DvNYfDIdfw7ml9LzMW9ifhzz+Dwbq/7jp7GIER+LeRN0XRN+ttMcnOORmEWj373U8V2Y7Rb8D+ZTMBsBfQ9mQ7ebADxrvHtr45MB/AE/0+cTy8bniZjn46cwb9r/O+Z1ezbrvRHzWH845jn5fczzczbq+m7MP4T/BvO78pcwk7MJe0aD6t7fw/zueRjmd8XzML97P58u3cHMvr0e+l7M75qfwDy2Hwfg88iY0lj4M5Zrfgqzq9mTpmn61axtzRlLFwittffA7Hf5jdM0ff35bs+7AtocZOYbp2nqBukpbC9aay/B7JLzcee7LecTiw79RgBfPk3TD57v9hS2H4fpVrDVWFxGvgOzePMdmK1avxJzMIgfOI9NKxS2Ec8D8FettUd01ELv6ng6Zgviw7KlKPwzR/1o7+EUZmvlF2K2UD6OWe/zH5TxS6FQiDFN0/VtDtV72OFbtw33YA6kxMarhcKBUOLxQqFQKBS2BFuRWadQKBQKhUL9aBcKhUKhsDWoH+1CoVAoFLYEG2WIdvHFF09XXHHFoZTlw7dyKNfe99Fyz6RNZ3ptdP4g95zJtQcZizNpg9lfvOUtb3nHNE374mxfeeWV00Mf+lDs7OwcuG1cj/+fP0fuHT23zj0HsUFZ556R+kbblI3ZOmNxmHY3N95448raueSSS/a9d2zt2FoCgCNHjuz7tHN8PHrv8OeZYFPKOFtYZ72vs1Z3d3fDz5MnT3brMVx//fUra+d8YKN+tK+44go8/elPP6My7GG64IILTh87enTuJj+Mve8e6tzIA6k2CdkDHrVB3csvEv6M2qFeKOrTl6XGbZ2xUNfaXEX1nDo1RxN89KMfvRLx65prrsGP//iPn553+8zm0h5cK9c+7UH2/993333htfwS8OAXAV/D9ft7ei+bbGOh6o+u69Xnx8Kg+s7H7V7fbz7G9fJ3f89h/Hhfe+21K2vH3jtW/v3vf38AwCWXXHL6mksvvRQAcPnllwMALrvsstP3AsDFF89RQS+6aC86p63l+91vDufNP+z2mfVLPYcjz5qVmz1z6j3TKzMqn9uc1cHPgtoc++ui58VfGz2/9tzee+8ce+r48Tnw2okTc/DIm2++ed93X4/Nl+GpT31qGmnwXKHE44VCoVAobAk2imkfBiJmqBio2hGuw0izNqhrRph2794RqJ2wPzcKv+O1HWhW/iiyfvNOtzfm97vf/U6zm0jaoFgF79w9emJcxZ6zMkaYFX/ntenb3Bv/ERG/YtoslYjapurn+YuOWT8ytmZ9V2N+ppimad+YRNKMHuPlNnpYeT3VTfacKlZ+kPdB1DZVH9ebrR01h74Ofi55nWXrgK/hebLP7N3P7weTqnimzdK0daURZxub1ZpCoVAoFAoS73JMm/W70bHIaKSHHhNex/AtOz5qtBLpmNfBuvf4HbbagY7YBKhrM925wXSDEYxp29zyjtqXxzoww4ixmWJ50b09tnomRlcju39lyOfb0etz1sYz0TErewWD7x+zcZvjTEJyJojKPcgzPfqMrcPkzsS4LZo3xV57tjXrIHsfsORlRApl9yh7Ev+9p1+PfgvU+2FTUEy7UCgUCoUtQf1oFwqFQqGwJXiXEY+zwYEXuygjhJ5bFdB3m1jH1SvDuqK0dYzYRgzfDMrwJRqTnhFJVu5I23l+vDsYo7WGI0eOrMx11CZudwblksSis0hUpwxluOwR9y0+H0GN5YgY+0zE5ModbUQcP7J2bC4z97rDxEGM7rJ7lKvXiEsmj9OIy5dSx2TuggcxgO1dm72rDDwGmeEdrx1+BllsHrVBjbn/veC1bu5im4Ji2oVCoVAobAneZZi2ilgE7O3U+Rq1A86YtoF3cJEBEuMg0bJGcBAWuw4rj74D40Fdsjbb50hEqV65Ozs76TroMd4oeIMKvKICs0QGez0mOsJ8RsZUsYiMRavgLVmQFT5mnzwG3H/+37eRjcsy5nq2XcBUW30b1jFIVVLAEaat6o3AblRqzUSSj57EbR2p4UhUwp77bSYhU5KyEZcvPj4iSdw0FNMuFAqFQmFL8C7DtI1NZ64+aqfLu/3sXj4e6Y96oSENWSAOtQNWIfaie7Pd7Ahr9fdkDIKvyViuqicLhjLK4FtrK1IVf0/P5SoLncjnFMvMWLoK9xmNTS+29YjL34g+ntuv2pj1y0JFqvoyFyPurx2PQsky1mF/Zwruk7IXWMfmIDuurslsNbhtyjUzkuyotmbouYeN6N3Xkc4p6VMmubI22hpdJ/RyFIZ3E1BMu1AoFAqFLcHWM20LQ2eBNzhIP6AZ54ilpArIwmVlTDvTexpG9eAjFsFKhxntZtcJkNKrL2sbhz5V/fISBCURiWAsm5lp1E5lj6CkG4BOjmGWpVmyAt6xcxkRE2Ur+CxojAr3qthyxJo5KYd9MhP35Y3MYQ9q7COJi9J3r2Mlf6ZQ0gRuC6DXL7Nmw0hSnkwPniWV8feOhNpV1utRchv1Pl1nPrJx7F2TjRE/N/wsZPccpB/nAsW0C4VCoVDYEmwt07adETNsZnT+f7aqzJiVgtKPR7sxFQYvsu5UVrsj6AW2z3RKozvsCIphR4xOsUGWVGS68wytNezs7AxZuyrGFunXVAhcbqMx0szzwJg39zWyOGcWzvPkU89yfdy2zDqe9cVqDjOLY+U/P8JQVMKQCDzW51LXqEIfK4lIdK1qb5RsJGK2Hux1EYHnNpNIKJ29tY1T1Pp7etb80TPNbeP3qI3niERRSbD8MavXfi8ye59zaStxEBTTLhQKhUJhS7B1TJt398rKdsQCXDHFTMfIzDALOK8+IzbI+taejjvagdvulfsZWZz39PzMHDMLZxW5zPePpQFqB+1ZG7OIEYv3TK9mLEEx3oxpG7O1nTrv6tma3J8zvbd93n333fvaMWLNzZ8jvqjKQnbEf5ZxEAlItHYU61fjCezNgWd5/pqzxbj9+uP5t+/2GUkbetbVma3LaN8iGxD2eWdWHnlH9J5LtnEA9uaD62N2nvVBefTYuI68x7kPmceI1XPRRRcB2HsWo/V9thPTHBTFtAuFQqFQ2BLUj3ahUCgUCluCrRCPRy5YSlydiQ85GASXHxmTKOMKFRYvaguL/iKxojI4UkZLmchpRNTeCwU4YkTEAW0yt67Mpcef9+K3ddzO7Hq+JwrSwUY37BbiRZ0svuUx5fXnkwuwePyee+4BANx1110AgBMnTqzcwyJ83zfftsxYjseAxabeHZJdYRiZK54KdmHIDN/YHY7v8f23+61eGz9WFR2Wa47VY+6kAHDhhRcCAC6++GIAwCWXXAJgVRTsoVy8WMWSBdnhwDWGzF0wc3tU6L1fIrWFUhFaGSZ6jtzElBicx97PAasiRgzfWCXAho9syOz/t88SjxcKhUKhUDgQto5pG5S5f5TggA1+1M422pnaTo9dbOxaY0mRCw7vHtVuL7qnxxrWCfsXuTWo3aNy9fHtYXc7vxv21/o6eHccsVpuI8+xZ4gRpmlKQ8X2DNsyxsb3cvtHjBgNtjaZcUV1KzeuTPqkgsdkgYDUfDPDB/qJd/h5i4K5KBcj7pM/x5IqZpaHZZAWsS97vs2AiSUukeSA30UcStMQuW9lLnfA3nvH16fcwKwf1vaRhCFcX+TyxeesXyZROn78+Mq13CbrB0sjIokTS5lGpIK8ju1dZW2LJEksESmmXSgUCoVC4UDYCqbtd32ZLtlfG+1AlV6Ima/fdapdMu8M/W6MGTazsijAgAoBySwmYoOKdY/od7k8doeKdpncZ9Y5Zm4w7EYRsRpuvwpskiGaSxUEJGOGDDVerMfz51Q9hiz5Ry+saXRNz7UrcvlhZpMFDVIBgFjvGbFPHmNjWsrGImoDM+tIt7kOO2qt4ciRIyvr1/TYwKqUh8PXRhIJ67exO2UXwTY3/l5eZ8Zio7Vk+nYuz1il2VBceumlp+/heWb7COV66P/neeb5j2yE+Nm2sVYudRGUPYmNkT+mJHv87oraVAlDCoVCoVAoHAhbwbT97tt2YrzzZVYzkuBA6TAjdqYsv1mP4+/hHXumv2X9owqbmFmpMnjH662Urb2801Q64ZGwoDxWfpfMO2vewUcsuhce0cPCmPK68OWqvqkwt/6cWjvMeDzTtvG2e5kJROuSJTisL8wSHKjgKlkAGGZuIxbYLBVi5si6epVa0987MsdKzxuxXL6nBz92mReJza9i/5FlPj87LF2K2m3Pjnr+Imkdh+jksTSm7eszPbfVx+8Bnh+/vm3tsFSA+xBJkvgdadb4/H739jK8nnoePcDeM2d9V5b7kbeRwUtcNgHFtAuFQqFQ2BJsBdP2uy3eVavdd7S7VyxCpd3053p+4ZF/Lu+OeecZ6aVVG7lf0e6Vd9/2mel6mB0ptpalulR6d18f99PGoue/7a/xYxyy4toRAAAgAElEQVTB6yUjXRXv0JVNgwcznZ4ezXyIgVUJR2Txy23kcbC1z5banmWo0Lo8/9kzkYXyZfBaZcmBkqb4NnCYXGalfi6UPQn3/6BM23TabCEetVutlchfWyXH4LVpz170PuD1xRIJX7atPV4Pnh1z2/l5VPYCyh7Dl6H8tiOvFesPf7K3TuSnzWUpC3vffq6XdfmRpMX6rGxhzheKaRcKhUKhsCXYrC0EIdOJKJ1ixpqYNSqdkmd0PT1RlpKT2QTXH0UMU9aNbK3q7+XylOV3FClI7ThZh+93uXYtW3pmekkbC9vpMpM0RLqlUT1ra21Fvx6xS2W5bMj0qqYbu/XWWwEAd955J4BV615gj/koC91IisGsixloNMbMpJgtMbuNopsZeP1Fls0cyY3H05iqjYlvH+tqDdY/Ww9+HUT+7B485/7+SNrDaK3h6NGjqf+v8rHm+fL3WLvuuOOOfd9HIsdZubxGbWwz6QKXp5Le+GvY/oLXqn2PdMzMsNm/OZJY2LOhbCmsrZF1PL+32Y4lY838e8GSLGDV3uewIu0dFoppFwqFQqGwJdhIps1s2u+klJWzivMLaOvVSO8JxDtsvoYZY2RpqvyKM+bAUgDe7WWRt7ifI3GRVf1see532Ny/zKeXwRIR9vHM/LUzC/ZpmjBN0wozjaQ0aiyjsbV2HTt2DABwyy23AFjV49522237rgf22MQDHvAAAHtWqNbnzJdcSV4ii3Nm0BxXmaVPkQ7dwGPAEhIP7gdbVtuY+TGxMTBrYRujLD6/iq2unpGDwNcX+Qar513Z1gB7EgmWTHDcchu3qA1sc8DPpx9bawv7hTMzzewh2A6DJVaRXYyBo8XZ+SjFKbfFJFdsd+LbauVddtllAICbb74ZwN46t/p9fRzDnHXa1p7oHdmT8JwvFNMuFAqFQmFLUD/ahUKhUChsCTZSPG5ggydAu3uwQZMXd6jgEwYWI/r6VFALdiWIRLfKvSUSqSvXCwOLyyKxmAorGRkvsSsHi9DsM0qvxwkIWDwfiRd76RujgAmRO4aCBVfhpBUZWLxv9fh7TXz7zne+E8BeSEgzirE2Wp/tOABcfvnlAFYDRlgZUUAOnnc2dMrcWrgfLAKMkkOw+JPFvJHImdUMVp+tByuT1QH+nJXBATq4Dt+PyDXKf49UBiOwtcPjFrmd2XtmJH0jjyWHx+SgHVGbbe5MxWL1R6ky7ZyFKVXuin4+VH/YuCtKAmSw+kzsPzKXyo3KnjdbF36M7J6rrroKwJ64/Pbbb9/XRmuH76v1h5+J6F2cqUs3AcW0C4VCoVDYEmwk02b2khml8M4tYiLKLYMNqCLDIHWvHR8x8lJh/qLdpjIMMkSuENZnO8cuQFGYR9ulqjSOdq0xxyggA6cltfG03TFLPzxYQhEZnihjrAitNdzvfvdbYdhRwAoVXtLg59TuMeMXZkdWBrPZCGaQxNIh37/I5cm3KTLE5JCQ3AZbq1ECD8UUs3CwbDTI7kg2Ruz65a/l/vBzHBlaGlRYVn/dOsZDZsTI9USueEqKEbknWjttHKyd9t0YYfScsNGd3WPg59W3xcaf2XEUkEW5XEbzAOx/t/DzzvXbuyNK5MIutFdfffW+trGRo2+THWPpQzRWbLipEhT574dp4Hg2UEy7UCgUCoUtwUYybUMUvpJ3vErnHAUDUSk4VfATYHV3x3qiTMfIbeYdYRQghWH1s8sJMyEP5YIVMUtmdMx8skQeStoRMW0eL9bRRm3LEiowjGlz+ZErHru3GFj/BawybGMappfO9O7s1mb94OQIfq3aNUqPH+36Wfqk5j06z1IgZkKRDpL1nirEZpZSlSUY3N9IksTrjs9HjH4Uu7u7K+5U3j6Bnzf7btdEUkFmuByghSUkfozV+0aFT43ayCF9rX4vLeqlCeX14Otg+xoOspLZEjGLZZ2zkjj5+mztmO0I9wlYDU6jUo1GqZxH7GLOB4ppFwqFQqGwJdhoph0Fqe8luMh2d8w4ePea3aOCHEQsUCXBsB2u3RtZ1TKb4J1vpOdVTIR1zZFtgJIycJCayNK9pyP286bmiev3LJB3w1lwFasjC8vJyVZUooPoHi5XJaaJduwGtqq3NeyZj2LNzAIjxs1jrGwoouQ2KhBL5unAQZCi5DncDsXCRyRXymrc4AN/9NaKh0lpojVo4PayBXj23lFBiLieEYt39kSInmkDs0t73xhD9W3gZ4HnNHrv9MKyRuOpEu+odKtZOGr13vHfOWxuFJTG1x/1WUlBzxeKaRcKhUKhsCXYaKad+V8q3WuU2INZpEo/Ge3qlGX5yO6LmSizJd9GlQJU1Z+xAd6BRmnuVCJ5LitjWkrvGlldKl1tNo68Ox7VbXtE1ry8rkaSwHD5ancf6RiVFCWyHuc+cnrNLIytknQoyY8vl+c5s21QUi5OtBCtLSU1yb6z1IElMCN2JRlam1NzZu8Bq4PtNdjP3TM4td64nsj6ndkkh+PMngWlr7V7vV6a7S3UsxCxTl4zzNoj2xqVKlV53ESSK9WmaK2yNEiF6Y3CHXM/NwWb1ZpCoVAoFAoSG820DVlUJsWi/W5J7XAzXba6l+uP2sgslvU3UeQwZS2qdoi+zUpHz233u3MVDD9KSMFQ1slKT52VwTv8aN5G2sT3RBKJXnmKBQCrUbnYXiDyn2coW4CIvfTamiX9yHSKvg5/jtcsM5AoahufszFgi93IT5fr575kUq91JCMjmKYJu7u7K/EOMmmWkhhFdhxZNDt/r38+WTrG0o2sTJ5DaxMnKsnapN5vkQ6d7SKU/Y+/X3k0sM1S1C9+JtT7z//P0jqVEjRqf/lpFwqFQqFQOBDqR7tQKBQKhS3BVojHPZRLChs/RCJAZZCTucr0RM+RCDAybvBtj4w6lJhKia+zAPfKQCczzlMi1ghqrDO1gzKwYxePSJzNZShE92YuZAojfeecxVECB4Vs/bE7IAe5iESOKre8IQuywyFplatPFE6S559VBlnubxXkIht7Ffr2MMSXp06dSl0M2V2P13NkGJYFKIrujYI6KRfAKH+3wdrPebqtD5aUI4Iy9uLzvm1sgMjzH61vNhjmd2a07tT7bERdwu8s9Tvi28Iqyk1BMe1CoVAoFLYEG8W0zfUiM1bhHRp/ZrvbHiPhOvw1iiFaW6OAFRx0n93VMqMrPp5B7eSz1Jzcdy4jY7W8W1ZMOzII4XHktkWhHFUbGb5/GQtTc8jfo/vVteskF8gM9FRADEPE6FT4UhUCM5LS8Hyo+oE8aE9UX+aeNmIUynPZY4PrYpqmfUzbEL0H+P2TBdBhiVqvz5FkistiiUg0tjZn9mkGaNGcjibHyNirnTPGzW5wflw53CszYDXX/n9+1ysDNf8/J3hSBsYebMS2KSimXSgUCoXClmDjmPbRo0dP76A4HCKg2Vamjxpx7eJ7DMr1hnWYnp0pPdRIWLyeLilqIzN7Zk8RW1L9YnaUudBxGRnTVm53vbC0HuuEE+R5itqpWHPE2Hs62IwZqLmL0h+yjo9d49YJ9MBtjALlcLnMKmztRGPC6y1jLYYeW47YEvdDBY05E8Y9TaupOaP+qGAq0frNnge+lqH0tcrGwV+rpDPRe4Clmj0bl+i9yu/rLCWvXcMJQtilMrNJ4Wc7s4tg/TTXn7HoTNp0PlFMu1AoFAqFLcFGMW1g3n0yI83YktJP+h3hOkzAl8n/R/VEFpJ8r7rG90sFGxjRvfBuUSUo8DvGnv4zC+bC9/Qs7KP7e3o+/z8nTVForcn2+/aqvkc6bcV8VVlRfYrBRf1h+wc+nkkxDMrWINJ9c/pT1pmyRMT/z4xbMcdMSqPGM6uPx3V0fShYcJWDhKvkeYos85XNgVqH0TVK5xyxSg4kot4PUXk8piroky+H6zl27BgA4NJLL12pz8Dvz5EQxarNhmico7DWvr6IRatnflNQTLtQKBQKhS3BxjFtYNV/MbKqZD1utlNX1q3rtCXTXar6lDVqlNKuZ7WZ1cdWo1xfxM4UQ1BWslGbuD/ZuHKflX4vYiqGnn+1vz+zJFWsOdKJKXa0jpWtuifayStdZqYPZYap2FJmAczPWqbHU6F1R6QnPdYS2SIwslCnB4WxbSCeA15XzC7N99kstf21PWaYPWMG5T/vn2P2deYERZENBY+hmls+7+th3TYzbl/HxRdfHPaT4xJka1bZk0T3WJ9tflSK20i6xsl0NgWb1ZpCoVAoFAoSG8W0p2nCvffeuxJ9iK/xsB0a3xOxl54/aXSvYmOGKDIRM1HFeEZ0JetE+4n0j/54xEyU5Xemy1ZRi3o6u6he9T3qT89f0vfPrEMjPT7vtvl8VE+PgUT96OltozKUp4Oa26hcdTzydDBw1Cy71sYvsopmP1y2COYUsVEbs2ePj/X04WcCX2+UFtLGgRPtjHi6KAnEOs+LYqR+Lm3uOHGLIWL2yu9cjW32nrN+8bNnjNtfoyzMR+aytw6iMhSDjyzuOZnIYayvw0Qx7UKhUCgUtgT1o10oFAqFwpZg48Tjp06dSsN9KiMXFmVEQQeU4cqI2w4jC67CYsGRsIUqmEEv/3BUPmMkpCcb9mWGINlY++MRWKSmXM18mzhcoYJ3+YoCibCaRH169xM2WFnHVYnXSM/4z9fNwSZUIImoXBaHq8+oLSwmj1QT/FzyGLH6IXL56blsRgZWfO4wxZa7u7srLqa+DWr8rf2Zy5Ka90wczmPGYnH7Hq0dE4tbWFFWtUShgtUznanAuPzo+fHXAXuichsTW2frqEmUGJzb6qHCX7MayB87TEPHw0Qx7UKhUCgUtgQbxbRba9jZ2UlTozE7UQlCMlcBtYPKdlaKCUS7fsW0bbfHBju+vcrtJGMVzHy4nxFbUvWxm0PmJqI+o3HusVtuly9nNPDCqVOnVnbUkbugSlLA/YuOqUAsUbhPO8ZrhBmBN6LkZByqfP9McPk996AsrK0KKOHr67n4MePOjAxVPZELTs8g7UyRGX2qsTWo9RxBPS9RQBk2QOPPCy+88PQ95tbE644lVv4eW2887sqI1q+dEydO7GujGZeZW1f03PJ7hg36sndwb2wjiQ6/59SzkgWe2jQU0y4UCoVCYUuwUUwbmHdLmVuDvw7YY60Z1nVNygJy8CfvYv3/o+5iUd28I2T26vvNu0alJ8x28syeWF/pd80qQMrIOCqmuk7glAjTNOHkyZMrO/bMZW3UxiE6xzt0Zjf+f9VHDiLkrzXWZJ+mF4yYMD8nKjCK1W9l+nJ4zXJZkZSG55RdjgyZ7YZaq5FrEbftoGFLGWZLw2kqI+lCj/VHyIIceUTPJ7eFpU++3uPHjwPYY7Gs27Y5vvzyy0/fY6ybw9fa+4UToXj3LavP2nTRRRftu9bK9vPPUkh2D2RkgWDU2I+MIz+3mWRn03TbxbQLhUKhUNgSbBTT9ta/QO4kHznFWxlRuf5eZXkeWQAzW2I2y9a+UdtGGIFiYayLifrX081m9SvLcg6JGNXHO1FuWxRUI7Ogj9rh0dNpGWOK2uLbzWsmswBndsd6YbU+/P9cPjMvz2KNBRvzMTZjbMk+o7FVUgxuj2faLElhm4BoHfAccjAKLjuzK+A+RHOg7EkOy3rc1g333a8Tnl9uS+bpouxtlCV6VA+zVzt+9913n77H5tXYsK0hK9dYs7/Hztm6sjJMWmL1WR9Mj+3LN9hYWPlRcB0rd8RLBYifxV6Qqmgc+Xm1tmceFXbPOimBzwWKaRcKhUKhsCXYKKYNzLuaET9GlYCC9VIevbClzKqic8p63ZfJDJv9VjMWq3Sx3Da/A+WdoH3nMjKmqkKtZvpwtsJW1vLZucNi2tO0P71iJnHhujK9pNrFr6PT5L5zOkwPYzzGlpg1RaxWMTZmg1lYxp40KNMtclhb1Q4PZS0c3cOsX6WpPFNktgE2/mzdz+2OQoSOxjGIWKXygY7GiUPOqnCy3m/amLXVbeeYiUY6dJbOqAQ/3v5GpSvt2QxEx0YkLdZ+6xfrsrmfUbmbZk1eTLtQKBQKhS3BRjHt1houuOCCFR++zOda6fH8TriXFnJk56YsQKO2qShDmZ6Q61EWkRl7UYk8It0SSwq4vGzHq1iZ2kX7+phpZ77dqnwFz7SZqURlq517FNVMRcDreQgAq7EEjHlErI0joCmdeSQNUn7h62AkDgKPrdI1Zs9IL+rUOj7ShwWeyyiJhGep3E5um2Ke/JxE+lRbBzwPPLbR2uGodnaPvVe9TlvZdxisvxwxEdjzy7Z6+btd670JuF/KeyBbw0qyFK031mFb+fw9YtqbZjVuKKZdKBQKhcKWYOOY9tGjR4diTStdY2Q9rJLNs16Nd7P+nGLY2S6Zy2OmlVnKZztqvlf5PNpn5Muu9JDKmjLSt/V0PVlEtJ5eNLqmt/Odpim1JOUdtLJxiPT3ym+eGbcvSzFs+zS/Vp+m8LLLLgOwF1Xq0ksvBbCn2zbrXc+W2D93HSZq7bU2KJuDaK0qew9VR3QvX5PZFZwths2I2sheA2rtRNEb1XclEfNtUOXbvZ7F2j22RpSEMXomGLZmbV1E/tT2v13DftmRbYuKAa7eP1HMAfaK4bGKogUq748okuGm6bAZxbQLhUKhUNgS1I92oVAoFApbgo0Tj+/s7KTiHAOLzDLXIb5fuShF1ytx4YhhWBTGD4jF48qNZSQEIiciYVeMyBCN+6pcTKLUo0p8lLlzsRuKmoNM7N8LY7q7u5um88xE2Vm563yPVAJKXWGiTROF+2MWatI+TTxuonD7BIA777xzX/ksLleqCF+fTyIBrKpH/D0qXWkvkUiEEVXL+RJXRmJWDijChpSRe1MvGEj0PuDAO8rFMEvGwu+dSMSt3jcs8lZupB5sYBsZ2imXUhUeOgpWxG3g5zpLpqOCrETv7001SCumXSgUCoXClmCjmDawGsrUjhl6wS5GArNkdXN9ynAqY768++0Z+UTl9oxvfL3sWsE7dzsfGVuwIQiz8mi3zDtalfIyMlpZh2mvk+7Q2qXa5tudseOozOhaxXyyoC69T2A1zKN9Z+bjmbExdbvGmLcZq2VjwlIA5YITGeexlKs3Nmp8/DXrGEsdNjIWy4FL+PmI3jfKrdHA858ZQ7EhauSqFLm7RmVF601JY5iBRs8iByhh1zMPdvVjg97MbZGlP2zomzHtXhjaSDKbuRyfTxTTLhQKhUJhS7CRTLuXOtGfU0E7snsylwRGz/Ui0vnyNZy6MHLjUrrrkTRx7HqhXNkyXQ+3w5BJEphlsN4r02mPuBZltgYKWbAL1ttzeyO9XS8oTNbGHrOPmAGzJWYt0ZrlMbX1wOk8s+AkylbDkIV55Hao0JS+jfx9xH6F7zlbDCjSp7JLEocmzpi2CqLCz3gUwMagXA6j5B/2nlFz6etR86Fcs3xZzOhVsB0/jup559CxUdIbJR1UjNvfr1w1o/dgz27lfKOYdqFQKBQKW4KNZtq966LvGWNT+qdMh8F6QL4m2mnzzo9351HwfWXFGQVG8ed9udmO07fD/9/T22S7TMXKmbn6/3tMa4TlKnid9ggb411/JCHopT3NkNk9+Lb5eeGwkSoZDFt7+/LYPiELWMH9UsEuojSVypZBPTMePYYd6dBHg/qcKaJ54fCymU7UoMKYGpRe11+rmKLdw9bs/h5m8iPhjHmtquBC/h72VmHJTiRRVM+pYtMR1Hrwa5WlPipVZ/TO3zSrcUMx7UKhUCgUtgQbxbSNZbO/cRTKTul4M39fvtcQ6bD4Wr4m2wnyDlclColYpfKbNozUpxJ6REy7Z30/wm5GdMPKzzOzpGYJQsa0jWXzTj2yRuexZUbqmQFb3vO1jKj9ag6jNJu8RiIfXiDWt/ZYU2QV3WMgxuRGdPXcb8M6krORJEFnG/y8RnVzONNobJUVt2KzkaU0W3GrdefL57ZZGXbchz5llsxtVJbvHr0UsJEOna9VrDZ6R3Jb1fvc18Psn9MnR3YlkUR0E1BMu1AoFAqFLcFGMW1jSiO6hJ5FaeTbrRKGrKNPy3RY3Bbe1XHbfD1sJdwL9p+xAG5zxMBH0zdmUgGlc8502oqNZ1bRI0yb+xddq1iEahuwt9vmHbmyso3q5Xt4lx/pJRVrjtiF3c/+snz8rrvu2nc+aouy3s2Yds9XPfKVz/qj6jvXiPy0mX3xsx1ZgPfsIqKkFRzNjucpS7DDz82IdXXUft+myNOBGT0jqo/fjcoThSUA/hjr5vmdmL3nbFxZohRZqY+8688HimkXCoVCobAlqB/tQqFQKBS2BBslHgfyQAwRDuIGwiLMLNygEnGzmM+XyYYs7PoQuUJwrmUDh09cJ/SpMp6Ljqn+ZLm4DereyABFBSeJQp+y2Dqb42macOrUqfRadX9mDKfGPVMFGNQ8KDG9/5+Ny7IgO+YmxkZjtnaU2Dw6x+JElcjG95lVOpxPPnqOe8/2uTI6G4WNU89wy2M0SEeUw57XDM8tG1H6/23eLbxtFkCpZwCojNl827hcFi9HxnMsemaRd2TExuiF3vXHlDg8M/DbNLG4oZh2oVAoFApbgo1j2tM0paE0edc4YgzT29WPBPHoMQ9/D7NTJQ3wu0je6bIBVMZiuR7FoiMDO76WQ2FmrlOMdRirMkjzzGHE3Y3PZ65qbGyjWIVHz0WN2WRk0GKfFnKS2WwU7lW5C0augIrR2HdVL7BqrKbcBSMwG2KDqyxgjkEF09g0ps2GTNnzwff0wm1ma1WF3TS3rSyoCz/LBv9+4nNcBksHI6My/s5rKJPw8TXKxdFfo97FEdNWroxZwCF+5tUYnS8U0y4UCoVCYUuwUVsI00saMuajduaRbkYx6J7LUlSvctaPdNo9VpG5pfFOlB3+M6idqB8TxayVW4XfnWdJPtTxnt6b642u7QWWGGHiUXszxq2C3DCYeQPabS8LhsOMV0lCovXGbTb2oHTe/pqDMFteOyrdqp9T5V7JUqJIkrAJYPc867ONcXTOoGxPrK8+NC3rhS0ZEM9hxpptblnyl71Xe2s2upelDpke2qBCq2ZST7V2soQ4/L5myZJ9RglDRmxpzgeKaRcKhUKhsCXYKKZtYUx5F+Z3tyoEYBYgRQXA4B0VW70Ce7oj3sUpa1t/rdJ7R2y5x/6YqUaW2ayzzSx/DSqdptppR21Wuq2RejkFZRSQxT6jcLYep06dWmGkkT1ET0KQ6WD5GhUwI7vXWFOkT7N7Tpw4sa98JXmJylcsPbNtWAfcD3tGVIrQaDyZPbM0KGI+mwR7J6lQpcDe+GTW28DeOEWsmZ/70fCf/hqWakXBgxTDZQnYiASTx8SHTeVnj6/l92kk9TIou49IcsXPmtl5ROufpRwqadP5QjHtQqFQKBS2BBvFtIF5J6b0rIC2OmQ2EVliKkbITDvSq3JZinFHbeCd7oj/udrBj/gzG7IdfuZnHiHShxtUONCRa9g/fSTJiGrfyZMnV3zgI7//ntV4pvMbsX/g9keME4iZwUUXXQRgT7/JTCHSg/NccshNlrxE1uM8p+y9MBKSVo1NxJbUZ5YwZBPBEo/ICln5dvP4GTP3/2cs2ZcFrK5vFfrUvzusHp47tqGJ6ldhWtlKPkuiwmVxmNEo5KoKvcvPSnTsIF4Sm7YWi2kXCoVCobAl2EimzTptr1Nga9cR1spg3aayZOa6/b3MbiIdHNejgvFH6PlCR37hKrLbiP6Ly+fdZRSEX7Up0lexzjqzGjesY71pTJstZtdh2hEzVLo+/p75XDPT4rmN/EqNcStvBd8HlRSB/WYj+wtmLcomIPLqiNZ+1M/s2dh2ps2ILN35ebA+mq43el5M0mKfdi3fEzFRtsSPLPINyrLc7snqY99qFTUwAq8ZthGwe709U8/Hmn2x/f9sLT4CZftyvlFMu1AoFAqFLcFGMe3WGo4cOSJ3psDebor1JiMWyxEb8vf22gboiD3RDrTH6DKmrfTfkVU0MznFtKNyuM08jpGNgNJ3ZtHNWGpiO3hm2JFV/IiF8zRNuPfee1NrdLU2lOW8v9927D3r8RHpSWaRqyJgsS7O38N6O2XbEKUaNCZn5Vr6znVsHhRrjtqqYgeso2PcZEQSEH5n9SKjedgasXkyHTRbffv6VIS8TJLE1zDTziIw8rrmfkQ2SSoymkoR6/vD8dgV447OjbxLMsnbJqCYdqFQKBQKW4L60S4UCoVCYUuwUeJxYBZJqIQOwF64QCVeie5RhhgqrGDkTsMioMyobDSpSRQApmfMEYnNeyEAR1QGKpiLakfUJh4bb+TSC6aSuQexQY3qx913370SDCdyc+sZ+UWhSLN2Kqg1an2P3KlY1cF9zlQdqk3Z/Cs3JF4XWYAUTmqjEjn4Yzw2mcvmtoLdmPi9xsZWZnwI6NCcLPLOQoaOuDj2RNsj7wHl4he901jtwuFfeX1ERmU8Nuq4KqeHERfW84nNak2hUCgUCgWJjWLaZoiW7WyMSbHpfmY4o3aP/Jm5azCLyIJrKGMHxS6idveMyyIDq8ygyl/n/1dsMEsUwG3ioDRRkBo2vmKmHdXDTKG3Wz558mQazpbBTDDrK7vt8fHI6Go0cUzURmU8FrEJNrZR5UcuX8oQSUmh/P8qTGrGllWCkDNx4dx0sCueCkqSzamF3WTpjJdm9RJoRO9GlpIpd9XIyJGN4dhVN5t/ZsAcIIUN0vy13EZ29YrG8SDhelVAm/ONYtqFQqFQKGwJNo5pHz169DSbjnag5vqQ6Yf9cSvXH+Pvma5UJeMwjISz5DYpdhuVrwJZRHpC3knzTj4bk15o0ogB9XTZUZAalSxhBJmec5qmVJLg61ZsPGP7vYQqhiyRR69+fz+7tTAT8QyEA6QYlE1AtA4UE4ncxKJ2+++ZBEHZj4wEAFLujwdhUecD1k5jzfZMcNhRYG/cObEFS6x86FMDv1+ygCIsLWMod07/Pz//7OIWwa4xF0Prp+m47TMLY9pj7f7cOovYvpAAACAASURBVMikf5uAYtqFQqFQKGwJNo5p3//+919hJFE4TGVRHFlMKobDTIStYiOokI1+N9bbqUVWyqptXEakL1RShnXCmCpL04hhqSQGmU6br1XW2L6N64S0bG1O68o6rCyFKWNknHqpTFXbPFQgm+gapT/2616xVqXbjurr3RN5Oqi1MqKr7zHtaA5Yh7ptAVm4vcwco0QXbIFuzNqeMX8Pv3fUmolsGlTwIDseec2wNbzy0okkSXbMmLb17/jx4wD2mHZmPc7PevZs9OD7pexYNgXFtAuFQqFQ2BJsHNOOdnI+ibpB+UtnrKWXDCNjWMrS2LddtVEl0oh8klW564ReZcvPaLfZKy9jwIptMhOKdq8qRGA0JjwvPbsBz7QjvZqyjF0Hym4gaiPXo8J7ZnM54r+vpDE9CYwHs/DMb5qlXOpzhGkrtp75A3Oq0UxisWksycPWqLXf7HWA1ZSpivlmdiMqVGzGPpVXhyHyIlB+4JlVPIfNtbEwhm3HoxDWar15XfaZgN9jpdMuFAqFQqFwIGwc0z569GjKQJSf4oh1ta+HrwFyXbay0I5YZdSv6J6of+rcCNNS3yMdZI/hcDsiCQh/V7puf075O0fJYVQksQzKV9X/z2wik8QoX/eR6E/KspznI7PMV1bqnmEpBsrPQhRlrReJLPOR76UNXcc2hOuL+sdjkEnZ7FrTAW9aVCtgj1UyiwZW1yYnruHIf/7/kefEoCLgcb2ZHUTkleCP+7lm7wezGlfeEZE+XHkgnIkXQfSuMmxadL7NW8mFQqFQKBRC1I92oVAoFApbgo0SjwNxsgYvnmC3IjZGMZFTJHJkMaj67kVOKgRlZvzSMx6KjJZ6or+RsKKMzPBotM2ZEZgKqD8S+pSvzdo/ci0w95NFsz6wBKtUWDQYqU2U+Jj7GLmHjCa1iYK5KPWEiUUj0TOLUNdJlqBEndHaUWEyRwKm8DiqhCWZuJLni9UCUTmbKB432Bo1UTGwuq6UAawXhasx5XGKAhopdVXPTRLQ6yvKb21zZO9p67t9Z/e3SM3ZC5+7juFYpMpTrmybgs1dyYVCoVAoFPZho5i2uXypoCfAKuPgXX20o+4F02BDnSjZCF/DO+Eo2AmHHszcrJSLhTIMi9hZL0DLCNTufKSt3J4IKplANG9Zn3vtt7H3qf+MlbALYWQEp8pVu/rIEFEF6xkJm5sFqPD1+3v4uxq3iL0oQ6TIrUddo4K7qHZHbcvWmzJws2sjA6x1wgyfL7D7E7DXV5XCNpIuGNjdkSVInmnze7M3XpFLI39nA0UvQVBMmw3QMparAv+MSAVUf/yYKOnqpmBzV3KhUCgUCoV92CimbbCdTqR74R2o7dCye5RLgkHtGP09KjRjxnxtp6kCcIwkDGFpQ1YfQ4WmjNBja1mwi5HgJ6OsOUobqNrImKZpKCgIz+WIW0sPmYSHXa2yNqrxUW4u/v/eOueyfHmKWUdrR13T+/RQiWMypqfShkb3rBNmdlPg7S+UhG9knJSLaTamKkASI3qHqIQdzLh9H419s+0J67KjYEtZW/geJdlh18JM+rBp2MxWFQqFQqFQWMHGMe2dnZ2uJTWwtxsy/SQ742esTF0TsRg+l7EHbptJA1hPE1nIrpPcw5cRHVNty9JGctAaQ2RRPRrmLzqugtREu2b2FMgwTVMYLjGSvLD180gqvkwv7PsRHVtnnfWkQVGiHBU+lO+JmA+PxUiSCRVGstcHDyV9GrFfUOvcr11eo4fNmg6iP10HHLJThW2OJFP8fsvWrgpQw++q6Pm0crmtbDXurcfZWlzdEwXZUbrrdYKq8NqJvAu4vE0LhVtMu1AoFAqFLcFGMW2zHvff/SewtyNiC0m2So7uUcngVYB9YEzHx9+5LWxVafV5K2blO66Yd8YGR3bYqnwVwi/T9yq9UZbUgj+jfrJfdWZ1PU1T6C8asQpmnqwnjMZJIfM86OmnIx20sp3IUnOqhAnMhLPQroqdZ21UOvSMhbJf7IiUhp+Nnt+2/38dhj1iNcz2D2fbstj6Zu+uzAOF9bP8/omeI5Uql9lllvyF9dCcVtO/d02XzTpsTpAyEr9BeVRkzJif8chP+1zN7UFRTLtQKBQKhS3BRjFtYN4JjSRU4J2S7SKz3THfa5/GULLEGj2L2Uj3woyEd7MRozuID3TP0ju6p7ejVj6Q3G5A70hH2jrirx1ZeEaILJwzewglPYn6M2K5rsB9XccS3JBFORtly1HZymo889PO1kb03c+pPac2l5xEJSqD2zTCorNENIzWGlprK20amVNDpBs9rFSRHtYP79Nt4Eh/tkaM+Zpkzz9HSvev4ilEtg12r7FoZuCeaXMKTtaHc7siSRmXz+ejcpREMWLa3JZNsyLfrNYUCoVCoVCQqB/tQqFQKBS2BBslHt/Z2cEFF1ywkvggMsc3sYddY6IhZcgD7ImHlOjPyvIioSgHcXRPZojGbhuReJxFWkokE4kGlegnE1P2Ar6o4A7RMa5/xB1GiUMjg5DRABlHjhxJ1Qu9JAiRKLiXWzczYmTwNZG4ml1flAFa5N7G61fltx4xtGREAYeUoR2vpUwc2zPW8//3ktpE7R1NGOJdTUcCGCnXoci4VBnAHga8mJyTJbH42HKLRy6ULFpW76qDuH75e1g8rkTR0TOaufhF3z24nhE3z00Tixs2s1WFQqFQKBRWsFFMu7WGCy64YGWX5XdQytXLdlK2i8zSEbJhGDMHvytj1sLGMNEOlOtWzCByveix5REWoAx1Inc63oEqo6kRjDBrbj8bgnhWto5BiBkTcTmRRIKZ20hf1Y6cv0dGXlwur+vIqMzY2QjTVsFTesZl/tw6oRsV61TGTNFa7QURikK7KlefSEqzTohdO59doyQsLE3wTJvbYHN6tlyJeFyOHTu277ux2yg5hnpX8DsyWjtcFvczYto9iU7m+tVz28pSK0drRZW/qdjs1hUKhUKhUDiNjWLawLwDYhbrd2UqCAC7A2Q79Z47VRZekllM5hLDCUOYzURuVKy3G2Ha6lzG2hVbMfTcqyJkrlM9fWQW5GAUni1Fuu1s7FR9al5UeMfIVcnWgdLbRno7lvCocKPZNYqZ9oLURG3NUo8qd8WoLD7H4zgiSRq14VDHomv8eyfqqzFEfi6MWWfuRtzuHts8W4jCiirYWHBAlizIEr+3zwSRlFW9G/k3wc85uxQqieZB3DzPF4ppFwqFQqGwJWibFKqttXYzgLee73YUNh7vOU3Tg/yBWjuFQdTaKRwUK2vnfGCjfrQLhUKhUCholHi8UCgUCoUtQf1oFwqFQqGwJagf7UKhUCgUtgT1o10oFAqFwpZgo/y0L7vssunqq69Oo1r1/JgjqIhU6vhByhq5lo8fth/gOv7Hvbqz8z3f8czXVvlHZj7LHA3sTW960zvYivPiiy+errjiirRPB8FI36LvWVnr1HuQezcFIzHoR57NXurUkTjVhhtvvHFl7Vx55ZXTNddck/RkFWdjPtZ55s4WDmKYfCZREw+jvnXe271PQMfg+Pu///uVtXM+sFE/2g960IPw/Oc/H1dddRUA4PLLLwcAXHrppaevueiiiwAAF154IYDVoAbRJHBoSA5kr8I9eqiA+VFOZD6nXjpZABgDB2bh6z3UD2EWElAFqMgCV/DGiXOaW8AJS1Dgj9m82Xe7h3PxAnvBQu688859nw9/+MNX3HOuuOIKPP3pT1/p35mC+8S5vbNwmb0XbRRwphewhO8FVgPAqAAmWSAJw0jyF/XSHNlo9ILH8Kf/35JjcLIJm5uRxBzXXnvtytp56EMfipe//OVy3Pz/fI5DtUbj1At6xHVE14yM7eimPQtjuw6h4TlU57OgRfydy8zuVfnjo/7ZMU5YEuX8PnHiBIC99WbXPOtZz9oIt8ASjxcKhUKhsCXYKKZtCUNs58zsBthjPhy6jnduEdPmnViUqpDL6u1Ae/3xUOkvs/KZJWf18+40kxwwFGOM2GBvTCImwelKDTaPxsBtB+zLMemKP3euofrMSQvWWR8jEhAGSzf8sYwd98pWoUIPAh6jKLSrqv8gIuKRsJw9nDp1amUc/XPDc9VLnev/V89UxrxHxqOHEdY8yrS5Xf4atd4yyY46x2VGCXhUutxoTlTynBEpZJaO9HyimHahUCgUCluCjWLawMwg2BDNp7tTydkNzKL9/xwwX+lNMp22QqbzUbu7LHED7/ZVYoWsfPtu/Y/0oIZeMH5fH0s5ODFCxM5tDtU4mgQlknKw7vJcgufK+sRjGrEAtUaz88ykeylN/TFu80gCh9EkKiNSoZHniPvM0q/DevbWwTRNOHny5Ok1mNWb6aHVtepzZE6VncLIvGTSR3UPH1/HwHIdvbti5fzu8mWotJ0RKzdkiaT898xmI3tPnw8U0y4UCoVCYUtQP9qFQqFQKGwJNko83lrblxOZ3WsALY4yEUaUM9YMmOyTxeOZK5Yythg1+okwIh5XYrFIpM/iMC4/ukeJTpVBmhdT8bywWxTXAfRVEpGo3dpmrmMsvjwX4DlSblSRiJCNbZT40ItF2aDNrrFxyfJaq++ZCLcn/oxEraMuPiNGPmwoFBmHnm1DoGmasLu7OyQWVeMVGZMpVQernPi8P9czEIzeA9ZuJTaOjOUMSqQ+4i7Kz8aIMZ3qT6QuUWtkZJ2pZyR6Fx/E6Phcoph2oVAoFApbgo1i2sAe2wbiiGgG3iGZc7yxaXOM9//bNfapHPqjnb3a8WZBTpSrR+by1dudRoZ2fIw/R4IO2Hfb9fPu38+BnWPXPPvk4DX+Hmbl7NaXGVixwdu5BEstDD0XIH9OsfOIxZp0gQ3gIhagpEB8PmIdal3z8xWtNxUoZcRVRkmBRiRJhw3/zvH1rMO0sueEJVMjbpU9pp0ZatkxxUg9RozHojZnbVwn4FDPaC5y+bJx5fcb3xuVP9pff++mMe5i2oVCoVAobAk2jmkDubsRuzEZq7MwmMePH9/3CeyFpWOmbffyji3Sbyhk7k3MHo1lRjtUdhnivnPbrL/RWKgQfZEbnOqfYgnAHgu0gCgcmjSyK+B7uc2RVEUxkk1CxAgYdq6n2/T/2/iwK1zGllQgniyIB7vEqNC7vn8q9KjSR2Z6VyXxifp5Nl1vomcxkmaokLDZe4LHg9d6FDDHoFw9M0kf65ZH1qiy0eHjkeunYtpRv5QNEM975KbKkhz1PZsLVf+mBVDJsHlvwUKhUCgUCiE2kmkbol0RszjTVx87dgzAHsO27/4au4cZN1uVe4bYY9rMooE95mnhN21nzUFC/O6uZ8XLrNkzbe6HnRtJoKDAzN6HELXx5PCiF198MYBVCQawt2NmnbayPAc2T5e0LlRADMNIsAsVJjULBqHawfYKURu5TFtDJq3yx1iio0J9Rsy+11+Pc8GCsjC9gJZ8GSJbE+6/krxF1uOGdcKYKknHiG0L90O1I1tr3P6RgDnqM9JXs4cQr7tIKsTHWGKQSYMMZxJK9mygmHahUCgUCluCjWPa0zStWAlH1rVKl23pG731ODNopds+CDNl615/TO0A2VLbX6N2y8xufFutr/Z5rsLu8Q7UswwFGydj1swyjL378tcJqXi+EDERxUqUf6uHshJmBuzPZfpHX18WatXKV7EM/P/MXlR4W/8887OtmF7EBs/kOc3QWjv9F7XF/88SqHVCxY4kCuF7DEpPnHlb9NoeQemylf7at6ln25C1hdmzzXHEmtk7hXX4Ud8ZI88g929TsFmtKRQKhUKhILFxTHtnZyfdjfOu25g2WyGbfjW6h9mq8m8GVnelvMM2vVTEJpSvc2ZVybs63pFmluBng2FfdtllAPaPJ1uWs14602Xa2N9+++377o30esa6N8GysxcpLmPabDXM/roerO9UlsaZXlK1MUvryYyaJSK+DrZPUG0f0Q0zU+UYCv5+fi8cFuO2iGgZlB6VJRKR54mSvGU+18yk1XqI0hbzM8VjvI5UIPMl5/WlvHG8jZCSdrLU02woIqbN7WdpQPYuVol4IpuGXsKf84Vi2oVCoVAobAnqR7tQKBQKhS3BRonHW2v78mlHySoi1wpgz80qEneo5AQsluLzwKrxmIlxTOwy4qpibckSX3A9vaAnfkw4UMk6YnIrz9pmIulLLrkEwJ5Y3IvHlfifkQVisDYr9zFfz4i7ydmCEuMqI5jMEI1FqhzKFVgNEWtrhcWhfmxZdMqqG+5LJOq2e20dcH/s+fL9UGuW64lE3SpIibUjEqlaOZdeeimAPaPTKIjPQcBBY3y5LPLtBWryx1g8roI5ZSoIDtgUrR37n98z7Gbn104vt/dI8g8OeMXqR++eav/bc29icHZTjUIhM/hdHxk+8nNk61iNTdTHMkQrFAqFQqFwIGwc0z569GhqJMABHLyLkD/ud1CKDfPOLAr3x7thdquKdtjcFivXdnfGWv2Oznanyp1GGa9wOb5Ntmu1854t2Q7UWMvll1++77uNK+9Qfd3KwCYKcsAGNWzkYW319diYMjs/W2CW64/xmlRSGw9eO1wWMyNglQGwsV/kLjiaAjRiSzyXds4kLQbPOnnO2D0nM3yzc0paEyUoYRbGjNueSc/o1oV/N1jdPqAMs0d+7tlVyfdFfY6wSYOtEVszzBj9OZXQx+DnQxmPKnYeSSHZEE2xaX/MXHTPZM5USNxI2sVSAJZcZGl/N83VtJh2oVAoFApbgo1i2sC808sSRNiuh3eItpOKgg4o1welJ/R6Vds9MpOynWKkj+KdmbXVGLa1x7NKTqRhbVChMKMQqBxW0tiy1RPppa+88koAwNVXX73vGtZxR8FjmDEwC/G7aMXoOGGFZ3TMUM+WTtv6nO26Wceo9Ox+7tl9xfrB4W0jNxoVEtLmMnKFsbZwmNzIPchg5Vi5XG/EIJWrj0oj6p9F5cLG4+vH1e6x9WSfnMbUI3IdU5imCSdPnjx9LYcDBvbCIrN0iZmch3KnU2kiPfjcSIAhlQRIhfD09yjXKB6/aN0ZeL1HgaAie4F1wTYbvGYjV1P+DWApUeQmtmmuXoZi2oVCoVAobAk2jmn7XSIzLWB1R66sbTMdhd3DLDkKrmK7bdbjZfrVXhADYwZRABhj8KzPZSlBFACGx4YTl0SWpqa7NP0g77h5J+7bwjozq8/GzEsSVHIJ1qFFOrOzteO1eeA+Z/Vxu1ny4VkMMwIeJ0MkpVHW6tbWKLAIs3+W6ETMXqVtVMFE/LU2p8ZCmT1xvb48FY4zkz6whMLabuvN12NtWcfzgFmgH2PuGzPfLI2w8uZgKUN2r7Ij8f3iNcg688wCXJ1jlh69d1hCMWIBzu/gdcBJW7I5yMbYtzELz3quwkKPoph2oVAoFApbgo1j2pHuNNolq5SOkf+d3W/MynZV5udp7JY/gX64vWgXxizM2mQ7TrZcBFYtZNnHkRm+17vzTlbpeiJ/WdM/veMd79h3DTMfvxNlHbmxdJZuRGkKmcFl/sdslXxY/rhsvW3tjnSCbAnPHgfctsg3naUaHFPAjxOzIn4GbL78WPB6sjL4WYhC7qokEmzdH4XntPLM84B9biP9pc2psWY7xywpsnDm7/Y8W33Re8Ku7YU83d3dlRbhwKrtjF3L4xRJJHqpciOLbZ53ngeWAPq+crkGlpD58vk55DZFltkqLDRL1TwOEkuCofTsyvId6IcfjjxdDOWnXSgUCoVC4UDYOKbdWjvty8c7ekCzBuVz7WE7v9tuuw0AcMstt+z7NIbtWSzrljn5iMHvxtgamaMYGUPwVq/MoGwMTBrATNvvNll3ZEyOJQt+N2l9tGNWj+3gWefkpQ+WRMQYllmgP/jBDwawx7wjf0krlxlWZOHMel0/LwoZazYw82XL9Wj+rV2sV7Vr7TOy0GcLbRs3jq4F7M07S2vsmij9qpWrmD1HyPJrl/2mOY0tr39fj5V3xRVXANh7jphFeR2+6b+tfzZevP78OuD3QJQYgvvF9jCZ1bUlDOFn3D/TLMVgO5jIv5yfMWZ7bKfg33PKToX77OtjS2h+F0Z+21YurxUG9wFYlahYf/n9HY29vUO4H9xv/56L0nV6RNIOK1fZdUT+5zwvxbQLhUKhUCgcCBvHtE+dOnV6R2W7vkzfwEzBELGXm2++GQBw66237ivLWK6xSWMDvm5jk7ZzM2Zgu1ZjT75c9pPmnW/EDJh98XcVV9q3jaMnZUyVGRbvit/+9rcDiHebtlt+61vfCmCPab33e783gD0G5svl3StbIkcxtdeJSJRFKDOwJIJ1ov5eu8akCFdddRWAvfm3MWfpCrC3Jmy9WZ+tLJP4+HXAFuzM4OzTz7/SXfL5iA3yPcrvPKrPxtE+bUwMNlaWhhXYGx/r+zXXXANg71l529vettJGxTrVd4+R9J2W86DHaj3Ym4QlFB42pw984ANP1wfsPS+2xqJogOyLztIh/67ie1gfHTFUq5NZOEt6Ij0/64XZN5517B7MtK0fUfRGA9tM2PslirxmYA8DfhdHkhjFxjcFxbQLhUKhUNgS1I92oVAoFApbgo0Sj0/ThPvuu28lqLsXzXFwCzbuMPGUid8A4I477gAAvPOd7zxdD7AqajexiBfrslGHiQDZad8bcJioj9NaWn8iUZoKeq8CfXhRIIu2rD4bNzYuA1ZFWyowCxtl+GtNVGf9sHG+6aabVu6xtnEKRisrCifI6osRsPGXBweb4QAykeGj9dHUIyzWs3Vm/fAqCDbMYmMeToPp28ChOlnk6UWPymiMxcWRkSarXVgMmqVf5bXKbWcjSt9nLt9UCbaG7NP33e5lgyN+rjxGgqtYoiK73+qJQrfa/LLYOBOL2/vEQgXz+Bh82FQ2KrVn2sqy8fHPC7trqvGK1CNKLcLvyugdwt85mYmvz+bKxoLXjI2vqSr9umNVh42FrR1TrURqQF6jKriPb/f5TAmcoZh2oVAoFApbgo1k2obI/cB2QSrdHRuGAKsJNJhhcUq7iO3Zzs/KtWusjVEwiChgiK832hFmQU08InbGBjTWDg4M4qGCh/AOP0ojamNh1xoLNXYaBSlRSSyiHS8bUI3seG0+IsM6NpRRCQ48i2UjRg5+Yn3nBDLA3jzbeNj6M4YVzX/magXEyWasjQYOHsMugX4dMHuxMbYyI3bOxnLsssSGaV5aZGvEWJL105ijGST5sYncf6L+Rud79/o+sXGnXwdsAKjcqnwZ5vpofWa3wQc84AEAVtPy+v9tPRub5FDBkYuktcHuZcPXKNRuxjyBVWNAX7ddy+lc+Vn3fefUyvaesWfR1mWUltnWDhsq23hHaWQN/N7h1M6+P5Fh6iagmHahUCgUCluCjWLaDNttReb/zPZY1+R3irYzY52OsSPbbRm7iNxEmPnwDjEKm8ruRxx60Ot6bOengoIww/P3qgQofN7vQFXSe7vXxpN308BqkAubH9vpRokiWMfMbigcJtKXHwWUYZjbjpVnLMnrCQ08Lxxgwd/Dujb7buyJ2aYPrsIBRAwqYI5vk4H1j+zG569hBsz9iyQuLH1hvWiUCKWX9MWeN2ZNvhy71yQYxrDt0/fP1htLJtiuxY+zPcsseVHY3d1NpVvWB2ZfNh9RkA7W7fLxBz3oQfvaFqW95ARI/A6J7EaUiylL0fw9LB3k90MUcEYlwMnSeRo4AAtL53i8gdV5ZnfR6Hnj9cvjGbml8VxWwpBCoVAoFAoHwkYx7Z2dHVx00UWpczsHNWBmwFbQ/n8OAsD6Q2a7wOoui/XiUfKPXgCRSNdjUFaOKh1dVI71j4NORPWx/lP12++eOXgLh2WNGIvSC7FVtGdT6wTun6YJp06dOj2nUX08hiw9iaxduf3GHlUgjkgiwVa8zKw8C1TnVHIT334lnWHm47/zuLNOM0vnqNKSsvdCxCD5ky3qfV+UNIDXtemIo3M9nfY0TTLtL7DKSO2TpQ5eqsB95LWuxjq6VyUsit4DvJ6ZtUehdnkNKWtyD7a/YelW9CyylNH6w1I7a2t0r/KwiHTr/M7gOY4COI1ICs4nimkXCoVCobAl2Cim3VrDhRdemCY1V6kEe9+B1R07+zNGjFT5YWbW41ye7QhNX8dhTn09ihFw230blYU5j2Omd+ddLO9Q/Y6XWaDtVtkWIEuzym2L+q3SH2ZgXbkfG/YV5/Jtl+/bzWuCrU6VL7TvmwpfG6Vs5CQMzF457Cz3EdAMj33igVV9Kz9fkY0IrycVVtQQJY4xWFuUpbuvR/UzksixVXDGlqZpwsmTJ1ee5UhSxAyNYy74cWKbhahvUb98few3z1KgbL0pnXbkRdJj2FG4aJYosu0B66cBLSVhu4hoTCK7AY8owQeXy89xZCMyEvr2fKKYdqFQKBQKW4KNY9pHjhxZsYb1YB2YCurud07MvuxTWdlGjFTpzLOoOdYPs5S0T9O9RTpaFamMxyJqI9/LfuiRTyePDe/ko+haKk0pW3xGvuRcBu/6M93ZCPjaSPfLejVlqevbxztzTqwQtZ916DxOkRSH16YxRvZw8MyRpQo81kqq4vvFlvr2PbJwZ4ZtiCIYcnuU37kdV2zUX8PzFiWJYW+IXtIHe/cA8TtFSf/4M5IqMONU0Q+jdwi3n20ofCwLjojIEqqoX8o/m9d1dFwlAeLYDv4ettmI7EdUW7neHlv3x/g5VlIw37bM9uh8YrNaUygUCoVCQaJ+tAuFQqFQ2BJslHgcmEUfLMaM3D+isHr+nsxth406WBziweIwDjaQuTUYOGEHh0319yixOIuLIrER36NCh3J7/T0sVszElDxPLP6LxNoqmEsmDrPxisJ+9trmy+OEEBzIJjKCUeOtRJuR6wgbKym1jP9fhYaMAnEo9QgjU+Hwc8ViQ2+co9wB7TirjqL+8b2sdorUW/yd1Q+RaHokv7qJxlVAEX9sRMzO97Aolt87fH10jEPFsrul/5+DLbE6IXMTU6LgTGVgbVMh4Z3q5gAAIABJREFUiv1cKhVR9g5WUIZ3UVITngtWM2SBrnpzfq5RTLtQKBQKhS3BxjHtnZ2dlUQX2e6VDUAyps2GaMqgJQsKwgFZOJGAbyPvIs2YKHJNYEag2FPEzlSwBk5X6sHj1dtxRztwbjMHuonSeapEBFFAC+7POkEOIsMg5QLFc+zrUYaB3C+uw5fL7Y6MX7huNiriwDy+np5RZgZOicpjHaUPVQxEJabImLYy5IvuUVKZSCrEY58xuGmaTv+pNqj28nE/18yG+X2TGcnxnLIhZGQ0ycZ87OoVuaWNrpXoeVJSLfU+8teoBE9qjPyxnjQyM/BVborR81QJQwqFQqFQKJwRNo5pA3mQf05Zp3b90a6bmS/vSKPdndKDc8B+Xz/vHnl3F+3keVengp1EbYx2+b5eq2ed5PDq0/+vGB7rq6P2MyKXkqwNChwWMYK5TUUpRPl7L1BJz90KiINZAPHaZYZtYF22n2sV9lfNbSZ9YKYdSU04hDBjhKmwPUTmOsdjbW1i97d19KGMU6dOrUjNMhaq1nyWXlPp16MANoq18lz7sjLdtS8je5YV+8/04Vwur+so8JTSu/M6j8Yzc2FTUC57GYs+k/V0NlFMu1AoFAqFLcHGMW2fIi+yPuwFso/0hcyoVZCViMWoa3nH5nXovENj/QmXHbWBv3PbIxZrn5yqLkrcYCyFd8Vq95rpmnmnrUKhRsfWYfQjuiWeL99upRPndkc7bHVNZq2uJAQZU+DgLWo9eCi7B2YmEeNnGxCVsMEnlOFkGYfBdHm9ReOo2p7Nm0FJO+z+3d1dmdoW0OF2+fiZBOLw96pgSplnDa9JZvCZN4d63pW0Blh91/IYZMl7bH2ZnQ8/t9G7WCXAyeZfSTWygEMGJcE83yimXSgUCoXClmDjmLa34mTfREAH6B8J1ad2laxXyRgw38tWj75NvLuPUjEa2G+R9eLsCx3tDFnPb8h8MBVLyqymlX8kSxSifrJuiZllxAbOxHoz2iV731ZgVaKTWTtnzAPIfUQNLAGJxpbXZKaXVmx/RGqi2GpmR8BhcVWSkQg9/+lozFjXzElVonVm4HCsWbv4+YzWIjNdrifT36vv0Vj37onaoay4lZdEVJ6yS4mkXcrrIrMR4bXC7w5+FjP7EpY+Rh5DyiYlCyGrnoVNwWa1plAoFAqFgsTGMe0jR46s7MIif1+VnCJKYccJ5E3nqyKjRTs23unyLt/vxi677LJ91zJLtnsjNmHXcJIR3lV6dsEWlzwWhiiQPlvHK0S6ZrV7NfjvKp0jW8N6Zpyl7TwMMJtgX1jfLvaXVdKbiDUrFhN5HrCtAUt4RqI+sS8vtyNikMyAeH6ie0z/zXpxlZDHo8e0I2mHej5HpDMjEdGyZ4EZJz8/kQ2F8vfuSUaie7j9I/7FLMnJpAAq8hrXn0kfbO0aMpskXm9qLDKJEq+hdWygRqRBnERnU1BMu1AoFAqFLUH9aBcKhUKhsCXYKPF4aw1Hjx6VhhT+/yiRgb8nC53XM/vPjB9YJGz1m6iQ7we0YZhvo4nsTcR04sSJfd9ZjOTLtHutXmsLG+FEbi92jRn3sNohaiuL37lcFrVFfVdhTTMjsBExeS+IC7A3XiZGzoKAsKiZxeP8PVp3LGJm8bhfw5lrny/Tg0X1bOSnAoFkYFdAv765PjWOUUhhFdqV5ysT+6pALP64XTuSZMZfD8SuSixqZlVUFGo3SkDjy81E4CpkZ2YIqRKQZAFFlCGYCjecuc7ZuNmYZ6oOXhs940l/TIUtjdzEDOp9kD37m2aAZtjMVhUKhUKhUFjBRjFtQ2b8YmA2wQZakcsXu6goJhcFSlHp9LjNvj7eVXK93pjMdqfHjx/f9znKFIA9ds5uVNEO247ZDpvdoLLACMqwKtstM8vsuacAq2xjhGmPGK/ZPJgUg9lGFjqRWRKzab8OlNEdG4j59ZYFz1D9YsOZqC3+uizZCLtPRWxRSRu4bSOMR32P3IR6hm5Z+OEM5mbKcxvNCxtocfsz5tszLsuuVQFFIikGzwuHDo0MRO0aDqqTuUYxkx9xS2VJWJas6aCIyui5i0VtzQwpzyeKaRcKhUKhsCXYKKY9TRPuvffelVCKfuekws6pXZ+/n9leFpSB6+N6rEzboXqdH7MT282Z3jgKpsC71HUYtoF3jYrNZm1UiHTazBw56EYU+tLGi6+NGB3rdTP23Fpbe5fOrnesp/R1qvCoKowusNpnZtjRmCu2xIwxCgBk11poSBVEKAtJq9xoIv0eS7vYhTLSX/fS4ka6/F6gmchdUAULitBaw87OjkxIEbVTseYorauyD8kClyiWp9ILe9g6s4Q49hmtO07xyesgey8oiZG9V02S5d+z0TPm+6lcKv01/D0LZ6ukMfyuzNzSimkXCoVCoVA4EDaKaQN7bBuIGaIKTJBZN/Z2xZnugnenvDvOktFzfYyIvRzGro4lCBnLYKbFenBmN8CqVKOXQMSXx+dGgh2MJqTY2dkZKldJXkYsV1WwFWPT3jagF6I1Yh2sM+VgQnyvbwNLPJiBZkE8WOJhayha38p6XK0D/0xyECEVAjWaN7ZXyeaLGeLIc8XjFbEvZe2chbxUVu8Zi1UM2yRwEeM3aZ+ldbVPJXkBdKAflt5EFu/MsFnCxiGn/bUGpdv2UjqDsvfg+fJ1sERHMexIymEopl0oFAqFQuFA2DimDazuuv1OnXenKoXciD+r0oOP7Kwyq2HeffM1EZtgS2PbaapEBxHzYUtQLjtLGKIs9SN9YY+pZklblDW0YiPA6m45AzOgiM0oZhoxQ2bSxmaMvbCO3ts2MFtQ/svR2CorW26XbwP7Eit9tGc+bOmr/OczzwN+Fvi8v5dZmQoHHOnBbTytrcojwZejrL65b/fdd99Ke/2YK99wXrfROI0moIj0+LxWjGlzuFlgb+3xPLCEoqffj9oeWatzsiSVRjYKuWzlcQhm9uCIQgorHXYkIeHnR4WujuwhuI2bgmLahUKhUChsCTaKaZs+m3UixmqA1d2W2jVmu0llfaqiNflr1PdI52uwHTDriaN0nnYt72Ktv5FfNUftYr9MtnSP2s19z6JoqeQJ6jNqi6o/0i2to9Pm9kd6SWbU7EcdsVibF7PEZV2vnc+Ygdrde2kKJ7PhtRjp+pjtK7uLKIaBtc3qVdHsvDcDj7GK+BY9gzzGHK0vS6XZS9YSRd6K1iLDmDZLwqLoZup79D5S9jcjPtCcmpclEpEExuI0WD94TiOpg4ohoGJM+HWgYktYO44dO7ZyD9sEqMQkUf96Ecoii3rl46903f7/qM+bgGLahUKhUChsCTaOae/u7spY4RnUbja7xpAxONZDKetkv1Nj/1+25mVLbX/OdtJ8TaZzZDbM/pPsLwysMh1lyZpZnCqms461OsO3g5lxL2Z2b1fO7VaW836c2CqcGQkz7CxOPu/qmT35/5UkKbIAt7pNIqV0s+wb7/9nNsFMO/O15fFj9uTLUjEEDNFzq3SLGfNax8ffmDZLMfw9Nlds/xLNB4PXnWKTWTph9Q70Eonbb78dwGqKTO67X9+2fvmTbQui+BEWd8IYNUdxzN4tKl+BIYvApt4vkX6adeYsuYje36y/H7GlOZcopl0oFAqFwpagfrQLhUKhUNgSbJx4/J577pHGUcCqiJTF1lEwEF8+oA2DRu7hdkTieHZrsLax2DAKkMGiRh6LyG1EiY1MXMoi3ahNbPijEmREbVkncEXPMCgSU40EYGmt4ciRI9JIDtCBJHjMvZhUuYf1wrFGfVIqlShgRc+9JapHha3NVCuj6QcjESGL99mQi8fZH2PjQlZVrBN4xBAZ2PVcGj2yOnupUqNnUCW64WeaRbb+fw5GwmJlf97E1bfeeiuAVaNGg38P2DvCPpV43Nro3xNWn0puFIm4eY30jBcjF7p1xONKFZUF38kMBDcBxbQLhUKhUNgSbBTTBvaMQoDYQIOhjKBGAgj4On190U7tIMFHrFzbgXJiBdup+mO8o1dBLrL0c9y2KPCDSr7AoQnZRQNYZZVqZ5q54DAyKQf3R91/6tSplQAjUbv5kxm4H3PlEsOsPHIX450/r01row/Iwm6BnEgmMmI02DUq1GrEZth4kdkfBz3x16p+ctlR0gdm1FlgHiVp4XWWJX0YYdpZ+EqVzlfNaXQtl2v1RUw7S/mp6rN7jPnedttt+8qNglXxOvZrMWsrsGpwxmuF15Y/p6ROLGGK3qvKdS5LNqMSrEQSJCXd3BQU0y4UCoVCYUuwcUy7tSbT9QFxIne+339G53hnxvqOKLF8lIjEI3L5MnDoQetXxLTtWk4MkIWV5N0rlxUFKmBWpHaT2W6TGfyo7jmrNwvc39O/7u7uroyXnzdmmooJRXpwZq2s2470t+zGp3TOUTAXvzaAVZsDH3BIBTfhQBnsCgisurcwW4lsEJiV8zPJenhfHz/TIzp1lSgiW2eZ1Ce6dnd3d6W86Hk5yHtHtS1LWsFMmiUsbBvgy+EgNCp0KLDnHqYSBmWsU0lYMhsKdgtUQVxU2OOobVniJ7W+ud7IHqKYdqFQKBQKhTPCxjHtnZ29ZPScxg/QjDfTmSrdB+ttI0aqmD3v2KIAGdZuK/+OO+7YV6bvF1/LTIeDrHgw01aBMiLdktLnK/2hv0btSEekHQojOqYI0zSd1msDq8kzRhCVz1b2/Mks19fH7FglWImYr6VV5PZH3gMqDCuPNbMbYJUlWbnG+COmrQJhZKF9+V5+1jKr4Z6Xwog9RM8C2DPtzF5EtSWz42Dw8cyqn59dnmsv1WNJGz/LFl40Ggu7lgOzcNnZM63sPrxUKAtG5MvK5ksFzslsn9S8ZeGw1/GOOZcopl0oFAqFwpZg45j27u7uCsP2O1C2blS6F1U2oJniyO6OmQ7rj/3/HIpQlenLVWBpQKR3VczXdr6+PsV4lCVmtjvntke78h4Li8pindnIjjfTpyrfTGZJUYhY5WfOffXtZy8IZk+9VI1RfZGkSek/+V5jzyMWuZlfvYoLwPdmrExJxrL11rPczpClVzQJDdtDRLEJ+HvGxnqMWsUJ8MeYtTLT9utNpZi1T7Mm9/YSvEYVovU3Kg3Ikhsp3XWmn1Y2TxFrVu+MkdDVymPgfKOYdqFQKBQKW4KNY9reT5sjLQF6h5TpQtTuXVk9++tY18w73MjCfSRg/rrgMiJfcsWSo2T0SleqGNeIdeW61t4eGZNX0aEiKAttVQcwJnFRrJzZcsRimVVk0dMUe7XjHCnPl6us0lnnGElp2MKdJRXRPcwYVdTArH89X2b/v3pe1frz6K0dbw8Rsb+eRG+EaRvYyjuyOeE0u3xNNLa8zni92af5cQN77yp+53KClChaILNmblsUu0ClV+VnMJJO8rtW6bYjpr2OXjqT1m0CimkXCoVCobAlqB/tQqFQKBS2BBslHp+mCSdPnlwJAuDFKybOidxXrAz/6f+PRNnRvV7MZkYbdo/Vz+Jjf48SrxyGmDyDMnzKDGt6ItvInacX4CZC5tLjv0c5jNdRMyjDMUCL5rI2cLnriGbZIEcZCEaJIuwcG1BFaiAWV3M/uY1+jqMAL778yAApEplHbY1UKyzi7q0L327+zq4+UVCk0TUaBXXy9fJYKjVS9N7phWGNnjEO4pOJxbk8u9bcBll87V2wzMWrF9QpWgfKOE59Zu3nMKms2vPHlPFs9u438FxEc8P3rKPmOxfYrNYUCoVCoVCQ2Cimvbu7i7vvvnslXaQ3frBjbOSjXAY8Rt02PGNQrl5ZYgqDsXQr175HjOcwWDi3gQ01/I5X7VrZoIqNmPw1yqUlS7+pAnFECQk4EUHmtmPIwrOyYZZKXhAluOgZIkWJVXqIDLjYYIoNguxab6hjx9hIjdlfJBUyqJS3EVQiGmZlmeRCPXuZ5KLHtDwyV7zo2tbakKRFjanhIM9xxCo5QIqSbkQSPjZa5LXj59oM3ZhxR+8MX7Y/13Nl8+DnxOpRqTOjZ149kyOBWXpGjcCZGdSeC2xWawqFQqFQKEhsJNO2XVbknG87MsXqMncdFQSE2bRnOxwW0/RBrNf1beRdOO8uI1291WMMah19cc8FJ2J/Ksxn5LrEUDvpTJ/MUEw1cs2x8VIhFq3unZ2doV02M4QRVqbsIrJ7lM6V14cPdsHrTbEHH8yHbRmYlXH/olCb3KasfmbWzHxZh+/nlMNvKqad6TKZmWYhKEeZr2faUTKTbAy5HG535j7p6/PrgPvM4YwjuxKWJKkwtpErG8+7CjQTrR2l5x8JmMSMWr0X/Dl+v/B7KArtymUYIskOs/By+SoUCoVCoXAgbBTTnqYJ99xzz4oFbcR8VQhNX1b0f4SRYPiKaRv8rtzaZOybd60+iIKB2RIzzsyikS07VbCN6H47xyww081y+Uq3lYW+5OQGrNPyx0z6kDFtK5OlJx5qB63CfkZQLI91kP5/Y8XW/oz9sTSAEyuwN4MHPzfKw8LDyuXgKszavF0Jjw+zPqV/9e3mccyeZ2aszD4z6RrrhEcQjW3P0yB6h6j3DjNSW9++77ZW1HPDaxdYTRfLiOxGDOxFoHTP0XtVzU+kq1fJlPjZjOwvVN+VbY1HL8lRZi9TYUwLhUKhUCgcCBvFtE2nbbs92/1E+jtmiKxH81A73hEdme1amWEzA/J1WJvsGt65R7olZqkcxo+tKiPfR5UuckRXG+2KfbsiXZb6zMJAcluUjgtYDQfLKUcz2Hh51sH6euW3HfVVgfvhJSSWCtHCRtp3Y1FZ8hdmuFGCCAbPO+s/I3sFluwwW478uFWCCCXxifqnwldGdhjKojyzNOdj69iIRKxyNLbDiE6bjzP7BFbnw5B5aCir8cxmQ+l8mWlH/e+lyIykhhwmlcdGheD1/6vUsxmUNEDp0tct/1yimHahUCgUCluCjWPax44dW2G3xlD8MaW/XUf30vv05atdcsQqOQIa69Mi/V0vaYWy8o7aqBIRRL6IvCtmRBaavIPnejPbAK4/SxRg+lv7XIdpZ762Bh7jSC+p9GaqDA9O22qfxrwjTwGeS8WaovngeeA4AXY8Yk1Kpxf56XMyC0uXy3r4iKX3osQZIparntPsecokEx7+eYrKU8+liuPgjykra34G/RxwIg/V5yyRi/KfztYbM+tMEtezAO+9W6I287VRfAhlc5JJXFQsDvZGAlbfa5uGzWxVoVAoFAqFFWwU056mOT2eMevIGtL0gXaMWW3mV6pYsiHz+1S+1gaOHOTLZ6YdsRqOr827VGZYvu0qjZ+NX8TOlHUtW61HfejpsjNdUI9hezZtx4wxRun6uGyeU98fHg9mPBHrY6tWxdajvkfxmv09kS6TmS17IkRsWUUgY71xZKXMFvqMSJJg680YNrfR4C3ODYpRMfvPvD8Uw46YdmZhbjAff362o1S2qk4lMYjawCyWr+P/fbk8X5GEL7MwZ/RigSt9te/HYUZzVHEDfFt7kotoHahYHJEEhcsrP+1CoVAoFAoHQv1oFwqFQqGwJdgo8TjDROGRcZKJUdk9jJMmeKjAISySicLuReE1o7KB1VCABmsbBxZQdUdtjNLdcdo+Jc6JxFgsSlNJGCLxkTJwiURb7GLBolt27/LXRoY6jGmaTqtXfNt8ef9/e+eu5LiOBFHoumOvvf//WWuvP8ZER2iNG3Wn9nRmAVJ3T4sReRy9SAIiQQlZL/z48UP2t1DmPp4zZwpUKVllPmZAGlOlej9YZKd/P9XeWr44DB+ngiyTa6gfY/fe1Oe13pswXQCmut+m+5SvXcliRy9jqlKjXL9OzOJTAZa+Xb9vGXDLe4FFUBQufWpKaeT1mFK+PgKLVrngWZVq6FJYp2A5jnMVyEdc8OF3E6UdQgghXISXVtqlTHoh/VKrpcIZXDSlfxS74iAdBjK4xRDUAgdFzeZKedUMuCtHKkPXZ6rq/vyZYgC7RVT4HTpK9bt+uEBBFtCZCjHsAtFUe+o9t6SkWmSCipAlO11J17V+j8267hVgWa+5oMxav8+Ds2aodBQXWMfgSaUGOZ6otJQKZIBova5HqiQ1dmg9mdK3nBrk64+owfv9/q6Ua2/XBS45i8Fa+zKbJ+U33UIe09KVu+JBHReUyzGkSkrTKuSCvNT3qbHDseIKRPV9nXVDWcpYJtmVTZ1+O1+tyEqUdgghhHARXlppF724Ss3QmA40ldAknOmelAZ0hUtU+ULOQDmrU2kv9Zy+qp2fsu/rUn3UzJ5+0GqPKXRTeT+3QIjyBbnZNwuPqFKOyprxDFTaXLjlpICEU30qnoDqu9pzqWeqT0WNe9X30yIQLtZiLV/KV6UY0urD78XiKso37HzbatydFEFiO85ioLjf7+vt7e2fsaeuy66E6jTmd8paWWm4Te/rWjrWxqX80aKkYl5cvADHf2+PVkH+hvDYvU+u5K5S2IR9nKyeLkWPv9uTVSBKO4QQQghPcVmlXZHApdA4i5yKM7gZlCq7WFBVUJEq5btbPrTPWpVi733n7FKpZkLFoPxDbN/5blV7bnlSFvNY6/d5o9+QCntS2s+grosrr6i+K/3qPNak4Hgta1yx7Gc/hhurVCBdabulMdlXhVOK0+IMzoLglkxUi2iwT5M1hfeTGw9K0avPyP1+X79+/Xq3jSpG5O7HqZ1T/+lUktTFK/R9nLJ3WTPqvdP4n963QkV8cx+OHVqOplLIuzK2any46HH3fftx3evvJko7hBBCuAiXUNp9plNR4+XLrnzGUkTKJ+jyJF0EsFKkXH6QnytcSU2Xi9v3cSpWzUDdZ9Nr58uhv1LN0l1U8GQNYJRrbTv5tPneMz7t3i79tXVc5vb3c++idp1ymxSds9L0cp/u+FS1nd2YnNTSTlkpnzbVP6PIJ2Xi8pwnBUTLiFNCzyqiihx3sSD9+XR92QeX9+3iBiZrlsoacG27eJRdLQi1zXRun/ndcfFEtCTxHlF9otVBKW3Wh+A1Ud+P13qqD/EdRGmHEEIIF+ESSrtDZUb1Wo/dr+JmnG5G2GezzscyzVp3Vc2UYpgWPFHHVEsJcobI9/sMVPnt1/L+8Skv2C2IMbXHBUKU75if7VTODuZ5Vz/pTzuJHq9+lqVHKYOCEbIufqC/x8hct4Qin3e4rVLaTpW7bIne33rkQiFkiup2lgVVldBZWmp8PJtdUNX0pj4wJoPjQS1WQZzPfFKzvB4u5kQdx+WWqxgD9z0mH77z1U81BXbZMJMlwY2dKaLeqXP+zk3V+z4SU/MVRGmHEEIIFyF/2iGEEMJFuJx5nObDMldNKVgFzScnJppdkfopRcW1qwIcptJ/ih6QRPMhTZpqMQuHO4+9PWeOnRZ74L5cRIOm8LXeB6B9NPWi2mAAYn03VcKVbdcjg9im9KZqh+ZxFfjG9k6u2a74A03d6jy6gCdV7MIFDbFsatGv6a4ghgpMO03V+8j4KBP5WtoFwcBMZzae+uBSlQrlmtqVKFauFf6OTUFlu8CzR87tM8WqXPqocje4AimPFJxx7sf+2rXzKkRphxBCCBfhckq7YCATZ8J9FuuCGzjrU0slurQmBqRMASFU1nzsx9ktkTgFedV7FRjEfqhUtl0gkktB69/LKYcOA6vqu7OoSqX0qX0+izouF2lRs34WeOFM3S180bfluaM1Q7VHi8TETmkzXayfT6pmBhfRStDf26X8qAAxKh63YMi0AM8uaOoZ7vf70QIevHaTFciVFebn6vWuINTJAhcMQFXnyf1W8TpN96CzzqjxsSsh7frRn7vlctW1mAJ4O327k6I030mUdgghhHARLqu06Qut1BvlC3SLB1AJqeIQblbnfHG9PVd+keqM+6vXRKkXplVNs0xXvKNwxR3U8U8WCqj+lqp1i9L3tKxHluJ8hmqzxlBd/35dXPlVLo1YxX5UegvHGVVt/55UvkyJmnyMU2pPp8cnsD2nNicrDS0Gk+WF6u+RUpQFldBnFL+43W5Hiopqsq5LjSG1bcHvys/VPb1bZlONNy7969JVezuM8+EYUhZAjkHXx0cKQrnfzv7c+bBdzIM6Pn/vejtT4ZVXIEo7hBBCuAiXVdpUOFQ+veCDW+yB/iHl06bfs5jUBFUDZ4TK//kRqDio7JSfcFoQpKN82dyHflhVxpQzes6KpwVDTpeefBZGqaviDFy2kVkLqmhDjcF6PFlQoc4tlZyz+PR9XKRsoUrxVju0MnEMqTgP5++cIt9pXaCSU/s6v/FnRffebrf1119/2fiOzs4nq2IQnKKezqPLWnDtr/V+LLqsAWWFPCn0wvedVWZX1rS/56LXJ6XN3/pdaWHV/9pWxXmcLCrynURphxBCCBfhskq7YBTyNOtyvjHOWvvMsGbOVOGPFO6nyvxqH4lTOsqX5XxY3E4dxymFqbRrXSc3o558mV+luKsPFbnez0H1l4qKSltF9bqYCe6j1Ett6xbYUPEQbly56N7+fGd5OVFYvP7qevH67zIt1vJ+fVpini1jutbf338qM0xFSv9x/T5McRjOmqDao1WO8RDKp+18zI9EZPMc8l5XUdY7lCXpVGGriHq3QMgjv6uPxIbEpx1CCCGEp7i80uaMtGa6PULWRbtyFqlUBiuicUGSqYIT+VMztkfyVjnDpR+cPla1D1HR5PQ/UbFO+ch/yqdEVd2f73JRle+fn5Vvm/60fm6pzqkmue9aPmqc41sp7V3+r7ouLtPBKex+b7hFLKgCp8wKZzH7CLfbzeYod04XWFlrv9AN7wUVc0L/LceSqjbm+jrF35xaA5XFxY2Hk0yencJWmTy7xZUe4STSPHnaIYQQQniK/GmHEEIIF+Hy5nGaj5RJypURPClXN5m/1Ha9Ty714avN5DSLPWJeduY4lfLD165gSv+MfZqC5fjenzKTVxrhWu/XDHfmZC4c0p+zFCjPn3Ll1HsMPFLnYjfOTtY3LlzamAoIcuP8JPDJbaMCuWg+/kjAmeO9ClcIAAACJUlEQVTt7W0sIVz9devNK/cCTdzOBaGKrbjzxPtSpXypz9bSCwe5lEUXVDj9djnTt7qmLljXPfK5aucRpvTIk1Kx30mUdgghhHARLq+0OUNXMzQ3I3PpDeq9mnUxAEQdu2arDFY7LWDwWZykLlBJUWlPRSOoQtmuKozAbVyhm+n7fBVKwVUaGAuT1LX8+fPn/+3bi/ow2K62nUpRMh2M7TqrUf9sp7wnpU1LFQPi+nOXwsS0tKkQzJTqVbjSlo8EXE7c738vy3kS4MSxPbXNMc1t3b231vtzzGvL4jSqvV3QnPrMHWuyPuxKkU7BZO5auqJCU/vPpHxN99Gr8tq9CyGEEMI/XF5pF0xZmJbmdLOskxm2W7xd+YmorNneZyx0oDjx/fB8udmyW3RgrfclANnu5I9y73fV/hW+y0epPpSfm77mQqkKpm/VMdQSoNzHpZKxmIfa1yk85Zd1aUKugAW/Y9+Gi76occ8CGcWkzlwBkM8qY1rHmJS2us97XwqlfB1UiqqUpivlq6wmO0WvXu/U6SMWMKeSlQXBbTMVx5piJT6KOg+0Nr0KUdohhBDCRbi9Uom22+3237XWf767H+Hl+ff9fv9XfyNjJxySsROe5d3Y+Q5e6k87hBBCCJ6Yx0MIIYSLkD/tEEII4SLkTzuEEEK4CPnTDiGEEC5C/rRDCCGEi5A/7RBCCOEi5E87hBBCuAj50w4hhBAuQv60QwghhIvwPzc5c41f2itHAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -1506,7 +1211,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1516,7 +1221,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbwAAAE9CAYAAABwXNeiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzsvXm0betZ1vnMvc8599w259wuN/dCEpqINCJSonSBlEIEEkIroNIEFRAFBYc6qgQkYDQiBMpRiCBITxAQRQoUCFUEQSgEaQoqIoHkhnS3Pfee251271l/zPXs9e7fet9vzrXvSVJxf88Ye6y91przm18353qftx3GcVRHR0dHR8f/6Nh5Z3ego6Ojo6PjHYH+g9fR0dHRcSzQf/A6Ojo6Oo4F+g9eR0dHR8exQP/B6+jo6Og4Fug/eB0dHR0dxwJH+sEbhuGlwzCMwzC897XqyDAMrxmG4TXXqr13FoZheMFqbl7wdrzGS4dh+Mtvr/Y72hiG4cuGYfjUd8J1n7vaW9nfy6/xtXaGYXhZto+HYXj5MAwb8UzDMJwahuFLhmH4pWEYzg/DcGkYhtcPw/CvhmH4oOT4YfX9OAzDi65x/z+mMVfx7zuu0fVevGrvT16j9l44DMNXJp9/wOo6n34trnMtMAzDlw7D8LphGC4Ow/DaYRheeoQ27hyG4dxqbB/6duimJOnE26vhjrcrXqpp7b7zndyP44ovk/SLkv7tO+n6r5D04/jszdf4GjuSvnr1/2vmDh6G4WZJPyXpT0j6Vkkvl/SkpOdJ+mxJr5Z0B057vqT3WP3/uZJ+8ul2OuC/SPqw8P7dJP3Iql/xOg9co+v94up6/+0atfdCSV+iqb8Rf7C6zu9do+s8LQzD8OWSvkHS10j6T5JeJOm7hmHYG8fx+7Zo6pskXXo7dPEQ+g9eR8e7Hl4/juP//c7uBPC/S/qfJH3UOI7/JXz+85K+YxiGT0nO+TxJVzT9oL5kGIYz4zg+ei06M47jY5IO5ihoo/5gydwNwzBIOjGO45WF13s0Xu/thXEcL7wjrrMEwzBcL+llkr51HMevXX38mmEYniPpFcMw/MA4jvsL2nmhpE+U9Hc1CUtvP4zjuPWfJoYxSnrv8NlrNEk5HyPp1yU9Jel3JH1Kcv5nSfpdTb/o/6+kT1md/xocd8dqAt6yOvZ3JX1h0ZePkvRjkp6Q9LCkfy7pehx7g6Svk/QGSZdXr18haScc84JVey+R9M2SHlr9fb+kM0n/XiXpMUmPSvpeSZ+8Ov8FOPZTNW3Up1bH/oikZ+OYe1fX+SxNkuKTkn5N0kdinkf8vYZznPTzWyS9aTWPb5L0fZKuC8d8nKRflnRB0vnVXL4P2vEaf5yk31wd+xuS/rQm4ekfS3qbpHOSvlvSjeHc5676+tclfaMmyfopST8h6bm4zklNku29q3W6d/X+ZNLeF0n62tV1H5X0f0h6t2QOvlDSb0m6uFrPfyXpVhwzrq7zN1d743FND+z3xxpx/r979d0fkfTvVmO7KOkPV+t84ij3WTIGj/mvzhz3t1Z77dxqTn5J0sfhmBOS/pGk14c5+UVJH776jmMcJX3l6tyXSxpDW+8u6aqk/22Lsdyg6b7596v9NEr6omsxT8X13nt1jZcW3z+k6VnzNyS9bjWej119909X+/3x1dr+jKQPxvkvXrX/J8Nnv6aJ9b5otfeeWr1+/ExfvyGZ+ydW333A6v2nh+P/jaZn40doYrYXJL1W0p+VNEj6+5rueT93zuJ6pzSx+ddpej68WZMW4eRMPz9+1ZcPw+efuPr8Qxasy/WaWOuXhzn8UBzzkZJ+TtIjqzn8fUmvPNI+OOLmeanyH7y3afoB++zVJn71auPE4z5G0r6mB9OLVm394erc14TjbpH031fffcHqvK+XtCfpS5O+/OFqo7xQ0ldqelB+N27wX9D0Y/hlq83wFZpu9leG416wau8NmqTWF0r60tUm+h7Mwy9oumm/RNKf06RifJPwgyfpr60++05JnyDpMzX9oL1B0s3huHslvVHSr0r69NUG+I3VRj2zOub9NAkUvyXpQ1d/79dYq7OrjfzwalP9WUl/QdK/9rVXa7W3Wq+XSPqLq031oKR7sMb3SfptTT/KL9Z0Y90v6dslfddqHr5Mk+T+T8O5z13NwZvC2n/+at1/T4d/zF6lad987Wr+X7Zq71VJe/eujv94TYzhIW0KTv9kdf4rV+19viYh6lck7Ybj3N5Pr+bh01dr9Pta/WhpUtm9TdODzPP/XqvvXqfpgfNpkj56NY/fL+nU03lYJ2P+Qk37+eAPx32jpL+8WuuPk/QvNN1zHxuO+WpND/AvXfX1JZL+oaQXrb7/iNW1viOM857Vd/zB+9zVsX9mi7H8pdU5nyZpV9JbJf3nazFPxfWW/OC9RdO99RmanjfPWX33vav+vmA1T/9O0/PgeeH86gfvzZL+H0333MdrUvtdVCKUhfOeLekHNP34eO4/ZPVd9YN3TtOz93NX1/nV1fr+M00/ch+vSTh8StJ3hnMHTerxxyX9r6tx/21NxOF7Zub076z6cjM+f8/V55+3YF1eoelZtqvkB0/S7VoLRi+S9D+v9vY3H2kfHHHzvFT5D94VbII7NT1I/3747D9rekhGVvWhAlOR9FWrjfE8XPvbV5vzBPryrTjuK1bX/iOr95+zOu6jkuMuS7pz9f4Fq+P44/bNq/4Mq/cfuzrus3Dcf1T4wZN0kybG9J047j1W1/2y8Nm9mqSYs+GzP7lq7y9irn9x4Vp97Woe/kTjmF/T9LA+gf5dkfSNyRq/Z/jsJav+/Sza/LeS3hDeP3d1HNfeD9a/ghv6ZWjvK1effyDaew2O8014dzhuT9I/wHG+7ieHz8bVPMQf309fff7hWKfvR3u3r457yVHuqYVr6TFnfymL1GSLOyHp/5L0o+Hzn5L0w41rmeW9LPmOP3hfsTr2vbYYy89oekifWr3/+lUbz1vaxpZzt+QH77zAfpLjdjUxojdL+kfh8+oH74Kkd0/W8G/OXOcbJF1MPq9+8EYF1qmJqY+aBOYhfP4vJT0e3pulfSqu80Vz66FJo3M1+fzM6twvnxnjH9P0o/7hmMP4g/eC1Wfv2Wpr6d+1Dkt43TiOr/ObcRwf0KQCeLYkDcOwK+lDJP2bMeh2x0mnfi/a+jhNEvgbhmE44T9N0vdtmphOxA/j/b/WdLP/qdDeGyX9Etr7GU0qNHoG0YD+25Kuk/TM1fsP0/Qg/dHkuhEfpomt/gCu+yZNaoiPwvG/PI7jI7iutJrDI+CFkn51HMffyL4chuFGSR8s6YfGcbzqz8dxfIMm4eSjccrvjeP4+vD+d1evP43jflfSu61sIRFc+/+s6eFhBwPPx/fjPL9nf/4D3nO+PlbTPuD8/4omqZbz/+rxsN1m6fw/rEk9+E+GYfiCYRieN3O8pOmeiP1K5ivDyzXdRwd/ce2GYfiQYRh+chiG+zXt0SuaJOP3CW38qqRPXHlcfsQwDKeW9PdaYBiGezSxzx8ax/Hy6uPvWb1+7sy5A+Zr9xp27edx7/manzAMwy8Mw3BOk+bhkqR7dHg+K/z2OI5v8ptxHO/VxJ6Oej9XeGAcx18P731f/sy4+uUIn980DMOZ1fuP08SgfiJ5LkqTY9E1x2qff5uk7xvH8Zcah75Wk2nnu4Zh+AvDMNz9dK57rX/wziWfXZJ0evX/7Zp+XO5PjuNnd2p6GF3B34+svr9t5ny/vye095ykPRvY2R7HYg8ij+VZkh4ZN43a2Tgk6WeTa/+xueuO48jrbovb1PbgO6tJrfG25Lv7JN2Kz/hAuNz4/IQmiTiiWnuvk6/H/tyH7425dfL8/7425/9mbb/uKVYPlY/VJNW/QtLvrVzuv7h1nib7RezT580cL0lvHMfx1+Kfv1g5DPysJiHrSzQJEh+iSV0dx/APNbH/T9Zku3toFT7A+V0CP9Cfs/D4z9H07Pn3wzCcWT1836zJ5v/ZMz/6f0WH5+u/H6G/FTbugWEYPlKTyu9+TWvzpzXN5+u07J6ceyZeK2xzX0qH749bVn2K82qhlvcHr7m78tCN8B7Kxm58vqT31+Tc4j1w4+q7m4ZhuEU6IE1/RpNZ59slvWUYht88ahjLO9pL8yFNk/nM5LtnamJgxsOa2OHfKtriRn+mJh12fC9Nenm39wZN+vkM9xafV3ibpLPDMJzEjx7H9vDq9aXon/H4ltfdFg9p/WOS4RFNKoO7ku/uUnvTHgXV2v/m6n9f7y5NPwaxL/H7pfD8v1CbN3/8/mljxXw/d/XA/uOafnC+ZRiGe8dx/I/FaZ+oSXNgvOFpduMTND3A/vw4jhYSzORjXy9r+mF+xTAMd6368Y2aHoR/actr/pwmG+EnalKdzsE/6tWcfLTqUIgf03qvSJOZ4VphTD7785pUnZ85juOePxyGofVD8K6EhzXdFy8svm8Jy36evb8Oe45a+/baxrnvp2mf/n7y3as1PbffTZLGyev3k4ZhOKlJ4PgqSf9uGIY/Cm3TLN6hP3jjOO4Nw/Crkj59GIaXWbU1DMOf1qTbjj94P6XJoP6Hq1/5OXyGDt9sn6XpJvyV0N6nafJ2+l09ffyyJvbyaTqsxvwsHPdLmn7U3nscx+/RtcElTexkCX5G0lcOw/DHx3H8LX45juOTwzD8V0l/frUme9IBU/hwTY471xJc+4/QtLF/efX9f1q9fpYmL0LDD+HXbHm9V2vaB88ex/HVR+rxJi5p8i5LsWJ7vzkMw9/WxEg+QMXDfRzH384+fxq4YfV6IIQNw/C+mh4U9xZ9uE/Stw/D8Ima+qpxHK8Ow7CvxjjD+W8ahuH7JH3xMAw/OB4OS3AfPnkcxx8bhuFPSfqjmryGfwSHndbEpj5PxTqP42iv6XcUbtCkxjz4MRyG4SXa1DRca1ySdHIYht34Q/t2wE9p8kzdHcfxV+YOBl6j6dn2l3T4B++zNTkh/dfGuf9Ck4d2xIdpsgv+DU22x0NYEYtfHIbhazT9QL+P1kx0Ed4ZcXhfrekh/GPDMHybJpf5r9FaZWV8kyZvxl8YhuGbNDG6GzXdLM8fx/GTcPwnDMPw9au2/9TqOt8bbIo/oIlG/5/DMLxSk2fQKUnvpcnx4pPHcXxq6SDGcXz1MAy/KOnbhmG4XZOK4zO1emCE4x4bhuHvSvrnwzDcoenBd14T6/poTU4Xr1p63RVeK+mvD8PwmZpY0OPjOFaqnW/S5C34s8OUjeO3NamWP0nSXxvH8XFNEtNPatLjf4smR5uvWfXzlVv2bQ436/Dav0LT3H2vJI3j+DvDMPygpJetbAm/pOlG+CpJP7jtD8Q4jn8wDMPXSfrmYRjeR1OYwUVNrvQfK+k7xnH8uS3H8FpJzx+G4cWa9u1DmqTVfybphzRJrbuaWP1VLWM91wqv1mS3+/7VfXO3prX8w3jQMAw/oemB9Oua1EUfrGk+vjkc9lpNdr5Xr455yziOmepbmoTT50n6uWEYvlWTWvVJTffXZ0v6QE3s7PM0CSBfN47jH7KRYRh+XNKnDcPwN7a5H9+O+ClJf1XSv1zty/fX5M3I59W1xms1qX3/zjAMPyfpSmWHf5r4SU1Cxk8Mw/CNmlTyO5qc1l4k6YvHcUxZ3jiOTw3D8LWa7NYPaB14/pmanIMObPXDMPyQpD83juOZ1bl/oMMaHA3DcNPq319f+XVoGIbP0CT8/rgmQnSLJi/SR1Z93Q5H8XRRIw4vOfZehfCA1Wd/QdMP2Fwc3llND+w3aNI9P6ApFODLkr58lCbX1Sc0qb2yOLzTmlzcHQN4TpPx/mVae32+YNXexxRjfm747A5JP6hJynEc3icpj8P7BE2qn8c0uQa/TlOYwvthrr4/mcND3nKa1Hv/YXXdDU/F5Pw7NXlnvW01j2/S5CTQisP79yri8PDZc5XEhq3m9MB7UJtxeA+u5uEnJb0Hzj2lyTHjjZqYyhtVx+Hxul4/zv/naJJCn1ztkf+m6eH+buGYUdLLi/G9NHz2RzXtw6dW3333ao6/R1OIxVOa9tbPa7rJn7Z3WWvMyXG+vy5qsot9hiann98Px/w9TdqPc6s1/++S/oEOe+p+lCZJ+5IacXhYty9d7aPHVnvt9ZpsL39s9f3Dkn660Xd7DX72tZq3VbuL4vCK7/7eag866Pv5mh62PxGOKePwims13eo1+Tp8x+rYfS2Iw8P5N62O+1/w+ZesPr8rfHZCU9D376z2zKOrdX+FQixto69/S9OPl2Ol/3JyzL/xGBrtZF6aH7g6942rvt2v6cev9Dpv/dnF/l0Ww5S37bs0uc9m+uCO/x9gGIbnahJcvmAcx2uSv7Cjo6NjG/RqCR0dHR0dxwL9B6+jo6Oj41jgXV6l2dHR0dHRsQSd4XV0dHR0HAv0H7yOjo6OjmOB/oPX0dHR0XEssFXg+alTp8YbbrhBOzvT76RfM1Tp8Jbkxl2WP/edg3e0zXPp9eJxPMfvq9f4//7+/uJzfKxfh2HQ3t6e9vf3Nxbw7Nmz4913332wtidOTFuvtYfm+rRtf7P3rWOzc5YcMwcf67lonTt3vWu9H3nv+X31KmnjeZAdk72Pn+3v7+u+++7To48+unHQrbfeOt5zzzo7Htc8fra3t3fou2oPtbBNv1vHzJ2zDY6yzkv2/rU4x1iyn6tzeD1/nj0fvMZeU0k6d+6cnnjiidkJ3uoH74YbbtDzn/983XTTFBB/8uTJjU5VP4a7u1MO4WxSeKNUbXAysu+qyc4mrrqJlzyAeAzbiIvBY71gHHd2A1fXrdqUpKtXrx5q48qVK4c+96s/l6TLl6ecsk8++eSh9z7G7T/xxBMH5zz11JQI49KlSwfjePzxPDXoPffcox/90R/VDTdMma/OnJmStV9//TpzFR9Ovravc/HixUOv8dp+rfrNB2L8jNfla5ynuWOz6/Bcv3r9+ZCOYB+9dj4n9q06t9rX2X3EPWnBxK+nTk1FFU6fXuc+9v9+Llx33XWHXt2WnxfxO/fpypUr+pzP+Zx0HHfffbd++Id/+GDMXus4du9b7z/ueb/PhBc+d/yez6zWc87HGq25nUNLoOM+q8YSj+HzgIifc6/wnEzINTy+StjIrs85531zyy23HDpOWj8P/Cza29vTK1+5LCFUV2l2dHR0dBwLbJ1LM0oyLYmFv+aUmlpqokoSqY6P51RSdGyzUsFUfW31qWKDsU2yP85BxgrZJ0s+PJbjlNbSuCW76rrxev7O5/p6LemQbCOkA9rAMAza3d09kOx9nWyO3V9K5b5OlAJ9jF/J8CoJOf6fSavsu1Ht1UqqbR1DiTgDmV31mp1DTQLXsHX/el0qBhvnxMe6L2aB2X1kmO35u52dnXL+x3HU5cuXN+bWay2tpX5/ls0LwefA3Gv27Gup3irMqanjOi1V0Wb9yFR/2TktlW32vI7fZ32tnqu8vrS5TrzHff0bb1wX+2g9N+fQGV5HR0dHx7HAVgxvGAbt7Owscjgg+IsdUUnYS1hVxXiWSD5kNZRq/Hl2bfaN0k1EJQW2JJPMBpS1mUmLlWRase7ssyVrwbm+cuVKk63s7Oxs9CmzAVSszNJ7lOxtz7lw4cKh95YclzjqbCNxz9klfN3Yx2rPcJ18btwntEHRNpXtk5bNJCJb6+oe4P0U7WcVk/DnZnwRbj/a9arnyf7+vi5fvryhffCaS2u7bpz3OXAv8rWyY8ZzyWYqNhW/qxxotmF4FYONfazObTnctNYgOzfTZGTtxvfZ/URmxzWOe4jzdvXq1cWOMp3hdXR0dHQcC/QfvI6Ojo6OY4GtVZonTpw4UEOYZmZqIlLuyvgZP6sMs5XRPWLOBTtzKSaieiW2xf+z67DNltMK+9FSQbl9z1+lpmip6raJSeK4KnVcduycaiGbk5bKx3vIakqrreyCLq1dk6nSpGqkpb6cC0fZRqVJ1WN2TLWXMgchhh8scbdnaATvo5azAtV6vsd5r8dz2acl4Q9sJzN1ROzt7R0c4+vF8BT/7z5k5oiqL54XOlLx80ylyX637i3u6yocpXUvV05k3EPZd9XzJ5ur6vnWuo+WhuoscdKiGcP3dTxmzuyToTO8jo6Ojo5jgSOFJVjayyQDSjHGErdtHstf8CXSReUSm4UlVNJl5lDhsc65dvv7OYk1HrvE4MqxVwwm/l9Jkpl7/1wYSXXcNuPI1jwLnHa/LLXb5dzM7rHHHjs41v8zOJ1jr9jHknG0HGuqwNlsrFWiAa5XnBP/T2ccOvBka8nQBTKYVkC173Fqc5w4IN7fPsdJBNwnaiWy5wWPqbC7u3swriwBga9Zre+SrFBkt2RAsQ0ew7YyzU/VN7K2ViD4NuB4KlYd12VpMo7Wc5wJAlohDpWzH59VkeF5T845nWXoDK+jo6Oj41hgK4a3s7Oj6667bkOnvYSt0cbWYgrbMJ/KhX1Jqh9LD0yBlKU2owRSSXaZ1Lw0dKJl46rObdnYKptntgZkXJQ6W6EoSyStcRx19erVRSmxmObMLO7cuXOH3kvS+fPnJa1teAxAZhqqzJ2e7zlvWUosf+a5bNm4/BlT8VVB5R5D7D/tmHzNWGEVusD7N0r4/t/pwphKzH0z05PW8+XgYH/ntqJ0blDL0MozOQyDhmE4GI/XOjI8apR4v2RsZs7WWaVHjP9XmqTsOeC+MNSD18/CrtinKsQgjs/7rQotyeak0kxV9vUIJn/wayv5QzUH3LtxrXnuNuFxneF1dHR0dBwLbO2led111x1IfQyYlTalfDKu7Fe50t/y+0yfPKfjziTIOT3/kpQ7vC51+q0Ae16PabBi+7R/VJ6rWdJYrxPtWJmdk+1UqauiNOj2YwBwhXGc0kOZIWTz5D5UzM6vjzzyyME5PoYMz+/dFm188f/M0zGOLyZKNou5+eabJW3auOjpm33G/U4WFxN0M7De4/ExZLTSpi3Q35EteFxxDWyHM5P1MWZtTNId4WM9R56TjM0z8HxOO7C/v79h041rWbEkspp4Hc+D++AxVWsa54nJKirbXcY+Ki/GzM48l8zZoL0u9rFiQC1tTWUH9msW6E8GTi1R63lavV+S9NsagCXoDK+jo6Oj41jgSDY82i+W2ON8DvXK1WdSbePKJKAqrRHLxPB8KZeOeM42pUM4FrI16vI5N3E8tL/w85Z3G6Vdzkm0rViy96vHY1ZlxDmiXefSpUulBGoJnXas2J775xIvFcOLJYh8jJmPpUu++vs4Zve7mkuPLzIUSuGeL54b15KeaGQjlpbJUuNn1THZuLjnmSKL+z2LLyODYUxkK4avsnNmeyNqiyqWZ/uv2YTnIo6Z3qoVU2nZx7g3W7YuziXZFO/trF2DnohxL1U2Qj5DsuM535UfRcumxmeF5973XVwDn1OtRWYzNubWIGqRWinf5tAZXkdHR0fHscDWcXhRX5rpgKmvJ3vJbB3M5tDSf0uH7UpZst7YPkuXSJt6dkqkWWYX2mHISikNZjE7lKiq5MHxf3orVbGJLftflZA1izOkVG7YGzLzOjMTunjxYtP78urVqwf9tGQYGZ7Hatbia9JDK66Fi45W0rj3FGPE4v/0UCUDi4lrmcCYMWduI5snaih8rNfDdrk4XjJUemd6HiNz4VrS89KvtkPG0iu0rXE+M7uQj3UfH3jgAUnr++rOO+88dG6cC4/j5MmTTYZ34cKFA1abZVrxd9Xc0o4dj61KYXHd4php26yeYZ6D+D/n0u1zP2agtov7vJXhJ2OQUh7P6NfKNm5tS7yfqqxGnIvo4evP3H++z2L3vM/czu7u7uJYvM7wOjo6OjqOBfoPXkdHR0fHscDTUmkycFbadFKhMwSDvKU6TY/h9lupaah+oGotMzhTHUA1QbwOKfackTVTabLPRitUgwHNVUqxLOEwHUOqwGppre7wd1bZ3HLLLYc+j8Zjz1N0JqjqdI3jqL29vY2ksHFdqIayqoVu9PEcqucIr4/bzNyo6QxBtWsW4MxwEQZqZ2EpXJcqWUJUg1FlytpyDPKO/3vs7tsznvEMSes19ee+N2PfjCoJRKZC5TitkvZ1rH6OiKEzLYenCxcubDgzxfANhmdQPZzVUqTLO50tqOqMa+q59fxTtekxx7XkfPPZkYVQVU4plZNM9typ1LxZogP/7zn2nNM5igkdpM3nCh37qFKPc+H5O3v27KFjst8LOtLE9ubQGV5HR0dHx7HA1oHnJ0+e3GB4UQq59dZbJWkjwTTft5Kq0ohLCSVKWmRUlICyJMhVah8yvegcUQWW0ojcShpdJfPN0vVQ6qzS9SwB2S/HGdvjqyWwLBCdktt11113SFpkH65cuXIglWWuxJbK/Voxu0w7QGnZbMIOGZ6DWFqIrv4sNZQlq2aaLCYeyFjMHCuvHEXiMXRs8r3gOYnXNds9c+aMJOn2228/9GqGl13P7XMuyJCjZE9Jnk4LPjdb88jAqj29t7enxx9/fGO94ro8+uijkjaZCB1RIsMje+WxZEBx39FRx/Pv+8VrEK/nPrk9OrFkDl8ME6rCRrJUZ3w+02ktK7flvpmdO8mDz+GzJK4Z17dK2RjBYHX30fPnNqIWguduUyaoM7yOjo6OjmOBIzE8ut5GN1Pa0MjwjMjqGFJAO9mSArCWnugCmwXIUpJjsl2Pp5UWiONopfGhVEzJNytySJZraZaB5y02WpWyqUIP4jFkrpmk5f5Hhlel+DHDo40vCx72tbwPaMuLdhFL1txftO15fTJpljYnS7W0QUmbTLdKLRf7OJfqq0ouEP8nK3SfbPO47bbbDs7x/n3Ws54lSXr3d393SWsbHqXneP+R7Xq+aD+L7IpzQVtllrjb8+V2Tp48OZu0gH0zq5PWbvLcX7SXxrVkKEmWLi2ek9nwqIWwRsGvmcaH9yWvG7UkHk8VJuK5zlLasWxTlZ4snutjme7Q42uFUvGZy/dZmSgG8DNZtF/jPeK+xFSESzVeneF1dHR0dBwLbJ1a7PTp0we/7pZi4q+rJUJKIq3yEpVHJSWhVlAvPRJbyURpYyDDy8oeVR5PtMOQ/UqbHk2UYjIJmF6RZhsGJbvImBnozuB7v8Y5opTucZA5RwmZDO+mm27SQw89pAyW0s3IsqTsc59VAAAgAElEQVSwZJX0hLPEGO1V9I7j+nMfZKVqWL7HUi5tnrHftGnwuvGcqkwK91LG9Fmeya+2x91xxx2S1kwv/n/PPfdIku6+++5D5zIdWsa8PMeec9/r/txsUVqzP3pGklFkRTyjJqhli7l69eqGPTEyIbczl4Ag82Ikw+J9k3kHkzl6npjEImNeBtO2ZcWcuc/YXsVoY/tc5ypJurT5rKhSNnpOsvuJfaO3cOwjE5G4b0wUHteavgNPPvnkYjteZ3gdHR0dHccCWzO8G2+88UAKsHQd7SJGFbfmY6NkMvfrTBtI5iloVBJdlGoqScfIUvBYsuV4GFvi19g22RpZQJbE1cdYGrf3K2PDsthEMjhKv4yVjPCYGRMWU0AZHmtst1WMcX9/fyNeKh7va7n/tM+ZucRUWIyDM+htxnI68X8yK3rEZknEmbKsKjwsbTIgpmfy+yzRueF7zXNC1hGvy7JNb33rWyVt2qh9nTgnTPFEpsI1j9/NaWQik2KasDkb3qVLlw7W0vOZ2bwN3gO0EcX/6R1cJXWPe4zrTa9J2jHj+ZU3a+aFTrZMOxj7mCVjZxt8vkXmynhcPk/p0d5KrO7vyOLiM4QeypX/QdyjTH6+tDSQ1BleR0dHR8cxwZEKwPLXOEsEbcmADIFxF9Km3YjeY/RMzEqvuH1L/5Zis4we9ET0MYy7iRJdTFQa22P2BH8eJRLq+ZkMmbEt8X/31Z51nAvOt7RmNZSoLMG2YmjI+mg7amXYOHHiRNNL8+rVqxvSebQfkPm6L44bc1wZPTKl9Zw6cbE9LW1T9NizJLQsA8RCoJmHGOPfaMONbIaJdpm9ghleMq9Q3iPM1hG1Hm7X43n44Yclbdpc7SH54IMPHpxrz05mcOHnEe637z2OM2OsfB7ExOKEiweT5WQZSXhMy3uPNnT33/vN8OfRTkr7FFmuX7NsMNU5mZ2RmVz8DOF1stJpsWyXtBlTmd3zXG8yY9rsMv8Nj5nFYv19limLRYNpm8zie1mQYAk6w+vo6OjoOBbYOpfm3t7ewS8qdcNSHf9WlbuR1lKFJSi3YSm90nXHY90XS6/2TLN0G4uG0oOP+mLGrbG/Um47i32Lx1clc2jryNgRPZIsPVEy8lzFfrtdl2exRGTWE6Uzt1OVZmIsTzwmMuSlRTw9njhPluKYrcfSbca4vO733nuvJOnNb37zoXNYuDSea0nX7NkS6P333y9p7Qnp/kibEjYzq3BNPfbYl6pYbVY6q7IVk+m19htjmXzOfffdd6jP0ub+etOb3nTo2A/4gA+QdNiOSrZO+73HG/c37dfjODZLvGTelVnuWWpAeG9lbNPr+9znPlfS+nlkbUG2D7ISRdKmJijOrRk17dfMxBPtcGQ+VQ5NenzGz9we7ab2tM1ieM1ymU+UnsxxzfyM9Zw85znPOXRd31d+ldbaD7fj+eMzP4vdy57Tc+gMr6Ojo6PjWKD/4HV0dHR0HAtspdK02oGpXTI1FykpjZ3RME9ViF9Nuak2aCWAJb21SiBen+pVUmOmCeIcSJtUnyVEovqGwaNMm5MlnqZ6lcewInFUnVDlTPWnVQwxnKRKoO1x0dEhnrMkrY9LvLi/Vl1k6mmrGOlc42tHhyc76FiV6fdULbKSsrRZJscqLCMrC8MAY7fh/WUVul+ltaqHTgRUt2bltlg+heW2jCwcgkHEDJJ/5jOfKSlPIk6V4Nve9jZJ67l69rOffXAO1Xt02ffn0RmEyZezxNIE04PFtaR6nen8YviDYScoj+Wuu+6SdHjtpPX8Wf0W22faMY/R+zArl0WXfzreZWEwVPcytVdWIqdKiu3nAENqpPWcOlWd96ZDW7yHmeBd2nTG8vPbyRFYjktaz6nbrVS2cX/wnmg5yxGd4XV0dHR0HAscKbUYDfVR4q5KgTBtThZc6V97ugUz6DFKQJYaaNylC2yW6omMjiEM0QWbTg+WiugcQeNu7EMVYNwqD2L4WDMLX5fFHONcMMC4KooZ+0u3e65jlgrM2NnZaYYlXLhwYYOlZZKb+2eJsUosK22GFhhkZ36NhWK9hk5CbCmToSdxXegGTqbvcUWWwD3hNeT1shRcVZozMprI+NweA+np2GEnsSilm5mw7I377PFGNszSS1Uiiax0TUzRVzmtuOg03ejjmMlMq8TwUWtjBuL7hEnK+SyJ88Sgeju2eJ6oCYrjrxKzM5l5HEc1N0xAnaUW86v3PtcrPqs8P5wvt+F7xXsrnuvP7NzDPUqtXzyfKSfppJWlv4v3aWd4HR0dHR0dAVsHnkemRAlI2kxbxQBdS+2RXTDg1+/pus50W9JmULffW1rK0nZRCqTNoVVWnmCZeUsoUdJiolyD9rk4t2SMTJXEwPrYVwbs02bIuYntU1L0+vn7rDxQFcpA7OzsHLTneYtJiD1+s0DvK7MOhgTEz/xaJdt2/yPzYmot2ogyuxgTjPt6lnxpk4jHGplbfUS8N7xmboOsl/2S1nuDNlAf4762+uG1sJ2PDDru5SpFm5EV380SQ7RCWvb39w/6lEn93PPUUMRyTYb76flg2jaztiyRclU2x+FBTNElbWpRqLnw+DIGRP8GBprzWRLbZ7v0icjCfHyfUFtk9ha1egYTjDMVnDVMmc2Qz2Q+f7LSTCyOuwSd4XV0dHR0HAtsHXgekdnjqqTRTMWV6ZopiVK6zSTuJQVmY9vxO9o0KEHGNpYWt8yS1FICYeAkddLxO3q+GbTlRBZRFSnNmCT7RM8uznlkeLTrtGx4Ozs7uv766zckuCh5UwIl88/KA3FvMG0Ti+xG6ZYaBY+NY45zXxXxdTCtJfw4D9RQVEV2My0C+8gEx7TXxXMo2bsftG9nAeFsn/sjstDKY5l2+8h6mZ6wFXju4sF8hmRMgXubqdCyZMdmILSXUeOTPX8M7wOvAz1ypU2m7/1WFXmNn/EZWaUUy547fHbQ3hzXn1ogetEyhWLULNAuy0B3gz4gsR3aNZnEPF5nSWFwojO8jo6Ojo5jga3j8GKS18wbizpZlljxr3KUvLI0Q9KmRJUxITKFShLNUj2R8dg71NJEZANMA2RU0nkWf+N+b3Os54lzznnNygPxPRP2ZtIgvQ/5GvvORK/ZOGL7119//YatJbOTcn3INrOyMIxpqgpjZvFelBjpvZsxb9p/HKfkOY77m15qHDuLX8Y+kukzlR41KrEdFu81OAeZLZeSNtck7h2OyyCDjeyLabTsiZlhHEddvHhxg3VG7UBlH6uKLsfP/Eq7FL1Cs/4xBpHaicyWT09oanqylIZZqrK5vjEOk8+qjIVW5a/IuKr4wNg+v1tSFJdrSy9RadObvvXcITrD6+jo6Og4FtjahpfFy2S/8sx44NeMpTE7CROiEpn9z6C3YcZCeT1LXNYtZ6yQJYSYPJpxP1npnSyTRuxjllC7kmqZJSGL3WGMTiX1xr5V482yJGybvDWz8cVzK5smmV5WWoqlnmhbzRhqFQ9JjUO0PXGdnYibMaRxXPSsIzujZ2EEvUKZYadlx6hi05i1J0vMbDCOjawk9olMgvsiK0OzdA+5NFlsv5VsmnNNz9H4GTUgcwWpY78rdpF5hzKDE5OhZ3Fq9LTkXvK8ZdqjKnsS43PjGLje3Gf0vo/3M9ewStKf7bfKq5YZhbJ2ehxeR0dHR0cH0H/wOjo6OjqOBbZ2Wrl8+fKGMTwzKNJFtXLrlzZdyqlqaRlIScvpFJGpbaj+YS04qsPidagupNooU0tUqXUqR5F4bRqtqVoysmrpBtUR/DwbD9NqZcG3/KylChqG4VDgeeYEZDUG1cZ0sslc8LnffA5VzEvCU6zGySprU03s4Fq3VYU2xHY8zioJe6ae5pp6XFnleN4nVC210lVV16GjQAT3Pu/bzIxBR53s2vHzkydPllXN47V4L7n/WWiTz6GzCvd1ltzdYBiH32cqObrYcxxMbRaPpeqvUhtnYQK+rsfjZA9MChLngqaBbM7j57FPNE2xzmOcR84twx/oNBXHXN0bLXSG19HR0dFxLLA1w9vb29sojZElVW0ZlKXDknYVVEmpPHN/zhw+pE1JKJNEmCSaxvfooMFQiaoMUsbwmGiVfcrcdCtJigwjGx+lMTp2ZBJrS7qW8tCDzDlmLgjU0l62TyjlERnzZnmkKuh+bj9m4zGilM4AcL9aSs5c5rkelUNSFgg+ty4sMRXbm3O+WOJs5L3Lvmasl5oEhgxl+y0y0zlJvUobFlGl02KS4vhZ5TxikKnGvnLP+plIN/4Iah0q9/14bb5WiagjKk0PmV0cV5UMnYwvu8+5f7lOLWdE98HzxwD3LIH7XGLtDJ3hdXR0dHQcCxwpLMFSZUvay5Iax+8jqjAHSr5ZG9WxLT2vJSja7hhCkbEZ6vGX6Lbpyk62lqVHY1FQjoPMLpNyOAeVm3/WXsWyW+EPly5dmpW2qKPPSj1ZyuM+yxgJbXW04bWS61YaBCNziXaIgsMQGKROe0UcI21ZZIPZPeN2GGbD+yiGTpBVcG9yvC1mRbt2i4XPBVJnzDXadFuMcxzHg3uiZdeptCYMAYn/tzRIEbFN+h1UYQNZ+EYVipHtnczuFdvnuFthAm6Dpbnic4cJmavUfBwL/4/Xa92/ZK60gWfPE7K+Vsq3jestPrKjo6Ojo+NdGE/LhpeVjCEzoN62xRSIKlFqxFywY3Yci8VacrT0khVVNcjoeExmU6tsQ2wrlmBhIGmVCDrz1iLr41xk80gpt7I3ZqzX89diCk4OzBRwWVA3bSZkUZlUSemcnp0Zi+O6MK2S30evUCfTJRul52VWGLNieEyLFu8N9oXjIgOT6iQPVbB0Zk+njYp2wRYbq2xhkRUy6UPL3ui9w2dIZrfkNStP2PgZ+8Q9zxRwcSy0W1aJ8ONnZCRkh3FuK9sp7w0mwI/HGrThZeV6fIyfkU6kwOLV9N6N7VTek9QeRXBclSYj9j/+tvTA846Ojo6OjoCtbXixjEdV/kHajKmifr9l66GEUNmvYjtkOrQRRPbEBLyWXqifjlJnJf0xVivTK1PayzzG+N59JAvlOS1Ju5pregvGvvm6jAPMdPZLkkYblMKYQFfalCIzW6OUx1IZZHotO92c7YaJgCVteChbu0GmF/sYpeB4PTK7LN6UydZdyqZlv6iK+TL2scWqyArZ55iEmTbIm2++WdKmXbOV9P3y5ctNKX1/f3+DiWf7jh6XZGeZhzf3UPUMiXu1sk+2tClMrJ8xR4LPN3qhsj9ZmrDKZstnVuwbn1X26KwKU8dzK7t/Nt9Msl1pwbK9Eb2BO8Pr6Ojo6OgI2IrhDcOg3d3dDakmSrCVzpkZD7IE0LTdVKwqojqWzC5KZ5XNjra7lkdpFeeXSTGUXiidZ1IMbWkshdGKd2O2Cdr0MrZDT9WshBDRisnJ+nT69OkDrUCWicL9tm2h6lvcb15LZh6p4vEiKu0AyyjFc81eWCyYZVMiqkwqnOOWZx9L1bAwcJa5iKVrqtjRbP2qLClZQU5/x+wYrXg5JoLe3d1txhyeOHHiYC7owSxt7lt6ZWbloaq4sOpZEsdc2Tpbsa7MFGTW3ipeXdkRae/LGBJjVJlBKHs2sq/U0PGZtSQGbglLq2Kws3jN7NnbGV5HR0dHR0dA/8Hr6Ojo6DgW2DosYRzHDfoe1V50iGCaITokxO/opl05ZGTqQqoQmNonSzhcOa1kDiJVstasxpOUU30acUnjs/RndJWvnDKy2nbsE6+bOeVQVUGDc0vN21Jv7OxMFc9ppM7cqLO6d1KeANigerAKS8hUtJXzit/bNVtaq+3oSs6EwJlzD1VydJLK7iempWO9sMwFnPeC1cicz1ZIC93tOc7s/uU9zyDmeE4r+XmGnZ2dg75lzxC2x9CM7DpZUmupNltU/ZLaVesNzz/np6rSHtvhOrBvmdnH7fJ5ZpOBz4lmhapWJ/dKNj5+VyXlyELSKvNIltaN1+4qzY6Ojo6ODmBrhnflypUNA33m3k4jMo+dC1KOaKWoqaRLXidKTZZ46KxiiTtLyEvWSUmYTiWZq6/PYSByxmSrBNCVkTr2lRIVHV0yhxQ6hDAsocXiWo4hEcMwHDh9xM8MsnOGv7AUkLQpYbPfZHyR6TOY3u/pkBIZHqtVV9qOeB3vp8cee0zSOnjdr5UTU2zPe9R9qSqTxzlhaAED6TO2y/n0KzUmkZlX99wSpw+OM8MwDGnqschGKk1LFagf+zWnEcnuz4odkoHFdeGc+l5guZ7olEVNiB1dqpCt2FdqEsggswTuVUV1snSmdIzfGVWIQQuVg0sWHM8yYkvQGV5HR0dHx7HA1oHnV69e3ZDGlthUqgS60iZbWRoIGtuhxM1AzMyVnYHFZDmxj5V7LnXeWYC2MSfVZkHRZFicz0xPXrEbfp7p0imFUVrPkj1HO1klxVk7QMYQ54SFhSndZna4yv5blamKe8vtkKH4emZzfo3f0Z26Kjwb+8Ag/qpvDFSXNlkZWXBmU+N9xFCdVuq8KjlyFmpAeybDErKE0+x3a+8Mw1QAlswks5NW4QFGFnhuUItTsZv4P/cf7624Dzw/tpndc889kqS77rrrUD9iWA7T6vncKk1cZNE+xpoFMiMnMcjSg1Vl0JZo5rYp21OFBrUSbPDZu+Q6B+0sPrKjo6Ojo+NdGFvb8DJJLL6fK9NjZF6FrQDz2FYmaVXHLElCStZBSTwea1Qel5nUbCnP7Vt3z6DiyCjJVCvdeSZNVd5RlSdmBAO2W+m3ltj3eH1KkFEirQKzfY6l3Mzul3kPRjCVFfuVvc9SYnF/0+aZ2TYq+3IVmJ2xNc+JpfWzZ89uXMfwfNFmRA0J7Z0RPJf3SLTh0eZZMbusr637M2J3d/egD9QExPO9ZyobVOaRSpAZLyktRX8Atx1TGvq+N6Pzq9fS7UeNgmFmxzRk1LK0guNtM7bNMNOYMHED79dWOjSuAW3k2VpXaSMrBh3RKiFUoTO8jo6Ojo5jgSMVgK3iyKRaJ0tGElFJY5V3ZiY9V/E2mc2wivcjW4iSQ3WdyjYZmR4lkMpmlKU9Issgg8xYr1ElUF5SKofHZCyO12ylh+J1Ms89splK6m+lCau8WrOUbDyWY2+lTqv2V9b3Koap0n5kZaLIwmx/Zjxe1d94Xe6trIQNbZVkeFmpnLkEynF/Z/bkuYTyLaZYJXHm3LdsnZUneXYubXReDyb3PnPmzME59rCtCk9nnpaMY648X7OE9xWz4v6O8ZlMP1ax9yyOliywlfTfmPPKzOY+85tYyvI6w+vo6OjoOBY4kg2PiaCzX+5M+q+OrWLplpTp4LFsk/Er0qbkTu+vTPJlfBJZImN6MjsTmRyl5ii5VqxjSUaBilWTXWWxgkbFElprPefBdfHixYN1oG0ggl6ZLW8stsNYvnh9jquyw5LdWmqXNvcVr8tsJvEc7hlKwpnUzHNpO2S5othulRyamow4V+wLtRFkfNlcVPdiRGXfyTCOoy5fvlwmbI+fcYx8n92XczHCmU3cjI5ZbFggOMZjcm/aG5PsKT6r/B1fq/0Q95/37UMPPSRJuu+++yRJjzzyiCTpgQceONRnabNcj22HHo/71mLMc+w6037MeXi2tFEXLlxYlMBe6gyvo6Ojo+OY4EhxeIx5yaLgq9I3rVx8c3rqFsPL4sRim1ECZukdSrpkfPGalGaZO6+VY44SD9liVkxxrq0lcVhL4ooqe1ImlRlZ2ZuWLn0cx2aGGO4dSt6ZJyzHVNk0snOrorocn6X4+Jn3igtjMvtQ5klcZbph3F0rawqLxmagB13lrZuxHp67zd6hfaeV55HPg1a2jHEctbe3tygzEVl7K8a3sh9xvhinK61ZkVkavXWzfLA+59y5c5LWtjzGL8bMPrYB+jN7enquvYe9R2MMn5nc/fffL0l6+OGHJa2ZH/seEZ+XUu33kGWjqrzBaTOPn1Xe4dScRcRzuw2vo6Ojo6MjoP/gdXR0dHQcC2yt0pQ2qWor5Q6dCjKV30FnCjf9ynAer0NQpZElu7VKgVW4WU06tkMVapUGq5VurXKVb9H2SiXcSmw7V0ooC9ydC0vI+pYFAhNOLUb1UVQxcs6YELqVmIBJwqvK7Vm4COeYqrOo4rKKiuogq56y67AaO/vouc5US7wn3H4s6RL7noHOWVQtZdXLKyezbD9Uqmh+nzkrRKez1hhi0oIlgeDs75K9wz3vz1nWSdpMOM+A92xNz58/L0l6y1vecuj6VGnGBOu33Xbbodeo7pRqpxlprbq0atPvq3R4sS+VqaZKvxbb5XqzrFPmLMcUkNxDmTq8SqHXQmd4HR0dHR3HAlsxvP39fV2+fHnDoBlBaa8Kuo2ognirQNnI1ozKiM8ASmmTJTGRMUvYSHXAN8MiWolyGay6JMC5csLhfGZuu3T2aJU74blE5hRE6Wx3d7dpPN7Z2dmQzufKwrhdtmNUDJQSfZbUuZUOTModrFjiya9c48zRhc4CXHf2Nf7P8AM6ycTxu11qRjgH7nu8nxlwXu2VLAk3x2tU5XfiZ6dOnSoZ3jAMTc2QtHl/km2wMHU8pkpU7M+ZbF7aTADOvmfPKLMwhwnYiaRKWi6t04BZg+D3HLfXNDI870GWoeI4WyEmdLSiFiLOHfcMnztZ0vSK4bmtVgmg+NuyJFxL6gyvo6Ojo+OYYGsb3t7e3sGvcGavaiVrlXKpne7LLElCqTML0GZwMqWLLBUSA0FpW8sk0spttmo79oE2G9o8lgRPMpVZ5m5dBTQb2zC8JYmmGayaYRgG7e7uNoNQq0DwVnqzqv9kMUyKG8Gil0xWEM+x1Ey3czLX6B7ua3v9zRSYPDyzqRiUnt1mxkIz+1i8Dm3UkbkY1b3QSlZeBQtn9jNqc06ePDlrhyRjjeB9yWdKlmKQ9ij2LbPHGlny5NgmWXXsG8v1eK/wvbS2vzEsoQrYzjQY1EK4b7YDR4bvMBteh2No2cT5bGLIRgQD58nEs1R9rSQmc+gMr6Ojo6PjWGDr1GJXrlxplqQwKmk/Y3hkOpTkyBYze0UVuJhJIpYmWOrE0k3mBVZJfUyCm42btrvKdpSxHY6ZtqKMSVeMsSU1VSyq8vSUNhlryx7ncVZ2k2yslddcXP+5ckZGVtaE0jhTblkCjsHDZD5mR2RJ8T1tKBVrajGKqjwVCxNnx/L+bKX1YrtMitDaq5V2IAPv+bm0dJmEH+1kXiPug1bAfFU2yeCeyZ5zc96McW5pb/c4bMtjWrJsXNYwVN7hmaaHCb9ZTDbaBc3sbEdckqKNc8HnAplmpqGr7tfsvceaeTXPoTO8jo6Ojo5jgSMlj6ZUzWMyUCLJ7H6UtHlOKz0U9cNkXq3SHpSAMg+rKhaQMVW+TpTwaUeq0l5FVDaTKl4uO5fS+JJYrVbS1tj3rP+XL19u2iGHYSg9E2O/q7FWyZDjd1V5qsze7HWfk9Iz9kR7Mu1zcf1j8mlp095Mr+dMs0BW0/J+5n1E2yQ9F+Oa8h6rGNgSOyrfZ/GzS5P+RngcMS6ONrvq/shi9yq2Se/JuE68x+hnkCWgtx3OjMqFXx988EFJ6xRg0dOyYjH02mUsX+y/P2MCan8ek1Wb2bHgbHUPLkkTxpjYDFW6u8yTtJWecA6d4XV0dHR0HAtsxfCGYUi9wbI4pepXd5uyEgYzQ0TJzv+TydHWFSXuSgKh7Sb2w8ykKgBbtRmv7dcq40WWTaCaxxYT47n0GMtsYVV7lf0xtle9z/pMz844n5QmlzC7OdAuk8WcGVUR4czux+TR9ISL4B5kfKSR2Ypod6EHaVbih2y28rSjLTn20aDmIitIW9lPK+/HiKwwLzEMQ2qjztaFmp7WfcJnRmUz5lpLmx6OVXL5OPeeS8bW3XnnnZKk22+/XdI6I4u0tuGx0CxZs21vLbbGPZTFNftYagmoMTMLjc+5OWbH509ElUw8iwfN1qfH4XV0dHR0dAT0H7yOjo6OjmOBrQPPW3XX+H18X9VIit9RDVCpJ7NgR6pGWimsKiO+r89kxVIdrM5UUpmKZq6qc2YA5hxUyW9b9deoyqxCHLJ26bxAx5t4zFJV4/7+flOdljkYzYF7I6u5JeUp3+YSfmfjiiojaa0Csoonc0f3OVZVceytWnqVk4w/t5oqU4NWacKsanKAcxYixLAX7uFWIgKOJ0sqzfWaQ6YOje35mnMOYa2AeT5fGEYQ1cZWIdrxhOrC7Prum/eMVY533HGHJOnWW2+VtA5TkNbPFd93MSg99snzE1X27iMdUHwO6/HF83kP+vpWsbpf2T6o0vllySaMyqyVqfkzh62u0uzo6Ojo6Ag4UlhCK4FoZfhvlRTisZXDRiYZkGWwXIcRJcnKHZwSXcYKfU4MRo7XzYKw6YpPqbZVsoSGf0r2met8FhycjSt+T4mbTipZ8mWu5f7+fumuPo5T1WqPJ3NaYYqyqgxIFvRcJQLgPogMlS79dATJGKzXmUyIJVAylpalf4rfZ8kLKi0E1ylLilwF7PMeyfYB0QrgNrheVahAvHYrcXpsNyYIpoZGWq8dg56p6cnSWxFVuq4sfIPXN3ti4unYLtmL54IOStJac2BGxcT21TNM2nRA8bHeQ2Z48ZzKYdBzwFR6mTMg57h6lsXvqAWgJiNLRRnv36UlgjrD6+jo6Og4FjhSWEIlPUmbdpjKptdiNRWWnFOxmCidkW2SlWYFYI0qOS2vG69HqZOBzlk/qvJDVZB+RMXw2LfMFkpmVxVSje23km3z+lU6rWwsc/bg2G+ud8WmokRaMS2mtItStPvIUBNK0ZmtiBJ2xfTjPFZB8NzDcS3JHLj/mOosCzGokhZk+26uJFimMclsxBXLG4ZB11133QZbz9JNeY6rNG4Zg2WKxCrZwqOPPrpxLr9zyAFt/FKeMFtasyb3PZYHqlKIuV3a8CJbYzFXHuvPo7aKTM77m2EITHUWz2UCaNqfs6LPc4Vms9+G6LwTklgAACAASURBVE/RbXgdHR0dHR0BR7Lh+VfXv/7WFUubkuFc4cYMc7/WWRBqlYCanmMeR7wOJdOod2efKvsEP89shpV9IbNrtuwV2fXinDB1FQM/szI0lM5Y0iNLcUSW1vKWctB5KxE0243nxjFmnpa8Lsfs15i2yef6M+9n2mOyZLf0WvO5GZOoEhkbreS6VcIDjjdL+cZgZdqxMu9g2hN5XzHwPv7Pe6+VBo/76qmnnmoyvJMnT254jGb9rthElkSgsufxvsk8JM+dO5der0rjJa2Zm199LtcrsiZqzCo/g8x7ludWKSHj8857xSWMPGbOo1+z50KVlD3TRs0V0M6ep7zO7u5uZ3gdHR0dHR0RRyoASw+dKClRsqpS7Szx0qStIyvYSKZgiSoraslzWmOMbWbfZZ5Csc+ZNDtXpDLTbVPyqdJstfpK+xuZZuwjmR37Hq/TYqjEOI66fPnyRlxNy35UpYXKmHA1ZvffLI5xTNJawrVkXaWNiu0zWbTbZ3LneCzboPSapaWjBG8G4XMze7OPJTOpym1lMU6Vl1xWhLkqUVPZt2O/Y0L1ysPXDM/ISiLRe9bHc69nccSVxoV7JzIvM3syD85F1H4xdaFf+WzM5oFaAY7H44/zlNl3Y98zO7fb8TFeH7I22gfjtblHuJfiWFhyqUpplvkHVAV8W+gMr6Ojo6PjWOBINjyD5W6kzTgU2vKypKqVXYwsKvNE4meWPPw+YzNVthKjSu6bfUZdc2YroP6d9hFK1fFY9o1zUpX1idchc8hi1MjoaNPLGF6rREzWlyeeeOLAPuZ1ypg4PR0rCTyiKhIcbUTS2jYRx0ZWQI+/ltRMhse2pLanaPw+05hwfO4TNQtxLeeK0/ocM4yWhEwWmNlhWlqbiGgr8npEr78Ww9vZ2TlYl2x+eA+xuKuvk8UrGvR8pW01lnl65JFHJK2z51SFiLMsJp53Pquye57joX20lQGnssdnieANskHaRj0G38fRRsk9UnnrxvHRvl1pd1qZpLZBZ3gdHR0dHccCW/9Exl9eejFJ6xIaR8mwUn1O1hSPp0TA98zswTHEc+bKFEmbUuESplUx1uqV/0fQS8vIvALJkCzpZwyvYlFV6Zf4/xJJa29vT+fPn9/YB5mNoyozlDFuSnucY+7RrGwT+0SGFz0Sub/cnhle5k1Gduy+VAUs4/hpF2PR0symyzUjs/d4Mk0G2ydTobQej6HdlEWSsxjIaINsMbzIlDx/sT32t7ofs71Vlfwia8p8BxiP5lfbwOLaVuV5mC0lK1JcPQ/oKZ1leCILbBXw5nWzfJvSem1jzCDtcUbrGclnCDMVZW2yvZ5Ls6Ojo6OjA+g/eB0dHR0dxwLXRKUZ3XWZWocqzSqdl1SXj2il06ocG3hOVAmwPEsVxB1pPNuvwhNaxuO5cUX6XrnyzqVSy65XqTayZLiVKjpTZdHQfPLkyVK1sL+/r6eeeqp0e5c2Va7cQz42SwBtZGrv2Gbm3FElIqDqUVqrcKjGY8qnLJUd1Z106FqStotrmu2tVsD3ku9jX6p7MkvvxrASOkfEdatCdSrs7u6WZa6yPvA5k6VRo1q4CnLO1sVJnLk3+RpNKZVaukobF/tUgSWfMtU2VZdVovV4Pd97LCnEgPr4jOQ53Pc0M0TQgaZKYhD7GLHUga4zvI6Ojo6OY4EjMTw6gmSSW+Wssk3SaEpprYTJlMqqshPSpoRRlbPIJK0qKTHbbhU5pPGWr9lnlaSdOS1UJT0o0WWOLhWDzZCxtRbDu3DhwgZ7y1z+q2Beji/2l3tlSTkbzi1drpc4ydhJi2sbGV7mZJFdv1U+hayGqZ4yjYJRsacsgTeTPNCxJQsEZiA4A+3pFh/PiYysJaXv7+9vpEiLa8rnztyYIyqtE4+NbMbn3HLLLZLW+5ihJfHZyPbtsOV7IUtaUJ1r8F6Pc29HKj5LokZOOvw85L72qzUbDJqPDl3UrnAtstAmgholph6L7Rs7Ozud4XV0dHR0dERszfCGYWgWbaTeniloMgmMv+q0wxmtANnKXpWl7ZpjWpltgwxrm3OJKoVaFpDJcVTpkFqppSh1tkr9cC1attClAcdu/4knntiwBWSJks2wjJbkS1AStoSY2Ul5zJkzZw71LbOLsH0GBme2G7fD8ACjNa7KdZw2qdgm7xNK1mRxWRIIg8dkBWcZhmCwpEyck+r+yTCOoy5dunSwn7Njs7WK48meHbR/Vq7wWZkof0b3fQb9ZwyPPgIM6o6sic+IijVlaencB3/mvlShLtlYqfUg04v3AwPO+WxyPzLtQFWiLQt5aiUxmUNneB0dHR0dxwJbpxbb29vbYG8ZM6EESg+orFxPFSzassOQzVSMKNOBtzwQ+Z59rPTU7HPWbhUs3fI6I5ti4HOUnj0XnJNWSqEqCLoq7pmdu8QGwwKqMdUX9xOl2iyNFvtNRsq5jlK696DtFGfPnj3UBr1G4/+tvRKvG69Nj7olqLQamXTO75hWi4yG6aqkTdZR2RAjc/GcMtGw32f7rlqnDPv7+6mfQJZ4vPJIrdqNfahS/hlxnip7FZ+NWbA99yJLLsVnIxkO7zUG92caGKZd9HWz507FPsnw2Ia0mfCZz/zMZsznHIvx0t4Yv4vrNuflezC+RUd1dHR0dHS8i2MrhmdPu1YqKXoNUceceRsy1qJKIh37YVSxJpSqs9g99pU654xJGC3POva5GldVRoX/x/eUsDPvLHtlVmuQMTKOryrEGEHJeC4B8O7u7kah1DjHTCydlRBiX6vyIWQxWeFSf+aYKkutlPyzsXMuabvJYun4vvKEbXmHVp7LWVq6yoO1iv+SNoveVt7BEWS9LGTasjPaFtRieOM4FQ+ubJPVORFLtBBGlVQ8orIrVwVNpboAdIsBVUnRK1+BrPTOXGmxbO9USaOZADuCc1z5O2R2TT6LuU6tBO67u7vdS7Ojo6OjoyNiay/N/f39DencjELajCmpPISiFMPIfKPKyhHZDCXtyjaQSQBVFoss48JcUtol9r/KO6+yIWbXo82O8xs/o+cWvfVaNkrPCb1sM9tU9OCrJK1xnArA0n4YJWDGMtGm0fLSrWyP9LyL/aPHqMfTYqGVNE6Gl2UiMZZkOiGYvNfgPSJt2pcqbUcW40TJvipOms2Jv7N3JksmxeuQRVXjc7tXrlzZsMPHObZ2wDbhLIm3lGsH2L8qPjZjQpzrKlNRBL2m+ZplXKpYGtvPnllVJqnMK5X2vqpUVpYBpfK2Z5+zeEw+c/m8yfwO4nO1Wm+iM7yOjo6OjmOB/oPX0dHR0XEssH3JWG0a6jMjJKkvVSSZ4wlVFnTjzQzoNHJSBdBy3zbohNM6pzLIUqURVT7VOUtcpqkOpeHbn0f350qVWbnUx37zO85nXKMlzhbxuwsXLhz0JQs8NxiozbXNUr5RhUTHlyyVGVWZbKMVzMv3PiarWs6AaaqauB9awbZU2bO2XQRVlj6WatAYqlG55DOhdlwDBgmzynyWjJ19mHM8sEo8nhMdJ6oExa0A9yWp3WIbmSMSVbGtBBt8zvEepuNGq09Ea3yVs1J2T/N+4euSMBJen+rKrDZpFUrj/mShPPHZ2J1WOjo6Ojo6ArYOPN/f3y8r6EprqY5urDwnM0JSiq3CBzJ3ZEozdCXOmEnF0pakMKtcfFmOJLZLt206QGRhAlUKIQbcZ448fF+VFor9ZtVxSmlxHrOxtxKBx7CFzIBN6dHOUD6H5YLisVV6KLOAbM9Q68BA/Syon3vQ7OaJJ5449D5jeHNJC5jyKx7rPcnQDR6XXYeOCEbL7Z6SN+/XuAYen+eAqaSMyI49jnjPtxye9vb2NvZgHE90nIv9Y9KFzMmCZYcqd/4syJp7thVqNJe0IHumVFoTMtolqQyrEJ04j/6fzI6B5q0k+fyM91OWMMBguAOfc9Lm70NPLdbR0dHR0QFsbcOL+tLMRdlSnF/J+CzZZQzIn1XBiJYc4q897SG0QWQSEI9puTsTmR0pvm+lQZtLON1K5kxWSPtp5pY7JwVmjJIMj1JZHFcVEtICdfSRBVia9Jgs7TFgNXMPr1KLuY1sXcgOq/nKpPTKTprZtTMpNbZbrXUcB+1jnOu4h6kpof2ScxQZZcXAK5f9OL7HH3/8UJ+4Z+Jak3VeunRpNjyDAftZ0mOyW7/38yie00qgEb/PnhNVImg+B+I6zdnQsv1W2f+zUI8KtNWS2WUMby4MIbvuXKhOpqHLtITS5r0fGXy2Ht2G19HR0dHREbC1De/q1asbkliUSMnOWCYjYyLU+c8Vksw8IKsCiRnTou63FZxuVHrjKvVSZlNpeYxJuW67st21Sv2wr0y63GKwVeLmbFxGvM5ciigjs2dwj1jKY7meTLqsWLtfnT4sO5eeh1kwP/tdFUrNPN+qUlVVwu6sXA/XxZJ4Zoer0kLRhpOtMfvmfcY1yLQDWVLnbNzS+rkQ263uv2EYdOLEiYMxZ17Oc1oGfx+ZAkvc0JuQie4jE+K60+7n9/Ec+jW43cqmL22XSqwC+0YP6ayIa5XI3a9ZMVdqMjzX1TMsgh6s1A7E3xjvHfcx+02q0BleR0dHR8exwJHKA7V+qfkrbymKCWVdkiWeQwmvKuoYr1sl1aUk0krIS2liSTLnKh1Y5g1YxdlwrjJvwMpGxPjDrERTlbQ4kxbn0iplpXmy1FsVnB6K7CLT59Nr0hKd7b+RedGDs4ofy+wVPpe2LUraUdOwtChx5klasWey0iwBML3l/Or7KHq30V5OG95cKZ7YN7LeLFk7Y0TZVmZDpndxy0vTDM/w3s/syVU5MH+esXYW7a1i7LJ4NT5v6OUY16Wy89L2lbHnKgl/lR4xfsc9WsVIZ+NhP9jHLCaaz64qSXY8lvbrKqF/bCdrbw6d4XV0dHR0HAtszfAuX768ISVF6YsSScXaYkwOWQqlB+qTM2ZZeS1l9oM576xMIm15xcVjMymVTI5ML7NNVqV9OPbMDsOMHZX0G8dHWySZXTZnmR2zZQcdhmGDPWdsjUzOWgFmRIn9rUpK0Tszk9KrPme2ZM6HJXhK9jF7ifc6PTur5L6RuZDR0S7H0kaxD+6T+0gmU5ViiX2j9MzE2tJm/CLbMLL7lknlK+zs7GzERcZ5om2Rr9n6s2CtkWkziIrZ8TXTvFSFUTObLtkMWXQr7o+fkfFlDLCKFa2yNsU5ouc1CylncXj0zPcx3sNZhhXOxTAM3Uuzo6Ojo6Mjov/gdXR0dHQcC2yt0rx48WKT6lc1nmjsjKos02fW0Ktqp7WcZagGXZKsmgHHmSMIv6MqcUnSWI6LaoGsTlTldNNSy1ZOCVTVZunWqnQ9mXNGpjZsOUQMw9AMsuZ6MHA1q1pu2AW6quNW9UfaVKcx+DaqVWjop0ruxhtvlLSuBRf7TyeYytge16VK8eS5sPo3qjS597O6hVKe5q8Kwvc4s+B/qjS5h7K15mcttZSfO57H7DiqNCsni/jsYFAz1YM0OWSmG4YlMKVdpkKvklNk4UocD58HvJdb6mm2acR14XOUz2A+qzJHO6phK3Vs/I5q6irxQRzrNgkvjM7wOjo6OjqOBbZiePv7+7p06dKGBBfdWqukx3QeiZIPS64wNZIlyCy4vCo9QaeLzJhLFtVKMUYJilIFJcgsILNyuW2dUyWnNjKWUKVZYpsZS6REx/VshXfMJXEdx7FM9hz/pwaB7C2iCoRl4uRWWAXZGUMnsrI23JvUTkTG5f5XJZ5aoQ5VWqhWAmCy3MpJymhJ6VUoS6v8UZaGjsi0GhXjtbMcmXIm2dPJgvdYxvDI9CpHlyw0ogoEZ8iLtJn4uwoFivNGNlal78oYXsXkWs8dXqeav2wv8flSsdGs2AC1EJlWwKCD4pUrV7rTSkdHR0dHR8TWyaOX/pIysXTFoqRN11RKhpQqomRnyaBK7ZX1lyyNkkkWVF61XyUgzvo/l1qsFaxcjadKTyVtMqVtkmSzT5n0TYZYpXdzO3t7exvB5VlCXoOsjZoAaS0tVy7elAaz/UCbV5W+K4L2PxaqzMIEvH8ZnsI+xnWpbERMvpyxQjIuvtJGGj8zqj0a90Nmm4nHZPdoxsSqZ8v+/r4uX7684RqfBejT9Z1p4rIA5mqshvsf58lrymeT+5GxXKYdoyYrA1lfxZ5abNfHZAkueC6fTVUZsixMir4K3OcZy+Z+4zM588HIWPXSEkGd4XV0dHR0HAsMSxmbJA3D8KCkN779utPxPwCeM47jHfyw752OBeh7p+OoSPcOsdUPXkdHR0dHx7squkqzo6Ojo+NYoP/gdXR0dHQcC/QfvI6Ojo6OY4H+g9fR0dHRcSywVRze6dOnx5tuumkj80AWA8S4EEb1t/LFVXFqGeZyQG6DJdc7ipMP+1T1Mfv86Yxnrj9ZlhPG/7UyHmTxNU8++aQuXbq00ekbbrhhvOWWW2ZLM8VrVtlrsr2zdM8sya3JNp7uGjwdx7Brsf5z+2+ba7Sy6jAzSetYZlrx3rl48eLGwadOnRqvv/765nOHpW6OMqbj6sC3ZK6ezj5ccs9VyMquZQVlH3vsMV24cGG2k1v94N1000168YtfrNtvv12S9IxnPOPgc+PMmTOS1oGZ7tzjjz8uKa+dxRp5DBLlD2IMBGbqIwaV8wGegUHyrQq6vE4VgB4XktdmuqsssJm163idVpA3x2UwoDpL1cWkxL7eQw89JOlw0u/HHntMkvToo48evP70T/902pdnPOMZ+vzP/3ydPXv20OetYGS/Ov0Q68rF/5kSy2jtg+pBV6WPi+dUN2q2d1pp2bK2sgf53LFZ29w7fJ/VQ6sSHVSp2uL/PpeV1v0+zvMjjzwiSbr//vslSefPn9eP//iPb4zB5z//+c8/eLb4ueNUcNI6WTNTr7Xmr1p3jr0lTFeC1pJ0e9v80PI61biyto4iYFc1Gpc8fyqBKks2UaXVY5pBp32T1s+D8+fPS5p+W171qleV/TnU/qKjOjo6Ojo63sWxFcMbhkEnT54sGUv8v0pgHNvi/xWrMTJJa45htaSy6n32+Vwpj0oqjKhYZpb2aq46catKNueCKZ5aab04DkvMUZo2WFZnTuq77rrrmqnSqrRpWVvG3J7hOS3mvUSin8MSqZmotAXxu4yNVderjqnGc61VeWbbTPsWyzpZu+DPdnd3m/O9s7PTrNQ9V3Inez+nDp9rS5rfo639sM28s48tLVR1vaWfx/Zb2gBirkzPEu0XP89MZFXZqyXoDK+jo6Oj41hga4Z34sSJReVTKP37FzpzWmAJn8ouZ7SYF6WITHrLEjxnbWWSNvXR2zjW0P7RKlZasbElEhcZIxPMtqQmskJfLyuG6s9iMtyWNLm7u3uwL7ZZl6qPsX9zSbZb88RzWgUzK7toJRFn7ZOBt7QC1XqzzXhftWyCGbI1m0vG3tr31fzFfrCw7cmTJ2ftXZyDzBY0x8qyJMRVEunWPPq7as9m/an8Czi3rWTOc/O/RLO0zTOrKmHUSlpdFZpulRarnll8dsb/Y0HdpSyvM7yOjo6OjmOB/oPX0dHR0XEssHU9vBMnThxQVLsCZ9WWqXbw5xlF9fmssVTR+EylVamyMpdwtm8ju6/vvrWqI7N9I1N1VuEArLgd54SqTM5fyxFiru4dVWoZlqg0HaJgh5YLFy40VZonT548GGvLVb9y1GAF73hs9b6leqnUKS2ngmrO2Nds/auQiZaKqQop4Pct54iqr0ZLZVu1n6mi5/ZVPIcV20+fPt3cO1aJx3NbTlLsQ6a+zOK5WsicLbYJR6Cqr1Jttu6JyrGqZQ6o7onsmTYXUtAyqVR7lOPN7kWaulphEKwF2Z1WOjo6Ojo6gCOFJfiX1ZJ9dFknW5nLuJJ9x0rXreDaCmQQWZVdMzu/slpyDHDOqvVKm66xSyQSVq+OhnuDrJDSDCWtODdzQaOtysMO8CSb5ppL6wDQrOo2sbOzo+uvv77ptMLK2XMhGfH8yqliLlwhfreE+c4xylaYSHVsxfykzfuIGoRtGF7FJLPg/6OEZFArUDlLSes9cxSnlczpqgqD4nMgS3jBZ0S1p+I8VQkhqtes33zfyhKzVHORab/4PN2G2bKPrfuqGgfbiGyO60NNVjYn/iw6/XWnlY6Ojo6OjoAjhSXYnnPzzTdLWqcOkjZZjCUC2/taDM8w49rGfbaCrxdTYjF1lVNW0ZYY80f6mLlUOJn06bmgVMtXz2s8h8cwhCNjDxUboJSbSbs+x2OnxBWDh72m7nfLPXgYBp06dWojnVnsQ2WboVtznNsq1Vu8bvbKdrJzt8ESZjQXEJ6FGNDeW11vSd+5D7ZJaWUs0bLM2bekTRveEim9ZbeuQiGozYj39BzD2yZshL4JmTaCYUnZelfjI5YcwznweOizEDUM1DbM+QxkmqyKuWYMz+tf7eclyUaWzIXRGV5HR0dHx7HAVgxvZ2dHp0+fPmB2frWkL60l0ij1S5u62swOk+nZI7Jf9ErH7PdZ8lH//+STTx5qg5KPv4/XroJEKeG1AiU9X3yNDI82PNvOKntmy4bDPnuckfVyHv0dvUWjBJgx1qVemj4u64OP8XctW1TltVYxvVY6qsyDmNebk/q3sTOzz/TalZYlCa9AaX2J7WbOK3OJZ+mSPrv9qMlo7Z3d3d2mjYtjIrPLtDZcy8o7fC75t1TbuDJ7VcUgl/gqzKWny/Yq58DMlj4M8ZjKRrhEk8VXz0E2j3P3CzVMHGPWxxY6w+vo6OjoOBbYmuHddNNNuuWWWyStbXeRmZituGSQf5ltA6M0JW16EdFmQ5bRSinEmKAsVoOMyzDzy0rNUBqq4lEYN5ddb85LKxvPE088cei9X7MEqrSB8rrU5UcwxpKI7MPHxFi9StqyDc97hWsd+0eGQGYa+13ZHCrm12J4XDvaWrI+UULNPGCrtGNVurrMm7HSfmRsikyFNttWGawqdRrtM3G/8T7iPc57JhvrqVOnmpL67u5uk3nTK5NsJmO1lS2o8mrcBi07afXsWGKHrTxHW3u0WveWP0VLIydt3iPxGK7tkrjPlq2V1+E89dRiHR0dHR0dwFYMb3d3VzfffPOB7S6LzTLrs/RvZudfbNvFzFikvCgsryvlBWDpvUiJlIwiwpIHj8mkBWZhMWj3ybwZGUtn9svk0a3Ctp4js1DPaybhU7rldTKJkvMXveekteQVr2em//DDD5d9MYZhOPDyjeOK0h+lPI/VxYMd9xfj9SpbDdtniSRpve5cH9rSWvYq7gdfP84F93W1hzj38f+s3XhuBCVqSvieP++plo2yYnaZty5ZFvdfZv+NMVUtG97Ozs6GB2TmucdxGK2SWGQZnONWlhba3zyuzIaXeabGzzNtTaWhqOJBl5zL62TatiqzCgtEx31AxkrNUmZnrDLIZJpAo4p9XoLO8Do6Ojo6jgX6D15HR0dHx7HAkVSaVmFatZm501uFadXlQw89JGmtnoru6FZV+ZXB4lTfRSM51aqm2ExsHZ0wTImtcqlc2luJZqvAyCwQnCorGsXZj3gdzyPVe35tGdSpKmGKs7hurG3nvp45cyZtI2tnifG4cgWX1utstfejjz4qaVOVGVWEPsfH+FzPl9vPXP69V7iPvVf8eVTZxznLwOQFEVW6JKqaM4en1t7ke+4Z34OeG5oZoorY/WZfqlqO0vo+ZSgSVZlxTlrORBli0vosQQFVi1Vqw9Z1qrABXoNjieOgSjPO09xccj+0rpNVD+d79mFJerKqVif77LWO90MVeN5y/qlUmJyL1vO0hyV0dHR0dHQAWzO8M2fObAScx19YS5OWHh988EFJa4ZnqTMyPEvy58+fl7Qp4T/yyCOS1hKCWYe0lr79mSUOG1UtcdnBIh5Dhwe6v0dkDjPxnCq4W1pLSx6XpTZL2p6LGOju//3quXnssccOvfp60Xg8F+Bupxm/Suv58jy5PUv//D4e4zU4derUbGotun5HCdZ7x2PzXqmkXKlOl+S5ZThH5mxBhuKxZinuKCVTos+ciSr388otPhsfx8V9F/eO2a7nkUzZbWRu6Rkz4XhiX2M7ni9fl2whrmNVIieDE160HELoVFYliIjjqhhcFQISz63c51tl0OZYZ+YklTkWZX1vweOo5jgL1amYHbU6UXNWMa3KgSz+X6UcrJhs7GNPHt3R0dHR0QFsHXh+4403HrKDSGvJUZLOnTt36LP77rtP0lrqs3RpxiKt2Z/d2y2RUkKlJC5tshWzDUrrt95668E5dFHmsWY1HGeEJbvKhTkLcPV4PHYzV38e59E2Oh/r92Y9/tzXN+uW1tKS58SsxuN7xjOeIekwW/OxZ8+elSTddttth9r1dWI4icfldm+88camPn1nZ6e0Tcbx+9VSrdeBLE6q7b2UzlvB1mSxRubK7r3ocXp+aOuMGow4/thnStGZfY6feU5oj4v3kz/z/nKfvXae3yyZL23eZOLeM1loEN3QmZw47m/OdQtOWkAbGFlBvCbd6rMk3NwL2yTo9l6syhIx6Duiema4zSwsxd8tTWIQj12aujG2x/lyP7g/WjbtKjVb5qvARBSt54jPqRKrt9AZXkdHR0fHscDW5YF2d3c3bBtRSrd0aUZiSdTvLWVa+pTWzM72PnrlMcVTlBB8TCW9WgKJzIRFTX3MXXfdJSkPqmRwuq9LXb3nJkrNPMdzYWZrCdxzJ60ldr/Se47eh1HSqorwug23GZkEPSDJHDNvKUq5t9xySxl87uBhMrLoIch1oe0ns/tVxXzpCZtJ3N6b9Hzzq9cjrgulcO99z4GZccYkKlskXzPPN7fhfew91NIOUFPCezHzYK6SonOfR3bFAH6Wu8oSj1OL0rLDcO9kntBVcD9ZeivJelXIuBV47nkgW8zYDNup0hJmNrWKrWVpCQ1qEio7bMs+ZvAZxkTvWf/JPrMUc1V6MyZniOBzp5XSkOgMr6Ojo6PjWGAr3wTyeAAAIABJREFUhjeOo/b395ulcCodtiUDs7nM5mD7m6UmS8+UJrKYDB9rSZdSdcY8KC2xtFGUfJkM2+PxMW7LEnhkvZXnoFlOJuVE5iOt54ap29zXaKNkgVsyJsbcxb5YeqInX8YGMj1/q3zJ/v7+BpPMip36Wp5Dzm1kM+5nxUAqT8jYLvcXGXHmtUu7FBlrHFfFer2WtKVl3oeeC+5zppqL37ld7w3adLPE6ozNox3b/ckKKns+ef8wpkuqbVEVTpw4sWHDi6yOLMl9qGyg8ZyqXd5HmZcpmVbFjOKxZCjsc0Q1PxVzjetCux5ZbxYfV6X0Yow009PF/vs1asiyMcW+VPOYsXnaM7sNr6Ojo6OjA9iK4Rn+dbd9J/7K06OOsVW0J0jrX3NLvPTC8fd33333oTak9S+/JVx7iTKWK0sabPDcyJZ4HbIAxvJlti63z/JDlFSipEXpk9Kz+3j77bcf6lccxwMPPCBp0/6Xgfp2SniW1n09adMj8fTp0814mKtXr5YleKQ1A3F7/s57iPMYx2bvQfePjMvSZmZb49yS7S7J8uA+elz2hI3jom2D9jm3Ge8nsg0mX2f5mzhW2xP93sfQVh2Z/tve9rZD7XpeaXeKGgivB7UgtCVnbH5JLFVMOh6vHY+nNyFt7llpqSpBu1/pS5D1j57jWaJsXi97RsT3mUagsjPTDhefIbRjU9uRaS6ybC/Seo09F7QpS+sxMxOX32d2OXrR8vMsWTafvS2vU6IzvI6Ojo6OY4Gt4/Cuu+66jXyV8RfWkoAlUXtjknlFmwOzhVjyZF5OxmlJNROh3j1KIrRP0HuKklE8hrFnvH6m22Z+R39XSZbxO76vPMliXJOv80Ef9EGS1vPnmMiMUVbX9Tox04K0luh9zlNPPdUsEbS7u7thn43tmRV5z9Aeysw00no9fO6znvUsSWsPxbe+9a2Hvo9SLcvY0PbkfRb3DrO/0BPW44nZgGg7YZ5XMs3IJKgV8By07BeU5H2sJW1/nsXU3XnnnYfOed/3fV9J673DrEfSZqYg2qxpm49zEO1LLe3A/v5+Gfvq8zPQTpXZuKrcj9TAxL1D+xSfYbzHOdaIVs5JsjEyeo5hSYyb0SoATX8JFtBtxfTRE9vX8TMqPquyvKgRrfJXFRttoTO8jo6Ojo5jgf6D19HR0dFxLLC1SvPmm28+UP3YKJm5B1t16WByB7tmbrY0iJvy0ikiK4nDoHRT8egUIx2mvTSmu/9WudB9X1qrqOj8QDWL+x5VC1aJUXVCOp+p2xjMa/WQX7OAWpa9odqNaso4Zqspre6iw0GWFNnr0nKKseNBq4q4z2foiucvU/l5jZwS7Y477pC06SpPdVuEj6EDAkND4rWt7uT6eC9niQeoKqNalK70sd9V2I2RBeOzfV/XffQ+yO5Fw85RVgm//vWvl7Re83g+U4y1UkCxVFZLLTWOY3PdYjtUp/lzOqBIm4H+VrMuqSrPZxbVa1lJHqaQyxJaS7nz2pwqMTN18LnGZ2V2PX/HPtHcw+ddbIcmL8+591uWtIBhFjQhZc/8uH978uiOjo6Ojo6ArcMS9vb2NgILM+nMv+J2jTYjydxZM+NpRJUI2P2RNtmF+2imkklNDE9giqTYJqUyuqzTiSC6pdthx4zLDMasMZs/S0V0hqCbutcgOvJYuvV1LYWZBWWBwHTG8byZ8bUCzxmknsFp6TzHWfAwtQB0bKC7e2zHTMhjZrJoO1tkqcw8ZrqyZ9I03bKNVgorszMmAibjp3NJ7EvFgLKE2nSK8Dp5jzAheRaqYabseXObmaOa26dWgKn7sv3m8bWcVszwWkHdBkvhkOm1kjswTIR9jMyE2oZMSxPbzM6pygXF+4jJDzgOhhxlha65JzmP2X1bFehlsoLYdya4oANMlhqQQfhMHMEkENIm293f30/3QobO8Do6Ojo6jgW2Ynj7+/uHwgmyX2xLC2Z2/qU2o8vCBFjqhIyO+uMlJTAokWblWuiebQZEVhOvTdf4yh4X4fbcF1+HiaYz2w1TVTHoMktllZWZiceYacYCsJTGWFCXtipp02W5JWU5tRhtk1Ei9tySnZtlZGVmfE2zlcgY4hizZL4ZY5Q2U5plEjDtbmZlZvZZADCZnM9lMHfsD+1LXhfbyLPAXI6Vthz3NVs3r6/H5wTnVeHb2Dd/5lcy58hcqUUZx3GxHaZVZoZMm2NsBTAzJRvbaLnx85is2CkTc9NelSXZZjgCbZVkh5GFMrH1Etsk7dlkhzwnjo+hEewj0/3F8yt7Y6YxqYriLkFneB0dHR0dxwJb2/CGYdiQMjLPJ0u6lPoyzzCDnlvUE/O60mZwKKXpzEPMfTGDMBv1awwaNsgyq9LzmW3K42Kx2siW4+fxHDM92nLICmM/YsmV2NdWEVS3R087elVGKZdS7dWrV0upy3aYLGk0+0A2SVtelFR5PY6RnneZxM01bM0TPXjNlv3qPRXvCV+bdtkqsXW2d3xdps7KUAUJ09ZmZPbtqs/sR/yfe5ISfewz1yOba2MYBp08eXKDzWZ7jXuSDC8rvcNnEe1klTdlHEdVuDTTDjCYnN6NcX9XZa+qZAXZs5jpD1sJ1ckG58r2ZBoTvlZlg7JjuR+y0kZsbxiG7qXZ0dHR0dERsXUc3unTp5txHJSG6JGW2UUotVAiaZWI52eVNBbf25ZgJueEw/7cTCuTXsg+Oa6MNbhPbJ8ScMZC6YVJry1K77FPVUJo68CzxK8GS8iw0G5s199duXJl1o7H/+OY6cXIz2kvjcdy3qvST0tit7L0cEZls6PHbUxwTdbPtFQVw4xjJrNiXzPmQlBqZjxq9h3nrVVIlRI893XLi3ccx3LvVAwvu3ZlV26VIaJti1qUlo26YjOtsTJVWcsuRqZaMeEsLRntYPQkz9raJk0XQe0Ar5/5KhAcJ22z8fzMD2C2j4uP7Ojo6OjoeBfGkQrAMrYl/mJTb1yVsciKQWY2Ol+3OpdxXQazpkT7mO06tmVUZSxiP5jgmXYyn2OJO8tIQu81nhttev6fcXGVTj+iipkxsj4atB16rnw9ZrCRDq91S0rf2dkps01k/WH2HI7P14yvZHiMm2x5wFFS9Nxn9irvFXvcmuHRw1Pa9GbO2GZ8H/vI7EP0ZM5sybx/Ku+8zC7LNsja6AUd2+Fc89xsXJEhzdlhKrt5dkylcYnntrQy8X3Gaqu1y2LE2B6vR8/ETPvFNeX8GfG4Ks6TbbTsjDy2lU0ps63F18qzNB7Tmr/qevv7+7N752Aci47q6Ojo6Oh4F0f/wevo6OjoOBbYOixhf39/QwUUHSZILU07mZA3UlWrg6yuYbLRygAdQfVAK2Da/1tN6GP9mlXSZd/Yp6yCd9XHKoFyPJfOIrxe5Z4cQZVp9RqPZfteY6ty41rToNwy1Ps4qjOiuo3t0WEjM2Czph2N3VSDZSpU7wc66vBV2gxodyiL944D4OPccj9VjgiZmsrHWLUck/VGZBXBuR6VmioLHuY53DNxH3DPM4F2Sz21VBUVE0hnoUZsb07lmB1bnZuhco4yMicTOl1VpocsiXx1n1cB4fGcStVotJwAs+TN2fWzY7aZX46jFXpCtfrFixd7arGOjo6Ojo6IIzE8pp+JEnDlxEHX/MwFn67WTKfT+hWnS2wrmS9TIVFqziRkVrpmEGeV4ix+RhZK6S26wVeJZSujfMvln69Z9XI64Rh0komgxHj58uVZp5WW80M8VtoMfjdapUKqEJfWunC+yOzi3vH82NHJ2gk688Rx0ZGlCr/JxudzyPB4Tpyjai4qdhDB+4aai0w7UIUAVfdGbH9OK2BkIUIZi+b+WsIY5lhM1ge2V5XvycJFqOkhE85SNVbXq8YSzyXD49y3nMCq589R2HDGRjknrXViezFRQ2d4HR0dHR0dAVuHJVy9evXAXmFJMqYqogRYpbHJkh3TplIFoFd9i8cyiXCWeouFZikZR8bFYOTKXTtL1MrQAbKaLKWU+1Kl52klVyUqyT4LS6gkyew6WfLdpRK75zNjT1WC6UwCNsyAKqbdsnVWdsUsHRmL6/oYpsxrFSzlXuI6ZImnvd7WkPDzLAyGabaWuOpXqbJY8iUrqGywhJDnrLXWrcBzh0MZ2f6tEkIYZNVsv4Ul9iQ+o7LECuwb5yBj/GTpZFhL3PercIAscLvSNlT2v6U2WKmd3o1oBeOTDbY0S0RneB0dHR0dxwJHYnj0wsrSKM0xj8xDkGnIKr145lVUJZx2X1v2KkvaTt/l8cQ0WiwLRGmtlSaM3mWcAxbHjf1mkD+DlslkY5+YbqnywIqgfYQ2nMy+FOetJaWP47ghCWdptDiHrRRCrRREsY/V+/gZpU164Epr70xrB1iqxP2I9wTnn4H/HGeUsmkD9zlOaRZLJRFuh16uRstztUr4m80J7wXvlZZ33jYMhX1v2eGMJcyhYv18vySlIZlXxp4rmzS9dzMvzYqlt1I2Vt6sXNNWya/KBp4xPl6nWpOW7XhJ+jFjm5RiB33Y+oyOjo6Ojo53QWztpRl17Zl3IWOOKJlmkgjZBKULJvHNbByU0skkslgqS8dmcva0c3HN6HlH2wzHsaRci9uwjcPjtT0o9pFMjt6hZFxZ2iaO12jpu+k5RqksMjKvy8MPP3zQbqvtTEKO5Uyq8iWWQMkopc1kx7wW1ytjEtyjRCxcaoZn6dJxd0y9FvdslfSYqc3Y9+w67qP3kJleRGUTqph9Zv+bY3iZh6T7tMSeUqVzy2AbXpVYOPZvLiVWVnqp0oBUnr7xf84p773IhLlHuf7ZnPB56lcy8WxtyZ6ZtJx22ewYxkJXsXXxM9r9qe1rlWhaksKMtult7Iid4XV0dHR0HAtsxfD29vb0xBNPbEi5EdQtU6LObHu0v1UeVa0ktDyHdoTYDzM421n8eu7cuUPfR2mQXoDUrVfsJLbjV1/PdqDsHPff7TMmrMqiIm0mzjY4V5lNpWI5zLgiSefPn5e0yVAy2P7biieqpGTGosWxksHx1fPWGjOlVbLcKJlTK+B2af+Ne7RKfl0l/s1KoXj+H3300UPvfWxkodFrNo6jkoTjfFfMnmuTeR9mdt4KXLeWlO7E0i1vxhaLiMgy+1RemK1YV16nymaSJdnmveQ9k9m1qalgYu7WuDlPZMiZTZExsOzz3JzFPsx5eGbjqJheq+j3zs5OTx7d0dHR0dER0X/wOjo6OjqOBbYOS7hw4cKBIdO0N6q0qmSzpMJWT0l1OqgqQWuWCsegodR9syoonuN2rZp78MEHJWljfPGaVWqsrDagQVf1ylkhU8PMOQ9k6qM5V+mWwZku8+5zZvT3sV7L8+fPNx0Wrl69uqGOyAz0VM+0As45PxwP2259VqUUi3UKvVeqZN6ZKovB29VrplZ2X5gUwf3wOdF5hfUWq3RQ2wSec99le6cKWs5CDzjWOTVoyzkionLiaKW1IpY43VQhNK0kAnTUsoOT15brFD+jSpHXyRyjeN/wuZc5rVBFykT3/nxJRfdKLZ5db27+4vWy50MPPO/o6Ojo6AjYiuHt7+/rqaee0iOPPCJpnVIs/vrSMMqQg0oalOok0S3XWzqn0DHE7tyWiGNfLCHYScWSF0sMSZsJpreRSOfCLsw+6RKcgRXeOf7YLvvC4NXMQaVKf1S1HdvLGFg8Zm9v72COMymd/ascaWIflrLYLAi3Giudp2ICAoaY0CWfzk3xWJYfYp/pTCCtQ1aq5AgMV4jXoRNJxXYy9kSQJSypfF2xxXjN+LxoJS3Y29sr1zj+T+ZNhhrHOufgUoVUZe1Vx2YaDDM6vmYhH9W4eM9lzoBkh0ySQY1KHAe1K95TVXKQ2A7npOXwtBQthr+U3Umd4XV0dHR0HBNszfCuXLmSuqgfNFgEObeCBOd06XyNEj5de/1K/Xi0w5it0W3f7Ckrtun/OXZKvAwMltZSmNugLj9LKUSbml+ZFs3u6JGNUu9Ot3RKehGVTYyB77G/SxIA+/otZkx7KNd7SYJcogr6jqCNqUrrJm0Wi3WfPf++XtxvlJK9PgxX8XFnz549OJdhFWZ0DqFplbIyqvljaItUs78lwcNVaaFMk1AlW84wjqOuXLlSsrZ4jSrJMvsaMcdaWyn4qhSKZO3SZhhXVWy3Cg3K+tpaF6639xLDEbLC01WZMN6T8XpcwyrkILPhUWNFDUqm1ekMr6Ojo6Ojo8DWXpoXL17cKPya/cpT4q7KXMRj3W6VYNjfR5uKmZylWtqIMknEUgQLwdLDLkv1ZQmb3qdGlvKJno6W9Nn3yJjZf9tuPD5eP57LcdGGmNkkjCplUZYKjMGwLRsex2VkunlK8lWAdsScnSqzqVACZsqiLC2dGfXtt98uaT3XLKoZ09IxgbnZIO3NbuO22247OJdMwef683gvGLxf5uzNmcRtVGuQ2c/mbDWxjW0Yno+nJ2xmj6uSLbSSHfPaFTvMrle9Mr2WtPm8rPwbMkZJL02DDClej33w3vXzx++z5xyZI/uUaXwM3r/sW8bMW/bZ7L10WDPWvTQ7Ojo6OjoCtrbhXbp0aaMIamYDoB2GdqrIBvwZWZqP8XvbRaL0TEbHmCdLxFESsS3NHnCVnj+TYn2uj6Ft0hJ/9Lj0/z7HbfjVUrq9RaW1dE4PLjM9X89zFiVbegySsWa2GyZh5vvMVkQ748WLF0s2wdRimd2kSsjbYqRzSXyr2LB4TpWgl3tJWq8ZbXmMj4qpvmifoA2P9r94PWoofKzT+3k80WZY2T4p8dMTL547V94rnlPF7BmZ1M7nxN7eXtNLc39/f4NVZDZoo0qnlo2nsj214lYr5tt6773i+9LPDu+plr2K2gfuN8aQRlQFr7NUfZXnKj/P7LNVodnKLyAD2XUrzjhL6j2HzvA6Ojo6Oo4FtrbhXbp06UDSslQZpQpK/Us831hc1SyGDM/fRzsMWYAlYL9mko+lb0splJJb2VJ4Herls2Kb9KRkUVVm2pDWrM9j9rmeX/c1S9zs+SPT41xECZlzwXFlEheZ0ZyUfvny5YNxLLHdVPE8USKtWAttxq01JbNbYmf0unD+6YkpbXrFsa+tROdzJWTIlOJ3ZHbUXLSux7luxcIeJTsLnwstO6O9NLlOPCZ7bSUuXppwOENlc2olVTbcJ96PWUahuWT19IiN+65ify273xxaXq9zrLCyB2Zo2fC2YXREZ3gdHR0dHccCR2J4zLcYpVza7GiPIzuU1tJyVS6D9r9Ml04Jx69mV7bXSZuedWZT9G7L7Ev0BqtYWuwjx2wbJO0MMZauyr9Zea5m2W74yjjATGpiPFMrs0IVR5bBNjzaxzK7TiU1ZzYASovM8MO+trJzZJ51HBdL7hheh8yGx8Ko3puVXSbLV+o96utzPbL1N9jXVqYVZkDhHs1ixaqMGnwf5572uGjfzbC3t9fMzUmbY2WXy0DtRfW+Zf+rYjkzjQjnlm3FuWVcWlUIls+hrN9LYve4/pU3bbZWc56rLbbNNlpaCD5nei7Njo6Ojo4OoP/gdXT8f+2dS28c15KEj0SYtmDLD9gXhlfz/3/WrAeQDAG2RZFszuIiyeBXEVlVAmZxpzM2TXbX45yqU90Z+YgcDAZXgdNlCZ8/f94UymoKPik3E03oxtG/U6JLV7TOAHBKU1cwqE6ZqC4oXqBrpytwrXmVO4pjo2tDP2OxcoHlHa4AlO5IJqI4V0btwySWgnOdqUu6S1pRlyZdNTqGlA6eiv11W7qW6QLuXH97RcR6HC2NWWtbPqJufiZqUdSZLnwn31aCB6k9TNc+hW5/uol0rSYx9tTRm3/r/51Lky6zM9Jizs2V3LbpfwdXppH2pYvvjEuTzxjXgyvMLrDEpSv2p8uea6drvZNaC/Ha6H1LUmndted95zPp7jWf5T1hBcUwvMFgMBhcBb6K4ZW1ecaqIPNThsf3WIbQpZgneSCm77t9WCbAwkwXZCdS4oNanHtp7+7YrtB7rS2rTpaX4og1zaA+A9zOGnRlI13h+ZcvXzZzdRais+rW8hYjrfKUtFBwrVeSZe8K9AuadLXWy1qtY+o+dc3YforzdIXHSViB68JJ56X5kBW4Fi+USkvrUP/eS17piv73GJ56B9L60HMd/Z/n6fZxCU+J4bnnkvuk7xTHZngtkwSYmw/Px+9M16w4rc3ueyaVv3TP5J64u7vXZ7wDm/Md3nIwGAwGg/9gnGJ4a/37l5ZyVmpdUtw2Fbt2/vyUru1AK6XO30mZ0UqhBd+xpiTXRPbh5KFooXZWe1n2SRQ7pRqvtTbi3keKYQvunqZ9KX+2J+J6uVye5+FSojmXZFUeYXjclqUAOidKVdEi1Rh1fUZhZpbjVLx2rZf1xdIFHtMxs8QYuE9XWM99unYtLo6k8zuSjk7Pj2OSjBE9PeXWUiUtlgrq07jcuM8UPfOYHVtLnh633lK8rysTSbEuxvT0XvJ8KXarxz7K8NxYU0lQis13IHvrBC/OYBjeYDAYDK4CpxneWi+/tmWxKpthqx3KJ7EJ4lrbX3HG8phdpBlwe1YlRZ71PCz0JBtUC4JZjLR4GJdRVlBggT2taT1f/U2ZtULKYFUkmTBKQen4UwEvLdi1vNj3npWerNoOZD7OAk5FvAUXK0hxEcacnCAv4yJkLBrjI8Mhw6PQeVcIzDgMPSr6N5kycaSgOrFCJzyemOOZLL0OjBm7750jHqU0hr19OubtZPb01e2TMr+7Ncq1SW+YY+sFskDnHajPUnYmvVJOlix5W74GXebyUdECxTC8wWAwGFwFviqGx/ohtYDJxlgDpI1K3bHX2jI8xke0BorMqySYyFjUIi2rmNumGhD9m0yLlg+bfeo2tFB5PmWhbIlEy57Wm2MFZLBsT+NkiMiMablqbKruv9ZqHbXqXEyFrC/VAiqSHBQtUTIlN4Yk5qxgTJDXqdaWMrwkwcY149qoJKaaMjEVZF6pptJloXLtdBJWFDB2HgSe38Uku7WjMbz6DlEvSoq7p5iUm2vyPtTn+t2V4vJ81vX7gs87z9PJn6XGzN3aSfeb68ExSjJVsl4neJ8k2ficHWH8nJ+r254GsIPBYDAYBJwWj76/v99Ye2rN0pdMi7ReXVsbWjqMk5WFVXWA+l6hLGxaomrFlmXIFj+0ahW0dFJspbO4a9+91klrvc581OPzulIkW+fH+AsVZZSFuvfcGIvV8e86/h7D65QaUi1gYp3uuDx/ipulMegxOss7xbhc3CyNiceqe+1q6tK1cEyZ1vFe480uZshYjfMOpGeNa1WvM+d6xDPA2I2Lj6W5J8+I7pNq69zzyTZNHIdjnFy3ZzJuEzhvtw72/tc50HOQvs9cDXZqIZWeL/1sLzvUeb+URQ/DGwwGg8FAMD94g8FgMLgKnHZpPj4+btyISjddL7nad62+uJJFz3RDFL1VF+qHDx/WWi8JKEySYbfxtbbuu5IU61K9awzsBdgFwwvJ7Vn7lmtQE0Lq7+Syrfn98MMPr+ag80vdkDu3VEo0YBKNvqdu68618Pj4+LxWmPSx1tadlgq09RwsduW1PZOWznXmxKqZPERJMa4LN/50jVkAr+fhWPfclGkM+r57FulCpbutxnYkaYX3yyUMnSlLSAIVa72sRY6frs0jCRN05znxCna8T8lSzqWZZPvc+qCrj/PormMqtu+eDSYK0i3duVD3RMS74v9UJM9EJX2P1/4IhuENBoPB4CpwWjz6n3/+iS0r1nphK0yq6CRpWJRelmIlWdDacEFPtuCpbet/ZUDa/Vy3ZWKNWrG0Ilzase6j18gV2ytcejCtmCQl5qymum4cS0og4nh1TExWURZaY6vzff78OVrsl8tl/f3338/XyxVZcwxkMUekkJg0lSSf0nscs26nx0uF7u5YSTA77ePKYVIijSsBSOU8KWVf36dwRIEeACcezaSLxJgcvnz50jLS+/v7TQmSPlf0ojARzXkNUnJFSolXlpEKs7ui+/S9mdiUvre3DjrPWSotOZLowmORQev2exJiHbNjUiCvvSbIueSlSVoZDAaDwUBwiuE9Pj6uT58+bSxDtXYZhzsic0TroRjDu3fvXn1e5yND0/dYqF3n0yLVinvVK6WdXNNVl8KrY0rxGT03hYUZd6j56vlqXoxz1thqDnpNOP567VLznZjvWls5NCeZpVZZx/Du7u6ej3Mk9sjzOKuS7JgWaJfezMJfMjFXBsEYVl3rOq4rcGdjYUrZFWqdaGlIjYFlPMki1vOkNdtZ6TwvyxE6OSqyjiQK4N67XC4tw3MNdfV4jA2zHOVI4TnHdoShJrF1V9KSmFXH0jhGxvKOiCSk43Yxw722PV8jG3am+J8eLn026dUbhjcYDAaDAXA6hvfXX39tLAZlQrQEGQ9zrR3I+mofNmQlA1xrrV9//fXVGGpMjpFwjDpu/Z/v67mT5cExqlVd56tti8lRasy1MKpt6d/visi5Da8NpeHW2opf03decm46ry6O6NAJT+t4UwG6iw2QzaR4jBM6oAwc2SCzUPX4dR24vjvxgj0R6UIX6yIbdde+PkuxlCT9pfMi20zSVjovgpmsLhZ6NNv0/v7++brUWnReDeYBdAXnhbRuu/VMj0t6Fhx74rZkVS47PDX8TdnJ7nhpHRxhR0dkwdK67grg94r86bFby8dwh+ENBoPBYCA4XYd3d3f3/Gta1k3VwK21jRelbLauISvr4djcVa3CYoHF9Mh8XP0YM7nI0gqakUjmyBhXjakYmbM+6nrVZ2QfykJY21RzZzzBSZoxVkTrh+xAt2Wcse5tybl1GX17jXofHx+ft6nju+uUYhtOzmiv3rMT101ZrIzt6ZzpMSDDPtLOJInr8p467MWS3diS1FdntTPOl/bVbTlGPutd9mm3di6XfzcOrjnWPVAPRT33bB2UWJXDXm2bzpNeFF7Dru4vCbO7zE6uJ7LC5NnQvxPj6vIp0tro2BrR1ftxG8bJuekXAAAQD0lEQVTu6t66eC09Yk9PuXkwMQxvMBgMBleB0+2B3r59u2FNammV5Z589LRU1tqyFFplZHqa2ff777+vtdb6448/1lov2X+1j6uXo3VMq73mp8y19qdgMhmEa2lTnxX7q/N1VmeyLsmQKp6hNUI1bl5rxnbcPGhF1/HdvjzOnoirZlNRqULPkWJ5Tgw5Zf/y2tZ90UxYMhPWq5GJ67kZR6Dqg1OGSLWotPDdPDimgnvOUg1dEnd29ZjcJ4lXu/mQQbhn3tVbdVmaej3rb/XAMNbt6mHTuI/iCMPrGNdevadjQimz8Qg75L3ivXVej5TJmcZzJKOUY9f/uQ7o7eq+v/V3YxjeYDAYDAaCUwzvzZs36/b29vnXtywt/fUtRlBWRP3PrCX9RWaNFJsLUvPy559/ft63Yne//fbbq8+YaeniMGzBU6/1frFFfY8xvKTVp4yDDO+XX355NUZXf0UriWoPf/7556vXjx8/Pu/rGiTqHJxlT83Muqdkvy5+dsbSYvzCNXakwg5jEV3rHYKtkXT8SS2HMTf9nLFcxoGdqgljc1wrzNZ19WrMNky6lWtt44pcZ6ytc3FNp5mp53GKJUTXUJmMdY/hqfegmJ16W2qdsua1a1FUcNfQfe5q6vhddaRN2B7TO6J8cgasc2YmfZdRTKaa9IDdWPfmqfvw+43fQ/o9wTFMe6DBYDAYDID5wRsMBoPBVeC0S/Obb755dhuUS0FdPuVaqKLQopp0OTjaTtqcRJ3V9Ue3DAPo7nx0B5FOd6UTdHPRrcdz6BjouiyXqXO30Y1S16/cOXW+GrNz77DYunPrsINzSo13hcJH3Dhr+eJoHTddeimd2rmealsm16RAvW5DWTDKlOl1ZCLGnmCyjon/M2nmSDduzsfdD7rQ6zW5tFw7Irr5jshepTG7a8IC4048uo7B9VHhkrW2yWp0NbPUxM3FyYHp/85tTGmvbo2mUgK6jV24JyWAJAnHbl4UEXDF8VzXfK6SIDnHr3ModO5+ujRdZ/m9a9JhGN5gMBgMrgJflbTCQKP+gvMXuyyuZBnXcRVMkd9LNV5rW0pQTMg1c2WyAputquXIeSWpn0JXPMpWP3Vex2jIGFgQzmuv1/No0bC7JrSiafE5CTMVOO6sdLWceU10TvWaJJf0OiXJpWSpurTteo9Fy+5edgXSa3kLn2yADK9jyHsNTLs2NLTseQ+Z0KPbJqbsEjiYwOWEoXU7fU/T0fcSPVgCoolp9GpQTJpJLDqHVEKVBKHX2q6rLkGHSAIHneA0PUtcB07EOrF13pdOVJ5j2lv/a+0nr7iStMToXGIZfx9GPHowGAwGA+AUw3v79u367rvvnq0OxrxqGwWt2c6Ko8WV0oX1fGURVHr+hw8f1lovFk+VMriGrIx/FTssa9ExVzLYFLvRMZclmlr7lIWtBfUF+rZr7CX1VWN3qfpMZa9Xsm49T5K/YvG/zlkZZSfE6z7vRGFZKM35de9Riq2gDNXFddbaWrwuBZ/XNMmh6XscayrVcZJvSYiAJQb6WRJd5/td7JiM1bEQMlTGeejd0X32YsY1hoeHh+dngMdfa1s2xHN3ItWpnVEnaZfS9Y8wjbTNEbHqvbXalQkQR+Z1Jj5GcD07AQLeL343d81+3brawzC8wWAwGFwFTjO8d+/ePf/alhWtv9ipmLGzGNhSJ4nRuozIird9+vTp1THKmq1sUS0iZ+yODK/Yk8aXOG5mQHasgEXKtEhYyL/W1orVZodu7HpNODbGL5ylxfMmaSnem7VerOu9Vi8u9qbXgnNM2V2OzSR5Js7HZYglluYsYMYaGMM5UyicLFOXwZyKh+tV43CpNReZ3pGMPjKvTlIq3QMX66+/NfaW2ERlaDKurM8LxYZTPLhjUal9U7dvEnUuuHuZrqGLdTqJMkXK4tV997I0u8xbjokeICeSkObjYtWM5afYnd5rilaMePRgMBgMBsBXMbzC999/v9byMTy2+KlfZReXqfcozMwaFyf1VKyM7IBtJdQHTOuV1pljKqzVojV6pBFjgRYKGafbNjWL7USYk2jxEVmgmk/dY4pkK7Q2bC8Oka69vsfPugw4ZrHROqfl28UkkndCz0/JLcZ0HWtjJq1jPG7Ma23XDuNwTgKMdXapkbITOi/sxSb1GdwTC3bPba3bI3V4FcPj2JxXI9VxOTaTMiz3WJV+tpdp2dUbkyU51lTYy7R22bOpjpnXomOUe7E8fT+16uL971r9pNZpTlqs7vXNzc0wvMFgMBgMFKcZ3vv37ze+bv11ZbyoYmflq3cMgAKsSanBxYqcCPFaL9aM+n75GS2gYjNUYNFzkynUK9mozpNqMKme0GWxUaA7MTynYkGmRCutU4NI9ZN6jDq3xpVSHK9UejqkjDdmxHaNK1ljluIKa21ZO9eDW99pLGRL7n5QDSbVqTmrmcpBrE1Vj0ldg/qM1yTV6aXx69j47Ov8uPZdrV2B2cV7FvrT09Mmru1aBiXG0DEg3sukWtJ5RFL8t4uTp30VKXM0nc/VGe5lu3fqM4npuXkxxkomzpiu/k0PCddMl+HbCY8Tw/AGg8FgcBWYH7zBYDAYXAVOuzS//fbbZ/pYSRau6JnuFCYruPTZQnKFOJcP01rrfExW0VR2ujeYeu+ScVJK8ZG055Tu3Ll8Ui87uiudiGvqNE1XoLoY6SKr5KQkrK1z1ZKFrvD85uZmE5TWMaXi0ySvpEiupE7MNyUesaea24bH5frQMSYBALpHXUIU3Wtcq0xQ0X1SAXpKouK59f9OMGAvZb7raVa4ubmJa+fp6Wk9Pj5urp8er9YKe13ynrrx8fWMWEYqzD/iYuO2nfxdWsfJ1dltm/7X91IiDefl5OLS65Hu5QVu66TF9L6NS3MwGAwGA8EphrfWa2bmUtTJ7PbaaKy1FYOlEKyz6ApMAKgkmQqK1zF1X7bj4ZhdcoUKJCtSoN4xoSRA7dgT03FTQeYRAW+yn674nxJiKaDPc9bx96x0BqH1WjMVObWUcgyPSSPJmu3amdR5UhKVvpcsebKEtV6uO9ktvR11TF1j9JCkFHN3Hbs2MHp+5x3gOmYil86bZRdJUkqvSZIjcyDDc56eOh4ZHsUxdAxder5uy3k5JAk4h7Q2O29EKmzv0InFp7E6YWb9n/fUfe/wO4PHcgIESZqNwhvpOEcxDG8wGAwGV4HTDE+LQF3R6/OB4f9mOrUrPqQlmvy77tc+WWvOauK2e01D19qm6/P9rsULGSqtTcYf1nphqLRYGcvrCp1TenXBve/aKa3l099rHl2rJ9327u5uc0+dmHPd37oGtXac6DVjqYz3dcLMtJrJamvO6h1gSx2mU7sU8DoPm5KmeKDzoqSSli6lvWssqv93rJfWescKU2G9KyNwZS4diuXpvgp6PFjO48otUqudlE7vmP6RJr6FTnZsb5+jscLumEfYdCo5S94pF8PjPl1pUxJu4LYu/qtlEBPDGwwGg8FAcIrhFburX1O2vVlrK6rLYkTGINba+mkZJ6OlqBJctS3jJGXhucJ0vsdYETO81uobYOqxnOWVpMTqPCWArdJqNcd6ZfsTsh9lwRQUTr57vW+8P86q5bHq+GqNdQzv4eEhFtLquXhPa841XictRhwpaE6Zlry3rpg3FRZ3RfE8Hj0MjnGTRaemuN3xk6jzmbhWdx357JENOgHgFPtOuFwum+8Fvfc8RypE132SpFgSr+9ktLpsSZ2D24dw1/ooO+wyy9O+Li6fsnXJrvQaMr7H9eX2SbKBHIeTkTsTzywMwxsMBoPBVeB0DO9yuWwy+Zy4LmvOmAnJWNhaW2ss1W/or30xoNq2mBBjYNpctfZh41WO0bWhSTEhxs1cfVmquyOLW+vFQi32RxbMmIVeT2b2kQ3UHHQfWrVsLFpjU1ZI63wvJnG5XGLLEN2f8T1Ky+m97OrfdB5OGJzxCjITl9V6tJmrgmsjrRkHni+JYzsklttlSPJacD7umqQMPkpJufrCLnO4oPE73dflAdCLQi+OPtMcN70baV5r5RhqlxmZWHNX27aHLvNyTx7uiPeDc09Z6mv1MU8dj8uyTk1du9hr8rZ1GIY3GAwGg6vAaYb39u3bDYNw9XGFYhEUsFXlA9a4JWZXrYCcdVlMqJq38lUtu59++mmt9WLRlaoI44u6T8rk27Nm3DxqW8YZ9Dqy3UmyfH788cfNWDlmvjr1CVqKVKxh89h0/L16KlpnLuaVLDen2JFaOnFNnmFCtW+xWccuUpzvSOyQrIaswFmsZL2Jya6VYxypnlW3Yyw61T66GDU/47rvMpj3WI3u67wDhSSY7jK+uXZ4vHpOOkbCa5zUbPS9xLy6TGI+V3uteNxnRzwye0orXe0bPztTu8exHsneZXbwEQzDGwwGg8FVYH7wBoPBYHAVOC0efXt7u0nu6Aoy2V3ZuasqCYFpzXyt82l6M90EdHu61PyPHz++Oh7T+FkorMejW5C03aWLM9Drkm/4f5LaqeOWq5gFyfoZA+s1n3LhuvtWx6ljlKvY3Te6oDvXAuWhkhtJx0D3Ro1Bk3s4x5SK79yThRqLk0rjGNN56vhuPnR3puQId43pfkquTH0mUnfslGqu59uTn3JuUY4xyfC5EpRCl3hQa4fJRApe472CZv07uQ2PFJEzIYcJMG7O6fWIGy8Vors5dFJleiz3HtcZXZpuTaXxH5nXXiJPt8/j4+MUng8Gg8FgoPiqpBWmYLu0bUpUkTloanlZDdWWhyn4LEh2bUFS+xJlA4VPnz69GhNZU6FLMSfD61hOKqbcK3jW49VnTFJxgtdMwiHrZsG4gveJXZOdyEBhTzz64eFhw1z1GrP0wwkVr/V6vVX5SUotZ5mIY7W0mmuOXH/uuLTOj6TZ8/w8ttuXEmpO9ozg8biW3DVhuQMtfrfPHnMt6PpOz0Kax8PDQ8vIUukFE2Z0O8rRscyKiSkd8+Yc2TbsCBxLSd8VBa5hVwaRCs1dklRK+ukShTj+I5JpaZ89UXb9O5XOdBiGNxgMBoOrwCmG9+bNm3V7exsLmRWMF9U+xeyUTTF2V/u+f//+1f8ursUmoWRexQBcKmxiVl26LlkAfc7OQnHFk3reer8Yrh6fxfGMiVJYea2Xa07G2olKs50TWaFjyrW/ionvWeod80lydLU+XJub1GKJcSxnkScrliUeXRyGDNIJD6R5Og9JArch43Ki3ile6uJLe+elPJ6OZ6/tkGPzha4Ug+C172JQ3Cc9gzpejonrW4/tRMLXyuUKOpbE7Lui/r04nIvHJnCbbqxcx938zogJ8DyJ0R2R6rtcLhPDGwwGg8FA8eakjM3/rLX++/9uOIP/B/ivp6enf/HNWTuDA5i1M/ha2LVDnPrBGwwGg8HgPxXj0hwMBoPBVWB+8AaDwWBwFZgfvMFgMBhcBeYHbzAYDAZXgfnBGwwGg8FVYH7wBoPBYHAVmB+8wWAwGFwF5gdvMBgMBleB+cEbDAaDwVXgfwF2dWcyyUizDwAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -1526,7 +1231,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1536,7 +1241,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1566,7 +1271,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1642,13 +1347,14 @@ "\n", " ('Non-negative components - NMF (Gensim)',\n", " NmfWrapper(\n", - " chunksize=1,\n", + " bow_matrix=faces.T,\n", + " chunksize=2,\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", + " minimum_probability=0,\n", + " random_state=42,\n", " ),\n", " False),\n", "\n", @@ -1715,6 +1421,22 @@ "\n", "plt.show()" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As you can see, Gensim NMF implementation works as fast as Sklearn NMF and achieves comparable quality, even though it's not optimised for dense matrices." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conclusion\n", + "\n", + "Gensim NMF is an extremely fast and memory-optimized model, and should be used whenever your system resources are too scarse for the task or when you want to try something different from LDA." + ] } ], "metadata": { @@ -1722,8 +1444,8 @@ "text_representation": { "extension": ".py", "format_name": "percent", - "format_version": "1.2", - "jupytext_version": "0.8.6" + "format_version": "1.1", + "jupytext_version": "0.8.3" } }, "kernelspec": { @@ -1741,7 +1463,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.2" + "version": "3.6.8" } }, "nbformat": 4, diff --git a/gensim/models/nmf.py b/gensim/models/nmf.py index 0a33660d00..d7993db5e7 100644 --- a/gensim/models/nmf.py +++ b/gensim/models/nmf.py @@ -1,10 +1,102 @@ -"""Online Non-Negative Matrix Factorization.""" +"""`Online Non-Negative Matrix Factorization. ` +Implements online non-negative matrix factorization algorithm, which allows for fast latent topic inference. +This NMF implementation updates in a streaming fashion and works best with sparse corpora. + +- W is a word-topic matrix +- h is a topic-document matrix +- v is an input word-document matrix +- A, B - matrices that accumulate information from every consecutive chunk. A = h.dot(ht), B = v.dot(ht). + +The idea of the algorithm is as follows: + +.. code-block:: text + + Initialize W, A and B matrices + + Input corpus + Split corpus to batches + + for v in batches: + infer h: + do coordinate gradient descent step to find h that minimizes (v - Wh) l2 norm + + bound h so that it is non-negative + + update A and B: + A = h.dot(ht) + B = v.dot(ht) + + update W: + do gradient descent step to find W that minimizes 0.5*trace(WtWA) - trace(WtB) l2 norm + +Examples +-------- + +Train an NMF model using a Gensim corpus + +.. sourcecode:: pycon + + >>> from gensim.test.utils import common_texts + >>> from gensim.corpora.dictionary import Dictionary + >>> + >>> # Create a corpus from a list of texts + >>> common_dictionary = Dictionary(common_texts) + >>> common_corpus = [common_dictionary.doc2bow(text) for text in common_texts] + >>> + >>> # Train the model on the corpus. + >>> nmf = Nmf(common_corpus, num_topics=10) + +Save a model to disk, or reload a pre-trained model + +.. sourcecode:: pycon + + >>> from gensim.test.utils import datapath + >>> + >>> # Save model to disk. + >>> temp_file = datapath("model") + >>> nmf.save(temp_file) + >>> + >>> # Load a potentially pretrained model from disk. + >>> nmf = Nmf.load(temp_file) + +Infer vectors for new documents + +.. sourcecode:: pycon + + >>> # Create a new corpus, made of previously unseen documents. + >>> other_texts = [ + ... ['computer', 'time', 'graph'], + ... ['survey', 'response', 'eps'], + ... ['human', 'system', 'computer'] + ... ] + >>> other_corpus = [common_dictionary.doc2bow(text) for text in other_texts] + >>> + >>> unseen_doc = other_corpus[0] + >>> vector = Nmf[unseen_doc] # get topic probability distribution for a document + +Update the model by incrementally training on the new corpus + +.. sourcecode:: pycon + + >>> nmf.update(other_corpus) + >>> vector = nmf[unseen_doc] + +A lot of parameters can be tuned to optimize training for your specific case + +.. sourcecode:: pycon + + >>> nmf = Nmf(common_corpus, num_topics=50, kappa=0.1, eval_every=5) # decrease training step size + +The NMF should be used whenever one needs extremely fast and memory optimized topic model. + +""" import itertools import logging import numpy as np import scipy.sparse +from gensim.models.nmf_pgd import solve_h from scipy.stats import halfnorm from gensim import interfaces @@ -12,10 +104,11 @@ 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__) +OLD_SCIPY = int(scipy.__version__.split('.')[1]) <= 18 + class Nmf(interfaces.TransformationABC, basemodel.BaseTopicModel): """Online Non-Negative Matrix Factorization. @@ -31,79 +124,74 @@ def __init__( 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, + h_max_iter=50, + h_stop_condition=1e-3, eval_every=10, - v_max=None, normalize=True, - sparse_coef=3, random_state=None, ): - """ + r""" Parameters ---------- corpus : iterable of list of (int, float), optional - Training corpus. If not given, model is left untrained. + Training corpus. + Can be either iterable of documents, which are lists of `(word_id, word_count)`, + or a sparse csc matrix of BOWs for each document. + If not specified, the model is left uninitialized (presumably, to be trained later with `self.train()`). 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. + id2word: {dict of (int, str), :class:`gensim.corpora.dictionary.Dictionary`} + Mapping from word IDs to words. It is used to determine the vocabulary size, as well as for + debugging and topic printing. chunksize: int, optional Number of documents to be used in each training chunk. - passes: int, optioanl + passes: int, optional 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. + Leave at default `passes=1` if your input is a non-repeatable generator. kappa : float, optional - Optimizer step coefficient. Increaing it makes model train faster, but adds a risk that it won't converge. + Gradient descent step size. + Larger value makes the model train faster, but could lead to non-convergence if set too large. + minimum_probability: + If `normalize` is True, topics with smaller probabilities are filtered out. + If `normalize` is False, topics with smaller factors are filtered out. + If set to None, a value of 1e-8 is used to prevent 0s. w_max_iter: int, optional - Maximum number of iterations to train W matrix per each batch. + Maximum number of iterations to train W 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. + If error difference gets less than that, training of ``W`` stops for the current batch. + h_max_iter: int, optional + Maximum number of iterations to train h per each batch. + h_stop_condition: float + If error difference gets less than that, training of ``h`` stops for the 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. + Number of batches after which l2 norm of (v - Wh) is computed. Decreases performance if set too low. + normalize: bool or None, optional + Whether to normalize the result. Allows for estimation of perplexity, coherence, e.t.c. random_state: {np.random.RandomState, int}, optional - Seed for random generator. Useful for reproducibility. + Seed for random generator. Needed 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._h_max_iter = h_max_iter + self.h_stop_condition = h_stop_condition self.eval_every = eval_every self.normalize = normalize - self.sparse_coef = sparse_coef self.random_state = utils.get_random_state(random_state) + self.v_max = None + if self.id2word is None: self.id2word = utils.dict_from_corpus(corpus) @@ -114,9 +202,9 @@ def __init__( self._W = None self.w_std = None + self._w_error = np.inf self._h = None - self._r = None if corpus is not None: self.update(corpus) @@ -126,8 +214,8 @@ def get_topics(self, normalize=None): Parameters ---------- - normalize : bool, optional - Whether to normalize an output vector. + normalize: bool or None, optional + Whether to normalize the result. Allows for estimation of perplexity, coherence, e.t.c. Returns ------- @@ -135,7 +223,7 @@ def get_topics(self, normalize=None): The probability for each word in each topic, shape (`num_topics`, `vocabulary_size`). """ - dense_topics = self._W.T.toarray() + dense_topics = self._W.T if normalize is None: normalize = self.normalize if normalize: @@ -146,9 +234,8 @@ def get_topics(self, normalize=None): 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. + def show_topics(self, num_topics=10, num_words=10, log=False, formatted=True, normalize=None): + """Get the topics sorted by sparsity. Parameters ---------- @@ -160,12 +247,12 @@ def show_topics(self, num_topics=10, num_words=10, log=False, 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. + Whether the result 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. + normalize: bool or None, optional + Whether to normalize the result. Allows for estimation of perplexity, coherence, e.t.c. Returns ------- @@ -177,7 +264,7 @@ def show_topics(self, num_topics=10, num_words=10, log=False, if normalize is None: normalize = self.normalize - sparsity = self._W.getnnz(axis=0) + sparsity = (self._W == 0).mean(axis=0) if num_topics < 0 or num_topics >= self.num_topics: num_topics = self.num_topics @@ -217,8 +304,8 @@ def show_topic(self, topicid, topn=10, normalize=None): 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. + normalize: bool or None, optional + Whether to normalize the result. Allows for estimation of perplexity, coherence, e.t.c. Returns ------- @@ -245,8 +332,8 @@ def get_topic_terms(self, topicid, topn=10, normalize=None): 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. + normalize: bool or None, optional + Whether to normalize the result. Allows for estimation of perplexity, coherence, e.t.c. Returns ------- @@ -254,7 +341,7 @@ def get_topic_terms(self, topicid, topn=10, normalize=None): Word ID - probability pairs for the most relevant words generated by the topic. """ - topic = self._W.getcol(topicid).toarray()[0] + topic = self._W[:, topicid] if normalize is None: normalize = self.normalize @@ -266,17 +353,20 @@ def get_topic_terms(self, topicid, topn=10, normalize=None): 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. + """Get the topics sorted by coherence. Parameters ---------- corpus : iterable of list of (int, float), optional - Corpus in BoW format. + Training corpus. + Can be either iterable of documents, which are lists of `(word_id, word_count)`, + or a sparse csc matrix of BOWs for each document. + If not specified, the model is left uninitialized (presumably, to be trained later with `self.train()`). 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. + dictionary : {dict of (int, str), :class:`gensim.corpora.dictionary.Dictionary`}, optional + 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 @@ -323,8 +413,11 @@ def log_perplexity(self, corpus): Parameters ---------- - corpus : list of list of (int, float) - The corpus on which the perplexity is computed. + corpus : iterable of list of (int, float), optional + Training corpus. + Can be either iterable of documents, which are lists of `(word_id, word_count)`, + or a sparse csc matrix of BOWs for each document. + If not specified, the model is left uninitialized (presumably, to be trained later with `self.train()`). Returns ------- @@ -346,8 +439,7 @@ def log_perplexity(self, corpus): 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): + def get_term_topics(self, word_id, minimum_probability=None, normalize=None): """Get the most relevant topics to the given word. Parameters @@ -355,9 +447,11 @@ def get_term_topics(self, word_id, minimum_probability=None, 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. + If `normalize` is True, topics with smaller probabilities are filtered out. + If `normalize` is False, topics with smaller factors are filtered out. + If set to None, a value of 1e-8 is used to prevent 0s. + normalize: bool or None, optional + Whether to normalize the result. Allows for estimation of perplexity, coherence, e.t.c. Returns ------- @@ -376,7 +470,7 @@ def get_term_topics(self, word_id, minimum_probability=None, values = [] - word_topics = self._W.getrow(word_id) + word_topics = self._W[word_id] if normalize is None: normalize = self.normalize @@ -384,7 +478,7 @@ def get_term_topics(self, word_id, minimum_probability=None, word_topics /= word_topics.sum() for topic_id in range(0, self.num_topics): - word_coef = word_topics[0, topic_id] + word_coef = word_topics[topic_id] if word_coef >= minimum_probability: values.append((topic_id, word_coef)) @@ -400,9 +494,11 @@ def get_document_topics(self, bow, minimum_probability=None, 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. + If `normalize` is True, topics with smaller probabilities are filtered out. + If `normalize` is False, topics with smaller factors are filtered out. + If set to None, a value of 1e-8 is used to prevent 0s. + normalize: bool or None, optional + Whether to normalize the result. Allows for estimation of perplexity, coherence, e.t.c. Returns ------- @@ -422,18 +518,18 @@ def get_document_topics(self, bow, minimum_probability=None, 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) + v = matutils.corpus2csc([bow], self.num_tokens) + h = self._solveproj(v, self._W, v_max=np.inf) if normalize is None: normalize = self.normalize if normalize: - h.data /= h.sum() + h /= h.sum() return [ - (idx, proba.toarray()[0, 0]) + (idx, proba) for idx, proba in enumerate(h[:, 0]) - if not minimum_probability or proba.toarray()[0, 0] > minimum_probability + if not minimum_probability or proba > minimum_probability ] def _setup(self, corpus): @@ -441,14 +537,21 @@ def _setup(self, corpus): Parameters ---------- - corpus : iterable of list(int, float) + corpus : iterable of list of (int, float), optional Training corpus. + Can be either iterable of documents, which are lists of `(word_id, word_count)`, + or a sparse csc matrix of BOWs for each document. + If not specified, the model is left uninitialized (presumably, to be trained later with `self.train()`). """ - 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._h = None + + if isinstance(corpus, scipy.sparse.csc.csc_matrix): + first_doc = corpus.getcol(0) + else: + 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( @@ -458,90 +561,88 @@ def _setup(self, corpus): ) ) - is_great_enough = self._W > self.w_std * self.sparse_coef + self.A = np.zeros((self.num_topics, self.num_topics)) + self.B = np.zeros((self.num_tokens, self.num_topics)) - 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): + def update(self, corpus): """Train the model with new documents. Parameters ---------- - corpus : iterable of list(int, float) + corpus : iterable of list of (int, float), optional 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`. + Can be either iterable of documents, which are lists of `(word_id, word_count)`, + or a sparse csc matrix of BOWs for each document. + If not specified, the model is left uninitialized (presumably, to be trained later with `self.train()`). """ - 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 + if isinstance(corpus, scipy.sparse.csc.csc_matrix): + grouper = ( + corpus[:, col_idx:col_idx + self.chunksize] + for col_idx + in range(0, corpus.shape[1], self.chunksize) ) - h, r = self._h, self._r + else: + grouper = utils.grouper(corpus, self.chunksize) + + for chunk in grouper: + if isinstance(corpus, scipy.sparse.csc.csc_matrix): + v = chunk[:, self.random_state.permutation(chunk.shape[1])] + else: + self.random_state.shuffle(chunk) + + v = matutils.corpus2csc( + chunk, + num_terms=self.num_tokens, + ) + + self._h = self._solveproj(v, self._W, h=self._h, v_max=self.v_max) + h = self._h 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 += v.dot(h.T) self.B /= chunk_idx + prev_w_error = self._w_error + 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), - ) - ) + logger.info("Loss: {}".format(self._w_error / prev_w_error)) 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), - ) - ) + logger.info("Loss: {}".format(self._w_error / prev_w_error)) def _solve_w(self): - """Update W matrix.""" + """Update W.""" def error(): + Wt = self._W.T return ( - 0.5 * self._W.T.dot(self._W).dot(self.A).diagonal().sum() - - self._W.T.dot(self.B).diagonal().sum() + 0.5 * Wt.dot(self._W).dot(self.A).trace() + - Wt.dot(self.B).trace() ) - eta = self._kappa / scipy.sparse.linalg.norm(self.A) + eta = self._kappa / np.linalg.norm(self.A) for iter_number in range(self._w_max_iter): - logger.debug("w_error: %s" % self._w_error) + logger.debug("w_error: {}".format(self._w_error)) error_ = error() if ( - self._w_error + self._w_error < np.inf and np.abs((error_ - self._w_error) / self._w_error) < self._w_stop_condition ): break @@ -556,8 +657,11 @@ def _apply(self, corpus, chunksize=None, **kwargs): Parameters ---------- - corpus : iterable of list of (int, number) - Corpus in sparse Gensim bag-of-words format. + corpus : iterable of list of (int, float), optional + Training corpus. + Can be either iterable of documents, which are lists of `(word_id, word_count)`, + or a sparse csc matrix of BOWs for each document. + If not specified, the model is left uninitialized (presumably, to be trained later with `self.train()`). chunksize : int, optional If provided, a more effective processing will performed. @@ -571,36 +675,29 @@ def _apply(self, corpus, chunksize=None, **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.clip(self._W, 0, self.v_max, out=self._W) + sumsq = np.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 + self._W /= 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() + @staticmethod + def _dense_dot_csc(dense, csc): + if OLD_SCIPY: + return (csc.T.dot(dense.T)).T + else: + return scipy.sparse.csc_matrix.dot(dense, csc) - def _solveproj(self, v, W, h=None, r=None, v_max=None): + def _solveproj(self, v, W, h=None, v_max=None): """Update residuals and representation(h) matrices. Parameters ---------- - v : iterable of list(int, float) + v : scipy.sparse.csc_matrix Subset of training corpus. - W : scipy.sparse.csc_matrix + W : ndarray Dictionary matrix. - h : scipy.sparse.csr_matrix + h : ndarray Representation matrix. - r : scipy.sparse.csr_matrix - Residuals matrix. v_max : float Maximum possible value in matrices. @@ -612,45 +709,30 @@ def _solveproj(self, v, W, h=None, r=None, v_max=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) + h = np.zeros(hshape) - WtW = W.T.dot(W) + Wt = W.T + WtW = Wt.dot(W) - _h_r_error = None + h_error = None - for iter_number in range(self._h_r_max_iter): - logger.debug("h_r_error: %s" % _h_r_error) + for iter_number in range(self._h_max_iter): + logger.debug("h_error: {}".format(h_error)) - error_ = 0. + Wtv = self._dense_dot_csc(Wt, v) - Wt_v_minus_r = W.T.dot(v - r) + permutation = self.random_state.permutation(self.num_topics).astype(np.int32) - 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_ = solve_h(h, Wtv, WtW, permutation, self._kappa) error_ /= m - if _h_r_error and np.abs(_h_r_error - error_) < self._h_r_stop_condition: + if h_error and np.abs(h_error - error_) < self.h_stop_condition: break - _h_r_error = error_ + h_error = error_ - return h, r + return h diff --git a/gensim/models/nmf_pgd.c b/gensim/models/nmf_pgd.c index 83857ce7fa..6ae13d947a 100644 --- a/gensim/models/nmf_pgd.c +++ b/gensim/models/nmf_pgd.c @@ -1,4 +1,4 @@ -/* Generated by Cython 0.29.2 */ +/* Generated by Cython 0.28.6 */ #define PY_SSIZE_T_CLEAN #include "Python.h" @@ -7,8 +7,7 @@ #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.6+ or Python 3.3+. #else -#define CYTHON_ABI "0_29_2" -#define CYTHON_HEX_VERSION 0x001D02F0 +#define CYTHON_ABI "0_28_6" #define CYTHON_FUTURE_DIVISION 0 #include #ifndef offsetof @@ -79,10 +78,6 @@ #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 #elif defined(PYSTON_VERSION) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 1 @@ -120,10 +115,6 @@ #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 @@ -177,17 +168,11 @@ #define CYTHON_FAST_PYCALL 1 #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #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 - #ifndef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) - #endif - #ifndef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) - #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) @@ -198,7 +183,7 @@ #undef BASE #undef MASK #ifdef SIZEOF_VOID_P - enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; + enum { __pyx_check_sizeof_voidp = 1/(SIZEOF_VOID_P == sizeof(void*)) }; #endif #endif #ifndef __has_attribute @@ -326,9 +311,6 @@ #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif -#ifndef METH_STACKLESS - #define METH_STACKLESS 0 -#endif #if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 @@ -342,40 +324,15 @@ #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 | METH_STACKLESS))))) + ((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_USE_DICT_VERSIONS -#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) -#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ - (version_var) = __PYX_GET_DICT_VERSION(dict);\ - (cache_var) = (value); -#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ - static PY_UINT64_T __pyx_dict_version = 0;\ - static PyObject *__pyx_dict_cached_value = NULL;\ - if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ - (VAR) = __pyx_dict_cached_value;\ - } else {\ - (VAR) = __pyx_dict_cached_value = (LOOKUP);\ - __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ - }\ - } -#else -#define __PYX_GET_DICT_VERSION(dict) (0) -#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) -#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); -#endif #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_CPYTHON && PY_VERSION_HEX < 0x030400A1 - #define PyMem_RawMalloc(n) PyMem_Malloc(n) - #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) - #define PyMem_RawFree(p) PyMem_Free(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) @@ -483,8 +440,8 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #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 || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) -#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#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 @@ -642,9 +599,6 @@ typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* enc (sizeof(type) == sizeof(Py_ssize_t) &&\ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) -static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { - return (size_t) i < (size_t) limit; -} #if defined (__cplusplus) && __cplusplus >= 201103L #include #define __Pyx_sst_abs(value) std::abs(value) @@ -703,7 +657,6 @@ static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); -static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); #define __Pyx_PySequence_Tuple(obj)\ (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) @@ -784,7 +737,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; - __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); + __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); @@ -821,7 +774,7 @@ static const char *__pyx_filename; static const char *__pyx_f[] = { - "gensim/models/nmf_pgd.pyx", + "nmf_pgd.pyx", "stringsource", }; /* NoFastGil.proto */ @@ -939,7 +892,7 @@ struct __pyx_MemviewEnum_obj; struct __pyx_memoryview_obj; struct __pyx_memoryviewslice_obj; -/* "View.MemoryView":105 +/* "View.MemoryView":104 * * @cname("__pyx_array") * cdef class array: # <<<<<<<<<<<<<< @@ -964,7 +917,7 @@ struct __pyx_array_obj { }; -/* "View.MemoryView":279 +/* "View.MemoryView":278 * * @cname('__pyx_MemviewEnum') * cdef class Enum(object): # <<<<<<<<<<<<<< @@ -977,7 +930,7 @@ struct __pyx_MemviewEnum_obj { }; -/* "View.MemoryView":330 +/* "View.MemoryView":329 * * @cname('__pyx_memoryview') * cdef class memoryview(object): # <<<<<<<<<<<<<< @@ -1000,7 +953,7 @@ struct __pyx_memoryview_obj { }; -/* "View.MemoryView":961 +/* "View.MemoryView":960 * * @cname('__pyx_memoryviewslice') * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< @@ -1017,7 +970,7 @@ struct __pyx_memoryviewslice_obj { -/* "View.MemoryView":105 +/* "View.MemoryView":104 * * @cname("__pyx_array") * cdef class array: # <<<<<<<<<<<<<< @@ -1031,7 +984,7 @@ struct __pyx_vtabstruct_array { static struct __pyx_vtabstruct_array *__pyx_vtabptr_array; -/* "View.MemoryView":330 +/* "View.MemoryView":329 * * @cname('__pyx_memoryview') * cdef class memoryview(object): # <<<<<<<<<<<<<< @@ -1051,7 +1004,7 @@ struct __pyx_vtabstruct_memoryview { static struct __pyx_vtabstruct_memoryview *__pyx_vtabptr_memoryview; -/* "View.MemoryView":961 +/* "View.MemoryView":960 * * @cname('__pyx_memoryviewslice') * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< @@ -1244,23 +1197,8 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, #else #define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif -#define __Pyx_BUILD_ASSERT_EXPR(cond)\ - (sizeof(char [1 - 2*!(cond)]) - 1) -#ifndef Py_MEMBER_SIZE -#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) -#endif - static size_t __pyx_pyframe_localsplus_offset = 0; - #include "frameobject.h" - #define __Pxy_PyFrame_Initialize_Offsets()\ - ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ - (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) - #define __Pyx_PyFrame_GetLocalsplus(frame)\ - (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) #endif -/* PyObjectCall2Args.proto */ -static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); - /* PyObjectCallMethO.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); @@ -1355,25 +1293,7 @@ static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tsta static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); /* GetModuleGlobalName.proto */ -#if CYTHON_USE_DICT_VERSIONS -#define __Pyx_GetModuleGlobalName(var, name) {\ - static PY_UINT64_T __pyx_dict_version = 0;\ - static PyObject *__pyx_dict_cached_value = NULL;\ - (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ - (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ - __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} -#define __Pyx_GetModuleGlobalNameUncached(var, name) {\ - PY_UINT64_T __pyx_dict_version;\ - PyObject *__pyx_dict_cached_value;\ - (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} -static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); -#else -#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) -#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) -static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); -#endif +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); /* RaiseTooManyValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); @@ -1387,11 +1307,6 @@ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); /* ExtTypeTest.proto */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); -/* GetTopmostException.proto */ -#if CYTHON_USE_EXC_INFO_STACK -static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); -#endif - /* SaveResetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) @@ -1614,6 +1529,9 @@ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_dc_d /* ObjectToMemviewSlice.proto */ static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dsds_double(PyObject *, int writable_flag); +/* ObjectToMemviewSlice.proto */ +static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_int(PyObject *, int writable_flag); + /* MemviewSliceCopyTemplate.proto */ static __Pyx_memviewslice __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, @@ -1636,12 +1554,6 @@ 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); @@ -1675,7 +1587,6 @@ 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*/ @@ -1727,13 +1638,12 @@ 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_Wtv[] = "Wtv"; 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__"; @@ -1753,57 +1663,43 @@ 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_Wt_v_minus_r[] = "Wt_v_minus_r"; +static const char __pyx_k_nmf_pgd_pyx[] = "nmf_pgd.pyx"; +static const char __pyx_k_permutation[] = "permutation"; 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"; @@ -1812,16 +1708,10 @@ 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"; @@ -1830,7 +1720,6 @@ static const char __pyx_k_MemoryView_of_r_at_0x_x[] = " y else y # <<<<<<<<<<<<<< * - * cdef double clip(double a, double a_min, double a_max) nogil: + * def solve_h(double[:, ::1] h, double[:, :] Wtv, double[:, ::1] WtW, int[::1] permutation, double kappa): */ if (((__pyx_v_x > __pyx_v_y) != 0)) { __pyx_t_1 = __pyx_v_x; @@ -2138,82 +2005,33 @@ static double __pyx_f_6gensim_6models_7nmf_pgd_fmax(double __pyx_v_x, double __p /* "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): # <<<<<<<<<<<<<< + * def solve_h(double[:, ::1] h, double[:, :] Wtv, double[:, ::1] WtW, int[::1] permutation, 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(double[:, ::1] h, double[:, :] Wt_v_minus_r, double[:, ::1] 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)(void*)(PyCFunctionWithKeywords)__pyx_pw_6gensim_6models_7nmf_pgd_1solve_h, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6gensim_6models_7nmf_pgd_solve_h}; +static char __pyx_doc_6gensim_6models_7nmf_pgd_solve_h[] = "solve_h(__Pyx_memviewslice h, __Pyx_memviewslice Wtv, __Pyx_memviewslice WtW, __Pyx_memviewslice permutation, 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 Wtv : 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_Wtv = { 0, 0, { 0 }, { 0 }, { 0 } }; __Pyx_memviewslice __pyx_v_WtW = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_permutation = { 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}; + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_h,&__pyx_n_s_Wtv,&__pyx_n_s_WtW,&__pyx_n_s_permutation,&__pyx_n_s_kappa,0}; + PyObject* values[5] = {0,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 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); @@ -2232,55 +2050,63 @@ static PyObject *__pyx_pw_6gensim_6models_7nmf_pgd_1solve_h(PyObject *__pyx_self 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--; + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Wtv)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("solve_h", 1, 4, 4, 1); __PYX_ERR(0, 23, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("solve_h", 1, 5, 5, 1); __PYX_ERR(0, 18, __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) + __Pyx_RaiseArgtupleInvalid("solve_h", 1, 5, 5, 2); __PYX_ERR(0, 18, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: - if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kappa)) != 0)) kw_args--; + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_permutation)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("solve_h", 1, 5, 5, 3); __PYX_ERR(0, 18, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __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) + __Pyx_RaiseArgtupleInvalid("solve_h", 1, 5, 5, 4); __PYX_ERR(0, 18, __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) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "solve_h") < 0)) __PYX_ERR(0, 18, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { + } else if (PyTuple_GET_SIZE(__pyx_args) != 5) { 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); + values[4] = PyTuple_GET_ITEM(__pyx_args, 4); } - __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) + __pyx_v_h = __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(values[0], PyBUF_WRITABLE); if (unlikely(!__pyx_v_h.memview)) __PYX_ERR(0, 18, __pyx_L3_error) + __pyx_v_Wtv = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_Wtv.memview)) __PYX_ERR(0, 18, __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, 18, __pyx_L3_error) + __pyx_v_permutation = __Pyx_PyObject_to_MemoryviewSlice_dc_int(values[3], PyBUF_WRITABLE); if (unlikely(!__pyx_v_permutation.memview)) __PYX_ERR(0, 18, __pyx_L3_error) + __pyx_v_kappa = __pyx_PyFloat_AsDouble(values[4]); if (unlikely((__pyx_v_kappa == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 18, __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_RaiseArgtupleInvalid("solve_h", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 18, __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); + __pyx_r = __pyx_pf_6gensim_6models_7nmf_pgd_solve_h(__pyx_self, __pyx_v_h, __pyx_v_Wtv, __pyx_v_WtW, __pyx_v_permutation, __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) { +static PyObject *__pyx_pf_6gensim_6models_7nmf_pgd_solve_h(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_h, __Pyx_memviewslice __pyx_v_Wtv, __Pyx_memviewslice __pyx_v_WtW, __Pyx_memviewslice __pyx_v_permutation, double __pyx_v_kappa) { Py_ssize_t __pyx_v_n_components; CYTHON_UNUSED Py_ssize_t __pyx_v_n_samples; double __pyx_v_violation; @@ -2309,17 +2135,18 @@ static PyObject *__pyx_pf_6gensim_6models_7nmf_pgd_solve_h(CYTHON_UNUSED PyObjec 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_18; + double __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; + Py_ssize_t __pyx_t_25; + PyObject *__pyx_t_26 = NULL; __Pyx_RefNannySetupContext("solve_h", 0); - /* "gensim/models/nmf_pgd.pyx":40 + /* "gensim/models/nmf_pgd.pyx":35 * """ * * cdef Py_ssize_t n_components = h.shape[0] # <<<<<<<<<<<<<< @@ -2328,7 +2155,7 @@ static PyObject *__pyx_pf_6gensim_6models_7nmf_pgd_solve_h(CYTHON_UNUSED PyObjec */ __pyx_v_n_components = (__pyx_v_h.shape[0]); - /* "gensim/models/nmf_pgd.pyx":41 + /* "gensim/models/nmf_pgd.pyx":36 * * cdef Py_ssize_t n_components = h.shape[0] * cdef Py_ssize_t n_samples = h.shape[1] # <<<<<<<<<<<<<< @@ -2337,7 +2164,7 @@ static PyObject *__pyx_pf_6gensim_6models_7nmf_pgd_solve_h(CYTHON_UNUSED PyObjec */ __pyx_v_n_samples = (__pyx_v_h.shape[1]); - /* "gensim/models/nmf_pgd.pyx":42 + /* "gensim/models/nmf_pgd.pyx":37 * cdef Py_ssize_t n_components = h.shape[0] * cdef Py_ssize_t n_samples = h.shape[1] * cdef double violation = 0 # <<<<<<<<<<<<<< @@ -2346,7 +2173,7 @@ static PyObject *__pyx_pf_6gensim_6models_7nmf_pgd_solve_h(CYTHON_UNUSED PyObjec */ __pyx_v_violation = 0.0; - /* "gensim/models/nmf_pgd.pyx":44 + /* "gensim/models/nmf_pgd.pyx":39 * cdef double violation = 0 * cdef double grad, projected_grad, hessian * cdef Py_ssize_t sample_idx = 0 # <<<<<<<<<<<<<< @@ -2355,7 +2182,7 @@ static PyObject *__pyx_pf_6gensim_6models_7nmf_pgd_solve_h(CYTHON_UNUSED PyObjec */ __pyx_v_sample_idx = 0; - /* "gensim/models/nmf_pgd.pyx":45 + /* "gensim/models/nmf_pgd.pyx":40 * cdef double grad, projected_grad, hessian * cdef Py_ssize_t sample_idx = 0 * cdef Py_ssize_t component_idx_1 = 0 # <<<<<<<<<<<<<< @@ -2364,7 +2191,7 @@ static PyObject *__pyx_pf_6gensim_6models_7nmf_pgd_solve_h(CYTHON_UNUSED PyObjec */ __pyx_v_component_idx_1 = 0; - /* "gensim/models/nmf_pgd.pyx":46 + /* "gensim/models/nmf_pgd.pyx":41 * cdef Py_ssize_t sample_idx = 0 * cdef Py_ssize_t component_idx_1 = 0 * cdef Py_ssize_t component_idx_2 = 0 # <<<<<<<<<<<<<< @@ -2373,12 +2200,12 @@ static PyObject *__pyx_pf_6gensim_6models_7nmf_pgd_solve_h(CYTHON_UNUSED PyObjec */ __pyx_v_component_idx_2 = 0; - /* "gensim/models/nmf_pgd.pyx":48 + /* "gensim/models/nmf_pgd.pyx":43 * 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): - * + * component_idx_1 = permutation[component_idx_1] */ { #ifdef WITH_THREAD @@ -2400,7 +2227,7 @@ static PyObject *__pyx_pf_6gensim_6models_7nmf_pgd_solve_h(CYTHON_UNUSED PyObjec 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) + #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_25, __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9) #endif /* _OPENMP */ { #ifdef _OPENMP @@ -2416,67 +2243,77 @@ static PyObject *__pyx_pf_6gensim_6models_7nmf_pgd_solve_h(CYTHON_UNUSED PyObjec __pyx_v_hessian = ((double)__PYX_NAN()); __pyx_v_projected_grad = ((double)__PYX_NAN()); - /* "gensim/models/nmf_pgd.pyx":49 + /* "gensim/models/nmf_pgd.pyx":44 * * for sample_idx in prange(n_samples, nogil=True): * for component_idx_1 in range(n_components): # <<<<<<<<<<<<<< + * component_idx_1 = permutation[component_idx_1] * - * 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 + /* "gensim/models/nmf_pgd.pyx":45 + * for sample_idx in prange(n_samples, nogil=True): * for component_idx_1 in range(n_components): + * component_idx_1 = permutation[component_idx_1] # <<<<<<<<<<<<<< + * + * grad = -Wtv[component_idx_1, sample_idx] + */ + __pyx_t_7 = __pyx_v_component_idx_1; + __pyx_v_component_idx_1 = (*((int *) ( /* dim=0 */ ((char *) (((int *) __pyx_v_permutation.data) + __pyx_t_7)) ))); + + /* "gensim/models/nmf_pgd.pyx":47 + * component_idx_1 = permutation[component_idx_1] * - * grad = -Wt_v_minus_r[component_idx_1, sample_idx] # <<<<<<<<<<<<<< + * grad = -Wtv[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]) )))); + __pyx_t_8 = __pyx_v_component_idx_1; + __pyx_t_9 = __pyx_v_sample_idx; + __pyx_v_grad = (-(*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_Wtv.data + __pyx_t_8 * __pyx_v_Wtv.strides[0]) ) + __pyx_t_9 * __pyx_v_Wtv.strides[1]) )))); - /* "gensim/models/nmf_pgd.pyx":53 - * grad = -Wt_v_minus_r[component_idx_1, sample_idx] + /* "gensim/models/nmf_pgd.pyx":49 + * grad = -Wtv[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; + __pyx_t_10 = __pyx_v_n_components; + __pyx_t_11 = __pyx_t_10; + for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) { + __pyx_v_component_idx_2 = __pyx_t_12; - /* "gensim/models/nmf_pgd.pyx":54 + /* "gensim/models/nmf_pgd.pyx":50 * * 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_13 = __pyx_v_component_idx_1; __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)) ))))); + __pyx_t_15 = __pyx_v_component_idx_2; + __pyx_t_16 = __pyx_v_sample_idx; + __pyx_v_grad = (__pyx_v_grad + ((*((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_WtW.data + __pyx_t_13 * __pyx_v_WtW.strides[0]) )) + __pyx_t_14)) ))) * (*((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_h.data + __pyx_t_15 * __pyx_v_h.strides[0]) )) + __pyx_t_16)) ))))); } - /* "gensim/models/nmf_pgd.pyx":56 + /* "gensim/models/nmf_pgd.pyx":52 * 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)) ))); + __pyx_t_18 = __pyx_v_component_idx_1; + __pyx_v_hessian = (*((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_WtW.data + __pyx_t_17 * __pyx_v_WtW.strides[0]) )) + __pyx_t_18)) ))); - /* "gensim/models/nmf_pgd.pyx":58 + /* "gensim/models/nmf_pgd.pyx":54 * hessian = WtW[component_idx_1, component_idx_1] * * grad = grad * kappa / hessian # <<<<<<<<<<<<<< @@ -2485,23 +2322,23 @@ static PyObject *__pyx_pf_6gensim_6models_7nmf_pgd_solve_h(CYTHON_UNUSED PyObjec */ __pyx_v_grad = ((__pyx_v_grad * __pyx_v_kappa) / __pyx_v_hessian); - /* "gensim/models/nmf_pgd.pyx":60 + /* "gensim/models/nmf_pgd.pyx":56 * 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); + __pyx_t_20 = __pyx_v_component_idx_1; + __pyx_t_21 = __pyx_v_sample_idx; + if ((((*((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_h.data + __pyx_t_20 * __pyx_v_h.strides[0]) )) + __pyx_t_21)) ))) == 0.0) != 0)) { + __pyx_t_19 = __pyx_f_6gensim_6models_7nmf_pgd_fmin(0.0, __pyx_v_grad); } else { - __pyx_t_18 = __pyx_v_grad; + __pyx_t_19 = __pyx_v_grad; } - __pyx_v_projected_grad = __pyx_t_18; + __pyx_v_projected_grad = __pyx_t_19; - /* "gensim/models/nmf_pgd.pyx":62 + /* "gensim/models/nmf_pgd.pyx":58 * projected_grad = fmin(0, grad) if h[component_idx_1, sample_idx] == 0 else grad * * violation += projected_grad * projected_grad # <<<<<<<<<<<<<< @@ -2510,18 +2347,18 @@ static PyObject *__pyx_pf_6gensim_6models_7nmf_pgd_solve_h(CYTHON_UNUSED PyObjec */ __pyx_v_violation = (__pyx_v_violation + (__pyx_v_projected_grad * __pyx_v_projected_grad)); - /* "gensim/models/nmf_pgd.pyx":64 + /* "gensim/models/nmf_pgd.pyx":60 * 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.); + __pyx_t_22 = __pyx_v_component_idx_1; + __pyx_t_23 = __pyx_v_sample_idx; + __pyx_t_24 = __pyx_v_component_idx_1; + __pyx_t_25 = __pyx_v_sample_idx; + *((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_h.data + __pyx_t_24 * __pyx_v_h.strides[0]) )) + __pyx_t_25)) )) = __pyx_f_6gensim_6models_7nmf_pgd_fmax(((*((double *) ( /* dim=1 */ ((char *) (((double *) ( /* dim=0 */ (__pyx_v_h.data + __pyx_t_22 * __pyx_v_h.strides[0]) )) + __pyx_t_23)) ))) - __pyx_v_grad), 0.); } } } @@ -2536,12 +2373,12 @@ static PyObject *__pyx_pf_6gensim_6models_7nmf_pgd_solve_h(CYTHON_UNUSED PyObjec #endif } - /* "gensim/models/nmf_pgd.pyx":48 + /* "gensim/models/nmf_pgd.pyx":43 * 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): - * + * component_idx_1 = permutation[component_idx_1] */ /*finally:*/ { /*normal exit:*/{ @@ -2555,69 +2392,70 @@ static PyObject *__pyx_pf_6gensim_6models_7nmf_pgd_solve_h(CYTHON_UNUSED PyObjec } } - /* "gensim/models/nmf_pgd.pyx":66 + /* "gensim/models/nmf_pgd.pyx":62 * 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; + __pyx_t_26 = PyFloat_FromDouble(sqrt(__pyx_v_violation)); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_26); + __pyx_r = __pyx_t_26; + __pyx_t_26 = 0; goto __pyx_L0; - /* "gensim/models/nmf_pgd.pyx":23 - * return a + /* "gensim/models/nmf_pgd.pyx":18 + * return x if x > y else y * - * def solve_h(double[:, ::1] h, double[:, :] Wt_v_minus_r, double[:, ::1] WtW, double kappa): # <<<<<<<<<<<<<< + * def solve_h(double[:, ::1] h, double[:, :] Wtv, double[:, ::1] WtW, int[::1] permutation, 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_XDECREF(__pyx_t_26); __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_Wtv, 1); __PYX_XDEC_MEMVIEW(&__pyx_v_WtW, 1); + __PYX_XDEC_MEMVIEW(&__pyx_v_permutation, 1); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "gensim/models/nmf_pgd.pyx":68 - * return sqrt(violation) +/* "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): * - * 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)(void*)(PyCFunctionWithKeywords)__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; +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("solve_r (wrapper)", 0); + __Pyx_RefNannySetupContext("__cinit__ (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}; + 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); @@ -2632,944 +2470,199 @@ static PyObject *__pyx_pw_6gensim_6models_7nmf_pgd_3solve_r(PyObject *__pyx_self 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--; + 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_r_actual)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_itemsize)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("solve_r", 1, 4, 4, 1); __PYX_ERR(0, 68, __pyx_L3_error) + __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_lambda)) != 0)) kw_args--; + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_format)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("solve_r", 1, 4, 4, 2); __PYX_ERR(0, 68, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 2); __PYX_ERR(1, 121, __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 (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, "solve_r") < 0)) __PYX_ERR(0, 68, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 121, __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); + 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); } - __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_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 121, __pyx_L3_error) __pyx_L3_error:; - __Pyx_AddTraceback("gensim.models.nmf_pgd.solve_r", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); - return NULL; + return -1; __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); + 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 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; +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 - 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_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; - 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); + 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); - /* "gensim/models/nmf_pgd.pyx":90 - * """ + /* "View.MemoryView":128 + * cdef PyObject **p * - * 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 + * self.ndim = len(shape) # <<<<<<<<<<<<<< + * self.itemsize = itemsize * - * 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; + 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); - /* "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 + /* "View.MemoryView":129 * - */ - __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 # <<<<<<<<<<<<<< + * self.ndim = len(shape) + * self.itemsize = itemsize # <<<<<<<<<<<<<< * - * cdef Py_ssize_t r_col_size = 0 + * if not self.ndim: */ - __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; + __pyx_v_self->itemsize = __pyx_v_itemsize; - /* "gensim/models/nmf_pgd.pyx":97 - * cdef double[::1] r_actual_data = r_actual.data + /* "View.MemoryView":131 + * self.itemsize = itemsize * - * 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 + * if not self.ndim: # <<<<<<<<<<<<<< + * raise ValueError("Empty shape tuple for cython.array") * - * 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; + __pyx_t_2 = ((!(__pyx_v_self->ndim != 0)) != 0); + if (unlikely(__pyx_t_2)) { - /* "gensim/models/nmf_pgd.pyx":106 - * cdef double* r_actual_element + /* "View.MemoryView":132 * - * cdef double r_actual_sign = 1.0 # <<<<<<<<<<<<<< + * if not self.ndim: + * raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<< * - * cdef Py_ssize_t n_samples = r_actual_indptr.shape[0] - 1 + * if itemsize <= 0: */ - __pyx_v_r_actual_sign = 1.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) - /* "gensim/models/nmf_pgd.pyx":108 - * cdef double r_actual_sign = 1.0 + /* "View.MemoryView":131 + * self.itemsize = itemsize * - * cdef Py_ssize_t n_samples = r_actual_indptr.shape[0] - 1 # <<<<<<<<<<<<<< - * cdef Py_ssize_t sample_idx + * if not self.ndim: # <<<<<<<<<<<<<< + * raise ValueError("Empty shape tuple for cython.array") * */ - __pyx_v_n_samples = ((__pyx_v_r_actual_indptr.shape[0]) - 1); + } - /* "gensim/models/nmf_pgd.pyx":111 - * cdef Py_ssize_t sample_idx + /* "View.MemoryView":134 + * raise ValueError("Empty shape tuple for cython.array") * - * cdef double violation = 0 # <<<<<<<<<<<<<< + * if itemsize <= 0: # <<<<<<<<<<<<<< + * raise ValueError("itemsize <= 0 for cython.array") * - * for sample_idx in prange(n_samples, nogil=True): */ - __pyx_v_violation = 0.0; + __pyx_t_2 = ((__pyx_v_itemsize <= 0) != 0); + if (unlikely(__pyx_t_2)) { - /* "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":122 - * cdef bint dtype_is_object - * - * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< - * mode="c", bint allocate_buffer=True): - * - */ - -/* 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, 122, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_format)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 2); __PYX_ERR(1, 122, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mode); - if (value) { values[3] = value; kw_args--; } - } - CYTHON_FALLTHROUGH; - case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_allocate_buffer); - if (value) { values[4] = value; kw_args--; } - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 122, __pyx_L3_error) - } - } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } - } - __pyx_v_shape = ((PyObject*)values[0]); - __pyx_v_itemsize = __Pyx_PyIndex_AsSsize_t(values[1]); if (unlikely((__pyx_v_itemsize == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 122, __pyx_L3_error) - __pyx_v_format = values[2]; - __pyx_v_mode = values[3]; - if (values[4]) { - __pyx_v_allocate_buffer = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_allocate_buffer == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 123, __pyx_L3_error) - } else { - - /* "View.MemoryView":123 - * - * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, - * mode="c", bint allocate_buffer=True): # <<<<<<<<<<<<<< - * - * cdef int idx - */ - __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, 122, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return -1; - __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_shape), (&PyTuple_Type), 1, "shape", 1))) __PYX_ERR(1, 122, __pyx_L1_error) - if (unlikely(((PyObject *)__pyx_v_format) == Py_None)) { - PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "format"); __PYX_ERR(1, 122, __pyx_L1_error) - } - __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v_shape, __pyx_v_itemsize, __pyx_v_format, __pyx_v_mode, __pyx_v_allocate_buffer); - - /* "View.MemoryView":122 - * cdef bint dtype_is_object - * - * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< - * mode="c", bint allocate_buffer=True): - * - */ - - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __pyx_r = -1; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer) { - int __pyx_v_idx; - Py_ssize_t __pyx_v_i; - Py_ssize_t __pyx_v_dim; - PyObject **__pyx_v_p; - char __pyx_v_order; - int __pyx_r; - __Pyx_RefNannyDeclarations - Py_ssize_t __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - char *__pyx_t_7; - int __pyx_t_8; - Py_ssize_t __pyx_t_9; - PyObject *__pyx_t_10 = NULL; - Py_ssize_t __pyx_t_11; - __Pyx_RefNannySetupContext("__cinit__", 0); - __Pyx_INCREF(__pyx_v_format); - - /* "View.MemoryView":129 - * cdef PyObject **p - * - * self.ndim = len(shape) # <<<<<<<<<<<<<< - * self.itemsize = itemsize - * - */ - if (unlikely(__pyx_v_shape == Py_None)) { - PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(1, 129, __pyx_L1_error) - } - __pyx_t_1 = PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 129, __pyx_L1_error) - __pyx_v_self->ndim = ((int)__pyx_t_1); - - /* "View.MemoryView":130 - * - * self.ndim = len(shape) - * self.itemsize = itemsize # <<<<<<<<<<<<<< - * - * if not self.ndim: - */ - __pyx_v_self->itemsize = __pyx_v_itemsize; - - /* "View.MemoryView":132 - * 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":133 - * - * 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, 133, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 133, __pyx_L1_error) - - /* "View.MemoryView":132 - * self.itemsize = itemsize - * - * if not self.ndim: # <<<<<<<<<<<<<< - * raise ValueError("Empty shape tuple for cython.array") - * - */ - } - - /* "View.MemoryView":135 - * 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":136 + /* "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, 136, __pyx_L1_error) + __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, 136, __pyx_L1_error) + __PYX_ERR(1, 135, __pyx_L1_error) - /* "View.MemoryView":135 + /* "View.MemoryView":134 * raise ValueError("Empty shape tuple for cython.array") * * if itemsize <= 0: # <<<<<<<<<<<<<< @@ -3578,7 +2671,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ */ } - /* "View.MemoryView":138 + /* "View.MemoryView":137 * raise ValueError("itemsize <= 0 for cython.array") * * if not isinstance(format, bytes): # <<<<<<<<<<<<<< @@ -3589,34 +2682,22 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ __pyx_t_4 = ((!(__pyx_t_2 != 0)) != 0); if (__pyx_t_4) { - /* "View.MemoryView":139 + /* "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_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 139, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_6)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - } - } - __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_n_s_ASCII) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_n_s_ASCII); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 139, __pyx_L1_error) + __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_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF_SET(__pyx_v_format, __pyx_t_3); - __pyx_t_3 = 0; + __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":138 + /* "View.MemoryView":137 * raise ValueError("itemsize <= 0 for cython.array") * * if not isinstance(format, bytes): # <<<<<<<<<<<<<< @@ -3625,23 +2706,23 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ */ } - /* "View.MemoryView":140 + /* "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, 140, __pyx_L1_error) - __pyx_t_3 = __pyx_v_format; - __Pyx_INCREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); + 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_3); - __pyx_t_3 = 0; + __pyx_v_self->_format = ((PyObject*)__pyx_t_5); + __pyx_t_5 = 0; - /* "View.MemoryView":141 + /* "View.MemoryView":140 * format = format.encode('ASCII') * self._format = format # keep a reference to the byte string * self.format = self._format # <<<<<<<<<<<<<< @@ -3650,12 +2731,12 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ */ if (unlikely(__pyx_v_self->_format == Py_None)) { PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); - __PYX_ERR(1, 141, __pyx_L1_error) + __PYX_ERR(1, 140, __pyx_L1_error) } - __pyx_t_7 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(1, 141, __pyx_L1_error) - __pyx_v_self->format = __pyx_t_7; + __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":144 + /* "View.MemoryView":143 * * * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) # <<<<<<<<<<<<<< @@ -3664,7 +2745,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ */ __pyx_v_self->_shape = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * __pyx_v_self->ndim) * 2))); - /* "View.MemoryView":145 + /* "View.MemoryView":144 * * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) * self._strides = self._shape + self.ndim # <<<<<<<<<<<<<< @@ -3673,7 +2754,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ */ __pyx_v_self->_strides = (__pyx_v_self->_shape + __pyx_v_self->ndim); - /* "View.MemoryView":147 + /* "View.MemoryView":146 * self._strides = self._shape + self.ndim * * if not self._shape: # <<<<<<<<<<<<<< @@ -3683,20 +2764,20 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ __pyx_t_4 = ((!(__pyx_v_self->_shape != 0)) != 0); if (unlikely(__pyx_t_4)) { - /* "View.MemoryView":148 + /* "View.MemoryView":147 * * if not self._shape: * raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<< * * */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 148, __pyx_L1_error) + __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":147 + /* "View.MemoryView":146 * self._strides = self._shape + self.ndim * * if not self._shape: # <<<<<<<<<<<<<< @@ -3705,30 +2786,30 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ */ } - /* "View.MemoryView":151 + /* "View.MemoryView":150 * * * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< * if dim <= 0: * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) */ - __pyx_t_8 = 0; - __pyx_t_3 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0; + __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_3)) break; + if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_5)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(1, 151, __pyx_L1_error) + __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_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 151, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); + __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_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_5); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 151, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_dim = __pyx_t_9; - __pyx_v_idx = __pyx_t_8; - __pyx_t_8 = (__pyx_t_8 + 1); + __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":152 + /* "View.MemoryView":151 * * for idx, dim in enumerate(shape): * if dim <= 0: # <<<<<<<<<<<<<< @@ -3738,36 +2819,36 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ __pyx_t_4 = ((__pyx_v_dim <= 0) != 0); if (unlikely(__pyx_t_4)) { - /* "View.MemoryView":153 + /* "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_5 = __Pyx_PyInt_From_int(__pyx_v_idx); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 153, __pyx_L1_error) + __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_5); - PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_5); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_6); - __pyx_t_5 = 0; - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __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_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 153, __pyx_L1_error) + __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_6); __pyx_t_6 = 0; + __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, 153, __pyx_L1_error) + __PYX_ERR(1, 152, __pyx_L1_error) - /* "View.MemoryView":152 + /* "View.MemoryView":151 * * for idx, dim in enumerate(shape): * if dim <= 0: # <<<<<<<<<<<<<< @@ -3776,7 +2857,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ */ } - /* "View.MemoryView":154 + /* "View.MemoryView":153 * if dim <= 0: * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) * self._shape[idx] = dim # <<<<<<<<<<<<<< @@ -3785,7 +2866,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ */ (__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim; - /* "View.MemoryView":151 + /* "View.MemoryView":150 * * * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< @@ -3793,19 +2874,19 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) */ } - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "View.MemoryView":157 + /* "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, 157, __pyx_L1_error) + __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":158 + /* "View.MemoryView":157 * cdef char order * if mode == 'fortran': * order = b'F' # <<<<<<<<<<<<<< @@ -3814,7 +2895,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ */ __pyx_v_order = 'F'; - /* "View.MemoryView":159 + /* "View.MemoryView":158 * if mode == 'fortran': * order = b'F' * self.mode = u'fortran' # <<<<<<<<<<<<<< @@ -3827,7 +2908,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ __Pyx_DECREF(__pyx_v_self->mode); __pyx_v_self->mode = __pyx_n_u_fortran; - /* "View.MemoryView":157 + /* "View.MemoryView":156 * * cdef char order * if mode == 'fortran': # <<<<<<<<<<<<<< @@ -3837,17 +2918,17 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ goto __pyx_L10; } - /* "View.MemoryView":160 + /* "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, 160, __pyx_L1_error) + __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":161 + /* "View.MemoryView":160 * self.mode = u'fortran' * elif mode == 'c': * order = b'C' # <<<<<<<<<<<<<< @@ -3856,7 +2937,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ */ __pyx_v_order = 'C'; - /* "View.MemoryView":162 + /* "View.MemoryView":161 * elif mode == 'c': * order = b'C' * self.mode = u'c' # <<<<<<<<<<<<<< @@ -3869,7 +2950,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ __Pyx_DECREF(__pyx_v_self->mode); __pyx_v_self->mode = __pyx_n_u_c; - /* "View.MemoryView":160 + /* "View.MemoryView":159 * order = b'F' * self.mode = u'fortran' * elif mode == 'c': # <<<<<<<<<<<<<< @@ -3879,7 +2960,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ goto __pyx_L10; } - /* "View.MemoryView":164 + /* "View.MemoryView":163 * self.mode = u'c' * else: * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) # <<<<<<<<<<<<<< @@ -3887,18 +2968,18 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ * self.len = fill_contig_strides_array(self._shape, self._strides, */ /*else*/ { - __pyx_t_3 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_v_mode); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 164, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 164, __pyx_L1_error) + __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_3); __pyx_t_3 = 0; + __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, 164, __pyx_L1_error) + __PYX_ERR(1, 163, __pyx_L1_error) } __pyx_L10:; - /* "View.MemoryView":166 + /* "View.MemoryView":165 * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) * * self.len = fill_contig_strides_array(self._shape, self._strides, # <<<<<<<<<<<<<< @@ -3907,7 +2988,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ */ __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":169 + /* "View.MemoryView":168 * itemsize, self.ndim, order) * * self.free_data = allocate_buffer # <<<<<<<<<<<<<< @@ -3916,19 +2997,19 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ */ __pyx_v_self->free_data = __pyx_v_allocate_buffer; - /* "View.MemoryView":170 + /* "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, 170, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 170, __pyx_L1_error) + __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":171 + /* "View.MemoryView":170 * self.free_data = allocate_buffer * self.dtype_is_object = format == b'O' * if allocate_buffer: # <<<<<<<<<<<<<< @@ -3938,7 +3019,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ __pyx_t_4 = (__pyx_v_allocate_buffer != 0); if (__pyx_t_4) { - /* "View.MemoryView":174 + /* "View.MemoryView":173 * * * self.data = malloc(self.len) # <<<<<<<<<<<<<< @@ -3947,7 +3028,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ */ __pyx_v_self->data = ((char *)malloc(__pyx_v_self->len)); - /* "View.MemoryView":175 + /* "View.MemoryView":174 * * self.data = malloc(self.len) * if not self.data: # <<<<<<<<<<<<<< @@ -3957,20 +3038,20 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ __pyx_t_4 = ((!(__pyx_v_self->data != 0)) != 0); if (unlikely(__pyx_t_4)) { - /* "View.MemoryView":176 + /* "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__4, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 176, __pyx_L1_error) + __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, 176, __pyx_L1_error) + __PYX_ERR(1, 175, __pyx_L1_error) - /* "View.MemoryView":175 + /* "View.MemoryView":174 * * self.data = malloc(self.len) * if not self.data: # <<<<<<<<<<<<<< @@ -3979,7 +3060,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ */ } - /* "View.MemoryView":178 + /* "View.MemoryView":177 * raise MemoryError("unable to allocate array data.") * * if self.dtype_is_object: # <<<<<<<<<<<<<< @@ -3989,7 +3070,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ __pyx_t_4 = (__pyx_v_self->dtype_is_object != 0); if (__pyx_t_4) { - /* "View.MemoryView":179 + /* "View.MemoryView":178 * * if self.dtype_is_object: * p = self.data # <<<<<<<<<<<<<< @@ -3998,7 +3079,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ */ __pyx_v_p = ((PyObject **)__pyx_v_self->data); - /* "View.MemoryView":180 + /* "View.MemoryView":179 * if self.dtype_is_object: * p = self.data * for i in range(self.len / itemsize): # <<<<<<<<<<<<<< @@ -4007,18 +3088,18 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ */ if (unlikely(__pyx_v_itemsize == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); - __PYX_ERR(1, 180, __pyx_L1_error) + __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, 180, __pyx_L1_error) + __PYX_ERR(1, 179, __pyx_L1_error) } __pyx_t_1 = (__pyx_v_self->len / __pyx_v_itemsize); - __pyx_t_9 = __pyx_t_1; - for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_9; __pyx_t_11+=1) { + __pyx_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":181 + /* "View.MemoryView":180 * p = self.data * for i in range(self.len / itemsize): * p[i] = Py_None # <<<<<<<<<<<<<< @@ -4027,7 +3108,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ */ (__pyx_v_p[__pyx_v_i]) = Py_None; - /* "View.MemoryView":182 + /* "View.MemoryView":181 * for i in range(self.len / itemsize): * p[i] = Py_None * Py_INCREF(Py_None) # <<<<<<<<<<<<<< @@ -4037,7 +3118,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ Py_INCREF(Py_None); } - /* "View.MemoryView":178 + /* "View.MemoryView":177 * raise MemoryError("unable to allocate array data.") * * if self.dtype_is_object: # <<<<<<<<<<<<<< @@ -4046,7 +3127,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ */ } - /* "View.MemoryView":171 + /* "View.MemoryView":170 * self.free_data = allocate_buffer * self.dtype_is_object = format == b'O' * if allocate_buffer: # <<<<<<<<<<<<<< @@ -4055,7 +3136,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ */ } - /* "View.MemoryView":122 + /* "View.MemoryView":121 * cdef bint dtype_is_object * * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< @@ -4069,7 +3150,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); + __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; @@ -4079,7 +3160,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __ return __pyx_r; } -/* "View.MemoryView":185 +/* "View.MemoryView":184 * * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< @@ -4119,7 +3200,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); __Pyx_GIVEREF(__pyx_v_info->obj); - /* "View.MemoryView":186 + /* "View.MemoryView":185 * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): * cdef int bufmode = -1 # <<<<<<<<<<<<<< @@ -4128,18 +3209,18 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru */ __pyx_v_bufmode = -1; - /* "View.MemoryView":187 + /* "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, 187, __pyx_L1_error) + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_c, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 186, __pyx_L1_error) __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "View.MemoryView":188 + /* "View.MemoryView":187 * cdef int bufmode = -1 * if self.mode == u"c": * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< @@ -4148,7 +3229,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru */ __pyx_v_bufmode = (PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); - /* "View.MemoryView":187 + /* "View.MemoryView":186 * def __getbuffer__(self, Py_buffer *info, int flags): * cdef int bufmode = -1 * if self.mode == u"c": # <<<<<<<<<<<<<< @@ -4158,18 +3239,18 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru goto __pyx_L3; } - /* "View.MemoryView":189 + /* "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, 189, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_fortran, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 188, __pyx_L1_error) __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "View.MemoryView":190 + /* "View.MemoryView":189 * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * elif self.mode == u"fortran": * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< @@ -4178,7 +3259,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru */ __pyx_v_bufmode = (PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); - /* "View.MemoryView":189 + /* "View.MemoryView":188 * if self.mode == u"c": * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * elif self.mode == u"fortran": # <<<<<<<<<<<<<< @@ -4188,7 +3269,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru } __pyx_L3:; - /* "View.MemoryView":191 + /* "View.MemoryView":190 * elif self.mode == u"fortran": * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * if not (flags & bufmode): # <<<<<<<<<<<<<< @@ -4198,20 +3279,20 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru __pyx_t_1 = ((!((__pyx_v_flags & __pyx_v_bufmode) != 0)) != 0); if (unlikely(__pyx_t_1)) { - /* "View.MemoryView":192 + /* "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__5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 192, __pyx_L1_error) + __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, 192, __pyx_L1_error) + __PYX_ERR(1, 191, __pyx_L1_error) - /* "View.MemoryView":191 + /* "View.MemoryView":190 * elif self.mode == u"fortran": * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS * if not (flags & bufmode): # <<<<<<<<<<<<<< @@ -4220,7 +3301,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru */ } - /* "View.MemoryView":193 + /* "View.MemoryView":192 * if not (flags & bufmode): * raise ValueError("Can only create a buffer that is contiguous in memory.") * info.buf = self.data # <<<<<<<<<<<<<< @@ -4230,7 +3311,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru __pyx_t_4 = __pyx_v_self->data; __pyx_v_info->buf = __pyx_t_4; - /* "View.MemoryView":194 + /* "View.MemoryView":193 * raise ValueError("Can only create a buffer that is contiguous in memory.") * info.buf = self.data * info.len = self.len # <<<<<<<<<<<<<< @@ -4240,7 +3321,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru __pyx_t_5 = __pyx_v_self->len; __pyx_v_info->len = __pyx_t_5; - /* "View.MemoryView":195 + /* "View.MemoryView":194 * info.buf = self.data * info.len = self.len * info.ndim = self.ndim # <<<<<<<<<<<<<< @@ -4250,7 +3331,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru __pyx_t_6 = __pyx_v_self->ndim; __pyx_v_info->ndim = __pyx_t_6; - /* "View.MemoryView":196 + /* "View.MemoryView":195 * info.len = self.len * info.ndim = self.ndim * info.shape = self._shape # <<<<<<<<<<<<<< @@ -4260,7 +3341,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru __pyx_t_7 = __pyx_v_self->_shape; __pyx_v_info->shape = __pyx_t_7; - /* "View.MemoryView":197 + /* "View.MemoryView":196 * info.ndim = self.ndim * info.shape = self._shape * info.strides = self._strides # <<<<<<<<<<<<<< @@ -4270,7 +3351,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru __pyx_t_7 = __pyx_v_self->_strides; __pyx_v_info->strides = __pyx_t_7; - /* "View.MemoryView":198 + /* "View.MemoryView":197 * info.shape = self._shape * info.strides = self._strides * info.suboffsets = NULL # <<<<<<<<<<<<<< @@ -4279,7 +3360,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru */ __pyx_v_info->suboffsets = NULL; - /* "View.MemoryView":199 + /* "View.MemoryView":198 * info.strides = self._strides * info.suboffsets = NULL * info.itemsize = self.itemsize # <<<<<<<<<<<<<< @@ -4289,7 +3370,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru __pyx_t_5 = __pyx_v_self->itemsize; __pyx_v_info->itemsize = __pyx_t_5; - /* "View.MemoryView":200 + /* "View.MemoryView":199 * info.suboffsets = NULL * info.itemsize = self.itemsize * info.readonly = 0 # <<<<<<<<<<<<<< @@ -4298,7 +3379,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru */ __pyx_v_info->readonly = 0; - /* "View.MemoryView":202 + /* "View.MemoryView":201 * info.readonly = 0 * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< @@ -4308,7 +3389,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); if (__pyx_t_1) { - /* "View.MemoryView":203 + /* "View.MemoryView":202 * * if flags & PyBUF_FORMAT: * info.format = self.format # <<<<<<<<<<<<<< @@ -4318,7 +3399,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru __pyx_t_4 = __pyx_v_self->format; __pyx_v_info->format = __pyx_t_4; - /* "View.MemoryView":202 + /* "View.MemoryView":201 * info.readonly = 0 * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< @@ -4328,7 +3409,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru goto __pyx_L5; } - /* "View.MemoryView":205 + /* "View.MemoryView":204 * info.format = self.format * else: * info.format = NULL # <<<<<<<<<<<<<< @@ -4340,7 +3421,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru } __pyx_L5:; - /* "View.MemoryView":207 + /* "View.MemoryView":206 * info.format = NULL * * info.obj = self # <<<<<<<<<<<<<< @@ -4353,7 +3434,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = ((PyObject *)__pyx_v_self); - /* "View.MemoryView":185 + /* "View.MemoryView":184 * * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< @@ -4383,7 +3464,7 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(stru return __pyx_r; } -/* "View.MemoryView":211 +/* "View.MemoryView":210 * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") * * def __dealloc__(array self): # <<<<<<<<<<<<<< @@ -4407,7 +3488,7 @@ static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struc int __pyx_t_1; __Pyx_RefNannySetupContext("__dealloc__", 0); - /* "View.MemoryView":212 + /* "View.MemoryView":211 * * def __dealloc__(array self): * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< @@ -4417,7 +3498,7 @@ static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struc __pyx_t_1 = ((__pyx_v_self->callback_free_data != NULL) != 0); if (__pyx_t_1) { - /* "View.MemoryView":213 + /* "View.MemoryView":212 * def __dealloc__(array self): * if self.callback_free_data != NULL: * self.callback_free_data(self.data) # <<<<<<<<<<<<<< @@ -4426,7 +3507,7 @@ static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struc */ __pyx_v_self->callback_free_data(__pyx_v_self->data); - /* "View.MemoryView":212 + /* "View.MemoryView":211 * * def __dealloc__(array self): * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< @@ -4436,7 +3517,7 @@ static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struc goto __pyx_L3; } - /* "View.MemoryView":214 + /* "View.MemoryView":213 * if self.callback_free_data != NULL: * self.callback_free_data(self.data) * elif self.free_data: # <<<<<<<<<<<<<< @@ -4446,7 +3527,7 @@ static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struc __pyx_t_1 = (__pyx_v_self->free_data != 0); if (__pyx_t_1) { - /* "View.MemoryView":215 + /* "View.MemoryView":214 * self.callback_free_data(self.data) * elif self.free_data: * if self.dtype_is_object: # <<<<<<<<<<<<<< @@ -4456,7 +3537,7 @@ static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struc __pyx_t_1 = (__pyx_v_self->dtype_is_object != 0); if (__pyx_t_1) { - /* "View.MemoryView":216 + /* "View.MemoryView":215 * elif self.free_data: * if self.dtype_is_object: * refcount_objects_in_slice(self.data, self._shape, # <<<<<<<<<<<<<< @@ -4465,7 +3546,7 @@ static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struc */ __pyx_memoryview_refcount_objects_in_slice(__pyx_v_self->data, __pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_self->ndim, 0); - /* "View.MemoryView":215 + /* "View.MemoryView":214 * self.callback_free_data(self.data) * elif self.free_data: * if self.dtype_is_object: # <<<<<<<<<<<<<< @@ -4474,7 +3555,7 @@ static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struc */ } - /* "View.MemoryView":218 + /* "View.MemoryView":217 * refcount_objects_in_slice(self.data, self._shape, * self._strides, self.ndim, False) * free(self.data) # <<<<<<<<<<<<<< @@ -4483,7 +3564,7 @@ static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struc */ free(__pyx_v_self->data); - /* "View.MemoryView":214 + /* "View.MemoryView":213 * if self.callback_free_data != NULL: * self.callback_free_data(self.data) * elif self.free_data: # <<<<<<<<<<<<<< @@ -4493,7 +3574,7 @@ static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struc } __pyx_L3:; - /* "View.MemoryView":219 + /* "View.MemoryView":218 * self._strides, self.ndim, False) * free(self.data) * PyObject_Free(self._shape) # <<<<<<<<<<<<<< @@ -4502,7 +3583,7 @@ static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struc */ PyObject_Free(__pyx_v_self->_shape); - /* "View.MemoryView":211 + /* "View.MemoryView":210 * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") * * def __dealloc__(array self): # <<<<<<<<<<<<<< @@ -4514,7 +3595,7 @@ static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struc __Pyx_RefNannyFinishContext(); } -/* "View.MemoryView":222 +/* "View.MemoryView":221 * * @property * def memview(self): # <<<<<<<<<<<<<< @@ -4541,7 +3622,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct _ PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__get__", 0); - /* "View.MemoryView":223 + /* "View.MemoryView":222 * @property * def memview(self): * return self.get_memview() # <<<<<<<<<<<<<< @@ -4549,13 +3630,13 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct _ * @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, 223, __pyx_L1_error) + __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":222 + /* "View.MemoryView":221 * * @property * def memview(self): # <<<<<<<<<<<<<< @@ -4574,7 +3655,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct _ return __pyx_r; } -/* "View.MemoryView":226 +/* "View.MemoryView":225 * * @cname('get_memview') * cdef get_memview(self): # <<<<<<<<<<<<<< @@ -4591,7 +3672,7 @@ static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) { PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("get_memview", 0); - /* "View.MemoryView":227 + /* "View.MemoryView":226 * @cname('get_memview') * cdef get_memview(self): * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE # <<<<<<<<<<<<<< @@ -4600,7 +3681,7 @@ static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) { */ __pyx_v_flags = ((PyBUF_ANY_CONTIGUOUS | PyBUF_FORMAT) | PyBUF_WRITABLE); - /* "View.MemoryView":228 + /* "View.MemoryView":227 * cdef get_memview(self): * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE * return memoryview(self, flags, self.dtype_is_object) # <<<<<<<<<<<<<< @@ -4608,11 +3689,11 @@ static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) { * 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, 228, __pyx_L1_error) + __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, 228, __pyx_L1_error) + __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, 228, __pyx_L1_error) + __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)); @@ -4623,14 +3704,14 @@ static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) { 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, 228, __pyx_L1_error) + __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":226 + /* "View.MemoryView":225 * * @cname('get_memview') * cdef get_memview(self): # <<<<<<<<<<<<<< @@ -4651,7 +3732,7 @@ static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) { return __pyx_r; } -/* "View.MemoryView":230 +/* "View.MemoryView":229 * return memoryview(self, flags, self.dtype_is_object) * * def __len__(self): # <<<<<<<<<<<<<< @@ -4677,7 +3758,7 @@ static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(str __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__len__", 0); - /* "View.MemoryView":231 + /* "View.MemoryView":230 * * def __len__(self): * return self._shape[0] # <<<<<<<<<<<<<< @@ -4687,7 +3768,7 @@ static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(str __pyx_r = (__pyx_v_self->_shape[0]); goto __pyx_L0; - /* "View.MemoryView":230 + /* "View.MemoryView":229 * return memoryview(self, flags, self.dtype_is_object) * * def __len__(self): # <<<<<<<<<<<<<< @@ -4701,7 +3782,7 @@ static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(str return __pyx_r; } -/* "View.MemoryView":233 +/* "View.MemoryView":232 * return self._shape[0] * * def __getattr__(self, attr): # <<<<<<<<<<<<<< @@ -4729,7 +3810,7 @@ static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__( PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("__getattr__", 0); - /* "View.MemoryView":234 + /* "View.MemoryView":233 * * def __getattr__(self, attr): * return getattr(self.memview, attr) # <<<<<<<<<<<<<< @@ -4737,16 +3818,16 @@ static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__( * 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, 234, __pyx_L1_error) + __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, 234, __pyx_L1_error) + __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":233 + /* "View.MemoryView":232 * return self._shape[0] * * def __getattr__(self, attr): # <<<<<<<<<<<<<< @@ -4766,7 +3847,7 @@ static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__( return __pyx_r; } -/* "View.MemoryView":236 +/* "View.MemoryView":235 * return getattr(self.memview, attr) * * def __getitem__(self, item): # <<<<<<<<<<<<<< @@ -4794,7 +3875,7 @@ static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__ PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("__getitem__", 0); - /* "View.MemoryView":237 + /* "View.MemoryView":236 * * def __getitem__(self, item): * return self.memview[item] # <<<<<<<<<<<<<< @@ -4802,16 +3883,16 @@ static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__ * 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, 237, __pyx_L1_error) + __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, 237, __pyx_L1_error) + __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":236 + /* "View.MemoryView":235 * return getattr(self.memview, attr) * * def __getitem__(self, item): # <<<<<<<<<<<<<< @@ -4831,7 +3912,7 @@ static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__ return __pyx_r; } -/* "View.MemoryView":239 +/* "View.MemoryView":238 * return self.memview[item] * * def __setitem__(self, item, value): # <<<<<<<<<<<<<< @@ -4858,19 +3939,19 @@ static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struc PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__setitem__", 0); - /* "View.MemoryView":240 + /* "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, 240, __pyx_L1_error) + __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, 240, __pyx_L1_error) + 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":239 + /* "View.MemoryView":238 * return self.memview[item] * * def __setitem__(self, item, value): # <<<<<<<<<<<<<< @@ -4921,7 +4002,7 @@ static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __p * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __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; @@ -4974,7 +4055,7 @@ static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __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; @@ -4997,7 +4078,7 @@ static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct return __pyx_r; } -/* "View.MemoryView":244 +/* "View.MemoryView":243 * * @cname("__pyx_array_new") * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< @@ -5016,7 +4097,7 @@ static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("array_cwrapper", 0); - /* "View.MemoryView":248 + /* "View.MemoryView":247 * cdef array result * * if buf == NULL: # <<<<<<<<<<<<<< @@ -5026,20 +4107,20 @@ static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize __pyx_t_1 = ((__pyx_v_buf == NULL) != 0); if (__pyx_t_1) { - /* "View.MemoryView":249 + /* "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, 249, __pyx_L1_error) + __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, 249, __pyx_L1_error) + __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, 249, __pyx_L1_error) + __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, 249, __pyx_L1_error) + __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); @@ -5053,13 +4134,13 @@ static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize __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, 249, __pyx_L1_error) + __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":248 + /* "View.MemoryView":247 * cdef array result * * if buf == NULL: # <<<<<<<<<<<<<< @@ -5069,7 +4150,7 @@ static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize goto __pyx_L3; } - /* "View.MemoryView":251 + /* "View.MemoryView":250 * result = array(shape, itemsize, format, mode.decode('ASCII')) * else: * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< @@ -5077,13 +4158,13 @@ static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize * result.data = buf */ /*else*/ { - __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 251, __pyx_L1_error) + __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, 251, __pyx_L1_error) + __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, 251, __pyx_L1_error) + __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, 251, __pyx_L1_error) + __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); @@ -5098,32 +4179,32 @@ static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize __pyx_t_5 = 0; __pyx_t_3 = 0; - /* "View.MemoryView":252 + /* "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, 252, __pyx_L1_error) + __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, 252, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_allocate_buffer, Py_False) < 0) __PYX_ERR(1, 251, __pyx_L1_error) - /* "View.MemoryView":251 + /* "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, 251, __pyx_L1_error) + __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":253 + /* "View.MemoryView":252 * result = array(shape, itemsize, format, mode.decode('ASCII'), * allocate_buffer=False) * result.data = buf # <<<<<<<<<<<<<< @@ -5134,7 +4215,7 @@ static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize } __pyx_L3:; - /* "View.MemoryView":255 + /* "View.MemoryView":254 * result.data = buf * * return result # <<<<<<<<<<<<<< @@ -5146,7 +4227,7 @@ static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize __pyx_r = __pyx_v_result; goto __pyx_L0; - /* "View.MemoryView":244 + /* "View.MemoryView":243 * * @cname("__pyx_array_new") * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< @@ -5169,7 +4250,7 @@ static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize return __pyx_r; } -/* "View.MemoryView":281 +/* "View.MemoryView":280 * cdef class Enum(object): * cdef object name * def __init__(self, name): # <<<<<<<<<<<<<< @@ -5203,7 +4284,7 @@ static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_ar 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, 281, __pyx_L3_error) + 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; @@ -5214,7 +4295,7 @@ static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_ar } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 281, __pyx_L3_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(); @@ -5232,7 +4313,7 @@ static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struc __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__", 0); - /* "View.MemoryView":282 + /* "View.MemoryView":281 * cdef object name * def __init__(self, name): * self.name = name # <<<<<<<<<<<<<< @@ -5245,7 +4326,7 @@ static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struc __Pyx_DECREF(__pyx_v_self->name); __pyx_v_self->name = __pyx_v_name; - /* "View.MemoryView":281 + /* "View.MemoryView":280 * cdef class Enum(object): * cdef object name * def __init__(self, name): # <<<<<<<<<<<<<< @@ -5259,7 +4340,7 @@ static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struc return __pyx_r; } -/* "View.MemoryView":283 +/* "View.MemoryView":282 * def __init__(self, name): * self.name = name * def __repr__(self): # <<<<<<<<<<<<<< @@ -5285,7 +4366,7 @@ static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr_ __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__", 0); - /* "View.MemoryView":284 + /* "View.MemoryView":283 * self.name = name * def __repr__(self): * return self.name # <<<<<<<<<<<<<< @@ -5297,7 +4378,7 @@ static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr_ __pyx_r = __pyx_v_self->name; goto __pyx_L0; - /* "View.MemoryView":283 + /* "View.MemoryView":282 * def __init__(self, name): * self.name = name * def __repr__(self): # <<<<<<<<<<<<<< @@ -5314,8 +4395,8 @@ static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr_ /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict + * cdef bint use_setstate + * state = (self.name,) */ /* Python wrapper */ @@ -5332,9 +4413,9 @@ static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v } static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { - PyObject *__pyx_v_state = 0; - PyObject *__pyx_v__dict = 0; int __pyx_v_use_setstate; + PyObject *__pyx_v_state = NULL; + PyObject *__pyx_v__dict = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; @@ -5344,14 +4425,14 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("__reduce_cython__", 0); - /* "(tree fragment)":5 - * cdef object _dict + /* "(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, 5, __pyx_L1_error) + __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); @@ -5359,19 +4440,19 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi __pyx_v_state = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "(tree fragment)":6 + /* "(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, 6, __pyx_L1_error) + __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)":7 + /* "(tree fragment)":5 * state = (self.name,) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< @@ -5382,25 +4463,25 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "(tree fragment)":8 + /* "(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, 8, __pyx_L1_error) + __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, 8, __pyx_L1_error) + __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)":9 + /* "(tree fragment)":7 * if _dict is not None: * state += (_dict,) * use_setstate = True # <<<<<<<<<<<<<< @@ -5409,7 +4490,7 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi */ __pyx_v_use_setstate = 1; - /* "(tree fragment)":7 + /* "(tree fragment)":5 * state = (self.name,) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< @@ -5419,7 +4500,7 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi goto __pyx_L3; } - /* "(tree fragment)":11 + /* "(tree fragment)":9 * use_setstate = True * else: * use_setstate = self.name is not None # <<<<<<<<<<<<<< @@ -5432,7 +4513,7 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi } __pyx_L3:; - /* "(tree fragment)":12 + /* "(tree fragment)":10 * else: * use_setstate = self.name is not None * if use_setstate: # <<<<<<<<<<<<<< @@ -5442,7 +4523,7 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi __pyx_t_3 = (__pyx_v_use_setstate != 0); if (__pyx_t_3) { - /* "(tree fragment)":13 + /* "(tree fragment)":11 * use_setstate = self.name is not None * if use_setstate: * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state # <<<<<<<<<<<<<< @@ -5450,9 +4531,9 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) */ __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) + __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, 13, __pyx_L1_error) + __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)))); @@ -5463,7 +4544,7 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi __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, 13, __pyx_L1_error) + __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); @@ -5478,7 +4559,7 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi __pyx_t_5 = 0; goto __pyx_L0; - /* "(tree fragment)":12 + /* "(tree fragment)":10 * else: * use_setstate = self.name is not None * if use_setstate: # <<<<<<<<<<<<<< @@ -5487,7 +4568,7 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi */ } - /* "(tree fragment)":15 + /* "(tree fragment)":13 * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state * else: * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) # <<<<<<<<<<<<<< @@ -5496,9 +4577,9 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi */ /*else*/ { __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error) + __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, 15, __pyx_L1_error) + __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)))); @@ -5509,7 +4590,7 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi __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, 15, __pyx_L1_error) + __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); @@ -5524,8 +4605,8 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict + * cdef bint use_setstate + * state = (self.name,) */ /* function exit code */ @@ -5543,7 +4624,7 @@ static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_Memvi return __pyx_r; } -/* "(tree fragment)":16 +/* "(tree fragment)":14 * else: * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< @@ -5569,17 +4650,17 @@ static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_Me PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__setstate_cython__", 0); - /* "(tree fragment)":17 + /* "(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, 17, __pyx_L1_error) - __pyx_t_1 = __pyx_unpickle_Enum__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) + 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)":16 + /* "(tree fragment)":14 * else: * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< @@ -5599,7 +4680,7 @@ static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_Me return __pyx_r; } -/* "View.MemoryView":298 +/* "View.MemoryView":297 * * @cname('__pyx_align_pointer') * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< @@ -5613,7 +4694,7 @@ static void *__pyx_align_pointer(void *__pyx_v_memory, size_t __pyx_v_alignment) void *__pyx_r; int __pyx_t_1; - /* "View.MemoryView":300 + /* "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 # <<<<<<<<<<<<<< @@ -5622,7 +4703,7 @@ static void *__pyx_align_pointer(void *__pyx_v_memory, size_t __pyx_v_alignment) */ __pyx_v_aligned_p = ((Py_intptr_t)__pyx_v_memory); - /* "View.MemoryView":304 + /* "View.MemoryView":303 * * with cython.cdivision(True): * offset = aligned_p % alignment # <<<<<<<<<<<<<< @@ -5631,7 +4712,7 @@ static void *__pyx_align_pointer(void *__pyx_v_memory, size_t __pyx_v_alignment) */ __pyx_v_offset = (__pyx_v_aligned_p % __pyx_v_alignment); - /* "View.MemoryView":306 + /* "View.MemoryView":305 * offset = aligned_p % alignment * * if offset > 0: # <<<<<<<<<<<<<< @@ -5641,7 +4722,7 @@ static void *__pyx_align_pointer(void *__pyx_v_memory, size_t __pyx_v_alignment) __pyx_t_1 = ((__pyx_v_offset > 0) != 0); if (__pyx_t_1) { - /* "View.MemoryView":307 + /* "View.MemoryView":306 * * if offset > 0: * aligned_p += alignment - offset # <<<<<<<<<<<<<< @@ -5650,7 +4731,7 @@ static void *__pyx_align_pointer(void *__pyx_v_memory, size_t __pyx_v_alignment) */ __pyx_v_aligned_p = (__pyx_v_aligned_p + (__pyx_v_alignment - __pyx_v_offset)); - /* "View.MemoryView":306 + /* "View.MemoryView":305 * offset = aligned_p % alignment * * if offset > 0: # <<<<<<<<<<<<<< @@ -5659,7 +4740,7 @@ static void *__pyx_align_pointer(void *__pyx_v_memory, size_t __pyx_v_alignment) */ } - /* "View.MemoryView":309 + /* "View.MemoryView":308 * aligned_p += alignment - offset * * return aligned_p # <<<<<<<<<<<<<< @@ -5669,7 +4750,7 @@ static void *__pyx_align_pointer(void *__pyx_v_memory, size_t __pyx_v_alignment) __pyx_r = ((void *)__pyx_v_aligned_p); goto __pyx_L0; - /* "View.MemoryView":298 + /* "View.MemoryView":297 * * @cname('__pyx_align_pointer') * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< @@ -5682,7 +4763,7 @@ static void *__pyx_align_pointer(void *__pyx_v_memory, size_t __pyx_v_alignment) return __pyx_r; } -/* "View.MemoryView":345 +/* "View.MemoryView":344 * cdef __Pyx_TypeInfo *typeinfo * * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< @@ -5724,7 +4805,7 @@ static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_ar 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, 345, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, 1); __PYX_ERR(1, 344, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: @@ -5734,7 +4815,7 @@ static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_ar } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 345, __pyx_L3_error) + 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)) { @@ -5747,16 +4828,16 @@ static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_ar } } __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, 345, __pyx_L3_error) + __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, 345, __pyx_L3_error) + __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, 345, __pyx_L3_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(); @@ -5778,7 +4859,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ int __pyx_t_4; __Pyx_RefNannySetupContext("__cinit__", 0); - /* "View.MemoryView":346 + /* "View.MemoryView":345 * * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): * self.obj = obj # <<<<<<<<<<<<<< @@ -5791,7 +4872,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ __Pyx_DECREF(__pyx_v_self->obj); __pyx_v_self->obj = __pyx_v_obj; - /* "View.MemoryView":347 + /* "View.MemoryView":346 * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): * self.obj = obj * self.flags = flags # <<<<<<<<<<<<<< @@ -5800,7 +4881,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ */ __pyx_v_self->flags = __pyx_v_flags; - /* "View.MemoryView":348 + /* "View.MemoryView":347 * self.obj = obj * self.flags = flags * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< @@ -5820,16 +4901,16 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ __pyx_L4_bool_binop_done:; if (__pyx_t_1) { - /* "View.MemoryView":349 + /* "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, 349, __pyx_L1_error) + __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":350 + /* "View.MemoryView":349 * if type(self) is memoryview or obj is not None: * __Pyx_GetBuffer(obj, &self.view, flags) * if self.view.obj == NULL: # <<<<<<<<<<<<<< @@ -5839,7 +4920,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ __pyx_t_1 = ((((PyObject *)__pyx_v_self->view.obj) == NULL) != 0); if (__pyx_t_1) { - /* "View.MemoryView":351 + /* "View.MemoryView":350 * __Pyx_GetBuffer(obj, &self.view, flags) * if self.view.obj == NULL: * (<__pyx_buffer *> &self.view).obj = Py_None # <<<<<<<<<<<<<< @@ -5848,7 +4929,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ */ ((Py_buffer *)(&__pyx_v_self->view))->obj = Py_None; - /* "View.MemoryView":352 + /* "View.MemoryView":351 * if self.view.obj == NULL: * (<__pyx_buffer *> &self.view).obj = Py_None * Py_INCREF(Py_None) # <<<<<<<<<<<<<< @@ -5857,7 +4938,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ */ Py_INCREF(Py_None); - /* "View.MemoryView":350 + /* "View.MemoryView":349 * if type(self) is memoryview or obj is not None: * __Pyx_GetBuffer(obj, &self.view, flags) * if self.view.obj == NULL: # <<<<<<<<<<<<<< @@ -5866,7 +4947,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ */ } - /* "View.MemoryView":348 + /* "View.MemoryView":347 * self.obj = obj * self.flags = flags * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< @@ -5875,7 +4956,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ */ } - /* "View.MemoryView":355 + /* "View.MemoryView":354 * * global __pyx_memoryview_thread_locks_used * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< @@ -5885,7 +4966,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ __pyx_t_1 = ((__pyx_memoryview_thread_locks_used < 8) != 0); if (__pyx_t_1) { - /* "View.MemoryView":356 + /* "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] # <<<<<<<<<<<<<< @@ -5894,7 +4975,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ */ __pyx_v_self->lock = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); - /* "View.MemoryView":357 + /* "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 # <<<<<<<<<<<<<< @@ -5903,7 +4984,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ */ __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used + 1); - /* "View.MemoryView":355 + /* "View.MemoryView":354 * * global __pyx_memoryview_thread_locks_used * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< @@ -5912,7 +4993,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ */ } - /* "View.MemoryView":358 + /* "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: # <<<<<<<<<<<<<< @@ -5922,7 +5003,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); if (__pyx_t_1) { - /* "View.MemoryView":359 + /* "View.MemoryView":358 * __pyx_memoryview_thread_locks_used += 1 * if self.lock is NULL: * self.lock = PyThread_allocate_lock() # <<<<<<<<<<<<<< @@ -5931,7 +5012,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ */ __pyx_v_self->lock = PyThread_allocate_lock(); - /* "View.MemoryView":360 + /* "View.MemoryView":359 * if self.lock is NULL: * self.lock = PyThread_allocate_lock() * if self.lock is NULL: # <<<<<<<<<<<<<< @@ -5941,16 +5022,16 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); if (unlikely(__pyx_t_1)) { - /* "View.MemoryView":361 + /* "View.MemoryView":360 * self.lock = PyThread_allocate_lock() * if self.lock is NULL: * raise MemoryError # <<<<<<<<<<<<<< * * if flags & PyBUF_FORMAT: */ - PyErr_NoMemory(); __PYX_ERR(1, 361, __pyx_L1_error) + PyErr_NoMemory(); __PYX_ERR(1, 360, __pyx_L1_error) - /* "View.MemoryView":360 + /* "View.MemoryView":359 * if self.lock is NULL: * self.lock = PyThread_allocate_lock() * if self.lock is NULL: # <<<<<<<<<<<<<< @@ -5959,7 +5040,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ */ } - /* "View.MemoryView":358 + /* "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: # <<<<<<<<<<<<<< @@ -5968,7 +5049,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ */ } - /* "View.MemoryView":363 + /* "View.MemoryView":362 * raise MemoryError * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< @@ -5978,7 +5059,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); if (__pyx_t_1) { - /* "View.MemoryView":364 + /* "View.MemoryView":363 * * if flags & PyBUF_FORMAT: * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') # <<<<<<<<<<<<<< @@ -5996,7 +5077,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ __pyx_L11_bool_binop_done:; __pyx_v_self->dtype_is_object = __pyx_t_1; - /* "View.MemoryView":363 + /* "View.MemoryView":362 * raise MemoryError * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< @@ -6006,7 +5087,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ goto __pyx_L10; } - /* "View.MemoryView":366 + /* "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 # <<<<<<<<<<<<<< @@ -6018,7 +5099,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ } __pyx_L10:; - /* "View.MemoryView":368 + /* "View.MemoryView":367 * self.dtype_is_object = dtype_is_object * * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( # <<<<<<<<<<<<<< @@ -6027,7 +5108,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ */ __pyx_v_self->acquisition_count_aligned_p = ((__pyx_atomic_int *)__pyx_align_pointer(((void *)(&(__pyx_v_self->acquisition_count[0]))), (sizeof(__pyx_atomic_int)))); - /* "View.MemoryView":370 + /* "View.MemoryView":369 * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) * self.typeinfo = NULL # <<<<<<<<<<<<<< @@ -6036,7 +5117,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ */ __pyx_v_self->typeinfo = NULL; - /* "View.MemoryView":345 + /* "View.MemoryView":344 * cdef __Pyx_TypeInfo *typeinfo * * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< @@ -6055,7 +5136,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit_ return __pyx_r; } -/* "View.MemoryView":372 +/* "View.MemoryView":371 * self.typeinfo = NULL * * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< @@ -6086,7 +5167,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal PyThread_type_lock __pyx_t_7; __Pyx_RefNannySetupContext("__dealloc__", 0); - /* "View.MemoryView":373 + /* "View.MemoryView":372 * * def __dealloc__(memoryview self): * if self.obj is not None: # <<<<<<<<<<<<<< @@ -6097,7 +5178,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "View.MemoryView":374 + /* "View.MemoryView":373 * def __dealloc__(memoryview self): * if self.obj is not None: * __Pyx_ReleaseBuffer(&self.view) # <<<<<<<<<<<<<< @@ -6106,7 +5187,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal */ __Pyx_ReleaseBuffer((&__pyx_v_self->view)); - /* "View.MemoryView":373 + /* "View.MemoryView":372 * * def __dealloc__(memoryview self): * if self.obj is not None: # <<<<<<<<<<<<<< @@ -6115,7 +5196,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal */ } - /* "View.MemoryView":378 + /* "View.MemoryView":377 * cdef int i * global __pyx_memoryview_thread_locks_used * if self.lock != NULL: # <<<<<<<<<<<<<< @@ -6125,7 +5206,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal __pyx_t_2 = ((__pyx_v_self->lock != NULL) != 0); if (__pyx_t_2) { - /* "View.MemoryView":379 + /* "View.MemoryView":378 * global __pyx_memoryview_thread_locks_used * if self.lock != NULL: * for i in range(__pyx_memoryview_thread_locks_used): # <<<<<<<<<<<<<< @@ -6137,7 +5218,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { __pyx_v_i = __pyx_t_5; - /* "View.MemoryView":380 + /* "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: # <<<<<<<<<<<<<< @@ -6147,7 +5228,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal __pyx_t_2 = (((__pyx_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock) != 0); if (__pyx_t_2) { - /* "View.MemoryView":381 + /* "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 # <<<<<<<<<<<<<< @@ -6156,7 +5237,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal */ __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used - 1); - /* "View.MemoryView":382 + /* "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: # <<<<<<<<<<<<<< @@ -6166,7 +5247,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal __pyx_t_2 = ((__pyx_v_i != __pyx_memoryview_thread_locks_used) != 0); if (__pyx_t_2) { - /* "View.MemoryView":384 + /* "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]) # <<<<<<<<<<<<<< @@ -6176,7 +5257,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal __pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); __pyx_t_7 = (__pyx_memoryview_thread_locks[__pyx_v_i]); - /* "View.MemoryView":383 + /* "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] = ( # <<<<<<<<<<<<<< @@ -6186,7 +5267,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal (__pyx_memoryview_thread_locks[__pyx_v_i]) = __pyx_t_6; (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_7; - /* "View.MemoryView":382 + /* "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: # <<<<<<<<<<<<<< @@ -6195,7 +5276,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal */ } - /* "View.MemoryView":385 + /* "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 # <<<<<<<<<<<<<< @@ -6204,7 +5285,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal */ goto __pyx_L6_break; - /* "View.MemoryView":380 + /* "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: # <<<<<<<<<<<<<< @@ -6215,7 +5296,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal } /*else*/ { - /* "View.MemoryView":387 + /* "View.MemoryView":386 * break * else: * PyThread_free_lock(self.lock) # <<<<<<<<<<<<<< @@ -6226,7 +5307,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal } __pyx_L6_break:; - /* "View.MemoryView":378 + /* "View.MemoryView":377 * cdef int i * global __pyx_memoryview_thread_locks_used * if self.lock != NULL: # <<<<<<<<<<<<<< @@ -6235,7 +5316,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal */ } - /* "View.MemoryView":372 + /* "View.MemoryView":371 * self.typeinfo = NULL * * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< @@ -6247,7 +5328,7 @@ static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__deal __Pyx_RefNannyFinishContext(); } -/* "View.MemoryView":389 +/* "View.MemoryView":388 * PyThread_free_lock(self.lock) * * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< @@ -6270,7 +5351,7 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py char *__pyx_t_7; __Pyx_RefNannySetupContext("get_item_pointer", 0); - /* "View.MemoryView":391 + /* "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 # <<<<<<<<<<<<<< @@ -6279,7 +5360,7 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py */ __pyx_v_itemp = ((char *)__pyx_v_self->view.buf); - /* "View.MemoryView":393 + /* "View.MemoryView":392 * cdef char *itemp = self.view.buf * * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< @@ -6291,26 +5372,26 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py __pyx_t_2 = __pyx_v_index; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; __pyx_t_4 = NULL; } else { - __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 393, __pyx_L1_error) + __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, 393, __pyx_L1_error) + __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, 393, __pyx_L1_error) + __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(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, 393, __pyx_L1_error) + __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, 393, __pyx_L1_error) + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(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, 393, __pyx_L1_error) + __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 } @@ -6320,7 +5401,7 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 393, __pyx_L1_error) + else __PYX_ERR(1, 392, __pyx_L1_error) } break; } @@ -6331,18 +5412,18 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py __pyx_v_dim = __pyx_t_1; __pyx_t_1 = (__pyx_t_1 + 1); - /* "View.MemoryView":394 + /* "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, 394, __pyx_L1_error) - __pyx_t_7 = __pyx_pybuffer_index((&__pyx_v_self->view), __pyx_v_itemp, __pyx_t_6, __pyx_v_dim); if (unlikely(__pyx_t_7 == ((char *)NULL))) __PYX_ERR(1, 394, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyIndex_AsSsize_t(__pyx_v_idx); if (unlikely((__pyx_t_6 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(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":393 + /* "View.MemoryView":392 * cdef char *itemp = self.view.buf * * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< @@ -6352,7 +5433,7 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "View.MemoryView":396 + /* "View.MemoryView":395 * itemp = pybuffer_index(&self.view, itemp, idx, dim) * * return itemp # <<<<<<<<<<<<<< @@ -6362,7 +5443,7 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py __pyx_r = __pyx_v_itemp; goto __pyx_L0; - /* "View.MemoryView":389 + /* "View.MemoryView":388 * PyThread_free_lock(self.lock) * * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< @@ -6382,7 +5463,7 @@ static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__py return __pyx_r; } -/* "View.MemoryView":399 +/* "View.MemoryView":398 * * * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< @@ -6417,7 +5498,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ char *__pyx_t_6; __Pyx_RefNannySetupContext("__getitem__", 0); - /* "View.MemoryView":400 + /* "View.MemoryView":399 * * def __getitem__(memoryview self, object index): * if index is Ellipsis: # <<<<<<<<<<<<<< @@ -6428,7 +5509,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "View.MemoryView":401 + /* "View.MemoryView":400 * def __getitem__(memoryview self, object index): * if index is Ellipsis: * return self # <<<<<<<<<<<<<< @@ -6440,7 +5521,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; - /* "View.MemoryView":400 + /* "View.MemoryView":399 * * def __getitem__(memoryview self, object index): * if index is Ellipsis: # <<<<<<<<<<<<<< @@ -6449,14 +5530,14 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ */ } - /* "View.MemoryView":403 + /* "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, 403, __pyx_L1_error) + __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; @@ -6464,7 +5545,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 403, __pyx_L1_error) + __PYX_ERR(1, 402, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); @@ -6472,31 +5553,31 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); #else - __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 403, __pyx_L1_error) + __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, 403, __pyx_L1_error) + __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, 403, __pyx_L1_error) + __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":406 + /* "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, 406, __pyx_L1_error) + __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":407 + /* "View.MemoryView":406 * cdef char *itemp * if have_slices: * return memview_slice(self, indices) # <<<<<<<<<<<<<< @@ -6504,13 +5585,13 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ * itemp = self.get_item_pointer(indices) */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 407, __pyx_L1_error) + __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":406 + /* "View.MemoryView":405 * * cdef char *itemp * if have_slices: # <<<<<<<<<<<<<< @@ -6519,7 +5600,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ */ } - /* "View.MemoryView":409 + /* "View.MemoryView":408 * return memview_slice(self, indices) * else: * itemp = self.get_item_pointer(indices) # <<<<<<<<<<<<<< @@ -6527,10 +5608,10 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ * */ /*else*/ { - __pyx_t_6 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_6 == ((char *)NULL))) __PYX_ERR(1, 409, __pyx_L1_error) + __pyx_t_6 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_6 == ((char *)NULL))) __PYX_ERR(1, 408, __pyx_L1_error) __pyx_v_itemp = __pyx_t_6; - /* "View.MemoryView":410 + /* "View.MemoryView":409 * else: * itemp = self.get_item_pointer(indices) * return self.convert_item_to_object(itemp) # <<<<<<<<<<<<<< @@ -6538,14 +5619,14 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ * def __setitem__(memoryview self, object index, object value): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 410, __pyx_L1_error) + __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 409, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; } - /* "View.MemoryView":399 + /* "View.MemoryView":398 * * * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< @@ -6568,7 +5649,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4_ return __pyx_r; } -/* "View.MemoryView":412 +/* "View.MemoryView":411 * return self.convert_item_to_object(itemp) * * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< @@ -6601,7 +5682,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit __Pyx_RefNannySetupContext("__setitem__", 0); __Pyx_INCREF(__pyx_v_index); - /* "View.MemoryView":413 + /* "View.MemoryView":412 * * def __setitem__(memoryview self, object index, object value): * if self.view.readonly: # <<<<<<<<<<<<<< @@ -6611,20 +5692,20 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit __pyx_t_1 = (__pyx_v_self->view.readonly != 0); if (unlikely(__pyx_t_1)) { - /* "View.MemoryView":414 + /* "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__8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 414, __pyx_L1_error) + __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, 414, __pyx_L1_error) + __PYX_ERR(1, 413, __pyx_L1_error) - /* "View.MemoryView":413 + /* "View.MemoryView":412 * * def __setitem__(memoryview self, object index, object value): * if self.view.readonly: # <<<<<<<<<<<<<< @@ -6633,14 +5714,14 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit */ } - /* "View.MemoryView":416 + /* "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, 416, __pyx_L1_error) + __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; @@ -6648,7 +5729,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 416, __pyx_L1_error) + __PYX_ERR(1, 415, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); @@ -6656,67 +5737,67 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); #else - __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 416, __pyx_L1_error) + __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, 416, __pyx_L1_error) + __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, 416, __pyx_L1_error) + __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":418 + /* "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, 418, __pyx_L1_error) + __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":419 + /* "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, 419, __pyx_L1_error) + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->is_slice(__pyx_v_self, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 418, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_obj = __pyx_t_2; __pyx_t_2 = 0; - /* "View.MemoryView":420 + /* "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, 420, __pyx_L1_error) + __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":421 + /* "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, 421, __pyx_L1_error) + __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, 421, __pyx_L1_error) + __pyx_t_4 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assignment(__pyx_v_self, __pyx_t_2, __pyx_v_obj); if (unlikely(!__pyx_t_4)) __PYX_ERR(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":420 + /* "View.MemoryView":419 * if have_slices: * obj = self.is_slice(value) * if obj: # <<<<<<<<<<<<<< @@ -6726,7 +5807,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit goto __pyx_L5; } - /* "View.MemoryView":423 + /* "View.MemoryView":422 * self.setitem_slice_assignment(self[index], obj) * else: * self.setitem_slice_assign_scalar(self[index], value) # <<<<<<<<<<<<<< @@ -6734,17 +5815,17 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit * self.setitem_indexed(index, value) */ /*else*/ { - __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 423, __pyx_L1_error) + __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, 423, __pyx_L1_error) - __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_4), __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 423, __pyx_L1_error) + 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":418 + /* "View.MemoryView":417 * have_slices, index = _unellipsify(index, self.view.ndim) * * if have_slices: # <<<<<<<<<<<<<< @@ -6754,7 +5835,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit goto __pyx_L4; } - /* "View.MemoryView":425 + /* "View.MemoryView":424 * self.setitem_slice_assign_scalar(self[index], value) * else: * self.setitem_indexed(index, value) # <<<<<<<<<<<<<< @@ -6762,13 +5843,13 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit * cdef is_slice(self, obj): */ /*else*/ { - __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 425, __pyx_L1_error) + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 424, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __pyx_L4:; - /* "View.MemoryView":412 + /* "View.MemoryView":411 * return self.convert_item_to_object(itemp) * * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< @@ -6793,7 +5874,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setit return __pyx_r; } -/* "View.MemoryView":427 +/* "View.MemoryView":426 * self.setitem_indexed(index, value) * * cdef is_slice(self, obj): # <<<<<<<<<<<<<< @@ -6816,22 +5897,22 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ __Pyx_RefNannySetupContext("is_slice", 0); __Pyx_INCREF(__pyx_v_obj); - /* "View.MemoryView":428 + /* "View.MemoryView":427 * * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< * try: - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * 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":429 + /* "View.MemoryView":428 * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): * try: # <<<<<<<<<<<<<< - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * obj = memoryview(obj, self.flags|PyBUF_ANY_CONTIGUOUS, * self.dtype_is_object) */ { @@ -6843,34 +5924,34 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ __Pyx_XGOTREF(__pyx_t_5); /*try:*/ { - /* "View.MemoryView":430 + /* "View.MemoryView":429 * if not isinstance(obj, memoryview): * try: - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< + * 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_WRITABLE)) | PyBUF_ANY_CONTIGUOUS)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 430, __pyx_L4_error) + __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":431 + /* "View.MemoryView":430 * try: - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * 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, 431, __pyx_L4_error) + __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":430 + /* "View.MemoryView":429 * if not isinstance(obj, memoryview): * try: - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< + * 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, 430, __pyx_L4_error) + __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); @@ -6881,17 +5962,17 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7); __pyx_t_6 = 0; __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 430, __pyx_L4_error) + __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":429 + /* "View.MemoryView":428 * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): * try: # <<<<<<<<<<<<<< - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * obj = memoryview(obj, self.flags|PyBUF_ANY_CONTIGUOUS, * self.dtype_is_object) */ } @@ -6904,8 +5985,8 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - /* "View.MemoryView":432 - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + /* "View.MemoryView":431 + * obj = memoryview(obj, self.flags|PyBUF_ANY_CONTIGUOUS, * self.dtype_is_object) * except TypeError: # <<<<<<<<<<<<<< * return None @@ -6914,12 +5995,12 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); if (__pyx_t_9) { __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_6) < 0) __PYX_ERR(1, 432, __pyx_L6_except_error) + 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":433 + /* "View.MemoryView":432 * self.dtype_is_object) * except TypeError: * return None # <<<<<<<<<<<<<< @@ -6936,11 +6017,11 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ goto __pyx_L6_except_error; __pyx_L6_except_error:; - /* "View.MemoryView":429 + /* "View.MemoryView":428 * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): * try: # <<<<<<<<<<<<<< - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * obj = memoryview(obj, self.flags|PyBUF_ANY_CONTIGUOUS, * self.dtype_is_object) */ __Pyx_XGIVEREF(__pyx_t_3); @@ -6957,16 +6038,16 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ __pyx_L9_try_end:; } - /* "View.MemoryView":428 + /* "View.MemoryView":427 * * cdef is_slice(self, obj): * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< * try: - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * obj = memoryview(obj, self.flags|PyBUF_ANY_CONTIGUOUS, */ } - /* "View.MemoryView":435 + /* "View.MemoryView":434 * return None * * return obj # <<<<<<<<<<<<<< @@ -6978,7 +6059,7 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ __pyx_r = __pyx_v_obj; goto __pyx_L0; - /* "View.MemoryView":427 + /* "View.MemoryView":426 * self.setitem_indexed(index, value) * * cdef is_slice(self, obj): # <<<<<<<<<<<<<< @@ -7000,7 +6081,7 @@ static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_ return __pyx_r; } -/* "View.MemoryView":437 +/* "View.MemoryView":436 * return obj * * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< @@ -7019,50 +6100,50 @@ static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryvi int __pyx_t_4; __Pyx_RefNannySetupContext("setitem_slice_assignment", 0); - /* "View.MemoryView":441 + /* "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, 441, __pyx_L1_error) + 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":442 + /* "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, 442, __pyx_L1_error) + 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":443 + /* "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, 443, __pyx_L1_error) + __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, 443, __pyx_L1_error) + __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, 443, __pyx_L1_error) + __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, 443, __pyx_L1_error) + __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":441 + /* "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, 441, __pyx_L1_error) + __pyx_t_4 = __pyx_memoryview_copy_contents((__pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_src), (&__pyx_v_src_slice))[0]), (__pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice))[0]), __pyx_t_2, __pyx_t_3, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 440, __pyx_L1_error) - /* "View.MemoryView":437 + /* "View.MemoryView":436 * return obj * * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< @@ -7083,7 +6164,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryvi return __pyx_r; } -/* "View.MemoryView":445 +/* "View.MemoryView":444 * src.ndim, dst.ndim, self.dtype_is_object) * * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< @@ -7112,7 +6193,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor PyObject *__pyx_t_11 = NULL; __Pyx_RefNannySetupContext("setitem_slice_assign_scalar", 0); - /* "View.MemoryView":447 + /* "View.MemoryView":446 * cdef setitem_slice_assign_scalar(self, memoryview dst, value): * cdef int array[128] * cdef void *tmp = NULL # <<<<<<<<<<<<<< @@ -7121,7 +6202,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor */ __pyx_v_tmp = NULL; - /* "View.MemoryView":452 + /* "View.MemoryView":451 * cdef __Pyx_memviewslice *dst_slice * cdef __Pyx_memviewslice tmp_slice * dst_slice = get_slice_from_memview(dst, &tmp_slice) # <<<<<<<<<<<<<< @@ -7130,7 +6211,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor */ __pyx_v_dst_slice = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_dst, (&__pyx_v_tmp_slice)); - /* "View.MemoryView":454 + /* "View.MemoryView":453 * dst_slice = get_slice_from_memview(dst, &tmp_slice) * * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< @@ -7140,7 +6221,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor __pyx_t_1 = ((((size_t)__pyx_v_self->view.itemsize) > (sizeof(__pyx_v_array))) != 0); if (__pyx_t_1) { - /* "View.MemoryView":455 + /* "View.MemoryView":454 * * if self.view.itemsize > sizeof(array): * tmp = PyMem_Malloc(self.view.itemsize) # <<<<<<<<<<<<<< @@ -7149,7 +6230,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor */ __pyx_v_tmp = PyMem_Malloc(__pyx_v_self->view.itemsize); - /* "View.MemoryView":456 + /* "View.MemoryView":455 * if self.view.itemsize > sizeof(array): * tmp = PyMem_Malloc(self.view.itemsize) * if tmp == NULL: # <<<<<<<<<<<<<< @@ -7159,16 +6240,16 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor __pyx_t_1 = ((__pyx_v_tmp == NULL) != 0); if (unlikely(__pyx_t_1)) { - /* "View.MemoryView":457 + /* "View.MemoryView":456 * tmp = PyMem_Malloc(self.view.itemsize) * if tmp == NULL: * raise MemoryError # <<<<<<<<<<<<<< * item = tmp * else: */ - PyErr_NoMemory(); __PYX_ERR(1, 457, __pyx_L1_error) + PyErr_NoMemory(); __PYX_ERR(1, 456, __pyx_L1_error) - /* "View.MemoryView":456 + /* "View.MemoryView":455 * if self.view.itemsize > sizeof(array): * tmp = PyMem_Malloc(self.view.itemsize) * if tmp == NULL: # <<<<<<<<<<<<<< @@ -7177,7 +6258,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor */ } - /* "View.MemoryView":458 + /* "View.MemoryView":457 * if tmp == NULL: * raise MemoryError * item = tmp # <<<<<<<<<<<<<< @@ -7186,7 +6267,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor */ __pyx_v_item = __pyx_v_tmp; - /* "View.MemoryView":454 + /* "View.MemoryView":453 * dst_slice = get_slice_from_memview(dst, &tmp_slice) * * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< @@ -7196,7 +6277,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor goto __pyx_L3; } - /* "View.MemoryView":460 + /* "View.MemoryView":459 * item = tmp * else: * item = array # <<<<<<<<<<<<<< @@ -7208,7 +6289,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor } __pyx_L3:; - /* "View.MemoryView":462 + /* "View.MemoryView":461 * item = array * * try: # <<<<<<<<<<<<<< @@ -7217,7 +6298,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor */ /*try:*/ { - /* "View.MemoryView":463 + /* "View.MemoryView":462 * * try: * if self.dtype_is_object: # <<<<<<<<<<<<<< @@ -7227,7 +6308,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor __pyx_t_1 = (__pyx_v_self->dtype_is_object != 0); if (__pyx_t_1) { - /* "View.MemoryView":464 + /* "View.MemoryView":463 * try: * if self.dtype_is_object: * ( item)[0] = value # <<<<<<<<<<<<<< @@ -7236,7 +6317,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor */ (((PyObject **)__pyx_v_item)[0]) = ((PyObject *)__pyx_v_value); - /* "View.MemoryView":463 + /* "View.MemoryView":462 * * try: * if self.dtype_is_object: # <<<<<<<<<<<<<< @@ -7246,7 +6327,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor goto __pyx_L8; } - /* "View.MemoryView":466 + /* "View.MemoryView":465 * ( item)[0] = value * else: * self.assign_item_from_object( item, value) # <<<<<<<<<<<<<< @@ -7254,13 +6335,13 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor * */ /*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, 466, __pyx_L6_error) + __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":470 + /* "View.MemoryView":469 * * * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< @@ -7270,18 +6351,18 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor __pyx_t_1 = ((__pyx_v_self->view.suboffsets != NULL) != 0); if (__pyx_t_1) { - /* "View.MemoryView":471 + /* "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, 471, __pyx_L6_error) + __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":470 + /* "View.MemoryView":469 * * * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< @@ -7290,7 +6371,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor */ } - /* "View.MemoryView":472 + /* "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, # <<<<<<<<<<<<<< @@ -7300,7 +6381,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor __pyx_memoryview_slice_assign_scalar(__pyx_v_dst_slice, __pyx_v_dst->view.ndim, __pyx_v_self->view.itemsize, __pyx_v_item, __pyx_v_self->dtype_is_object); } - /* "View.MemoryView":475 + /* "View.MemoryView":474 * item, self.dtype_is_object) * finally: * PyMem_Free(tmp) # <<<<<<<<<<<<<< @@ -7347,7 +6428,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor __pyx_L7:; } - /* "View.MemoryView":445 + /* "View.MemoryView":444 * src.ndim, dst.ndim, self.dtype_is_object) * * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< @@ -7368,7 +6449,7 @@ static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memor return __pyx_r; } -/* "View.MemoryView":477 +/* "View.MemoryView":476 * PyMem_Free(tmp) * * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< @@ -7384,28 +6465,28 @@ static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *_ PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("setitem_indexed", 0); - /* "View.MemoryView":478 + /* "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, 478, __pyx_L1_error) + __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_index); if (unlikely(__pyx_t_1 == ((char *)NULL))) __PYX_ERR(1, 477, __pyx_L1_error) __pyx_v_itemp = __pyx_t_1; - /* "View.MemoryView":479 + /* "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, 479, __pyx_L1_error) + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 478, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "View.MemoryView":477 + /* "View.MemoryView":476 * PyMem_Free(tmp) * * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< @@ -7426,7 +6507,7 @@ static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *_ return __pyx_r; } -/* "View.MemoryView":481 +/* "View.MemoryView":480 * self.assign_item_from_object(itemp, value) * * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< @@ -7453,31 +6534,31 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview int __pyx_t_11; __Pyx_RefNannySetupContext("convert_item_to_object", 0); - /* "View.MemoryView":484 + /* "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, 484, __pyx_L1_error) + __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":487 + /* "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, 487, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_itemp + 0, __pyx_v_self->view.itemsize - 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 486, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_bytesitem = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "View.MemoryView":488 + /* "View.MemoryView":487 * * bytesitem = itemp[:self.view.itemsize] * try: # <<<<<<<<<<<<<< @@ -7493,16 +6574,16 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { - /* "View.MemoryView":489 + /* "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, 489, __pyx_L3_error) + __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, 489, __pyx_L3_error) + __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; @@ -7519,7 +6600,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 489, __pyx_L3_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(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; @@ -7528,14 +6609,14 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 489, __pyx_L3_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(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, 489, __pyx_L3_error) + __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; @@ -7546,7 +6627,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview __Pyx_GIVEREF(__pyx_v_bytesitem); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_bytesitem); __pyx_t_6 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 489, __pyx_L3_error) + __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; } @@ -7554,7 +6635,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview __pyx_v_result = __pyx_t_1; __pyx_t_1 = 0; - /* "View.MemoryView":488 + /* "View.MemoryView":487 * * bytesitem = itemp[:self.view.itemsize] * try: # <<<<<<<<<<<<<< @@ -7563,7 +6644,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview */ } - /* "View.MemoryView":493 + /* "View.MemoryView":492 * raise ValueError("Unable to convert item to object") * else: * if len(self.view.format) == 1: # <<<<<<<<<<<<<< @@ -7575,7 +6656,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview __pyx_t_11 = ((__pyx_t_10 == 1) != 0); if (__pyx_t_11) { - /* "View.MemoryView":494 + /* "View.MemoryView":493 * else: * if len(self.view.format) == 1: * return result[0] # <<<<<<<<<<<<<< @@ -7583,13 +6664,13 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_result, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 494, __pyx_L5_except_error) + __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":493 + /* "View.MemoryView":492 * raise ValueError("Unable to convert item to object") * else: * if len(self.view.format) == 1: # <<<<<<<<<<<<<< @@ -7598,7 +6679,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview */ } - /* "View.MemoryView":495 + /* "View.MemoryView":494 * if len(self.view.format) == 1: * return result[0] * return result # <<<<<<<<<<<<<< @@ -7617,7 +6698,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "View.MemoryView":490 + /* "View.MemoryView":489 * try: * result = struct.unpack(self.view.format, bytesitem) * except struct.error: # <<<<<<<<<<<<<< @@ -7625,7 +6706,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview * else: */ __Pyx_ErrFetch(&__pyx_t_1, &__pyx_t_5, &__pyx_t_9); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 490, __pyx_L5_except_error) + __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; @@ -7633,28 +6714,28 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_9 = 0; if (__pyx_t_8) { __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(1, 490, __pyx_L5_except_error) + 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":491 + /* "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__9, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 491, __pyx_L5_except_error) + __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, 491, __pyx_L5_except_error) + __PYX_ERR(1, 490, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; - /* "View.MemoryView":488 + /* "View.MemoryView":487 * * bytesitem = itemp[:self.view.itemsize] * try: # <<<<<<<<<<<<<< @@ -7674,7 +6755,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview goto __pyx_L0; } - /* "View.MemoryView":481 + /* "View.MemoryView":480 * self.assign_item_from_object(itemp, value) * * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< @@ -7700,7 +6781,7 @@ static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview return __pyx_r; } -/* "View.MemoryView":497 +/* "View.MemoryView":496 * return result * * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< @@ -7731,19 +6812,19 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie char *__pyx_t_14; __Pyx_RefNannySetupContext("assign_item_from_object", 0); - /* "View.MemoryView":500 + /* "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, 500, __pyx_L1_error) + __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":505 + /* "View.MemoryView":504 * cdef Py_ssize_t i * * if isinstance(value, tuple): # <<<<<<<<<<<<<< @@ -7754,37 +6835,37 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "View.MemoryView":506 + /* "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, 506, __pyx_L1_error) + __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, 506, __pyx_L1_error) + __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, 506, __pyx_L1_error) + __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, 506, __pyx_L1_error) + __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, 506, __pyx_L1_error) + __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, 506, __pyx_L1_error) + __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, 506, __pyx_L1_error) + if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 505, __pyx_L1_error) __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; - /* "View.MemoryView":505 + /* "View.MemoryView":504 * cdef Py_ssize_t i * * if isinstance(value, tuple): # <<<<<<<<<<<<<< @@ -7794,7 +6875,7 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie goto __pyx_L3; } - /* "View.MemoryView":508 + /* "View.MemoryView":507 * bytesvalue = struct.pack(self.view.format, *value) * else: * bytesvalue = struct.pack(self.view.format, value) # <<<<<<<<<<<<<< @@ -7802,9 +6883,9 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie * for i, c in enumerate(bytesvalue): */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 508, __pyx_L1_error) + __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, 508, __pyx_L1_error) + __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; @@ -7821,7 +6902,7 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value}; - __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 508, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(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; @@ -7830,14 +6911,14 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value}; - __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 508, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(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, 508, __pyx_L1_error) + __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; @@ -7848,18 +6929,18 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie __Pyx_GIVEREF(__pyx_v_value); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_value); __pyx_t_1 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 508, __pyx_L1_error) + __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, 508, __pyx_L1_error) + if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 507, __pyx_L1_error) __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; } __pyx_L3:; - /* "View.MemoryView":510 + /* "View.MemoryView":509 * bytesvalue = struct.pack(self.view.format, value) * * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< @@ -7869,7 +6950,7 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie __pyx_t_9 = 0; if (unlikely(__pyx_v_bytesvalue == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable"); - __PYX_ERR(1, 510, __pyx_L1_error) + __PYX_ERR(1, 509, __pyx_L1_error) } __Pyx_INCREF(__pyx_v_bytesvalue); __pyx_t_10 = __pyx_v_bytesvalue; @@ -7879,7 +6960,7 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie __pyx_t_11 = __pyx_t_14; __pyx_v_c = (__pyx_t_11[0]); - /* "View.MemoryView":511 + /* "View.MemoryView":510 * * for i, c in enumerate(bytesvalue): * itemp[i] = c # <<<<<<<<<<<<<< @@ -7888,7 +6969,7 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie */ __pyx_v_i = __pyx_t_9; - /* "View.MemoryView":510 + /* "View.MemoryView":509 * bytesvalue = struct.pack(self.view.format, value) * * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< @@ -7897,7 +6978,7 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie */ __pyx_t_9 = (__pyx_t_9 + 1); - /* "View.MemoryView":511 + /* "View.MemoryView":510 * * for i, c in enumerate(bytesvalue): * itemp[i] = c # <<<<<<<<<<<<<< @@ -7908,7 +6989,7 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie } __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - /* "View.MemoryView":497 + /* "View.MemoryView":496 * return result * * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< @@ -7936,7 +7017,7 @@ static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryvie return __pyx_r; } -/* "View.MemoryView":514 +/* "View.MemoryView":513 * * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< @@ -7976,7 +7057,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); __Pyx_GIVEREF(__pyx_v_info->obj); - /* "View.MemoryView":515 + /* "View.MemoryView":514 * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< @@ -7994,20 +7075,20 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_L4_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "View.MemoryView":516 + /* "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_ND: + * if flags & PyBUF_STRIDES: */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 516, __pyx_L1_error) + __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, 516, __pyx_L1_error) + __PYX_ERR(1, 515, __pyx_L1_error) - /* "View.MemoryView":515 + /* "View.MemoryView":514 * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< @@ -8016,19 +7097,19 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu */ } - /* "View.MemoryView":518 + /* "View.MemoryView":517 * raise ValueError("Cannot create writable memory view from read-only memoryview") * - * if flags & PyBUF_ND: # <<<<<<<<<<<<<< + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< * info.shape = self.view.shape * else: */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0); + __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0); if (__pyx_t_1) { - /* "View.MemoryView":519 + /* "View.MemoryView":518 * - * if flags & PyBUF_ND: + * if flags & PyBUF_STRIDES: * info.shape = self.view.shape # <<<<<<<<<<<<<< * else: * info.shape = NULL @@ -8036,17 +7117,17 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_4 = __pyx_v_self->view.shape; __pyx_v_info->shape = __pyx_t_4; - /* "View.MemoryView":518 + /* "View.MemoryView":517 * raise ValueError("Cannot create writable memory view from read-only memoryview") * - * if flags & PyBUF_ND: # <<<<<<<<<<<<<< + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< * info.shape = self.view.shape * else: */ goto __pyx_L6; } - /* "View.MemoryView":521 + /* "View.MemoryView":520 * info.shape = self.view.shape * else: * info.shape = NULL # <<<<<<<<<<<<<< @@ -8058,7 +7139,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu } __pyx_L6:; - /* "View.MemoryView":523 + /* "View.MemoryView":522 * info.shape = NULL * * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< @@ -8068,7 +7149,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0); if (__pyx_t_1) { - /* "View.MemoryView":524 + /* "View.MemoryView":523 * * if flags & PyBUF_STRIDES: * info.strides = self.view.strides # <<<<<<<<<<<<<< @@ -8078,7 +7159,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_4 = __pyx_v_self->view.strides; __pyx_v_info->strides = __pyx_t_4; - /* "View.MemoryView":523 + /* "View.MemoryView":522 * info.shape = NULL * * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< @@ -8088,7 +7169,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu goto __pyx_L7; } - /* "View.MemoryView":526 + /* "View.MemoryView":525 * info.strides = self.view.strides * else: * info.strides = NULL # <<<<<<<<<<<<<< @@ -8100,7 +7181,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu } __pyx_L7:; - /* "View.MemoryView":528 + /* "View.MemoryView":527 * info.strides = NULL * * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< @@ -8110,7 +7191,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_1 = ((__pyx_v_flags & PyBUF_INDIRECT) != 0); if (__pyx_t_1) { - /* "View.MemoryView":529 + /* "View.MemoryView":528 * * if flags & PyBUF_INDIRECT: * info.suboffsets = self.view.suboffsets # <<<<<<<<<<<<<< @@ -8120,7 +7201,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_4 = __pyx_v_self->view.suboffsets; __pyx_v_info->suboffsets = __pyx_t_4; - /* "View.MemoryView":528 + /* "View.MemoryView":527 * info.strides = NULL * * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< @@ -8130,7 +7211,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu goto __pyx_L8; } - /* "View.MemoryView":531 + /* "View.MemoryView":530 * info.suboffsets = self.view.suboffsets * else: * info.suboffsets = NULL # <<<<<<<<<<<<<< @@ -8142,7 +7223,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu } __pyx_L8:; - /* "View.MemoryView":533 + /* "View.MemoryView":532 * info.suboffsets = NULL * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< @@ -8152,7 +7233,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); if (__pyx_t_1) { - /* "View.MemoryView":534 + /* "View.MemoryView":533 * * if flags & PyBUF_FORMAT: * info.format = self.view.format # <<<<<<<<<<<<<< @@ -8162,7 +7243,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_5 = __pyx_v_self->view.format; __pyx_v_info->format = __pyx_t_5; - /* "View.MemoryView":533 + /* "View.MemoryView":532 * info.suboffsets = NULL * * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< @@ -8172,7 +7253,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu goto __pyx_L9; } - /* "View.MemoryView":536 + /* "View.MemoryView":535 * info.format = self.view.format * else: * info.format = NULL # <<<<<<<<<<<<<< @@ -8184,7 +7265,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu } __pyx_L9:; - /* "View.MemoryView":538 + /* "View.MemoryView":537 * info.format = NULL * * info.buf = self.view.buf # <<<<<<<<<<<<<< @@ -8194,7 +7275,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_6 = __pyx_v_self->view.buf; __pyx_v_info->buf = __pyx_t_6; - /* "View.MemoryView":539 + /* "View.MemoryView":538 * * info.buf = self.view.buf * info.ndim = self.view.ndim # <<<<<<<<<<<<<< @@ -8204,7 +7285,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_7 = __pyx_v_self->view.ndim; __pyx_v_info->ndim = __pyx_t_7; - /* "View.MemoryView":540 + /* "View.MemoryView":539 * info.buf = self.view.buf * info.ndim = self.view.ndim * info.itemsize = self.view.itemsize # <<<<<<<<<<<<<< @@ -8214,7 +7295,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_8 = __pyx_v_self->view.itemsize; __pyx_v_info->itemsize = __pyx_t_8; - /* "View.MemoryView":541 + /* "View.MemoryView":540 * info.ndim = self.view.ndim * info.itemsize = self.view.itemsize * info.len = self.view.len # <<<<<<<<<<<<<< @@ -8224,7 +7305,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_8 = __pyx_v_self->view.len; __pyx_v_info->len = __pyx_t_8; - /* "View.MemoryView":542 + /* "View.MemoryView":541 * info.itemsize = self.view.itemsize * info.len = self.view.len * info.readonly = self.view.readonly # <<<<<<<<<<<<<< @@ -8234,7 +7315,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __pyx_t_1 = __pyx_v_self->view.readonly; __pyx_v_info->readonly = __pyx_t_1; - /* "View.MemoryView":543 + /* "View.MemoryView":542 * info.len = self.view.len * info.readonly = self.view.readonly * info.obj = self # <<<<<<<<<<<<<< @@ -8247,7 +7328,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = ((PyObject *)__pyx_v_self); - /* "View.MemoryView":514 + /* "View.MemoryView":513 * * @cname('getbuffer') * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< @@ -8277,7 +7358,7 @@ static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbu return __pyx_r; } -/* "View.MemoryView":549 +/* "View.MemoryView":548 * * @property * def T(self): # <<<<<<<<<<<<<< @@ -8306,29 +7387,29 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct _ int __pyx_t_2; __Pyx_RefNannySetupContext("__get__", 0); - /* "View.MemoryView":550 + /* "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, 550, __pyx_L1_error) + __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, 550, __pyx_L1_error) + 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":551 + /* "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, 551, __pyx_L1_error) + __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":552 + /* "View.MemoryView":551 * cdef _memoryviewslice result = memoryview_copy(self) * transpose_memslice(&result.from_slice) * return result # <<<<<<<<<<<<<< @@ -8340,7 +7421,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct _ __pyx_r = ((PyObject *)__pyx_v_result); goto __pyx_L0; - /* "View.MemoryView":549 + /* "View.MemoryView":548 * * @property * def T(self): # <<<<<<<<<<<<<< @@ -8360,7 +7441,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct _ return __pyx_r; } -/* "View.MemoryView":555 +/* "View.MemoryView":554 * * @property * def base(self): # <<<<<<<<<<<<<< @@ -8386,7 +7467,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struc __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); - /* "View.MemoryView":556 + /* "View.MemoryView":555 * @property * def base(self): * return self.obj # <<<<<<<<<<<<<< @@ -8398,7 +7479,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struc __pyx_r = __pyx_v_self->obj; goto __pyx_L0; - /* "View.MemoryView":555 + /* "View.MemoryView":554 * * @property * def base(self): # <<<<<<<<<<<<<< @@ -8413,7 +7494,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struc return __pyx_r; } -/* "View.MemoryView":559 +/* "View.MemoryView":558 * * @property * def shape(self): # <<<<<<<<<<<<<< @@ -8445,7 +7526,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(stru PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("__get__", 0); - /* "View.MemoryView":560 + /* "View.MemoryView":559 * @property * def shape(self): * return tuple([length for length in self.view.shape[:self.view.ndim]]) # <<<<<<<<<<<<<< @@ -8453,25 +7534,25 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(stru * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 560, __pyx_L1_error) + __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, 560, __pyx_L1_error) + __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, 560, __pyx_L1_error) + 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, 560, __pyx_L1_error) + __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":559 + /* "View.MemoryView":558 * * @property * def shape(self): # <<<<<<<<<<<<<< @@ -8491,7 +7572,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(stru return __pyx_r; } -/* "View.MemoryView":563 +/* "View.MemoryView":562 * * @property * def strides(self): # <<<<<<<<<<<<<< @@ -8524,7 +7605,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(st PyObject *__pyx_t_6 = NULL; __Pyx_RefNannySetupContext("__get__", 0); - /* "View.MemoryView":564 + /* "View.MemoryView":563 * @property * def strides(self): * if self.view.strides == NULL: # <<<<<<<<<<<<<< @@ -8534,20 +7615,20 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(st __pyx_t_1 = ((__pyx_v_self->view.strides == NULL) != 0); if (unlikely(__pyx_t_1)) { - /* "View.MemoryView":566 + /* "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__11, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 566, __pyx_L1_error) + __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, 566, __pyx_L1_error) + __PYX_ERR(1, 565, __pyx_L1_error) - /* "View.MemoryView":564 + /* "View.MemoryView":563 * @property * def strides(self): * if self.view.strides == NULL: # <<<<<<<<<<<<<< @@ -8556,7 +7637,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(st */ } - /* "View.MemoryView":568 + /* "View.MemoryView":567 * raise ValueError("Buffer view does not expose strides") * * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) # <<<<<<<<<<<<<< @@ -8564,25 +7645,25 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(st * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 568, __pyx_L1_error) + __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, 568, __pyx_L1_error) + __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, 568, __pyx_L1_error) + 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, 568, __pyx_L1_error) + __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":563 + /* "View.MemoryView":562 * * @property * def strides(self): # <<<<<<<<<<<<<< @@ -8602,7 +7683,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(st return __pyx_r; } -/* "View.MemoryView":571 +/* "View.MemoryView":570 * * @property * def suboffsets(self): # <<<<<<<<<<<<<< @@ -8635,7 +7716,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get_ Py_ssize_t *__pyx_t_6; __Pyx_RefNannySetupContext("__get__", 0); - /* "View.MemoryView":572 + /* "View.MemoryView":571 * @property * def suboffsets(self): * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< @@ -8645,7 +7726,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get_ __pyx_t_1 = ((__pyx_v_self->view.suboffsets == NULL) != 0); if (__pyx_t_1) { - /* "View.MemoryView":573 + /* "View.MemoryView":572 * def suboffsets(self): * if self.view.suboffsets == NULL: * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< @@ -8653,16 +7734,16 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get_ * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 573, __pyx_L1_error) + __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__12, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 573, __pyx_L1_error) + __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":572 + /* "View.MemoryView":571 * @property * def suboffsets(self): * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< @@ -8671,7 +7752,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get_ */ } - /* "View.MemoryView":575 + /* "View.MemoryView":574 * return (-1,) * self.view.ndim * * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) # <<<<<<<<<<<<<< @@ -8679,25 +7760,25 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get_ * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 575, __pyx_L1_error) + __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, 575, __pyx_L1_error) + __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, 575, __pyx_L1_error) + 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, 575, __pyx_L1_error) + __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":571 + /* "View.MemoryView":570 * * @property * def suboffsets(self): # <<<<<<<<<<<<<< @@ -8717,7 +7798,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get_ return __pyx_r; } -/* "View.MemoryView":578 +/* "View.MemoryView":577 * * @property * def ndim(self): # <<<<<<<<<<<<<< @@ -8744,7 +7825,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struc PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__get__", 0); - /* "View.MemoryView":579 + /* "View.MemoryView":578 * @property * def ndim(self): * return self.view.ndim # <<<<<<<<<<<<<< @@ -8752,13 +7833,13 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struc * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 579, __pyx_L1_error) + __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":578 + /* "View.MemoryView":577 * * @property * def ndim(self): # <<<<<<<<<<<<<< @@ -8777,7 +7858,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struc return __pyx_r; } -/* "View.MemoryView":582 +/* "View.MemoryView":581 * * @property * def itemsize(self): # <<<<<<<<<<<<<< @@ -8804,7 +7885,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(s PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("__get__", 0); - /* "View.MemoryView":583 + /* "View.MemoryView":582 * @property * def itemsize(self): * return self.view.itemsize # <<<<<<<<<<<<<< @@ -8812,13 +7893,13 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(s * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 583, __pyx_L1_error) + __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":582 + /* "View.MemoryView":581 * * @property * def itemsize(self): # <<<<<<<<<<<<<< @@ -8837,7 +7918,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(s return __pyx_r; } -/* "View.MemoryView":586 +/* "View.MemoryView":585 * * @property * def nbytes(self): # <<<<<<<<<<<<<< @@ -8866,7 +7947,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(str PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("__get__", 0); - /* "View.MemoryView":587 + /* "View.MemoryView":586 * @property * def nbytes(self): * return self.size * self.view.itemsize # <<<<<<<<<<<<<< @@ -8874,11 +7955,11 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(str * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 587, __pyx_L1_error) + __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, 587, __pyx_L1_error) + __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, 587, __pyx_L1_error) + __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; @@ -8886,7 +7967,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(str __pyx_t_3 = 0; goto __pyx_L0; - /* "View.MemoryView":586 + /* "View.MemoryView":585 * * @property * def nbytes(self): # <<<<<<<<<<<<<< @@ -8907,7 +7988,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(str return __pyx_r; } -/* "View.MemoryView":590 +/* "View.MemoryView":589 * * @property * def size(self): # <<<<<<<<<<<<<< @@ -8941,7 +8022,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc PyObject *__pyx_t_6 = NULL; __Pyx_RefNannySetupContext("__get__", 0); - /* "View.MemoryView":591 + /* "View.MemoryView":590 * @property * def size(self): * if self._size is None: # <<<<<<<<<<<<<< @@ -8952,7 +8033,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "View.MemoryView":592 + /* "View.MemoryView":591 * def size(self): * if self._size is None: * result = 1 # <<<<<<<<<<<<<< @@ -8962,7 +8043,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc __Pyx_INCREF(__pyx_int_1); __pyx_v_result = __pyx_int_1; - /* "View.MemoryView":594 + /* "View.MemoryView":593 * result = 1 * * for length in self.view.shape[:self.view.ndim]: # <<<<<<<<<<<<<< @@ -8972,25 +8053,25 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc __pyx_t_4 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); for (__pyx_t_5 = __pyx_v_self->view.shape; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { __pyx_t_3 = __pyx_t_5; - __pyx_t_6 = PyInt_FromSsize_t((__pyx_t_3[0])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 594, __pyx_L1_error) + __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":595 + /* "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, 595, __pyx_L1_error) + __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":597 + /* "View.MemoryView":596 * result *= length * * self._size = result # <<<<<<<<<<<<<< @@ -9003,7 +8084,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc __Pyx_DECREF(__pyx_v_self->_size); __pyx_v_self->_size = __pyx_v_result; - /* "View.MemoryView":591 + /* "View.MemoryView":590 * @property * def size(self): * if self._size is None: # <<<<<<<<<<<<<< @@ -9012,7 +8093,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc */ } - /* "View.MemoryView":599 + /* "View.MemoryView":598 * self._size = result * * return self._size # <<<<<<<<<<<<<< @@ -9024,7 +8105,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc __pyx_r = __pyx_v_self->_size; goto __pyx_L0; - /* "View.MemoryView":590 + /* "View.MemoryView":589 * * @property * def size(self): # <<<<<<<<<<<<<< @@ -9045,7 +8126,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struc return __pyx_r; } -/* "View.MemoryView":601 +/* "View.MemoryView":600 * return self._size * * def __len__(self): # <<<<<<<<<<<<<< @@ -9072,7 +8153,7 @@ static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_1 int __pyx_t_1; __Pyx_RefNannySetupContext("__len__", 0); - /* "View.MemoryView":602 + /* "View.MemoryView":601 * * def __len__(self): * if self.view.ndim >= 1: # <<<<<<<<<<<<<< @@ -9082,7 +8163,7 @@ static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_1 __pyx_t_1 = ((__pyx_v_self->view.ndim >= 1) != 0); if (__pyx_t_1) { - /* "View.MemoryView":603 + /* "View.MemoryView":602 * def __len__(self): * if self.view.ndim >= 1: * return self.view.shape[0] # <<<<<<<<<<<<<< @@ -9092,7 +8173,7 @@ static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_1 __pyx_r = (__pyx_v_self->view.shape[0]); goto __pyx_L0; - /* "View.MemoryView":602 + /* "View.MemoryView":601 * * def __len__(self): * if self.view.ndim >= 1: # <<<<<<<<<<<<<< @@ -9101,7 +8182,7 @@ static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_1 */ } - /* "View.MemoryView":605 + /* "View.MemoryView":604 * return self.view.shape[0] * * return 0 # <<<<<<<<<<<<<< @@ -9111,7 +8192,7 @@ static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_1 __pyx_r = 0; goto __pyx_L0; - /* "View.MemoryView":601 + /* "View.MemoryView":600 * return self._size * * def __len__(self): # <<<<<<<<<<<<<< @@ -9125,7 +8206,7 @@ static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_1 return __pyx_r; } -/* "View.MemoryView":607 +/* "View.MemoryView":606 * return 0 * * def __repr__(self): # <<<<<<<<<<<<<< @@ -9154,7 +8235,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12 PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("__repr__", 0); - /* "View.MemoryView":608 + /* "View.MemoryView":607 * * def __repr__(self): * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< @@ -9162,33 +8243,33 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12 * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 608, __pyx_L1_error) + __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, 608, __pyx_L1_error) + __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, 608, __pyx_L1_error) + __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":609 + /* "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, 609, __pyx_L1_error) + __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":608 + /* "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, 608, __pyx_L1_error) + __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); @@ -9196,14 +8277,14 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12 PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); __pyx_t_1 = 0; __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 608, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(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":607 + /* "View.MemoryView":606 * return 0 * * def __repr__(self): # <<<<<<<<<<<<<< @@ -9224,7 +8305,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12 return __pyx_r; } -/* "View.MemoryView":611 +/* "View.MemoryView":610 * id(self)) * * def __str__(self): # <<<<<<<<<<<<<< @@ -9252,7 +8333,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14 PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("__str__", 0); - /* "View.MemoryView":612 + /* "View.MemoryView":611 * * def __str__(self): * return "" % (self.base.__class__.__name__,) # <<<<<<<<<<<<<< @@ -9260,27 +8341,27 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14 * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 612, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(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, 612, __pyx_L1_error) + __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, 612, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(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, 612, __pyx_L1_error) + __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, 612, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_object, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(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":611 + /* "View.MemoryView":610 * id(self)) * * def __str__(self): # <<<<<<<<<<<<<< @@ -9300,7 +8381,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14 return __pyx_r; } -/* "View.MemoryView":615 +/* "View.MemoryView":614 * * * def is_c_contig(self): # <<<<<<<<<<<<<< @@ -9329,7 +8410,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16 PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("is_c_contig", 0); - /* "View.MemoryView":618 + /* "View.MemoryView":617 * cdef __Pyx_memviewslice *mslice * cdef __Pyx_memviewslice tmp * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<< @@ -9338,7 +8419,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16 */ __pyx_v_mslice = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); - /* "View.MemoryView":619 + /* "View.MemoryView":618 * cdef __Pyx_memviewslice tmp * mslice = get_slice_from_memview(self, &tmp) * return slice_is_contig(mslice[0], 'C', self.view.ndim) # <<<<<<<<<<<<<< @@ -9346,13 +8427,13 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16 * 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, 619, __pyx_L1_error) + __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":615 + /* "View.MemoryView":614 * * * def is_c_contig(self): # <<<<<<<<<<<<<< @@ -9371,7 +8452,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16 return __pyx_r; } -/* "View.MemoryView":621 +/* "View.MemoryView":620 * return slice_is_contig(mslice[0], 'C', self.view.ndim) * * def is_f_contig(self): # <<<<<<<<<<<<<< @@ -9400,7 +8481,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18 PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("is_f_contig", 0); - /* "View.MemoryView":624 + /* "View.MemoryView":623 * cdef __Pyx_memviewslice *mslice * cdef __Pyx_memviewslice tmp * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<< @@ -9409,7 +8490,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18 */ __pyx_v_mslice = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); - /* "View.MemoryView":625 + /* "View.MemoryView":624 * cdef __Pyx_memviewslice tmp * mslice = get_slice_from_memview(self, &tmp) * return slice_is_contig(mslice[0], 'F', self.view.ndim) # <<<<<<<<<<<<<< @@ -9417,13 +8498,13 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18 * 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, 625, __pyx_L1_error) + __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":621 + /* "View.MemoryView":620 * return slice_is_contig(mslice[0], 'C', self.view.ndim) * * def is_f_contig(self): # <<<<<<<<<<<<<< @@ -9442,7 +8523,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18 return __pyx_r; } -/* "View.MemoryView":627 +/* "View.MemoryView":626 * return slice_is_contig(mslice[0], 'F', self.view.ndim) * * def copy(self): # <<<<<<<<<<<<<< @@ -9472,7 +8553,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20 PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("copy", 0); - /* "View.MemoryView":629 + /* "View.MemoryView":628 * def copy(self): * cdef __Pyx_memviewslice mslice * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS # <<<<<<<<<<<<<< @@ -9481,7 +8562,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20 */ __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_F_CONTIGUOUS)); - /* "View.MemoryView":631 + /* "View.MemoryView":630 * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS * * slice_copy(self, &mslice) # <<<<<<<<<<<<<< @@ -9490,17 +8571,17 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20 */ __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_mslice)); - /* "View.MemoryView":632 + /* "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, 632, __pyx_L1_error) + __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_mslice), ((char *)"c"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_C_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 631, __pyx_L1_error) __pyx_v_mslice = __pyx_t_1; - /* "View.MemoryView":637 + /* "View.MemoryView":636 * self.dtype_is_object) * * return memoryview_copy_from_slice(self, &mslice) # <<<<<<<<<<<<<< @@ -9508,13 +8589,13 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20 * def copy_fortran(self): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_mslice)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 637, __pyx_L1_error) + __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_mslice)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 636, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "View.MemoryView":627 + /* "View.MemoryView":626 * return slice_is_contig(mslice[0], 'F', self.view.ndim) * * def copy(self): # <<<<<<<<<<<<<< @@ -9533,7 +8614,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20 return __pyx_r; } -/* "View.MemoryView":639 +/* "View.MemoryView":638 * return memoryview_copy_from_slice(self, &mslice) * * def copy_fortran(self): # <<<<<<<<<<<<<< @@ -9564,7 +8645,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22 PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("copy_fortran", 0); - /* "View.MemoryView":641 + /* "View.MemoryView":640 * def copy_fortran(self): * cdef __Pyx_memviewslice src, dst * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS # <<<<<<<<<<<<<< @@ -9573,7 +8654,7 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22 */ __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_C_CONTIGUOUS)); - /* "View.MemoryView":643 + /* "View.MemoryView":642 * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS * * slice_copy(self, &src) # <<<<<<<<<<<<<< @@ -9582,17 +8663,17 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22 */ __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_src)); - /* "View.MemoryView":644 + /* "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, 644, __pyx_L1_error) + __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_src), ((char *)"fortran"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_F_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 643, __pyx_L1_error) __pyx_v_dst = __pyx_t_1; - /* "View.MemoryView":649 + /* "View.MemoryView":648 * self.dtype_is_object) * * return memoryview_copy_from_slice(self, &dst) # <<<<<<<<<<<<<< @@ -9600,13 +8681,13 @@ static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22 * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_dst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 649, __pyx_L1_error) + __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_dst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 648, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "View.MemoryView":639 + /* "View.MemoryView":638 * return memoryview_copy_from_slice(self, &mslice) * * def copy_fortran(self): # <<<<<<<<<<<<<< @@ -9656,7 +8737,7 @@ static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struc * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __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; @@ -9709,7 +8790,7 @@ static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED st * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __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; @@ -9732,7 +8813,7 @@ static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED st return __pyx_r; } -/* "View.MemoryView":653 +/* "View.MemoryView":652 * * @cname('__pyx_memoryview_new') * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<< @@ -9749,18 +8830,18 @@ static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, in PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("memoryview_cwrapper", 0); - /* "View.MemoryView":654 + /* "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, 654, __pyx_L1_error) + __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, 654, __pyx_L1_error) + __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, 654, __pyx_L1_error) + __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); @@ -9771,13 +8852,13 @@ static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, in PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); __pyx_t_1 = 0; __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 654, __pyx_L1_error) + __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":655 + /* "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 # <<<<<<<<<<<<<< @@ -9786,7 +8867,7 @@ static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, in */ __pyx_v_result->typeinfo = __pyx_v_typeinfo; - /* "View.MemoryView":656 + /* "View.MemoryView":655 * cdef memoryview result = memoryview(o, flags, dtype_is_object) * result.typeinfo = typeinfo * return result # <<<<<<<<<<<<<< @@ -9798,7 +8879,7 @@ static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, in __pyx_r = ((PyObject *)__pyx_v_result); goto __pyx_L0; - /* "View.MemoryView":653 + /* "View.MemoryView":652 * * @cname('__pyx_memoryview_new') * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<< @@ -9820,7 +8901,7 @@ static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, in return __pyx_r; } -/* "View.MemoryView":659 +/* "View.MemoryView":658 * * @cname('__pyx_memoryview_check') * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< @@ -9834,7 +8915,7 @@ static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) { int __pyx_t_1; __Pyx_RefNannySetupContext("memoryview_check", 0); - /* "View.MemoryView":660 + /* "View.MemoryView":659 * @cname('__pyx_memoryview_check') * cdef inline bint memoryview_check(object o): * return isinstance(o, memoryview) # <<<<<<<<<<<<<< @@ -9845,7 +8926,7 @@ static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) { __pyx_r = __pyx_t_1; goto __pyx_L0; - /* "View.MemoryView":659 + /* "View.MemoryView":658 * * @cname('__pyx_memoryview_check') * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< @@ -9859,7 +8940,7 @@ static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) { return __pyx_r; } -/* "View.MemoryView":662 +/* "View.MemoryView":661 * return isinstance(o, memoryview) * * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< @@ -9890,7 +8971,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { PyObject *__pyx_t_11 = NULL; __Pyx_RefNannySetupContext("_unellipsify", 0); - /* "View.MemoryView":667 + /* "View.MemoryView":666 * full slices. * """ * if not isinstance(index, tuple): # <<<<<<<<<<<<<< @@ -9901,14 +8982,14 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_2) { - /* "View.MemoryView":668 + /* "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, 668, __pyx_L1_error) + __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); @@ -9916,7 +8997,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __pyx_v_tup = __pyx_t_3; __pyx_t_3 = 0; - /* "View.MemoryView":667 + /* "View.MemoryView":666 * full slices. * """ * if not isinstance(index, tuple): # <<<<<<<<<<<<<< @@ -9926,7 +9007,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { goto __pyx_L3; } - /* "View.MemoryView":670 + /* "View.MemoryView":669 * tup = (index,) * else: * tup = index # <<<<<<<<<<<<<< @@ -9939,19 +9020,19 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { } __pyx_L3:; - /* "View.MemoryView":672 + /* "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, 672, __pyx_L1_error) + __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":673 + /* "View.MemoryView":672 * * result = [] * have_slices = False # <<<<<<<<<<<<<< @@ -9960,7 +9041,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { */ __pyx_v_have_slices = 0; - /* "View.MemoryView":674 + /* "View.MemoryView":673 * result = [] * have_slices = False * seen_ellipsis = False # <<<<<<<<<<<<<< @@ -9969,7 +9050,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { */ __pyx_v_seen_ellipsis = 0; - /* "View.MemoryView":675 + /* "View.MemoryView":674 * have_slices = False * seen_ellipsis = False * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< @@ -9982,26 +9063,26 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __pyx_t_4 = __pyx_v_tup; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0; __pyx_t_6 = NULL; } else { - __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_v_tup); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 675, __pyx_L1_error) + __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, 675, __pyx_L1_error) + __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, 675, __pyx_L1_error) + __pyx_t_7 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(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, 675, __pyx_L1_error) + __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, 675, __pyx_L1_error) + __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(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, 675, __pyx_L1_error) + __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 } @@ -10011,7 +9092,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 675, __pyx_L1_error) + else __PYX_ERR(1, 674, __pyx_L1_error) } break; } @@ -10021,13 +9102,13 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __pyx_t_7 = 0; __Pyx_INCREF(__pyx_t_3); __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_3); - __pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 675, __pyx_L1_error) + __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":676 + /* "View.MemoryView":675 * seen_ellipsis = False * for idx, item in enumerate(tup): * if item is Ellipsis: # <<<<<<<<<<<<<< @@ -10038,7 +9119,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "View.MemoryView":677 + /* "View.MemoryView":676 * for idx, item in enumerate(tup): * if item is Ellipsis: * if not seen_ellipsis: # <<<<<<<<<<<<<< @@ -10048,27 +9129,27 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __pyx_t_1 = ((!(__pyx_v_seen_ellipsis != 0)) != 0); if (__pyx_t_1) { - /* "View.MemoryView":678 + /* "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, 678, __pyx_L1_error) - __pyx_t_7 = PyList_New(1 * ((((__pyx_v_ndim - __pyx_t_8) + 1)<0) ? 0:((__pyx_v_ndim - __pyx_t_8) + 1))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 678, __pyx_L1_error) + __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__15); - __Pyx_GIVEREF(__pyx_slice__15); - PyList_SET_ITEM(__pyx_t_7, __pyx_temp, __pyx_slice__15); + __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, 678, __pyx_L1_error) + __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":679 + /* "View.MemoryView":678 * if not seen_ellipsis: * result.extend([slice(None)] * (ndim - len(tup) + 1)) * seen_ellipsis = True # <<<<<<<<<<<<<< @@ -10077,7 +9158,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { */ __pyx_v_seen_ellipsis = 1; - /* "View.MemoryView":677 + /* "View.MemoryView":676 * for idx, item in enumerate(tup): * if item is Ellipsis: * if not seen_ellipsis: # <<<<<<<<<<<<<< @@ -10087,7 +9168,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { goto __pyx_L7; } - /* "View.MemoryView":681 + /* "View.MemoryView":680 * seen_ellipsis = True * else: * result.append(slice(None)) # <<<<<<<<<<<<<< @@ -10095,11 +9176,11 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { * else: */ /*else*/ { - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_slice__15); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 681, __pyx_L1_error) + __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":682 + /* "View.MemoryView":681 * else: * result.append(slice(None)) * have_slices = True # <<<<<<<<<<<<<< @@ -10108,7 +9189,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { */ __pyx_v_have_slices = 1; - /* "View.MemoryView":676 + /* "View.MemoryView":675 * seen_ellipsis = False * for idx, item in enumerate(tup): * if item is Ellipsis: # <<<<<<<<<<<<<< @@ -10118,7 +9199,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { goto __pyx_L6; } - /* "View.MemoryView":684 + /* "View.MemoryView":683 * have_slices = True * else: * if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<< @@ -10138,23 +9219,23 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __pyx_L9_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "View.MemoryView":685 + /* "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_FormatSafe(__pyx_kp_s_Cannot_index_with_type_s, ((PyObject *)Py_TYPE(__pyx_v_item))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 685, __pyx_L1_error) + __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, 685, __pyx_L1_error) + __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, 685, __pyx_L1_error) + __PYX_ERR(1, 684, __pyx_L1_error) - /* "View.MemoryView":684 + /* "View.MemoryView":683 * have_slices = True * else: * if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<< @@ -10163,7 +9244,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { */ } - /* "View.MemoryView":687 + /* "View.MemoryView":686 * raise TypeError("Cannot index with type '%s'" % type(item)) * * have_slices = have_slices or isinstance(item, slice) # <<<<<<<<<<<<<< @@ -10182,18 +9263,18 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __pyx_L11_bool_binop_done:; __pyx_v_have_slices = __pyx_t_1; - /* "View.MemoryView":688 + /* "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, 688, __pyx_L1_error) + __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":675 + /* "View.MemoryView":674 * have_slices = False * seen_ellipsis = False * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< @@ -10204,17 +9285,17 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "View.MemoryView":690 + /* "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, 690, __pyx_L1_error) + __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":691 + /* "View.MemoryView":690 * * nslices = ndim - len(result) * if nslices: # <<<<<<<<<<<<<< @@ -10224,26 +9305,26 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __pyx_t_1 = (__pyx_v_nslices != 0); if (__pyx_t_1) { - /* "View.MemoryView":692 + /* "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, 692, __pyx_L1_error) + __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__15); - __Pyx_GIVEREF(__pyx_slice__15); - PyList_SET_ITEM(__pyx_t_3, __pyx_temp, __pyx_slice__15); + __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, 692, __pyx_L1_error) + __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":691 + /* "View.MemoryView":690 * * nslices = ndim - len(result) * if nslices: # <<<<<<<<<<<<<< @@ -10252,7 +9333,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { */ } - /* "View.MemoryView":694 + /* "View.MemoryView":693 * result.extend([slice(None)] * nslices) * * return have_slices or nslices, tuple(result) # <<<<<<<<<<<<<< @@ -10262,20 +9343,20 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __Pyx_XDECREF(__pyx_r); if (!__pyx_v_have_slices) { } else { - __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_have_slices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 694, __pyx_L1_error) + __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, 694, __pyx_L1_error) + __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, 694, __pyx_L1_error) + __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, 694, __pyx_L1_error) + __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); @@ -10287,7 +9368,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { __pyx_t_11 = 0; goto __pyx_L0; - /* "View.MemoryView":662 + /* "View.MemoryView":661 * return isinstance(o, memoryview) * * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< @@ -10313,7 +9394,7 @@ static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { return __pyx_r; } -/* "View.MemoryView":696 +/* "View.MemoryView":695 * return have_slices or nslices, tuple(result) * * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< @@ -10332,7 +9413,7 @@ static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __ PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("assert_direct_dimensions", 0); - /* "View.MemoryView":697 + /* "View.MemoryView":696 * * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): * for suboffset in suboffsets[:ndim]: # <<<<<<<<<<<<<< @@ -10344,7 +9425,7 @@ static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __ __pyx_t_1 = __pyx_t_3; __pyx_v_suboffset = (__pyx_t_1[0]); - /* "View.MemoryView":698 + /* "View.MemoryView":697 * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: # <<<<<<<<<<<<<< @@ -10354,20 +9435,20 @@ static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __ __pyx_t_4 = ((__pyx_v_suboffset >= 0) != 0); if (unlikely(__pyx_t_4)) { - /* "View.MemoryView":699 + /* "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__16, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 699, __pyx_L1_error) + __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, 699, __pyx_L1_error) + __PYX_ERR(1, 698, __pyx_L1_error) - /* "View.MemoryView":698 + /* "View.MemoryView":697 * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: # <<<<<<<<<<<<<< @@ -10377,7 +9458,7 @@ static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __ } } - /* "View.MemoryView":696 + /* "View.MemoryView":695 * return have_slices or nslices, tuple(result) * * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< @@ -10398,7 +9479,7 @@ static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __ return __pyx_r; } -/* "View.MemoryView":706 +/* "View.MemoryView":705 * * @cname('__pyx_memview_slice') * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< @@ -10439,7 +9520,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ Py_ssize_t __pyx_t_12; __Pyx_RefNannySetupContext("memview_slice", 0); - /* "View.MemoryView":707 + /* "View.MemoryView":706 * @cname('__pyx_memview_slice') * cdef memoryview memview_slice(memoryview memview, object indices): * cdef int new_ndim = 0, suboffset_dim = -1, dim # <<<<<<<<<<<<<< @@ -10449,7 +9530,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_v_new_ndim = 0; __pyx_v_suboffset_dim = -1; - /* "View.MemoryView":714 + /* "View.MemoryView":713 * * * memset(&dst, 0, sizeof(dst)) # <<<<<<<<<<<<<< @@ -10458,7 +9539,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ (void)(memset((&__pyx_v_dst), 0, (sizeof(__pyx_v_dst)))); - /* "View.MemoryView":718 + /* "View.MemoryView":717 * cdef _memoryviewslice memviewsliceobj * * assert memview.view.ndim > 0 # <<<<<<<<<<<<<< @@ -10469,12 +9550,12 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ if (unlikely(!Py_OptimizeFlag)) { if (unlikely(!((__pyx_v_memview->view.ndim > 0) != 0))) { PyErr_SetNone(PyExc_AssertionError); - __PYX_ERR(1, 718, __pyx_L1_error) + __PYX_ERR(1, 717, __pyx_L1_error) } } #endif - /* "View.MemoryView":720 + /* "View.MemoryView":719 * assert memview.view.ndim > 0 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< @@ -10485,20 +9566,20 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "View.MemoryView":721 + /* "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, 721, __pyx_L1_error) + 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":722 + /* "View.MemoryView":721 * if isinstance(memview, _memoryviewslice): * memviewsliceobj = memview * p_src = &memviewsliceobj.from_slice # <<<<<<<<<<<<<< @@ -10507,7 +9588,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ __pyx_v_p_src = (&__pyx_v_memviewsliceobj->from_slice); - /* "View.MemoryView":720 + /* "View.MemoryView":719 * assert memview.view.ndim > 0 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< @@ -10517,7 +9598,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ goto __pyx_L3; } - /* "View.MemoryView":724 + /* "View.MemoryView":723 * p_src = &memviewsliceobj.from_slice * else: * slice_copy(memview, &src) # <<<<<<<<<<<<<< @@ -10527,7 +9608,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ /*else*/ { __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_src)); - /* "View.MemoryView":725 + /* "View.MemoryView":724 * else: * slice_copy(memview, &src) * p_src = &src # <<<<<<<<<<<<<< @@ -10538,7 +9619,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ } __pyx_L3:; - /* "View.MemoryView":731 + /* "View.MemoryView":730 * * * dst.memview = p_src.memview # <<<<<<<<<<<<<< @@ -10548,7 +9629,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_t_4 = __pyx_v_p_src->memview; __pyx_v_dst.memview = __pyx_t_4; - /* "View.MemoryView":732 + /* "View.MemoryView":731 * * dst.memview = p_src.memview * dst.data = p_src.data # <<<<<<<<<<<<<< @@ -10558,7 +9639,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_t_5 = __pyx_v_p_src->data; __pyx_v_dst.data = __pyx_t_5; - /* "View.MemoryView":737 + /* "View.MemoryView":736 * * * cdef __Pyx_memviewslice *p_dst = &dst # <<<<<<<<<<<<<< @@ -10567,7 +9648,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ __pyx_v_p_dst = (&__pyx_v_dst); - /* "View.MemoryView":738 + /* "View.MemoryView":737 * * cdef __Pyx_memviewslice *p_dst = &dst * cdef int *p_suboffset_dim = &suboffset_dim # <<<<<<<<<<<<<< @@ -10576,7 +9657,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ __pyx_v_p_suboffset_dim = (&__pyx_v_suboffset_dim); - /* "View.MemoryView":742 + /* "View.MemoryView":741 * cdef bint have_start, have_stop, have_step * * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< @@ -10588,26 +9669,26 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_t_3 = __pyx_v_indices; __Pyx_INCREF(__pyx_t_3); __pyx_t_7 = 0; __pyx_t_8 = NULL; } else { - __pyx_t_7 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_indices); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 742, __pyx_L1_error) + __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, 742, __pyx_L1_error) + __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, 742, __pyx_L1_error) + __pyx_t_9 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(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, 742, __pyx_L1_error) + __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, 742, __pyx_L1_error) + __pyx_t_9 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(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, 742, __pyx_L1_error) + __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 } @@ -10617,7 +9698,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 742, __pyx_L1_error) + else __PYX_ERR(1, 741, __pyx_L1_error) } break; } @@ -10628,7 +9709,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_v_dim = __pyx_t_6; __pyx_t_6 = (__pyx_t_6 + 1); - /* "View.MemoryView":743 + /* "View.MemoryView":742 * * for dim, index in enumerate(indices): * if PyIndex_Check(index): # <<<<<<<<<<<<<< @@ -10638,25 +9719,25 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_t_2 = (PyIndex_Check(__pyx_v_index) != 0); if (__pyx_t_2) { - /* "View.MemoryView":747 + /* "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, 747, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_index); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 746, __pyx_L1_error) - /* "View.MemoryView":744 + /* "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, 744, __pyx_L1_error) + __pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_t_10, 0, 0, 0, 0, 0, 0); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(1, 743, __pyx_L1_error) - /* "View.MemoryView":743 + /* "View.MemoryView":742 * * for dim, index in enumerate(indices): * if PyIndex_Check(index): # <<<<<<<<<<<<<< @@ -10666,7 +9747,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ goto __pyx_L6; } - /* "View.MemoryView":750 + /* "View.MemoryView":749 * 0, 0, 0, # have_{start,stop,step} * False) * elif index is None: # <<<<<<<<<<<<<< @@ -10677,7 +9758,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "View.MemoryView":751 + /* "View.MemoryView":750 * False) * elif index is None: * p_dst.shape[new_ndim] = 1 # <<<<<<<<<<<<<< @@ -10686,7 +9767,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ (__pyx_v_p_dst->shape[__pyx_v_new_ndim]) = 1; - /* "View.MemoryView":752 + /* "View.MemoryView":751 * elif index is None: * p_dst.shape[new_ndim] = 1 * p_dst.strides[new_ndim] = 0 # <<<<<<<<<<<<<< @@ -10695,7 +9776,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ (__pyx_v_p_dst->strides[__pyx_v_new_ndim]) = 0; - /* "View.MemoryView":753 + /* "View.MemoryView":752 * p_dst.shape[new_ndim] = 1 * p_dst.strides[new_ndim] = 0 * p_dst.suboffsets[new_ndim] = -1 # <<<<<<<<<<<<<< @@ -10704,7 +9785,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ (__pyx_v_p_dst->suboffsets[__pyx_v_new_ndim]) = -1L; - /* "View.MemoryView":754 + /* "View.MemoryView":753 * p_dst.strides[new_ndim] = 0 * p_dst.suboffsets[new_ndim] = -1 * new_ndim += 1 # <<<<<<<<<<<<<< @@ -10713,7 +9794,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); - /* "View.MemoryView":750 + /* "View.MemoryView":749 * 0, 0, 0, # have_{start,stop,step} * False) * elif index is None: # <<<<<<<<<<<<<< @@ -10723,7 +9804,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ goto __pyx_L6; } - /* "View.MemoryView":756 + /* "View.MemoryView":755 * new_ndim += 1 * else: * start = index.start or 0 # <<<<<<<<<<<<<< @@ -10731,13 +9812,13 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ * step = index.step or 0 */ /*else*/ { - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 756, __pyx_L1_error) + __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, 756, __pyx_L1_error) + __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, 756, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(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; @@ -10746,20 +9827,20 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_L7_bool_binop_done:; __pyx_v_start = __pyx_t_10; - /* "View.MemoryView":757 + /* "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, 757, __pyx_L1_error) + __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, 757, __pyx_L1_error) + __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, 757, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(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; @@ -10768,20 +9849,20 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_L9_bool_binop_done:; __pyx_v_stop = __pyx_t_10; - /* "View.MemoryView":758 + /* "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, 758, __pyx_L1_error) + __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, 758, __pyx_L1_error) + __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, 758, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(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; @@ -10790,55 +9871,55 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_L11_bool_binop_done:; __pyx_v_step = __pyx_t_10; - /* "View.MemoryView":760 + /* "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, 760, __pyx_L1_error) + __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":761 + /* "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, 761, __pyx_L1_error) + __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":762 + /* "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, 762, __pyx_L1_error) + __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":764 + /* "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, 764, __pyx_L1_error) + __pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_v_start, __pyx_v_stop, __pyx_v_step, __pyx_v_have_start, __pyx_v_have_stop, __pyx_v_have_step, 1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(1, 763, __pyx_L1_error) - /* "View.MemoryView":770 + /* "View.MemoryView":769 * have_start, have_stop, have_step, * True) * new_ndim += 1 # <<<<<<<<<<<<<< @@ -10849,7 +9930,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ } __pyx_L6:; - /* "View.MemoryView":742 + /* "View.MemoryView":741 * cdef bint have_start, have_stop, have_step * * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< @@ -10859,7 +9940,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "View.MemoryView":772 + /* "View.MemoryView":771 * new_ndim += 1 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< @@ -10870,7 +9951,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "View.MemoryView":773 + /* "View.MemoryView":772 * * if isinstance(memview, _memoryviewslice): * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< @@ -10879,39 +9960,39 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ __Pyx_XDECREF(((PyObject *)__pyx_r)); - /* "View.MemoryView":774 + /* "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, 774, __pyx_L1_error) } + if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(1, 773, __pyx_L1_error) } - /* "View.MemoryView":775 + /* "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, 775, __pyx_L1_error) } + if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(1, 774, __pyx_L1_error) } - /* "View.MemoryView":773 + /* "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, 773, __pyx_L1_error) + __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, __pyx_v_memviewsliceobj->to_object_func, __pyx_v_memviewsliceobj->to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(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, 773, __pyx_L1_error) + 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":772 + /* "View.MemoryView":771 * new_ndim += 1 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< @@ -10920,7 +10001,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ */ } - /* "View.MemoryView":778 + /* "View.MemoryView":777 * memview.dtype_is_object) * else: * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< @@ -10930,30 +10011,30 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ /*else*/ { __Pyx_XDECREF(((PyObject *)__pyx_r)); - /* "View.MemoryView":779 + /* "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, 778, __pyx_L1_error) + __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, NULL, NULL, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 777, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - /* "View.MemoryView":778 + /* "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, 778, __pyx_L1_error) + 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":706 + /* "View.MemoryView":705 * * @cname('__pyx_memview_slice') * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< @@ -10975,7 +10056,7 @@ static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_ return __pyx_r; } -/* "View.MemoryView":803 +/* "View.MemoryView":802 * * @cname('__pyx_memoryview_slice_memviewslice') * cdef int slice_memviewslice( # <<<<<<<<<<<<<< @@ -10991,7 +10072,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, int __pyx_t_2; int __pyx_t_3; - /* "View.MemoryView":823 + /* "View.MemoryView":822 * cdef bint negative_step * * if not is_slice: # <<<<<<<<<<<<<< @@ -11001,7 +10082,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_1 = ((!(__pyx_v_is_slice != 0)) != 0); if (__pyx_t_1) { - /* "View.MemoryView":825 + /* "View.MemoryView":824 * if not is_slice: * * if start < 0: # <<<<<<<<<<<<<< @@ -11011,7 +10092,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_1 = ((__pyx_v_start < 0) != 0); if (__pyx_t_1) { - /* "View.MemoryView":826 + /* "View.MemoryView":825 * * if start < 0: * start += shape # <<<<<<<<<<<<<< @@ -11020,7 +10101,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_start = (__pyx_v_start + __pyx_v_shape); - /* "View.MemoryView":825 + /* "View.MemoryView":824 * if not is_slice: * * if start < 0: # <<<<<<<<<<<<<< @@ -11029,7 +10110,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ } - /* "View.MemoryView":827 + /* "View.MemoryView":826 * if start < 0: * start += shape * if not 0 <= start < shape: # <<<<<<<<<<<<<< @@ -11043,16 +10124,16 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_2) { - /* "View.MemoryView":828 + /* "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, 828, __pyx_L1_error) + __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"Index out of bounds (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 827, __pyx_L1_error) - /* "View.MemoryView":827 + /* "View.MemoryView":826 * if start < 0: * start += shape * if not 0 <= start < shape: # <<<<<<<<<<<<<< @@ -11061,7 +10142,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ } - /* "View.MemoryView":823 + /* "View.MemoryView":822 * cdef bint negative_step * * if not is_slice: # <<<<<<<<<<<<<< @@ -11071,7 +10152,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, goto __pyx_L3; } - /* "View.MemoryView":831 + /* "View.MemoryView":830 * else: * * negative_step = have_step != 0 and step < 0 # <<<<<<<<<<<<<< @@ -11090,7 +10171,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_L6_bool_binop_done:; __pyx_v_negative_step = __pyx_t_2; - /* "View.MemoryView":833 + /* "View.MemoryView":832 * negative_step = have_step != 0 and step < 0 * * if have_step and step == 0: # <<<<<<<<<<<<<< @@ -11108,16 +10189,16 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_L9_bool_binop_done:; if (__pyx_t_2) { - /* "View.MemoryView":834 + /* "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, 834, __pyx_L1_error) + __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Step may not be zero (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 833, __pyx_L1_error) - /* "View.MemoryView":833 + /* "View.MemoryView":832 * negative_step = have_step != 0 and step < 0 * * if have_step and step == 0: # <<<<<<<<<<<<<< @@ -11126,7 +10207,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ } - /* "View.MemoryView":837 + /* "View.MemoryView":836 * * * if have_start: # <<<<<<<<<<<<<< @@ -11136,7 +10217,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = (__pyx_v_have_start != 0); if (__pyx_t_2) { - /* "View.MemoryView":838 + /* "View.MemoryView":837 * * if have_start: * if start < 0: # <<<<<<<<<<<<<< @@ -11146,7 +10227,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = ((__pyx_v_start < 0) != 0); if (__pyx_t_2) { - /* "View.MemoryView":839 + /* "View.MemoryView":838 * if have_start: * if start < 0: * start += shape # <<<<<<<<<<<<<< @@ -11155,7 +10236,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_start = (__pyx_v_start + __pyx_v_shape); - /* "View.MemoryView":840 + /* "View.MemoryView":839 * if start < 0: * start += shape * if start < 0: # <<<<<<<<<<<<<< @@ -11165,7 +10246,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = ((__pyx_v_start < 0) != 0); if (__pyx_t_2) { - /* "View.MemoryView":841 + /* "View.MemoryView":840 * start += shape * if start < 0: * start = 0 # <<<<<<<<<<<<<< @@ -11174,7 +10255,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_start = 0; - /* "View.MemoryView":840 + /* "View.MemoryView":839 * if start < 0: * start += shape * if start < 0: # <<<<<<<<<<<<<< @@ -11183,7 +10264,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ } - /* "View.MemoryView":838 + /* "View.MemoryView":837 * * if have_start: * if start < 0: # <<<<<<<<<<<<<< @@ -11193,7 +10274,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, goto __pyx_L12; } - /* "View.MemoryView":842 + /* "View.MemoryView":841 * if start < 0: * start = 0 * elif start >= shape: # <<<<<<<<<<<<<< @@ -11203,7 +10284,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = ((__pyx_v_start >= __pyx_v_shape) != 0); if (__pyx_t_2) { - /* "View.MemoryView":843 + /* "View.MemoryView":842 * start = 0 * elif start >= shape: * if negative_step: # <<<<<<<<<<<<<< @@ -11213,7 +10294,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = (__pyx_v_negative_step != 0); if (__pyx_t_2) { - /* "View.MemoryView":844 + /* "View.MemoryView":843 * elif start >= shape: * if negative_step: * start = shape - 1 # <<<<<<<<<<<<<< @@ -11222,7 +10303,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_start = (__pyx_v_shape - 1); - /* "View.MemoryView":843 + /* "View.MemoryView":842 * start = 0 * elif start >= shape: * if negative_step: # <<<<<<<<<<<<<< @@ -11232,7 +10313,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, goto __pyx_L14; } - /* "View.MemoryView":846 + /* "View.MemoryView":845 * start = shape - 1 * else: * start = shape # <<<<<<<<<<<<<< @@ -11244,7 +10325,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, } __pyx_L14:; - /* "View.MemoryView":842 + /* "View.MemoryView":841 * if start < 0: * start = 0 * elif start >= shape: # <<<<<<<<<<<<<< @@ -11254,7 +10335,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, } __pyx_L12:; - /* "View.MemoryView":837 + /* "View.MemoryView":836 * * * if have_start: # <<<<<<<<<<<<<< @@ -11264,7 +10345,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, goto __pyx_L11; } - /* "View.MemoryView":848 + /* "View.MemoryView":847 * start = shape * else: * if negative_step: # <<<<<<<<<<<<<< @@ -11275,7 +10356,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = (__pyx_v_negative_step != 0); if (__pyx_t_2) { - /* "View.MemoryView":849 + /* "View.MemoryView":848 * else: * if negative_step: * start = shape - 1 # <<<<<<<<<<<<<< @@ -11284,7 +10365,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_start = (__pyx_v_shape - 1); - /* "View.MemoryView":848 + /* "View.MemoryView":847 * start = shape * else: * if negative_step: # <<<<<<<<<<<<<< @@ -11294,7 +10375,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, goto __pyx_L15; } - /* "View.MemoryView":851 + /* "View.MemoryView":850 * start = shape - 1 * else: * start = 0 # <<<<<<<<<<<<<< @@ -11308,7 +10389,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, } __pyx_L11:; - /* "View.MemoryView":853 + /* "View.MemoryView":852 * start = 0 * * if have_stop: # <<<<<<<<<<<<<< @@ -11318,7 +10399,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = (__pyx_v_have_stop != 0); if (__pyx_t_2) { - /* "View.MemoryView":854 + /* "View.MemoryView":853 * * if have_stop: * if stop < 0: # <<<<<<<<<<<<<< @@ -11328,7 +10409,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = ((__pyx_v_stop < 0) != 0); if (__pyx_t_2) { - /* "View.MemoryView":855 + /* "View.MemoryView":854 * if have_stop: * if stop < 0: * stop += shape # <<<<<<<<<<<<<< @@ -11337,7 +10418,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_stop = (__pyx_v_stop + __pyx_v_shape); - /* "View.MemoryView":856 + /* "View.MemoryView":855 * if stop < 0: * stop += shape * if stop < 0: # <<<<<<<<<<<<<< @@ -11347,7 +10428,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = ((__pyx_v_stop < 0) != 0); if (__pyx_t_2) { - /* "View.MemoryView":857 + /* "View.MemoryView":856 * stop += shape * if stop < 0: * stop = 0 # <<<<<<<<<<<<<< @@ -11356,7 +10437,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_stop = 0; - /* "View.MemoryView":856 + /* "View.MemoryView":855 * if stop < 0: * stop += shape * if stop < 0: # <<<<<<<<<<<<<< @@ -11365,7 +10446,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ } - /* "View.MemoryView":854 + /* "View.MemoryView":853 * * if have_stop: * if stop < 0: # <<<<<<<<<<<<<< @@ -11375,7 +10456,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, goto __pyx_L17; } - /* "View.MemoryView":858 + /* "View.MemoryView":857 * if stop < 0: * stop = 0 * elif stop > shape: # <<<<<<<<<<<<<< @@ -11385,7 +10466,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = ((__pyx_v_stop > __pyx_v_shape) != 0); if (__pyx_t_2) { - /* "View.MemoryView":859 + /* "View.MemoryView":858 * stop = 0 * elif stop > shape: * stop = shape # <<<<<<<<<<<<<< @@ -11394,7 +10475,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_stop = __pyx_v_shape; - /* "View.MemoryView":858 + /* "View.MemoryView":857 * if stop < 0: * stop = 0 * elif stop > shape: # <<<<<<<<<<<<<< @@ -11404,7 +10485,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, } __pyx_L17:; - /* "View.MemoryView":853 + /* "View.MemoryView":852 * start = 0 * * if have_stop: # <<<<<<<<<<<<<< @@ -11414,7 +10495,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, goto __pyx_L16; } - /* "View.MemoryView":861 + /* "View.MemoryView":860 * stop = shape * else: * if negative_step: # <<<<<<<<<<<<<< @@ -11425,7 +10506,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = (__pyx_v_negative_step != 0); if (__pyx_t_2) { - /* "View.MemoryView":862 + /* "View.MemoryView":861 * else: * if negative_step: * stop = -1 # <<<<<<<<<<<<<< @@ -11434,7 +10515,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_stop = -1L; - /* "View.MemoryView":861 + /* "View.MemoryView":860 * stop = shape * else: * if negative_step: # <<<<<<<<<<<<<< @@ -11444,7 +10525,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, goto __pyx_L19; } - /* "View.MemoryView":864 + /* "View.MemoryView":863 * stop = -1 * else: * stop = shape # <<<<<<<<<<<<<< @@ -11458,7 +10539,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, } __pyx_L16:; - /* "View.MemoryView":866 + /* "View.MemoryView":865 * stop = shape * * if not have_step: # <<<<<<<<<<<<<< @@ -11468,7 +10549,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = ((!(__pyx_v_have_step != 0)) != 0); if (__pyx_t_2) { - /* "View.MemoryView":867 + /* "View.MemoryView":866 * * if not have_step: * step = 1 # <<<<<<<<<<<<<< @@ -11477,7 +10558,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_step = 1; - /* "View.MemoryView":866 + /* "View.MemoryView":865 * stop = shape * * if not have_step: # <<<<<<<<<<<<<< @@ -11486,7 +10567,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ } - /* "View.MemoryView":871 + /* "View.MemoryView":870 * * with cython.cdivision(True): * new_shape = (stop - start) // step # <<<<<<<<<<<<<< @@ -11495,7 +10576,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_new_shape = ((__pyx_v_stop - __pyx_v_start) / __pyx_v_step); - /* "View.MemoryView":873 + /* "View.MemoryView":872 * new_shape = (stop - start) // step * * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< @@ -11505,7 +10586,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = (((__pyx_v_stop - __pyx_v_start) - (__pyx_v_step * __pyx_v_new_shape)) != 0); if (__pyx_t_2) { - /* "View.MemoryView":874 + /* "View.MemoryView":873 * * if (stop - start) - step * new_shape: * new_shape += 1 # <<<<<<<<<<<<<< @@ -11514,7 +10595,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_new_shape = (__pyx_v_new_shape + 1); - /* "View.MemoryView":873 + /* "View.MemoryView":872 * new_shape = (stop - start) // step * * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< @@ -11523,7 +10604,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ } - /* "View.MemoryView":876 + /* "View.MemoryView":875 * new_shape += 1 * * if new_shape < 0: # <<<<<<<<<<<<<< @@ -11533,7 +10614,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = ((__pyx_v_new_shape < 0) != 0); if (__pyx_t_2) { - /* "View.MemoryView":877 + /* "View.MemoryView":876 * * if new_shape < 0: * new_shape = 0 # <<<<<<<<<<<<<< @@ -11542,7 +10623,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_new_shape = 0; - /* "View.MemoryView":876 + /* "View.MemoryView":875 * new_shape += 1 * * if new_shape < 0: # <<<<<<<<<<<<<< @@ -11551,7 +10632,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ } - /* "View.MemoryView":880 + /* "View.MemoryView":879 * * * dst.strides[new_ndim] = stride * step # <<<<<<<<<<<<<< @@ -11560,7 +10641,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ (__pyx_v_dst->strides[__pyx_v_new_ndim]) = (__pyx_v_stride * __pyx_v_step); - /* "View.MemoryView":881 + /* "View.MemoryView":880 * * dst.strides[new_ndim] = stride * step * dst.shape[new_ndim] = new_shape # <<<<<<<<<<<<<< @@ -11569,7 +10650,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ (__pyx_v_dst->shape[__pyx_v_new_ndim]) = __pyx_v_new_shape; - /* "View.MemoryView":882 + /* "View.MemoryView":881 * dst.strides[new_ndim] = stride * step * dst.shape[new_ndim] = new_shape * dst.suboffsets[new_ndim] = suboffset # <<<<<<<<<<<<<< @@ -11580,7 +10661,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, } __pyx_L3:; - /* "View.MemoryView":885 + /* "View.MemoryView":884 * * * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< @@ -11590,7 +10671,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = (((__pyx_v_suboffset_dim[0]) < 0) != 0); if (__pyx_t_2) { - /* "View.MemoryView":886 + /* "View.MemoryView":885 * * if suboffset_dim[0] < 0: * dst.data += start * stride # <<<<<<<<<<<<<< @@ -11599,7 +10680,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_dst->data = (__pyx_v_dst->data + (__pyx_v_start * __pyx_v_stride)); - /* "View.MemoryView":885 + /* "View.MemoryView":884 * * * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< @@ -11609,7 +10690,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, goto __pyx_L23; } - /* "View.MemoryView":888 + /* "View.MemoryView":887 * dst.data += start * stride * else: * dst.suboffsets[suboffset_dim[0]] += start * stride # <<<<<<<<<<<<<< @@ -11622,7 +10703,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, } __pyx_L23:; - /* "View.MemoryView":890 + /* "View.MemoryView":889 * dst.suboffsets[suboffset_dim[0]] += start * stride * * if suboffset >= 0: # <<<<<<<<<<<<<< @@ -11632,7 +10713,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0); if (__pyx_t_2) { - /* "View.MemoryView":891 + /* "View.MemoryView":890 * * if suboffset >= 0: * if not is_slice: # <<<<<<<<<<<<<< @@ -11642,7 +10723,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = ((!(__pyx_v_is_slice != 0)) != 0); if (__pyx_t_2) { - /* "View.MemoryView":892 + /* "View.MemoryView":891 * if suboffset >= 0: * if not is_slice: * if new_ndim == 0: # <<<<<<<<<<<<<< @@ -11652,7 +10733,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_t_2 = ((__pyx_v_new_ndim == 0) != 0); if (__pyx_t_2) { - /* "View.MemoryView":893 + /* "View.MemoryView":892 * if not is_slice: * if new_ndim == 0: * dst.data = ( dst.data)[0] + suboffset # <<<<<<<<<<<<<< @@ -11661,7 +10742,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ __pyx_v_dst->data = ((((char **)__pyx_v_dst->data)[0]) + __pyx_v_suboffset); - /* "View.MemoryView":892 + /* "View.MemoryView":891 * if suboffset >= 0: * if not is_slice: * if new_ndim == 0: # <<<<<<<<<<<<<< @@ -11671,7 +10752,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, goto __pyx_L26; } - /* "View.MemoryView":895 + /* "View.MemoryView":894 * dst.data = ( dst.data)[0] + suboffset * else: * _err_dim(IndexError, "All dimensions preceding dimension %d " # <<<<<<<<<<<<<< @@ -11680,18 +10761,18 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ /*else*/ { - /* "View.MemoryView":896 + /* "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, 895, __pyx_L1_error) + __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"All dimensions preceding dimension %d must be indexed and not sliced"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 894, __pyx_L1_error) } __pyx_L26:; - /* "View.MemoryView":891 + /* "View.MemoryView":890 * * if suboffset >= 0: * if not is_slice: # <<<<<<<<<<<<<< @@ -11701,7 +10782,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, goto __pyx_L25; } - /* "View.MemoryView":898 + /* "View.MemoryView":897 * "must be indexed and not sliced", dim) * else: * suboffset_dim[0] = new_ndim # <<<<<<<<<<<<<< @@ -11713,7 +10794,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, } __pyx_L25:; - /* "View.MemoryView":890 + /* "View.MemoryView":889 * dst.suboffsets[suboffset_dim[0]] += start * stride * * if suboffset >= 0: # <<<<<<<<<<<<<< @@ -11722,7 +10803,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, */ } - /* "View.MemoryView":900 + /* "View.MemoryView":899 * suboffset_dim[0] = new_ndim * * return 0 # <<<<<<<<<<<<<< @@ -11732,7 +10813,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, __pyx_r = 0; goto __pyx_L0; - /* "View.MemoryView":803 + /* "View.MemoryView":802 * * @cname('__pyx_memoryview_slice_memviewslice') * cdef int slice_memviewslice( # <<<<<<<<<<<<<< @@ -11756,7 +10837,7 @@ static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, return __pyx_r; } -/* "View.MemoryView":906 +/* "View.MemoryView":905 * * @cname('__pyx_pybuffer_index') * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<< @@ -11778,7 +10859,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P PyObject *__pyx_t_4 = NULL; __Pyx_RefNannySetupContext("pybuffer_index", 0); - /* "View.MemoryView":908 + /* "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 # <<<<<<<<<<<<<< @@ -11787,7 +10868,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ __pyx_v_suboffset = -1L; - /* "View.MemoryView":909 + /* "View.MemoryView":908 * Py_ssize_t dim) except NULL: * cdef Py_ssize_t shape, stride, suboffset = -1 * cdef Py_ssize_t itemsize = view.itemsize # <<<<<<<<<<<<<< @@ -11797,7 +10878,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P __pyx_t_1 = __pyx_v_view->itemsize; __pyx_v_itemsize = __pyx_t_1; - /* "View.MemoryView":912 + /* "View.MemoryView":911 * cdef char *resultp * * if view.ndim == 0: # <<<<<<<<<<<<<< @@ -11807,7 +10888,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P __pyx_t_2 = ((__pyx_v_view->ndim == 0) != 0); if (__pyx_t_2) { - /* "View.MemoryView":913 + /* "View.MemoryView":912 * * if view.ndim == 0: * shape = view.len / itemsize # <<<<<<<<<<<<<< @@ -11816,15 +10897,15 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ if (unlikely(__pyx_v_itemsize == 0)) { PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); - __PYX_ERR(1, 913, __pyx_L1_error) + __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, 913, __pyx_L1_error) + __PYX_ERR(1, 912, __pyx_L1_error) } __pyx_v_shape = (__pyx_v_view->len / __pyx_v_itemsize); - /* "View.MemoryView":914 + /* "View.MemoryView":913 * if view.ndim == 0: * shape = view.len / itemsize * stride = itemsize # <<<<<<<<<<<<<< @@ -11833,7 +10914,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ __pyx_v_stride = __pyx_v_itemsize; - /* "View.MemoryView":912 + /* "View.MemoryView":911 * cdef char *resultp * * if view.ndim == 0: # <<<<<<<<<<<<<< @@ -11843,7 +10924,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P goto __pyx_L3; } - /* "View.MemoryView":916 + /* "View.MemoryView":915 * stride = itemsize * else: * shape = view.shape[dim] # <<<<<<<<<<<<<< @@ -11853,7 +10934,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P /*else*/ { __pyx_v_shape = (__pyx_v_view->shape[__pyx_v_dim]); - /* "View.MemoryView":917 + /* "View.MemoryView":916 * else: * shape = view.shape[dim] * stride = view.strides[dim] # <<<<<<<<<<<<<< @@ -11862,7 +10943,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ __pyx_v_stride = (__pyx_v_view->strides[__pyx_v_dim]); - /* "View.MemoryView":918 + /* "View.MemoryView":917 * shape = view.shape[dim] * stride = view.strides[dim] * if view.suboffsets != NULL: # <<<<<<<<<<<<<< @@ -11872,7 +10953,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P __pyx_t_2 = ((__pyx_v_view->suboffsets != NULL) != 0); if (__pyx_t_2) { - /* "View.MemoryView":919 + /* "View.MemoryView":918 * stride = view.strides[dim] * if view.suboffsets != NULL: * suboffset = view.suboffsets[dim] # <<<<<<<<<<<<<< @@ -11881,7 +10962,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ __pyx_v_suboffset = (__pyx_v_view->suboffsets[__pyx_v_dim]); - /* "View.MemoryView":918 + /* "View.MemoryView":917 * shape = view.shape[dim] * stride = view.strides[dim] * if view.suboffsets != NULL: # <<<<<<<<<<<<<< @@ -11892,7 +10973,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P } __pyx_L3:; - /* "View.MemoryView":921 + /* "View.MemoryView":920 * suboffset = view.suboffsets[dim] * * if index < 0: # <<<<<<<<<<<<<< @@ -11902,7 +10983,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P __pyx_t_2 = ((__pyx_v_index < 0) != 0); if (__pyx_t_2) { - /* "View.MemoryView":922 + /* "View.MemoryView":921 * * if index < 0: * index += view.shape[dim] # <<<<<<<<<<<<<< @@ -11911,7 +10992,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ __pyx_v_index = (__pyx_v_index + (__pyx_v_view->shape[__pyx_v_dim])); - /* "View.MemoryView":923 + /* "View.MemoryView":922 * if index < 0: * index += view.shape[dim] * if index < 0: # <<<<<<<<<<<<<< @@ -11921,26 +11002,26 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P __pyx_t_2 = ((__pyx_v_index < 0) != 0); if (unlikely(__pyx_t_2)) { - /* "View.MemoryView":924 + /* "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, 924, __pyx_L1_error) + __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, 924, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(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, 924, __pyx_L1_error) + __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, 924, __pyx_L1_error) + __PYX_ERR(1, 923, __pyx_L1_error) - /* "View.MemoryView":923 + /* "View.MemoryView":922 * if index < 0: * index += view.shape[dim] * if index < 0: # <<<<<<<<<<<<<< @@ -11949,7 +11030,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ } - /* "View.MemoryView":921 + /* "View.MemoryView":920 * suboffset = view.suboffsets[dim] * * if index < 0: # <<<<<<<<<<<<<< @@ -11958,7 +11039,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ } - /* "View.MemoryView":926 + /* "View.MemoryView":925 * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) * * if index >= shape: # <<<<<<<<<<<<<< @@ -11968,26 +11049,26 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P __pyx_t_2 = ((__pyx_v_index >= __pyx_v_shape) != 0); if (unlikely(__pyx_t_2)) { - /* "View.MemoryView":927 + /* "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, 927, __pyx_L1_error) + __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, 927, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(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, 927, __pyx_L1_error) + __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, 927, __pyx_L1_error) + __PYX_ERR(1, 926, __pyx_L1_error) - /* "View.MemoryView":926 + /* "View.MemoryView":925 * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) * * if index >= shape: # <<<<<<<<<<<<<< @@ -11996,7 +11077,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ } - /* "View.MemoryView":929 + /* "View.MemoryView":928 * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) * * resultp = bufp + index * stride # <<<<<<<<<<<<<< @@ -12005,7 +11086,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ __pyx_v_resultp = (__pyx_v_bufp + (__pyx_v_index * __pyx_v_stride)); - /* "View.MemoryView":930 + /* "View.MemoryView":929 * * resultp = bufp + index * stride * if suboffset >= 0: # <<<<<<<<<<<<<< @@ -12015,7 +11096,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0); if (__pyx_t_2) { - /* "View.MemoryView":931 + /* "View.MemoryView":930 * resultp = bufp + index * stride * if suboffset >= 0: * resultp = ( resultp)[0] + suboffset # <<<<<<<<<<<<<< @@ -12024,7 +11105,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ __pyx_v_resultp = ((((char **)__pyx_v_resultp)[0]) + __pyx_v_suboffset); - /* "View.MemoryView":930 + /* "View.MemoryView":929 * * resultp = bufp + index * stride * if suboffset >= 0: # <<<<<<<<<<<<<< @@ -12033,7 +11114,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P */ } - /* "View.MemoryView":933 + /* "View.MemoryView":932 * resultp = ( resultp)[0] + suboffset * * return resultp # <<<<<<<<<<<<<< @@ -12043,7 +11124,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P __pyx_r = __pyx_v_resultp; goto __pyx_L0; - /* "View.MemoryView":906 + /* "View.MemoryView":905 * * @cname('__pyx_pybuffer_index') * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<< @@ -12062,7 +11143,7 @@ static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, P return __pyx_r; } -/* "View.MemoryView":939 +/* "View.MemoryView":938 * * @cname('__pyx_memslice_transpose') * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< @@ -12087,7 +11168,7 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { int __pyx_t_8; int __pyx_t_9; - /* "View.MemoryView":940 + /* "View.MemoryView":939 * @cname('__pyx_memslice_transpose') * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: * cdef int ndim = memslice.memview.view.ndim # <<<<<<<<<<<<<< @@ -12097,7 +11178,7 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { __pyx_t_1 = __pyx_v_memslice->memview->view.ndim; __pyx_v_ndim = __pyx_t_1; - /* "View.MemoryView":942 + /* "View.MemoryView":941 * cdef int ndim = memslice.memview.view.ndim * * cdef Py_ssize_t *shape = memslice.shape # <<<<<<<<<<<<<< @@ -12107,7 +11188,7 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { __pyx_t_2 = __pyx_v_memslice->shape; __pyx_v_shape = __pyx_t_2; - /* "View.MemoryView":943 + /* "View.MemoryView":942 * * cdef Py_ssize_t *shape = memslice.shape * cdef Py_ssize_t *strides = memslice.strides # <<<<<<<<<<<<<< @@ -12117,7 +11198,7 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { __pyx_t_2 = __pyx_v_memslice->strides; __pyx_v_strides = __pyx_t_2; - /* "View.MemoryView":947 + /* "View.MemoryView":946 * * cdef int i, j * for i in range(ndim / 2): # <<<<<<<<<<<<<< @@ -12129,7 +11210,7 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { for (__pyx_t_1 = 0; __pyx_t_1 < __pyx_t_4; __pyx_t_1+=1) { __pyx_v_i = __pyx_t_1; - /* "View.MemoryView":948 + /* "View.MemoryView":947 * cdef int i, j * for i in range(ndim / 2): * j = ndim - 1 - i # <<<<<<<<<<<<<< @@ -12138,7 +11219,7 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { */ __pyx_v_j = ((__pyx_v_ndim - 1) - __pyx_v_i); - /* "View.MemoryView":949 + /* "View.MemoryView":948 * for i in range(ndim / 2): * j = ndim - 1 - i * strides[i], strides[j] = strides[j], strides[i] # <<<<<<<<<<<<<< @@ -12150,7 +11231,7 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { (__pyx_v_strides[__pyx_v_i]) = __pyx_t_5; (__pyx_v_strides[__pyx_v_j]) = __pyx_t_6; - /* "View.MemoryView":950 + /* "View.MemoryView":949 * j = ndim - 1 - i * strides[i], strides[j] = strides[j], strides[i] * shape[i], shape[j] = shape[j], shape[i] # <<<<<<<<<<<<<< @@ -12162,7 +11243,7 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { (__pyx_v_shape[__pyx_v_i]) = __pyx_t_6; (__pyx_v_shape[__pyx_v_j]) = __pyx_t_5; - /* "View.MemoryView":952 + /* "View.MemoryView":951 * shape[i], shape[j] = shape[j], shape[i] * * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< @@ -12180,16 +11261,16 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { __pyx_L6_bool_binop_done:; if (__pyx_t_7) { - /* "View.MemoryView":953 + /* "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, 953, __pyx_L1_error) + __pyx_t_9 = __pyx_memoryview_err(__pyx_builtin_ValueError, ((char *)"Cannot transpose memoryview with indirect dimensions")); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 952, __pyx_L1_error) - /* "View.MemoryView":952 + /* "View.MemoryView":951 * shape[i], shape[j] = shape[j], shape[i] * * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< @@ -12199,7 +11280,7 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { } } - /* "View.MemoryView":955 + /* "View.MemoryView":954 * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") * * return 1 # <<<<<<<<<<<<<< @@ -12209,7 +11290,7 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { __pyx_r = 1; goto __pyx_L0; - /* "View.MemoryView":939 + /* "View.MemoryView":938 * * @cname('__pyx_memslice_transpose') * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< @@ -12233,7 +11314,7 @@ static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { return __pyx_r; } -/* "View.MemoryView":972 +/* "View.MemoryView":971 * cdef int (*to_dtype_func)(char *, object) except 0 * * def __dealloc__(self): # <<<<<<<<<<<<<< @@ -12256,7 +11337,7 @@ static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewsl __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__", 0); - /* "View.MemoryView":973 + /* "View.MemoryView":972 * * def __dealloc__(self): * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) # <<<<<<<<<<<<<< @@ -12265,7 +11346,7 @@ static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewsl */ __PYX_XDEC_MEMVIEW((&__pyx_v_self->from_slice), 1); - /* "View.MemoryView":972 + /* "View.MemoryView":971 * cdef int (*to_dtype_func)(char *, object) except 0 * * def __dealloc__(self): # <<<<<<<<<<<<<< @@ -12277,7 +11358,7 @@ static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewsl __Pyx_RefNannyFinishContext(); } -/* "View.MemoryView":975 +/* "View.MemoryView":974 * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) * * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< @@ -12292,7 +11373,7 @@ static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memor PyObject *__pyx_t_2 = NULL; __Pyx_RefNannySetupContext("convert_item_to_object", 0); - /* "View.MemoryView":976 + /* "View.MemoryView":975 * * cdef convert_item_to_object(self, char *itemp): * if self.to_object_func != NULL: # <<<<<<<<<<<<<< @@ -12302,7 +11383,7 @@ static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memor __pyx_t_1 = ((__pyx_v_self->to_object_func != NULL) != 0); if (__pyx_t_1) { - /* "View.MemoryView":977 + /* "View.MemoryView":976 * cdef convert_item_to_object(self, char *itemp): * if self.to_object_func != NULL: * return self.to_object_func(itemp) # <<<<<<<<<<<<<< @@ -12310,13 +11391,13 @@ static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memor * return memoryview.convert_item_to_object(self, itemp) */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __pyx_v_self->to_object_func(__pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 977, __pyx_L1_error) + __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":976 + /* "View.MemoryView":975 * * cdef convert_item_to_object(self, char *itemp): * if self.to_object_func != NULL: # <<<<<<<<<<<<<< @@ -12325,7 +11406,7 @@ static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memor */ } - /* "View.MemoryView":979 + /* "View.MemoryView":978 * return self.to_object_func(itemp) * else: * return memoryview.convert_item_to_object(self, itemp) # <<<<<<<<<<<<<< @@ -12334,14 +11415,14 @@ static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memor */ /*else*/ { __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __pyx_memoryview_convert_item_to_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 979, __pyx_L1_error) + __pyx_t_2 = __pyx_memoryview_convert_item_to_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 978, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; } - /* "View.MemoryView":975 + /* "View.MemoryView":974 * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) * * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< @@ -12360,7 +11441,7 @@ static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memor return __pyx_r; } -/* "View.MemoryView":981 +/* "View.MemoryView":980 * return memoryview.convert_item_to_object(self, itemp) * * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< @@ -12376,7 +11457,7 @@ static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memo PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("assign_item_from_object", 0); - /* "View.MemoryView":982 + /* "View.MemoryView":981 * * cdef assign_item_from_object(self, char *itemp, object value): * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< @@ -12386,16 +11467,16 @@ static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memo __pyx_t_1 = ((__pyx_v_self->to_dtype_func != NULL) != 0); if (__pyx_t_1) { - /* "View.MemoryView":983 + /* "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, 983, __pyx_L1_error) + __pyx_t_2 = __pyx_v_self->to_dtype_func(__pyx_v_itemp, __pyx_v_value); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(1, 982, __pyx_L1_error) - /* "View.MemoryView":982 + /* "View.MemoryView":981 * * cdef assign_item_from_object(self, char *itemp, object value): * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< @@ -12405,7 +11486,7 @@ static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memo goto __pyx_L3; } - /* "View.MemoryView":985 + /* "View.MemoryView":984 * self.to_dtype_func(itemp, value) * else: * memoryview.assign_item_from_object(self, itemp, value) # <<<<<<<<<<<<<< @@ -12413,13 +11494,13 @@ static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memo * @property */ /*else*/ { - __pyx_t_3 = __pyx_memoryview_assign_item_from_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 985, __pyx_L1_error) + __pyx_t_3 = __pyx_memoryview_assign_item_from_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 984, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_L3:; - /* "View.MemoryView":981 + /* "View.MemoryView":980 * return memoryview.convert_item_to_object(self, itemp) * * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< @@ -12440,7 +11521,7 @@ static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memo return __pyx_r; } -/* "View.MemoryView":988 +/* "View.MemoryView":987 * * @property * def base(self): # <<<<<<<<<<<<<< @@ -12466,7 +11547,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__ __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); - /* "View.MemoryView":989 + /* "View.MemoryView":988 * @property * def base(self): * return self.from_object # <<<<<<<<<<<<<< @@ -12478,7 +11559,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__ __pyx_r = __pyx_v_self->from_object; goto __pyx_L0; - /* "View.MemoryView":988 + /* "View.MemoryView":987 * * @property * def base(self): # <<<<<<<<<<<<<< @@ -12524,7 +11605,7 @@ static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __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; @@ -12577,7 +11658,7 @@ static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUS * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __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; @@ -12600,7 +11681,7 @@ static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUS return __pyx_r; } -/* "View.MemoryView":995 +/* "View.MemoryView":994 * * @cname('__pyx_memoryview_fromslice') * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< @@ -12625,7 +11706,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl Py_ssize_t __pyx_t_9; __Pyx_RefNannySetupContext("memoryview_fromslice", 0); - /* "View.MemoryView":1003 + /* "View.MemoryView":1002 * cdef _memoryviewslice result * * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< @@ -12635,7 +11716,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __pyx_t_1 = ((((PyObject *)__pyx_v_memviewslice.memview) == Py_None) != 0); if (__pyx_t_1) { - /* "View.MemoryView":1004 + /* "View.MemoryView":1003 * * if memviewslice.memview == Py_None: * return None # <<<<<<<<<<<<<< @@ -12646,7 +11727,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "View.MemoryView":1003 + /* "View.MemoryView":1002 * cdef _memoryviewslice result * * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< @@ -12655,16 +11736,16 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ } - /* "View.MemoryView":1009 + /* "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, 1009, __pyx_L1_error) + __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, 1009, __pyx_L1_error) + __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); @@ -12675,13 +11756,13 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryviewslice_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1009, __pyx_L1_error) + __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":1011 + /* "View.MemoryView":1010 * result = _memoryviewslice(None, 0, dtype_is_object) * * result.from_slice = memviewslice # <<<<<<<<<<<<<< @@ -12690,7 +11771,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ __pyx_v_result->from_slice = __pyx_v_memviewslice; - /* "View.MemoryView":1012 + /* "View.MemoryView":1011 * * result.from_slice = memviewslice * __PYX_INC_MEMVIEW(&memviewslice, 1) # <<<<<<<<<<<<<< @@ -12699,14 +11780,14 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ __PYX_INC_MEMVIEW((&__pyx_v_memviewslice), 1); - /* "View.MemoryView":1014 + /* "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, 1014, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_memviewslice.memview), __pyx_n_s_base); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1013, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_v_result->from_object); @@ -12714,7 +11795,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __pyx_v_result->from_object = __pyx_t_2; __pyx_t_2 = 0; - /* "View.MemoryView":1015 + /* "View.MemoryView":1014 * * result.from_object = ( memviewslice.memview).base * result.typeinfo = memviewslice.memview.typeinfo # <<<<<<<<<<<<<< @@ -12724,7 +11805,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __pyx_t_4 = __pyx_v_memviewslice.memview->typeinfo; __pyx_v_result->__pyx_base.typeinfo = __pyx_t_4; - /* "View.MemoryView":1017 + /* "View.MemoryView":1016 * result.typeinfo = memviewslice.memview.typeinfo * * result.view = memviewslice.memview.view # <<<<<<<<<<<<<< @@ -12734,7 +11815,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __pyx_t_5 = __pyx_v_memviewslice.memview->view; __pyx_v_result->__pyx_base.view = __pyx_t_5; - /* "View.MemoryView":1018 + /* "View.MemoryView":1017 * * result.view = memviewslice.memview.view * result.view.buf = memviewslice.data # <<<<<<<<<<<<<< @@ -12743,7 +11824,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ __pyx_v_result->__pyx_base.view.buf = ((void *)__pyx_v_memviewslice.data); - /* "View.MemoryView":1019 + /* "View.MemoryView":1018 * result.view = memviewslice.memview.view * result.view.buf = memviewslice.data * result.view.ndim = ndim # <<<<<<<<<<<<<< @@ -12752,7 +11833,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ __pyx_v_result->__pyx_base.view.ndim = __pyx_v_ndim; - /* "View.MemoryView":1020 + /* "View.MemoryView":1019 * result.view.buf = memviewslice.data * result.view.ndim = ndim * (<__pyx_buffer *> &result.view).obj = Py_None # <<<<<<<<<<<<<< @@ -12761,7 +11842,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ ((Py_buffer *)(&__pyx_v_result->__pyx_base.view))->obj = Py_None; - /* "View.MemoryView":1021 + /* "View.MemoryView":1020 * result.view.ndim = ndim * (<__pyx_buffer *> &result.view).obj = Py_None * Py_INCREF(Py_None) # <<<<<<<<<<<<<< @@ -12770,7 +11851,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ Py_INCREF(Py_None); - /* "View.MemoryView":1023 + /* "View.MemoryView":1022 * Py_INCREF(Py_None) * * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< @@ -12780,7 +11861,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __pyx_t_1 = ((((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->flags & PyBUF_WRITABLE) != 0); if (__pyx_t_1) { - /* "View.MemoryView":1024 + /* "View.MemoryView":1023 * * if (memviewslice.memview).flags & PyBUF_WRITABLE: * result.flags = PyBUF_RECORDS # <<<<<<<<<<<<<< @@ -12789,7 +11870,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS; - /* "View.MemoryView":1023 + /* "View.MemoryView":1022 * Py_INCREF(Py_None) * * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< @@ -12799,7 +11880,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl goto __pyx_L4; } - /* "View.MemoryView":1026 + /* "View.MemoryView":1025 * result.flags = PyBUF_RECORDS * else: * result.flags = PyBUF_RECORDS_RO # <<<<<<<<<<<<<< @@ -12811,7 +11892,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl } __pyx_L4:; - /* "View.MemoryView":1028 + /* "View.MemoryView":1027 * result.flags = PyBUF_RECORDS_RO * * result.view.shape = result.from_slice.shape # <<<<<<<<<<<<<< @@ -12820,7 +11901,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ __pyx_v_result->__pyx_base.view.shape = ((Py_ssize_t *)__pyx_v_result->from_slice.shape); - /* "View.MemoryView":1029 + /* "View.MemoryView":1028 * * result.view.shape = result.from_slice.shape * result.view.strides = result.from_slice.strides # <<<<<<<<<<<<<< @@ -12829,7 +11910,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ __pyx_v_result->__pyx_base.view.strides = ((Py_ssize_t *)__pyx_v_result->from_slice.strides); - /* "View.MemoryView":1032 + /* "View.MemoryView":1031 * * * result.view.suboffsets = NULL # <<<<<<<<<<<<<< @@ -12838,7 +11919,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ __pyx_v_result->__pyx_base.view.suboffsets = NULL; - /* "View.MemoryView":1033 + /* "View.MemoryView":1032 * * result.view.suboffsets = NULL * for suboffset in result.from_slice.suboffsets[:ndim]: # <<<<<<<<<<<<<< @@ -12850,7 +11931,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __pyx_t_6 = __pyx_t_8; __pyx_v_suboffset = (__pyx_t_6[0]); - /* "View.MemoryView":1034 + /* "View.MemoryView":1033 * result.view.suboffsets = NULL * for suboffset in result.from_slice.suboffsets[:ndim]: * if suboffset >= 0: # <<<<<<<<<<<<<< @@ -12860,7 +11941,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __pyx_t_1 = ((__pyx_v_suboffset >= 0) != 0); if (__pyx_t_1) { - /* "View.MemoryView":1035 + /* "View.MemoryView":1034 * for suboffset in result.from_slice.suboffsets[:ndim]: * if suboffset >= 0: * result.view.suboffsets = result.from_slice.suboffsets # <<<<<<<<<<<<<< @@ -12869,7 +11950,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ __pyx_v_result->__pyx_base.view.suboffsets = ((Py_ssize_t *)__pyx_v_result->from_slice.suboffsets); - /* "View.MemoryView":1036 + /* "View.MemoryView":1035 * if suboffset >= 0: * result.view.suboffsets = result.from_slice.suboffsets * break # <<<<<<<<<<<<<< @@ -12878,7 +11959,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ goto __pyx_L6_break; - /* "View.MemoryView":1034 + /* "View.MemoryView":1033 * result.view.suboffsets = NULL * for suboffset in result.from_slice.suboffsets[:ndim]: * if suboffset >= 0: # <<<<<<<<<<<<<< @@ -12889,7 +11970,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl } __pyx_L6_break:; - /* "View.MemoryView":1038 + /* "View.MemoryView":1037 * break * * result.view.len = result.view.itemsize # <<<<<<<<<<<<<< @@ -12899,7 +11980,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __pyx_t_9 = __pyx_v_result->__pyx_base.view.itemsize; __pyx_v_result->__pyx_base.view.len = __pyx_t_9; - /* "View.MemoryView":1039 + /* "View.MemoryView":1038 * * result.view.len = result.view.itemsize * for length in result.view.shape[:ndim]: # <<<<<<<<<<<<<< @@ -12909,29 +11990,29 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __pyx_t_7 = (__pyx_v_result->__pyx_base.view.shape + __pyx_v_ndim); for (__pyx_t_8 = __pyx_v_result->__pyx_base.view.shape; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) { __pyx_t_6 = __pyx_t_8; - __pyx_t_2 = PyInt_FromSsize_t((__pyx_t_6[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1039, __pyx_L1_error) + __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":1040 + /* "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, 1040, __pyx_L1_error) + __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, 1040, __pyx_L1_error) + __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, 1040, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(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":1042 + /* "View.MemoryView":1041 * result.view.len *= length * * result.to_object_func = to_object_func # <<<<<<<<<<<<<< @@ -12940,7 +12021,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ __pyx_v_result->to_object_func = __pyx_v_to_object_func; - /* "View.MemoryView":1043 + /* "View.MemoryView":1042 * * result.to_object_func = to_object_func * result.to_dtype_func = to_dtype_func # <<<<<<<<<<<<<< @@ -12949,7 +12030,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl */ __pyx_v_result->to_dtype_func = __pyx_v_to_dtype_func; - /* "View.MemoryView":1045 + /* "View.MemoryView":1044 * result.to_dtype_func = to_dtype_func * * return result # <<<<<<<<<<<<<< @@ -12961,7 +12042,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl __pyx_r = ((PyObject *)__pyx_v_result); goto __pyx_L0; - /* "View.MemoryView":995 + /* "View.MemoryView":994 * * @cname('__pyx_memoryview_fromslice') * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< @@ -12983,7 +12064,7 @@ static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewsl return __pyx_r; } -/* "View.MemoryView":1048 +/* "View.MemoryView":1047 * * @cname('__pyx_memoryview_get_slice_from_memoryview') * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< @@ -13000,7 +12081,7 @@ static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __p PyObject *__pyx_t_3 = NULL; __Pyx_RefNannySetupContext("get_slice_from_memview", 0); - /* "View.MemoryView":1051 + /* "View.MemoryView":1050 * __Pyx_memviewslice *mslice): * cdef _memoryviewslice obj * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< @@ -13011,20 +12092,20 @@ static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __p __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "View.MemoryView":1052 + /* "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, 1052, __pyx_L1_error) + 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":1053 + /* "View.MemoryView":1052 * if isinstance(memview, _memoryviewslice): * obj = memview * return &obj.from_slice # <<<<<<<<<<<<<< @@ -13034,7 +12115,7 @@ static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __p __pyx_r = (&__pyx_v_obj->from_slice); goto __pyx_L0; - /* "View.MemoryView":1051 + /* "View.MemoryView":1050 * __Pyx_memviewslice *mslice): * cdef _memoryviewslice obj * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< @@ -13043,7 +12124,7 @@ static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __p */ } - /* "View.MemoryView":1055 + /* "View.MemoryView":1054 * return &obj.from_slice * else: * slice_copy(memview, mslice) # <<<<<<<<<<<<<< @@ -13053,7 +12134,7 @@ static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __p /*else*/ { __pyx_memoryview_slice_copy(__pyx_v_memview, __pyx_v_mslice); - /* "View.MemoryView":1056 + /* "View.MemoryView":1055 * else: * slice_copy(memview, mslice) * return mslice # <<<<<<<<<<<<<< @@ -13064,7 +12145,7 @@ static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __p goto __pyx_L0; } - /* "View.MemoryView":1048 + /* "View.MemoryView":1047 * * @cname('__pyx_memoryview_get_slice_from_memoryview') * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< @@ -13083,7 +12164,7 @@ static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __p return __pyx_r; } -/* "View.MemoryView":1059 +/* "View.MemoryView":1058 * * @cname('__pyx_memoryview_slice_copy') * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< @@ -13104,7 +12185,7 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem Py_ssize_t __pyx_t_5; __Pyx_RefNannySetupContext("slice_copy", 0); - /* "View.MemoryView":1063 + /* "View.MemoryView":1062 * cdef (Py_ssize_t*) shape, strides, suboffsets * * shape = memview.view.shape # <<<<<<<<<<<<<< @@ -13114,7 +12195,7 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem __pyx_t_1 = __pyx_v_memview->view.shape; __pyx_v_shape = __pyx_t_1; - /* "View.MemoryView":1064 + /* "View.MemoryView":1063 * * shape = memview.view.shape * strides = memview.view.strides # <<<<<<<<<<<<<< @@ -13124,7 +12205,7 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem __pyx_t_1 = __pyx_v_memview->view.strides; __pyx_v_strides = __pyx_t_1; - /* "View.MemoryView":1065 + /* "View.MemoryView":1064 * shape = memview.view.shape * strides = memview.view.strides * suboffsets = memview.view.suboffsets # <<<<<<<<<<<<<< @@ -13134,7 +12215,7 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem __pyx_t_1 = __pyx_v_memview->view.suboffsets; __pyx_v_suboffsets = __pyx_t_1; - /* "View.MemoryView":1067 + /* "View.MemoryView":1066 * suboffsets = memview.view.suboffsets * * dst.memview = <__pyx_memoryview *> memview # <<<<<<<<<<<<<< @@ -13143,7 +12224,7 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem */ __pyx_v_dst->memview = ((struct __pyx_memoryview_obj *)__pyx_v_memview); - /* "View.MemoryView":1068 + /* "View.MemoryView":1067 * * dst.memview = <__pyx_memoryview *> memview * dst.data = memview.view.buf # <<<<<<<<<<<<<< @@ -13152,7 +12233,7 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem */ __pyx_v_dst->data = ((char *)__pyx_v_memview->view.buf); - /* "View.MemoryView":1070 + /* "View.MemoryView":1069 * dst.data = memview.view.buf * * for dim in range(memview.view.ndim): # <<<<<<<<<<<<<< @@ -13164,7 +12245,7 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_dim = __pyx_t_4; - /* "View.MemoryView":1071 + /* "View.MemoryView":1070 * * for dim in range(memview.view.ndim): * dst.shape[dim] = shape[dim] # <<<<<<<<<<<<<< @@ -13173,7 +12254,7 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem */ (__pyx_v_dst->shape[__pyx_v_dim]) = (__pyx_v_shape[__pyx_v_dim]); - /* "View.MemoryView":1072 + /* "View.MemoryView":1071 * for dim in range(memview.view.ndim): * dst.shape[dim] = shape[dim] * dst.strides[dim] = strides[dim] # <<<<<<<<<<<<<< @@ -13182,7 +12263,7 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem */ (__pyx_v_dst->strides[__pyx_v_dim]) = (__pyx_v_strides[__pyx_v_dim]); - /* "View.MemoryView":1073 + /* "View.MemoryView":1072 * dst.shape[dim] = shape[dim] * dst.strides[dim] = strides[dim] * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 # <<<<<<<<<<<<<< @@ -13197,7 +12278,7 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem (__pyx_v_dst->suboffsets[__pyx_v_dim]) = __pyx_t_5; } - /* "View.MemoryView":1059 + /* "View.MemoryView":1058 * * @cname('__pyx_memoryview_slice_copy') * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< @@ -13209,7 +12290,7 @@ static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_mem __Pyx_RefNannyFinishContext(); } -/* "View.MemoryView":1076 +/* "View.MemoryView":1075 * * @cname('__pyx_memoryview_copy_object') * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< @@ -13224,7 +12305,7 @@ static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx PyObject *__pyx_t_1 = NULL; __Pyx_RefNannySetupContext("memoryview_copy", 0); - /* "View.MemoryView":1079 + /* "View.MemoryView":1078 * "Create a new memoryview object" * cdef __Pyx_memviewslice memviewslice * slice_copy(memview, &memviewslice) # <<<<<<<<<<<<<< @@ -13233,7 +12314,7 @@ static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx */ __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_memviewslice)); - /* "View.MemoryView":1080 + /* "View.MemoryView":1079 * cdef __Pyx_memviewslice memviewslice * slice_copy(memview, &memviewslice) * return memoryview_copy_from_slice(memview, &memviewslice) # <<<<<<<<<<<<<< @@ -13241,13 +12322,13 @@ static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx * @cname('__pyx_memoryview_copy_object_from_slice') */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_memoryview_copy_object_from_slice(__pyx_v_memview, (&__pyx_v_memviewslice)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1080, __pyx_L1_error) + __pyx_t_1 = __pyx_memoryview_copy_object_from_slice(__pyx_v_memview, (&__pyx_v_memviewslice)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1079, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "View.MemoryView":1076 + /* "View.MemoryView":1075 * * @cname('__pyx_memoryview_copy_object') * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< @@ -13266,7 +12347,7 @@ static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx return __pyx_r; } -/* "View.MemoryView":1083 +/* "View.MemoryView":1082 * * @cname('__pyx_memoryview_copy_object_from_slice') * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< @@ -13286,7 +12367,7 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview PyObject *__pyx_t_5 = NULL; __Pyx_RefNannySetupContext("memoryview_copy_from_slice", 0); - /* "View.MemoryView":1090 + /* "View.MemoryView":1089 * cdef int (*to_dtype_func)(char *, object) except 0 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< @@ -13297,7 +12378,7 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "View.MemoryView":1091 + /* "View.MemoryView":1090 * * if isinstance(memview, _memoryviewslice): * to_object_func = (<_memoryviewslice> memview).to_object_func # <<<<<<<<<<<<<< @@ -13307,7 +12388,7 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview __pyx_t_3 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_object_func; __pyx_v_to_object_func = __pyx_t_3; - /* "View.MemoryView":1092 + /* "View.MemoryView":1091 * if isinstance(memview, _memoryviewslice): * to_object_func = (<_memoryviewslice> memview).to_object_func * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func # <<<<<<<<<<<<<< @@ -13317,7 +12398,7 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview __pyx_t_4 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_dtype_func; __pyx_v_to_dtype_func = __pyx_t_4; - /* "View.MemoryView":1090 + /* "View.MemoryView":1089 * cdef int (*to_dtype_func)(char *, object) except 0 * * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< @@ -13327,7 +12408,7 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview goto __pyx_L3; } - /* "View.MemoryView":1094 + /* "View.MemoryView":1093 * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func * else: * to_object_func = NULL # <<<<<<<<<<<<<< @@ -13337,7 +12418,7 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview /*else*/ { __pyx_v_to_object_func = NULL; - /* "View.MemoryView":1095 + /* "View.MemoryView":1094 * else: * to_object_func = NULL * to_dtype_func = NULL # <<<<<<<<<<<<<< @@ -13348,7 +12429,7 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview } __pyx_L3:; - /* "View.MemoryView":1097 + /* "View.MemoryView":1096 * to_dtype_func = NULL * * return memoryview_fromslice(memviewslice[0], memview.view.ndim, # <<<<<<<<<<<<<< @@ -13357,20 +12438,20 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview */ __Pyx_XDECREF(__pyx_r); - /* "View.MemoryView":1099 + /* "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, 1097, __pyx_L1_error) + __pyx_t_5 = __pyx_memoryview_fromslice((__pyx_v_memviewslice[0]), __pyx_v_memview->view.ndim, __pyx_v_to_object_func, __pyx_v_to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1096, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; - /* "View.MemoryView":1083 + /* "View.MemoryView":1082 * * @cname('__pyx_memoryview_copy_object_from_slice') * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< @@ -13389,7 +12470,7 @@ static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview return __pyx_r; } -/* "View.MemoryView":1105 +/* "View.MemoryView":1104 * * * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< @@ -13401,7 +12482,7 @@ static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { Py_ssize_t __pyx_r; int __pyx_t_1; - /* "View.MemoryView":1106 + /* "View.MemoryView":1105 * * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: * if arg < 0: # <<<<<<<<<<<<<< @@ -13411,7 +12492,7 @@ static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { __pyx_t_1 = ((__pyx_v_arg < 0) != 0); if (__pyx_t_1) { - /* "View.MemoryView":1107 + /* "View.MemoryView":1106 * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: * if arg < 0: * return -arg # <<<<<<<<<<<<<< @@ -13421,7 +12502,7 @@ static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { __pyx_r = (-__pyx_v_arg); goto __pyx_L0; - /* "View.MemoryView":1106 + /* "View.MemoryView":1105 * * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: * if arg < 0: # <<<<<<<<<<<<<< @@ -13430,7 +12511,7 @@ static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { */ } - /* "View.MemoryView":1109 + /* "View.MemoryView":1108 * return -arg * else: * return arg # <<<<<<<<<<<<<< @@ -13442,7 +12523,7 @@ static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { goto __pyx_L0; } - /* "View.MemoryView":1105 + /* "View.MemoryView":1104 * * * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< @@ -13455,7 +12536,7 @@ static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { return __pyx_r; } -/* "View.MemoryView":1112 +/* "View.MemoryView":1111 * * @cname('__pyx_get_best_slice_order') * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<< @@ -13473,7 +12554,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ int __pyx_t_3; int __pyx_t_4; - /* "View.MemoryView":1117 + /* "View.MemoryView":1116 * """ * cdef int i * cdef Py_ssize_t c_stride = 0 # <<<<<<<<<<<<<< @@ -13482,7 +12563,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ */ __pyx_v_c_stride = 0; - /* "View.MemoryView":1118 + /* "View.MemoryView":1117 * cdef int i * cdef Py_ssize_t c_stride = 0 * cdef Py_ssize_t f_stride = 0 # <<<<<<<<<<<<<< @@ -13491,7 +12572,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ */ __pyx_v_f_stride = 0; - /* "View.MemoryView":1120 + /* "View.MemoryView":1119 * cdef Py_ssize_t f_stride = 0 * * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< @@ -13501,7 +12582,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { __pyx_v_i = __pyx_t_1; - /* "View.MemoryView":1121 + /* "View.MemoryView":1120 * * for i in range(ndim - 1, -1, -1): * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< @@ -13511,7 +12592,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1122 + /* "View.MemoryView":1121 * for i in range(ndim - 1, -1, -1): * if mslice.shape[i] > 1: * c_stride = mslice.strides[i] # <<<<<<<<<<<<<< @@ -13520,7 +12601,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ */ __pyx_v_c_stride = (__pyx_v_mslice->strides[__pyx_v_i]); - /* "View.MemoryView":1123 + /* "View.MemoryView":1122 * if mslice.shape[i] > 1: * c_stride = mslice.strides[i] * break # <<<<<<<<<<<<<< @@ -13529,7 +12610,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ */ goto __pyx_L4_break; - /* "View.MemoryView":1121 + /* "View.MemoryView":1120 * * for i in range(ndim - 1, -1, -1): * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< @@ -13540,7 +12621,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ } __pyx_L4_break:; - /* "View.MemoryView":1125 + /* "View.MemoryView":1124 * break * * for i in range(ndim): # <<<<<<<<<<<<<< @@ -13552,7 +12633,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - /* "View.MemoryView":1126 + /* "View.MemoryView":1125 * * for i in range(ndim): * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< @@ -13562,7 +12643,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1127 + /* "View.MemoryView":1126 * for i in range(ndim): * if mslice.shape[i] > 1: * f_stride = mslice.strides[i] # <<<<<<<<<<<<<< @@ -13571,7 +12652,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ */ __pyx_v_f_stride = (__pyx_v_mslice->strides[__pyx_v_i]); - /* "View.MemoryView":1128 + /* "View.MemoryView":1127 * if mslice.shape[i] > 1: * f_stride = mslice.strides[i] * break # <<<<<<<<<<<<<< @@ -13580,7 +12661,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ */ goto __pyx_L7_break; - /* "View.MemoryView":1126 + /* "View.MemoryView":1125 * * for i in range(ndim): * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< @@ -13591,7 +12672,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ } __pyx_L7_break:; - /* "View.MemoryView":1130 + /* "View.MemoryView":1129 * break * * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< @@ -13601,7 +12682,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ __pyx_t_2 = ((abs_py_ssize_t(__pyx_v_c_stride) <= abs_py_ssize_t(__pyx_v_f_stride)) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1131 + /* "View.MemoryView":1130 * * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): * return 'C' # <<<<<<<<<<<<<< @@ -13611,7 +12692,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ __pyx_r = 'C'; goto __pyx_L0; - /* "View.MemoryView":1130 + /* "View.MemoryView":1129 * break * * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< @@ -13620,7 +12701,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ */ } - /* "View.MemoryView":1133 + /* "View.MemoryView":1132 * return 'C' * else: * return 'F' # <<<<<<<<<<<<<< @@ -13632,7 +12713,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ goto __pyx_L0; } - /* "View.MemoryView":1112 + /* "View.MemoryView":1111 * * @cname('__pyx_get_best_slice_order') * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<< @@ -13645,7 +12726,7 @@ static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int _ return __pyx_r; } -/* "View.MemoryView":1136 +/* "View.MemoryView":1135 * * @cython.cdivision(True) * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< @@ -13666,7 +12747,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v Py_ssize_t __pyx_t_5; Py_ssize_t __pyx_t_6; - /* "View.MemoryView":1143 + /* "View.MemoryView":1142 * * cdef Py_ssize_t i * cdef Py_ssize_t src_extent = src_shape[0] # <<<<<<<<<<<<<< @@ -13675,7 +12756,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ __pyx_v_src_extent = (__pyx_v_src_shape[0]); - /* "View.MemoryView":1144 + /* "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] # <<<<<<<<<<<<<< @@ -13684,7 +12765,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ __pyx_v_dst_extent = (__pyx_v_dst_shape[0]); - /* "View.MemoryView":1145 + /* "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] # <<<<<<<<<<<<<< @@ -13693,7 +12774,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ __pyx_v_src_stride = (__pyx_v_src_strides[0]); - /* "View.MemoryView":1146 + /* "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] # <<<<<<<<<<<<<< @@ -13702,7 +12783,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ __pyx_v_dst_stride = (__pyx_v_dst_strides[0]); - /* "View.MemoryView":1148 + /* "View.MemoryView":1147 * cdef Py_ssize_t dst_stride = dst_strides[0] * * if ndim == 1: # <<<<<<<<<<<<<< @@ -13712,7 +12793,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v __pyx_t_1 = ((__pyx_v_ndim == 1) != 0); if (__pyx_t_1) { - /* "View.MemoryView":1149 + /* "View.MemoryView":1148 * * if ndim == 1: * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< @@ -13732,7 +12813,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v goto __pyx_L5_bool_binop_done; } - /* "View.MemoryView":1150 + /* "View.MemoryView":1149 * if ndim == 1: * if (src_stride > 0 and dst_stride > 0 and * src_stride == itemsize == dst_stride): # <<<<<<<<<<<<<< @@ -13747,7 +12828,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v __pyx_t_1 = __pyx_t_3; __pyx_L5_bool_binop_done:; - /* "View.MemoryView":1149 + /* "View.MemoryView":1148 * * if ndim == 1: * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< @@ -13756,7 +12837,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ if (__pyx_t_1) { - /* "View.MemoryView":1151 + /* "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) # <<<<<<<<<<<<<< @@ -13765,7 +12846,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, (__pyx_v_itemsize * __pyx_v_dst_extent))); - /* "View.MemoryView":1149 + /* "View.MemoryView":1148 * * if ndim == 1: * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< @@ -13775,7 +12856,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v goto __pyx_L4; } - /* "View.MemoryView":1153 + /* "View.MemoryView":1152 * memcpy(dst_data, src_data, itemsize * dst_extent) * else: * for i in range(dst_extent): # <<<<<<<<<<<<<< @@ -13788,7 +12869,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "View.MemoryView":1154 + /* "View.MemoryView":1153 * else: * for i in range(dst_extent): * memcpy(dst_data, src_data, itemsize) # <<<<<<<<<<<<<< @@ -13797,7 +12878,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, __pyx_v_itemsize)); - /* "View.MemoryView":1155 + /* "View.MemoryView":1154 * for i in range(dst_extent): * memcpy(dst_data, src_data, itemsize) * src_data += src_stride # <<<<<<<<<<<<<< @@ -13806,7 +12887,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); - /* "View.MemoryView":1156 + /* "View.MemoryView":1155 * memcpy(dst_data, src_data, itemsize) * src_data += src_stride * dst_data += dst_stride # <<<<<<<<<<<<<< @@ -13818,7 +12899,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v } __pyx_L4:; - /* "View.MemoryView":1148 + /* "View.MemoryView":1147 * cdef Py_ssize_t dst_stride = dst_strides[0] * * if ndim == 1: # <<<<<<<<<<<<<< @@ -13828,7 +12909,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v goto __pyx_L3; } - /* "View.MemoryView":1158 + /* "View.MemoryView":1157 * dst_data += dst_stride * else: * for i in range(dst_extent): # <<<<<<<<<<<<<< @@ -13841,7 +12922,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "View.MemoryView":1159 + /* "View.MemoryView":1158 * else: * for i in range(dst_extent): * _copy_strided_to_strided(src_data, src_strides + 1, # <<<<<<<<<<<<<< @@ -13850,7 +12931,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ _copy_strided_to_strided(__pyx_v_src_data, (__pyx_v_src_strides + 1), __pyx_v_dst_data, (__pyx_v_dst_strides + 1), (__pyx_v_src_shape + 1), (__pyx_v_dst_shape + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize); - /* "View.MemoryView":1163 + /* "View.MemoryView":1162 * src_shape + 1, dst_shape + 1, * ndim - 1, itemsize) * src_data += src_stride # <<<<<<<<<<<<<< @@ -13859,7 +12940,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v */ __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); - /* "View.MemoryView":1164 + /* "View.MemoryView":1163 * ndim - 1, itemsize) * src_data += src_stride * dst_data += dst_stride # <<<<<<<<<<<<<< @@ -13871,7 +12952,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v } __pyx_L3:; - /* "View.MemoryView":1136 + /* "View.MemoryView":1135 * * @cython.cdivision(True) * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< @@ -13882,7 +12963,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v /* function exit code */ } -/* "View.MemoryView":1166 +/* "View.MemoryView":1165 * dst_data += dst_stride * * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< @@ -13892,7 +12973,7 @@ static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v static void copy_strided_to_strided(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize) { - /* "View.MemoryView":1169 + /* "View.MemoryView":1168 * __Pyx_memviewslice *dst, * int ndim, size_t itemsize) nogil: * _copy_strided_to_strided(src.data, src.strides, dst.data, dst.strides, # <<<<<<<<<<<<<< @@ -13901,7 +12982,7 @@ static void copy_strided_to_strided(__Pyx_memviewslice *__pyx_v_src, __Pyx_memvi */ _copy_strided_to_strided(__pyx_v_src->data, __pyx_v_src->strides, __pyx_v_dst->data, __pyx_v_dst->strides, __pyx_v_src->shape, __pyx_v_dst->shape, __pyx_v_ndim, __pyx_v_itemsize); - /* "View.MemoryView":1166 + /* "View.MemoryView":1165 * dst_data += dst_stride * * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< @@ -13912,7 +12993,7 @@ static void copy_strided_to_strided(__Pyx_memviewslice *__pyx_v_src, __Pyx_memvi /* function exit code */ } -/* "View.MemoryView":1173 +/* "View.MemoryView":1172 * * @cname('__pyx_memoryview_slice_get_size') * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<< @@ -13929,7 +13010,7 @@ static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_sr int __pyx_t_3; int __pyx_t_4; - /* "View.MemoryView":1176 + /* "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 # <<<<<<<<<<<<<< @@ -13939,7 +13020,7 @@ static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_sr __pyx_t_1 = __pyx_v_src->memview->view.itemsize; __pyx_v_size = __pyx_t_1; - /* "View.MemoryView":1178 + /* "View.MemoryView":1177 * cdef Py_ssize_t size = src.memview.view.itemsize * * for i in range(ndim): # <<<<<<<<<<<<<< @@ -13951,7 +13032,7 @@ static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_sr for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - /* "View.MemoryView":1179 + /* "View.MemoryView":1178 * * for i in range(ndim): * size *= src.shape[i] # <<<<<<<<<<<<<< @@ -13961,7 +13042,7 @@ static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_sr __pyx_v_size = (__pyx_v_size * (__pyx_v_src->shape[__pyx_v_i])); } - /* "View.MemoryView":1181 + /* "View.MemoryView":1180 * size *= src.shape[i] * * return size # <<<<<<<<<<<<<< @@ -13971,7 +13052,7 @@ static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_sr __pyx_r = __pyx_v_size; goto __pyx_L0; - /* "View.MemoryView":1173 + /* "View.MemoryView":1172 * * @cname('__pyx_memoryview_slice_get_size') * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<< @@ -13984,7 +13065,7 @@ static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_sr return __pyx_r; } -/* "View.MemoryView":1184 +/* "View.MemoryView":1183 * * @cname('__pyx_fill_contig_strides_array') * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< @@ -14000,7 +13081,7 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ int __pyx_t_3; int __pyx_t_4; - /* "View.MemoryView":1193 + /* "View.MemoryView":1192 * cdef int idx * * if order == 'F': # <<<<<<<<<<<<<< @@ -14010,7 +13091,7 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ __pyx_t_1 = ((__pyx_v_order == 'F') != 0); if (__pyx_t_1) { - /* "View.MemoryView":1194 + /* "View.MemoryView":1193 * * if order == 'F': * for idx in range(ndim): # <<<<<<<<<<<<<< @@ -14022,7 +13103,7 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_idx = __pyx_t_4; - /* "View.MemoryView":1195 + /* "View.MemoryView":1194 * if order == 'F': * for idx in range(ndim): * strides[idx] = stride # <<<<<<<<<<<<<< @@ -14031,7 +13112,7 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ */ (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; - /* "View.MemoryView":1196 + /* "View.MemoryView":1195 * for idx in range(ndim): * strides[idx] = stride * stride = stride * shape[idx] # <<<<<<<<<<<<<< @@ -14041,7 +13122,7 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx])); } - /* "View.MemoryView":1193 + /* "View.MemoryView":1192 * cdef int idx * * if order == 'F': # <<<<<<<<<<<<<< @@ -14051,7 +13132,7 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ goto __pyx_L3; } - /* "View.MemoryView":1198 + /* "View.MemoryView":1197 * stride = stride * shape[idx] * else: * for idx in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< @@ -14062,7 +13143,7 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ for (__pyx_t_2 = (__pyx_v_ndim - 1); __pyx_t_2 > -1; __pyx_t_2-=1) { __pyx_v_idx = __pyx_t_2; - /* "View.MemoryView":1199 + /* "View.MemoryView":1198 * else: * for idx in range(ndim - 1, -1, -1): * strides[idx] = stride # <<<<<<<<<<<<<< @@ -14071,7 +13152,7 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ */ (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; - /* "View.MemoryView":1200 + /* "View.MemoryView":1199 * for idx in range(ndim - 1, -1, -1): * strides[idx] = stride * stride = stride * shape[idx] # <<<<<<<<<<<<<< @@ -14083,7 +13164,7 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ } __pyx_L3:; - /* "View.MemoryView":1202 + /* "View.MemoryView":1201 * stride = stride * shape[idx] * * return stride # <<<<<<<<<<<<<< @@ -14093,7 +13174,7 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ __pyx_r = __pyx_v_stride; goto __pyx_L0; - /* "View.MemoryView":1184 + /* "View.MemoryView":1183 * * @cname('__pyx_fill_contig_strides_array') * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< @@ -14106,7 +13187,7 @@ static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ return __pyx_r; } -/* "View.MemoryView":1205 +/* "View.MemoryView":1204 * * @cname('__pyx_memoryview_copy_data_to_temp') * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< @@ -14127,7 +13208,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, int __pyx_t_5; int __pyx_t_6; - /* "View.MemoryView":1216 + /* "View.MemoryView":1215 * cdef void *result * * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< @@ -14137,7 +13218,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __pyx_t_1 = __pyx_v_src->memview->view.itemsize; __pyx_v_itemsize = __pyx_t_1; - /* "View.MemoryView":1217 + /* "View.MemoryView":1216 * * cdef size_t itemsize = src.memview.view.itemsize * cdef size_t size = slice_get_size(src, ndim) # <<<<<<<<<<<<<< @@ -14146,7 +13227,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, */ __pyx_v_size = __pyx_memoryview_slice_get_size(__pyx_v_src, __pyx_v_ndim); - /* "View.MemoryView":1219 + /* "View.MemoryView":1218 * cdef size_t size = slice_get_size(src, ndim) * * result = malloc(size) # <<<<<<<<<<<<<< @@ -14155,7 +13236,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, */ __pyx_v_result = malloc(__pyx_v_size); - /* "View.MemoryView":1220 + /* "View.MemoryView":1219 * * result = malloc(size) * if not result: # <<<<<<<<<<<<<< @@ -14165,16 +13246,16 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __pyx_t_2 = ((!(__pyx_v_result != 0)) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1221 + /* "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, 1221, __pyx_L1_error) + __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":1220 + /* "View.MemoryView":1219 * * result = malloc(size) * if not result: # <<<<<<<<<<<<<< @@ -14183,7 +13264,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, */ } - /* "View.MemoryView":1224 + /* "View.MemoryView":1223 * * * tmpslice.data = result # <<<<<<<<<<<<<< @@ -14192,7 +13273,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, */ __pyx_v_tmpslice->data = ((char *)__pyx_v_result); - /* "View.MemoryView":1225 + /* "View.MemoryView":1224 * * tmpslice.data = result * tmpslice.memview = src.memview # <<<<<<<<<<<<<< @@ -14202,7 +13283,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __pyx_t_4 = __pyx_v_src->memview; __pyx_v_tmpslice->memview = __pyx_t_4; - /* "View.MemoryView":1226 + /* "View.MemoryView":1225 * tmpslice.data = result * tmpslice.memview = src.memview * for i in range(ndim): # <<<<<<<<<<<<<< @@ -14214,7 +13295,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "View.MemoryView":1227 + /* "View.MemoryView":1226 * tmpslice.memview = src.memview * for i in range(ndim): * tmpslice.shape[i] = src.shape[i] # <<<<<<<<<<<<<< @@ -14223,7 +13304,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, */ (__pyx_v_tmpslice->shape[__pyx_v_i]) = (__pyx_v_src->shape[__pyx_v_i]); - /* "View.MemoryView":1228 + /* "View.MemoryView":1227 * for i in range(ndim): * tmpslice.shape[i] = src.shape[i] * tmpslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< @@ -14233,7 +13314,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, (__pyx_v_tmpslice->suboffsets[__pyx_v_i]) = -1L; } - /* "View.MemoryView":1230 + /* "View.MemoryView":1229 * tmpslice.suboffsets[i] = -1 * * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, # <<<<<<<<<<<<<< @@ -14242,7 +13323,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, */ (void)(__pyx_fill_contig_strides_array((&(__pyx_v_tmpslice->shape[0])), (&(__pyx_v_tmpslice->strides[0])), __pyx_v_itemsize, __pyx_v_ndim, __pyx_v_order)); - /* "View.MemoryView":1234 + /* "View.MemoryView":1233 * * * for i in range(ndim): # <<<<<<<<<<<<<< @@ -14254,7 +13335,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { __pyx_v_i = __pyx_t_6; - /* "View.MemoryView":1235 + /* "View.MemoryView":1234 * * for i in range(ndim): * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< @@ -14264,7 +13345,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __pyx_t_2 = (((__pyx_v_tmpslice->shape[__pyx_v_i]) == 1) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1236 + /* "View.MemoryView":1235 * for i in range(ndim): * if tmpslice.shape[i] == 1: * tmpslice.strides[i] = 0 # <<<<<<<<<<<<<< @@ -14273,7 +13354,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, */ (__pyx_v_tmpslice->strides[__pyx_v_i]) = 0; - /* "View.MemoryView":1235 + /* "View.MemoryView":1234 * * for i in range(ndim): * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< @@ -14283,7 +13364,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, } } - /* "View.MemoryView":1238 + /* "View.MemoryView":1237 * tmpslice.strides[i] = 0 * * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< @@ -14293,7 +13374,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __pyx_t_2 = (__pyx_memviewslice_is_contig((__pyx_v_src[0]), __pyx_v_order, __pyx_v_ndim) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1239 + /* "View.MemoryView":1238 * * if slice_is_contig(src[0], order, ndim): * memcpy(result, src.data, size) # <<<<<<<<<<<<<< @@ -14302,7 +13383,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, */ (void)(memcpy(__pyx_v_result, __pyx_v_src->data, __pyx_v_size)); - /* "View.MemoryView":1238 + /* "View.MemoryView":1237 * tmpslice.strides[i] = 0 * * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< @@ -14312,7 +13393,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, goto __pyx_L9; } - /* "View.MemoryView":1241 + /* "View.MemoryView":1240 * memcpy(result, src.data, size) * else: * copy_strided_to_strided(src, tmpslice, ndim, itemsize) # <<<<<<<<<<<<<< @@ -14324,7 +13405,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, } __pyx_L9:; - /* "View.MemoryView":1243 + /* "View.MemoryView":1242 * copy_strided_to_strided(src, tmpslice, ndim, itemsize) * * return result # <<<<<<<<<<<<<< @@ -14334,7 +13415,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __pyx_r = __pyx_v_result; goto __pyx_L0; - /* "View.MemoryView":1205 + /* "View.MemoryView":1204 * * @cname('__pyx_memoryview_copy_data_to_temp') * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< @@ -14358,7 +13439,7 @@ static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, return __pyx_r; } -/* "View.MemoryView":1248 +/* "View.MemoryView":1247 * * @cname('__pyx_memoryview_err_extents') * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< @@ -14378,20 +13459,20 @@ static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent #endif __Pyx_RefNannySetupContext("_err_extents", 0); - /* "View.MemoryView":1251 + /* "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, 1251, __pyx_L1_error) + __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, 1251, __pyx_L1_error) + __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, 1251, __pyx_L1_error) + __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, 1251, __pyx_L1_error) + __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); @@ -14403,24 +13484,24 @@ static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent __pyx_t_2 = 0; __pyx_t_3 = 0; - /* "View.MemoryView":1250 + /* "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, 1250, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(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, 1250, __pyx_L1_error) + __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, 1250, __pyx_L1_error) + __PYX_ERR(1, 1249, __pyx_L1_error) - /* "View.MemoryView":1248 + /* "View.MemoryView":1247 * * @cname('__pyx_memoryview_err_extents') * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< @@ -14443,7 +13524,7 @@ static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent return __pyx_r; } -/* "View.MemoryView":1254 +/* "View.MemoryView":1253 * * @cname('__pyx_memoryview_err_dim') * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< @@ -14458,24 +13539,25 @@ static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg, PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; + 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":1255 + /* "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, 1255, __pyx_L1_error) + __pyx_t_2 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) __PYX_ERR(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, 1255, __pyx_L1_error) + __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, 1255, __pyx_L1_error) + __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; @@ -14490,17 +13572,47 @@ static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg, __Pyx_DECREF_SET(__pyx_t_3, function); } } - __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1255, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + 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, 1255, __pyx_L1_error) + __PYX_ERR(1, 1254, __pyx_L1_error) - /* "View.MemoryView":1254 + /* "View.MemoryView":1253 * * @cname('__pyx_memoryview_err_dim') * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< @@ -14514,6 +13626,7 @@ static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg, __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); @@ -14524,7 +13637,7 @@ static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg, return __pyx_r; } -/* "View.MemoryView":1258 +/* "View.MemoryView":1257 * * @cname('__pyx_memoryview_err') * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< @@ -14540,13 +13653,14 @@ static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; + 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":1259 + /* "View.MemoryView":1258 * @cname('__pyx_memoryview_err') * cdef int _err(object error, char *msg) except -1 with gil: * if msg != NULL: # <<<<<<<<<<<<<< @@ -14556,14 +13670,14 @@ static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { __pyx_t_1 = ((__pyx_v_msg != NULL) != 0); if (unlikely(__pyx_t_1)) { - /* "View.MemoryView":1260 + /* "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, 1260, __pyx_L1_error) + __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(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; @@ -14576,17 +13690,47 @@ static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { __Pyx_DECREF_SET(__pyx_t_4, function); } } - __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1260, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + 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, 1260, __pyx_L1_error) + __PYX_ERR(1, 1259, __pyx_L1_error) - /* "View.MemoryView":1259 + /* "View.MemoryView":1258 * @cname('__pyx_memoryview_err') * cdef int _err(object error, char *msg) except -1 with gil: * if msg != NULL: # <<<<<<<<<<<<<< @@ -14595,7 +13739,7 @@ static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { */ } - /* "View.MemoryView":1262 + /* "View.MemoryView":1261 * raise error(msg.decode('ascii')) * else: * raise error # <<<<<<<<<<<<<< @@ -14604,10 +13748,10 @@ static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { */ /*else*/ { __Pyx_Raise(__pyx_v_error, 0, 0, 0); - __PYX_ERR(1, 1262, __pyx_L1_error) + __PYX_ERR(1, 1261, __pyx_L1_error) } - /* "View.MemoryView":1258 + /* "View.MemoryView":1257 * * @cname('__pyx_memoryview_err') * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< @@ -14621,6 +13765,7 @@ static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { __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); @@ -14631,7 +13776,7 @@ static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { return __pyx_r; } -/* "View.MemoryView":1265 +/* "View.MemoryView":1264 * * @cname('__pyx_memoryview_copy_contents') * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< @@ -14658,7 +13803,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ void *__pyx_t_7; int __pyx_t_8; - /* "View.MemoryView":1273 + /* "View.MemoryView":1272 * Check for overlapping memory and verify the shapes. * """ * cdef void *tmpdata = NULL # <<<<<<<<<<<<<< @@ -14667,7 +13812,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_tmpdata = NULL; - /* "View.MemoryView":1274 + /* "View.MemoryView":1273 * """ * cdef void *tmpdata = NULL * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< @@ -14677,7 +13822,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_1 = __pyx_v_src.memview->view.itemsize; __pyx_v_itemsize = __pyx_t_1; - /* "View.MemoryView":1276 + /* "View.MemoryView":1275 * cdef size_t itemsize = src.memview.view.itemsize * cdef int i * cdef char order = get_best_order(&src, src_ndim) # <<<<<<<<<<<<<< @@ -14686,7 +13831,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_src), __pyx_v_src_ndim); - /* "View.MemoryView":1277 + /* "View.MemoryView":1276 * cdef int i * cdef char order = get_best_order(&src, src_ndim) * cdef bint broadcasting = False # <<<<<<<<<<<<<< @@ -14695,7 +13840,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_broadcasting = 0; - /* "View.MemoryView":1278 + /* "View.MemoryView":1277 * cdef char order = get_best_order(&src, src_ndim) * cdef bint broadcasting = False * cdef bint direct_copy = False # <<<<<<<<<<<<<< @@ -14704,7 +13849,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_direct_copy = 0; - /* "View.MemoryView":1281 + /* "View.MemoryView":1280 * cdef __Pyx_memviewslice tmp * * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< @@ -14714,7 +13859,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_2 = ((__pyx_v_src_ndim < __pyx_v_dst_ndim) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1282 + /* "View.MemoryView":1281 * * if src_ndim < dst_ndim: * broadcast_leading(&src, src_ndim, dst_ndim) # <<<<<<<<<<<<<< @@ -14723,7 +13868,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_memoryview_broadcast_leading((&__pyx_v_src), __pyx_v_src_ndim, __pyx_v_dst_ndim); - /* "View.MemoryView":1281 + /* "View.MemoryView":1280 * cdef __Pyx_memviewslice tmp * * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< @@ -14733,7 +13878,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ goto __pyx_L3; } - /* "View.MemoryView":1283 + /* "View.MemoryView":1282 * if src_ndim < dst_ndim: * broadcast_leading(&src, src_ndim, dst_ndim) * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< @@ -14743,7 +13888,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_2 = ((__pyx_v_dst_ndim < __pyx_v_src_ndim) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1284 + /* "View.MemoryView":1283 * broadcast_leading(&src, src_ndim, dst_ndim) * elif dst_ndim < src_ndim: * broadcast_leading(&dst, dst_ndim, src_ndim) # <<<<<<<<<<<<<< @@ -14752,7 +13897,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_memoryview_broadcast_leading((&__pyx_v_dst), __pyx_v_dst_ndim, __pyx_v_src_ndim); - /* "View.MemoryView":1283 + /* "View.MemoryView":1282 * if src_ndim < dst_ndim: * broadcast_leading(&src, src_ndim, dst_ndim) * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< @@ -14762,7 +13907,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ } __pyx_L3:; - /* "View.MemoryView":1286 + /* "View.MemoryView":1285 * broadcast_leading(&dst, dst_ndim, src_ndim) * * cdef int ndim = max(src_ndim, dst_ndim) # <<<<<<<<<<<<<< @@ -14778,7 +13923,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ } __pyx_v_ndim = __pyx_t_5; - /* "View.MemoryView":1288 + /* "View.MemoryView":1287 * cdef int ndim = max(src_ndim, dst_ndim) * * for i in range(ndim): # <<<<<<<<<<<<<< @@ -14790,7 +13935,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - /* "View.MemoryView":1289 + /* "View.MemoryView":1288 * * for i in range(ndim): * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< @@ -14800,7 +13945,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) != (__pyx_v_dst.shape[__pyx_v_i])) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1290 + /* "View.MemoryView":1289 * for i in range(ndim): * if src.shape[i] != dst.shape[i]: * if src.shape[i] == 1: # <<<<<<<<<<<<<< @@ -14810,7 +13955,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) == 1) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1291 + /* "View.MemoryView":1290 * if src.shape[i] != dst.shape[i]: * if src.shape[i] == 1: * broadcasting = True # <<<<<<<<<<<<<< @@ -14819,7 +13964,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_broadcasting = 1; - /* "View.MemoryView":1292 + /* "View.MemoryView":1291 * if src.shape[i] == 1: * broadcasting = True * src.strides[i] = 0 # <<<<<<<<<<<<<< @@ -14828,7 +13973,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ (__pyx_v_src.strides[__pyx_v_i]) = 0; - /* "View.MemoryView":1290 + /* "View.MemoryView":1289 * for i in range(ndim): * if src.shape[i] != dst.shape[i]: * if src.shape[i] == 1: # <<<<<<<<<<<<<< @@ -14838,7 +13983,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ goto __pyx_L7; } - /* "View.MemoryView":1294 + /* "View.MemoryView":1293 * src.strides[i] = 0 * else: * _err_extents(i, dst.shape[i], src.shape[i]) # <<<<<<<<<<<<<< @@ -14846,11 +13991,11 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ * if src.suboffsets[i] >= 0: */ /*else*/ { - __pyx_t_6 = __pyx_memoryview_err_extents(__pyx_v_i, (__pyx_v_dst.shape[__pyx_v_i]), (__pyx_v_src.shape[__pyx_v_i])); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1294, __pyx_L1_error) + __pyx_t_6 = __pyx_memoryview_err_extents(__pyx_v_i, (__pyx_v_dst.shape[__pyx_v_i]), (__pyx_v_src.shape[__pyx_v_i])); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1293, __pyx_L1_error) } __pyx_L7:; - /* "View.MemoryView":1289 + /* "View.MemoryView":1288 * * for i in range(ndim): * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< @@ -14859,7 +14004,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ } - /* "View.MemoryView":1296 + /* "View.MemoryView":1295 * _err_extents(i, dst.shape[i], src.shape[i]) * * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< @@ -14869,16 +14014,16 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_2 = (((__pyx_v_src.suboffsets[__pyx_v_i]) >= 0) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1297 + /* "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, 1297, __pyx_L1_error) + __pyx_t_6 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Dimension %d is not direct"), __pyx_v_i); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1296, __pyx_L1_error) - /* "View.MemoryView":1296 + /* "View.MemoryView":1295 * _err_extents(i, dst.shape[i], src.shape[i]) * * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< @@ -14888,7 +14033,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ } } - /* "View.MemoryView":1299 + /* "View.MemoryView":1298 * _err_dim(ValueError, "Dimension %d is not direct", i) * * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< @@ -14898,7 +14043,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_2 = (__pyx_slices_overlap((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1301 + /* "View.MemoryView":1300 * if slices_overlap(&src, &dst, ndim, itemsize): * * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< @@ -14908,7 +14053,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_2 = ((!(__pyx_memviewslice_is_contig(__pyx_v_src, __pyx_v_order, __pyx_v_ndim) != 0)) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1302 + /* "View.MemoryView":1301 * * if not slice_is_contig(src, order, ndim): * order = get_best_order(&dst, ndim) # <<<<<<<<<<<<<< @@ -14917,7 +14062,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim); - /* "View.MemoryView":1301 + /* "View.MemoryView":1300 * if slices_overlap(&src, &dst, ndim, itemsize): * * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< @@ -14926,17 +14071,17 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ } - /* "View.MemoryView":1304 + /* "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, 1304, __pyx_L1_error) + __pyx_t_7 = __pyx_memoryview_copy_data_to_temp((&__pyx_v_src), (&__pyx_v_tmp), __pyx_v_order, __pyx_v_ndim); if (unlikely(__pyx_t_7 == ((void *)NULL))) __PYX_ERR(1, 1303, __pyx_L1_error) __pyx_v_tmpdata = __pyx_t_7; - /* "View.MemoryView":1305 + /* "View.MemoryView":1304 * * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) * src = tmp # <<<<<<<<<<<<<< @@ -14945,7 +14090,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_src = __pyx_v_tmp; - /* "View.MemoryView":1299 + /* "View.MemoryView":1298 * _err_dim(ValueError, "Dimension %d is not direct", i) * * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< @@ -14954,7 +14099,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ } - /* "View.MemoryView":1307 + /* "View.MemoryView":1306 * src = tmp * * if not broadcasting: # <<<<<<<<<<<<<< @@ -14964,7 +14109,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_2 = ((!(__pyx_v_broadcasting != 0)) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1310 + /* "View.MemoryView":1309 * * * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< @@ -14974,7 +14119,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'C', __pyx_v_ndim) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1311 + /* "View.MemoryView":1310 * * if slice_is_contig(src, 'C', ndim): * direct_copy = slice_is_contig(dst, 'C', ndim) # <<<<<<<<<<<<<< @@ -14983,7 +14128,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'C', __pyx_v_ndim); - /* "View.MemoryView":1310 + /* "View.MemoryView":1309 * * * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< @@ -14993,7 +14138,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ goto __pyx_L12; } - /* "View.MemoryView":1312 + /* "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): # <<<<<<<<<<<<<< @@ -15003,7 +14148,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'F', __pyx_v_ndim) != 0); if (__pyx_t_2) { - /* "View.MemoryView":1313 + /* "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) # <<<<<<<<<<<<<< @@ -15012,7 +14157,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'F', __pyx_v_ndim); - /* "View.MemoryView":1312 + /* "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): # <<<<<<<<<<<<<< @@ -15022,7 +14167,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ } __pyx_L12:; - /* "View.MemoryView":1315 + /* "View.MemoryView":1314 * direct_copy = slice_is_contig(dst, 'F', ndim) * * if direct_copy: # <<<<<<<<<<<<<< @@ -15032,7 +14177,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_2 = (__pyx_v_direct_copy != 0); if (__pyx_t_2) { - /* "View.MemoryView":1317 + /* "View.MemoryView":1316 * if direct_copy: * * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< @@ -15041,7 +14186,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); - /* "View.MemoryView":1318 + /* "View.MemoryView":1317 * * refcount_copying(&dst, dtype_is_object, ndim, False) * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) # <<<<<<<<<<<<<< @@ -15050,7 +14195,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ (void)(memcpy(__pyx_v_dst.data, __pyx_v_src.data, __pyx_memoryview_slice_get_size((&__pyx_v_src), __pyx_v_ndim))); - /* "View.MemoryView":1319 + /* "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) # <<<<<<<<<<<<<< @@ -15059,7 +14204,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); - /* "View.MemoryView":1320 + /* "View.MemoryView":1319 * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) * refcount_copying(&dst, dtype_is_object, ndim, True) * free(tmpdata) # <<<<<<<<<<<<<< @@ -15068,7 +14213,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ free(__pyx_v_tmpdata); - /* "View.MemoryView":1321 + /* "View.MemoryView":1320 * refcount_copying(&dst, dtype_is_object, ndim, True) * free(tmpdata) * return 0 # <<<<<<<<<<<<<< @@ -15078,7 +14223,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_r = 0; goto __pyx_L0; - /* "View.MemoryView":1315 + /* "View.MemoryView":1314 * direct_copy = slice_is_contig(dst, 'F', ndim) * * if direct_copy: # <<<<<<<<<<<<<< @@ -15087,7 +14232,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ } - /* "View.MemoryView":1307 + /* "View.MemoryView":1306 * src = tmp * * if not broadcasting: # <<<<<<<<<<<<<< @@ -15096,7 +14241,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ } - /* "View.MemoryView":1323 + /* "View.MemoryView":1322 * return 0 * * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< @@ -15110,25 +14255,25 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_t_8 = (__pyx_t_2 != 0); if (__pyx_t_8) { - /* "View.MemoryView":1326 + /* "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, 1326, __pyx_L1_error) + __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":1327 + /* "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, 1327, __pyx_L1_error) + __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":1323 + /* "View.MemoryView":1322 * return 0 * * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< @@ -15137,7 +14282,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ } - /* "View.MemoryView":1329 + /* "View.MemoryView":1328 * transpose_memslice(&dst) * * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< @@ -15146,7 +14291,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); - /* "View.MemoryView":1330 + /* "View.MemoryView":1329 * * refcount_copying(&dst, dtype_is_object, ndim, False) * copy_strided_to_strided(&src, &dst, ndim, itemsize) # <<<<<<<<<<<<<< @@ -15155,7 +14300,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ copy_strided_to_strided((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize); - /* "View.MemoryView":1331 + /* "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) # <<<<<<<<<<<<<< @@ -15164,7 +14309,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); - /* "View.MemoryView":1333 + /* "View.MemoryView":1332 * refcount_copying(&dst, dtype_is_object, ndim, True) * * free(tmpdata) # <<<<<<<<<<<<<< @@ -15173,7 +14318,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ */ free(__pyx_v_tmpdata); - /* "View.MemoryView":1334 + /* "View.MemoryView":1333 * * free(tmpdata) * return 0 # <<<<<<<<<<<<<< @@ -15183,7 +14328,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ __pyx_r = 0; goto __pyx_L0; - /* "View.MemoryView":1265 + /* "View.MemoryView":1264 * * @cname('__pyx_memoryview_copy_contents') * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< @@ -15207,7 +14352,7 @@ static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_ return __pyx_r; } -/* "View.MemoryView":1337 +/* "View.MemoryView":1336 * * @cname('__pyx_memoryview_broadcast_leading') * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< @@ -15222,7 +14367,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic int __pyx_t_2; int __pyx_t_3; - /* "View.MemoryView":1341 + /* "View.MemoryView":1340 * int ndim_other) nogil: * cdef int i * cdef int offset = ndim_other - ndim # <<<<<<<<<<<<<< @@ -15231,7 +14376,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic */ __pyx_v_offset = (__pyx_v_ndim_other - __pyx_v_ndim); - /* "View.MemoryView":1343 + /* "View.MemoryView":1342 * cdef int offset = ndim_other - ndim * * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< @@ -15241,7 +14386,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { __pyx_v_i = __pyx_t_1; - /* "View.MemoryView":1344 + /* "View.MemoryView":1343 * * for i in range(ndim - 1, -1, -1): * mslice.shape[i + offset] = mslice.shape[i] # <<<<<<<<<<<<<< @@ -15250,7 +14395,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic */ (__pyx_v_mslice->shape[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->shape[__pyx_v_i]); - /* "View.MemoryView":1345 + /* "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] # <<<<<<<<<<<<<< @@ -15259,7 +14404,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic */ (__pyx_v_mslice->strides[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->strides[__pyx_v_i]); - /* "View.MemoryView":1346 + /* "View.MemoryView":1345 * mslice.shape[i + offset] = mslice.shape[i] * mslice.strides[i + offset] = mslice.strides[i] * mslice.suboffsets[i + offset] = mslice.suboffsets[i] # <<<<<<<<<<<<<< @@ -15269,7 +14414,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic (__pyx_v_mslice->suboffsets[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->suboffsets[__pyx_v_i]); } - /* "View.MemoryView":1348 + /* "View.MemoryView":1347 * mslice.suboffsets[i + offset] = mslice.suboffsets[i] * * for i in range(offset): # <<<<<<<<<<<<<< @@ -15281,7 +14426,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { __pyx_v_i = __pyx_t_3; - /* "View.MemoryView":1349 + /* "View.MemoryView":1348 * * for i in range(offset): * mslice.shape[i] = 1 # <<<<<<<<<<<<<< @@ -15290,7 +14435,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic */ (__pyx_v_mslice->shape[__pyx_v_i]) = 1; - /* "View.MemoryView":1350 + /* "View.MemoryView":1349 * for i in range(offset): * mslice.shape[i] = 1 * mslice.strides[i] = mslice.strides[0] # <<<<<<<<<<<<<< @@ -15299,7 +14444,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic */ (__pyx_v_mslice->strides[__pyx_v_i]) = (__pyx_v_mslice->strides[0]); - /* "View.MemoryView":1351 + /* "View.MemoryView":1350 * mslice.shape[i] = 1 * mslice.strides[i] = mslice.strides[0] * mslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< @@ -15309,7 +14454,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic (__pyx_v_mslice->suboffsets[__pyx_v_i]) = -1L; } - /* "View.MemoryView":1337 + /* "View.MemoryView":1336 * * @cname('__pyx_memoryview_broadcast_leading') * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< @@ -15320,7 +14465,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic /* function exit code */ } -/* "View.MemoryView":1359 +/* "View.MemoryView":1358 * * @cname('__pyx_memoryview_refcount_copying') * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< @@ -15331,7 +14476,7 @@ static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslic static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_dtype_is_object, int __pyx_v_ndim, int __pyx_v_inc) { int __pyx_t_1; - /* "View.MemoryView":1363 + /* "View.MemoryView":1362 * * * if dtype_is_object: # <<<<<<<<<<<<<< @@ -15341,7 +14486,7 @@ static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *__pyx_v_dst, i __pyx_t_1 = (__pyx_v_dtype_is_object != 0); if (__pyx_t_1) { - /* "View.MemoryView":1364 + /* "View.MemoryView":1363 * * if dtype_is_object: * refcount_objects_in_slice_with_gil(dst.data, dst.shape, # <<<<<<<<<<<<<< @@ -15350,7 +14495,7 @@ static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *__pyx_v_dst, i */ __pyx_memoryview_refcount_objects_in_slice_with_gil(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_inc); - /* "View.MemoryView":1363 + /* "View.MemoryView":1362 * * * if dtype_is_object: # <<<<<<<<<<<<<< @@ -15359,7 +14504,7 @@ static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *__pyx_v_dst, i */ } - /* "View.MemoryView":1359 + /* "View.MemoryView":1358 * * @cname('__pyx_memoryview_refcount_copying') * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< @@ -15370,7 +14515,7 @@ static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *__pyx_v_dst, i /* function exit code */ } -/* "View.MemoryView":1368 +/* "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, # <<<<<<<<<<<<<< @@ -15385,7 +14530,7 @@ static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *__pyx_v_da #endif __Pyx_RefNannySetupContext("refcount_objects_in_slice_with_gil", 0); - /* "View.MemoryView":1371 + /* "View.MemoryView":1370 * Py_ssize_t *strides, int ndim, * bint inc) with gil: * refcount_objects_in_slice(data, shape, strides, ndim, inc) # <<<<<<<<<<<<<< @@ -15394,7 +14539,7 @@ static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *__pyx_v_da */ __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, __pyx_v_shape, __pyx_v_strides, __pyx_v_ndim, __pyx_v_inc); - /* "View.MemoryView":1368 + /* "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, # <<<<<<<<<<<<<< @@ -15409,7 +14554,7 @@ static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *__pyx_v_da #endif } -/* "View.MemoryView":1374 +/* "View.MemoryView":1373 * * @cname('__pyx_memoryview_refcount_objects_in_slice') * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< @@ -15426,7 +14571,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss int __pyx_t_4; __Pyx_RefNannySetupContext("refcount_objects_in_slice", 0); - /* "View.MemoryView":1378 + /* "View.MemoryView":1377 * cdef Py_ssize_t i * * for i in range(shape[0]): # <<<<<<<<<<<<<< @@ -15438,7 +14583,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { __pyx_v_i = __pyx_t_3; - /* "View.MemoryView":1379 + /* "View.MemoryView":1378 * * for i in range(shape[0]): * if ndim == 1: # <<<<<<<<<<<<<< @@ -15448,7 +14593,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss __pyx_t_4 = ((__pyx_v_ndim == 1) != 0); if (__pyx_t_4) { - /* "View.MemoryView":1380 + /* "View.MemoryView":1379 * for i in range(shape[0]): * if ndim == 1: * if inc: # <<<<<<<<<<<<<< @@ -15458,7 +14603,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss __pyx_t_4 = (__pyx_v_inc != 0); if (__pyx_t_4) { - /* "View.MemoryView":1381 + /* "View.MemoryView":1380 * if ndim == 1: * if inc: * Py_INCREF(( data)[0]) # <<<<<<<<<<<<<< @@ -15467,7 +14612,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss */ Py_INCREF((((PyObject **)__pyx_v_data)[0])); - /* "View.MemoryView":1380 + /* "View.MemoryView":1379 * for i in range(shape[0]): * if ndim == 1: * if inc: # <<<<<<<<<<<<<< @@ -15477,7 +14622,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss goto __pyx_L6; } - /* "View.MemoryView":1383 + /* "View.MemoryView":1382 * Py_INCREF(( data)[0]) * else: * Py_DECREF(( data)[0]) # <<<<<<<<<<<<<< @@ -15489,7 +14634,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss } __pyx_L6:; - /* "View.MemoryView":1379 + /* "View.MemoryView":1378 * * for i in range(shape[0]): * if ndim == 1: # <<<<<<<<<<<<<< @@ -15499,7 +14644,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss goto __pyx_L5; } - /* "View.MemoryView":1385 + /* "View.MemoryView":1384 * Py_DECREF(( data)[0]) * else: * refcount_objects_in_slice(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< @@ -15508,7 +14653,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss */ /*else*/ { - /* "View.MemoryView":1386 + /* "View.MemoryView":1385 * else: * refcount_objects_in_slice(data, shape + 1, strides + 1, * ndim - 1, inc) # <<<<<<<<<<<<<< @@ -15519,7 +14664,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss } __pyx_L5:; - /* "View.MemoryView":1388 + /* "View.MemoryView":1387 * ndim - 1, inc) * * data += strides[0] # <<<<<<<<<<<<<< @@ -15529,7 +14674,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss __pyx_v_data = (__pyx_v_data + (__pyx_v_strides[0])); } - /* "View.MemoryView":1374 + /* "View.MemoryView":1373 * * @cname('__pyx_memoryview_refcount_objects_in_slice') * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< @@ -15541,7 +14686,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss __Pyx_RefNannyFinishContext(); } -/* "View.MemoryView":1394 +/* "View.MemoryView":1393 * * @cname('__pyx_memoryview_slice_assign_scalar') * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< @@ -15551,7 +14696,7 @@ static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ss static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item, int __pyx_v_dtype_is_object) { - /* "View.MemoryView":1397 + /* "View.MemoryView":1396 * size_t itemsize, void *item, * bint dtype_is_object) nogil: * refcount_copying(dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< @@ -15560,7 +14705,7 @@ static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *__pyx_v_dst */ __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 0); - /* "View.MemoryView":1398 + /* "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, # <<<<<<<<<<<<<< @@ -15569,7 +14714,7 @@ static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *__pyx_v_dst */ __pyx_memoryview__slice_assign_scalar(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_itemsize, __pyx_v_item); - /* "View.MemoryView":1400 + /* "View.MemoryView":1399 * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, * itemsize, item) * refcount_copying(dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< @@ -15578,7 +14723,7 @@ static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *__pyx_v_dst */ __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 1); - /* "View.MemoryView":1394 + /* "View.MemoryView":1393 * * @cname('__pyx_memoryview_slice_assign_scalar') * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< @@ -15589,7 +14734,7 @@ static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *__pyx_v_dst /* function exit code */ } -/* "View.MemoryView":1404 +/* "View.MemoryView":1403 * * @cname('__pyx_memoryview__slice_assign_scalar') * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< @@ -15606,7 +14751,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t Py_ssize_t __pyx_t_3; Py_ssize_t __pyx_t_4; - /* "View.MemoryView":1408 + /* "View.MemoryView":1407 * size_t itemsize, void *item) nogil: * cdef Py_ssize_t i * cdef Py_ssize_t stride = strides[0] # <<<<<<<<<<<<<< @@ -15615,7 +14760,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t */ __pyx_v_stride = (__pyx_v_strides[0]); - /* "View.MemoryView":1409 + /* "View.MemoryView":1408 * cdef Py_ssize_t i * cdef Py_ssize_t stride = strides[0] * cdef Py_ssize_t extent = shape[0] # <<<<<<<<<<<<<< @@ -15624,7 +14769,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t */ __pyx_v_extent = (__pyx_v_shape[0]); - /* "View.MemoryView":1411 + /* "View.MemoryView":1410 * cdef Py_ssize_t extent = shape[0] * * if ndim == 1: # <<<<<<<<<<<<<< @@ -15634,7 +14779,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t __pyx_t_1 = ((__pyx_v_ndim == 1) != 0); if (__pyx_t_1) { - /* "View.MemoryView":1412 + /* "View.MemoryView":1411 * * if ndim == 1: * for i in range(extent): # <<<<<<<<<<<<<< @@ -15646,7 +14791,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - /* "View.MemoryView":1413 + /* "View.MemoryView":1412 * if ndim == 1: * for i in range(extent): * memcpy(data, item, itemsize) # <<<<<<<<<<<<<< @@ -15655,7 +14800,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t */ (void)(memcpy(__pyx_v_data, __pyx_v_item, __pyx_v_itemsize)); - /* "View.MemoryView":1414 + /* "View.MemoryView":1413 * for i in range(extent): * memcpy(data, item, itemsize) * data += stride # <<<<<<<<<<<<<< @@ -15665,7 +14810,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t __pyx_v_data = (__pyx_v_data + __pyx_v_stride); } - /* "View.MemoryView":1411 + /* "View.MemoryView":1410 * cdef Py_ssize_t extent = shape[0] * * if ndim == 1: # <<<<<<<<<<<<<< @@ -15675,7 +14820,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t goto __pyx_L3; } - /* "View.MemoryView":1416 + /* "View.MemoryView":1415 * data += stride * else: * for i in range(extent): # <<<<<<<<<<<<<< @@ -15688,7 +14833,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - /* "View.MemoryView":1417 + /* "View.MemoryView":1416 * else: * for i in range(extent): * _slice_assign_scalar(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< @@ -15697,7 +14842,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t */ __pyx_memoryview__slice_assign_scalar(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize, __pyx_v_item); - /* "View.MemoryView":1419 + /* "View.MemoryView":1418 * _slice_assign_scalar(data, shape + 1, strides + 1, * ndim - 1, itemsize, item) * data += stride # <<<<<<<<<<<<<< @@ -15709,7 +14854,7 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t } __pyx_L3:; - /* "View.MemoryView":1404 + /* "View.MemoryView":1403 * * @cname('__pyx_memoryview__slice_assign_scalar') * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< @@ -15722,13 +14867,13 @@ static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t /* "(tree fragment)":1 * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result + * 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)(void*)(PyCFunctionWithKeywords)__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum, METH_VARARGS|METH_KEYWORDS, 0}; +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; @@ -15800,8 +14945,8 @@ static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *_ } static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_v___pyx_PickleError = 0; - PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_v___pyx_PickleError = NULL; + PyObject *__pyx_v___pyx_result = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; @@ -15809,12 +14954,12 @@ static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSE PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; - int __pyx_t_6; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; __Pyx_RefNannySetupContext("__pyx_unpickle_Enum", 0); - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result + /* "(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) @@ -15822,38 +14967,38 @@ static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSE __pyx_t_1 = ((__pyx_v___pyx_checksum != 0xb068931) != 0); if (__pyx_t_1) { - /* "(tree fragment)":5 - * cdef object __pyx_result + /* "(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, 5, __pyx_L1_error) + __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, 5, __pyx_L1_error) + __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, 5, __pyx_L1_error) + __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)":6 + /* "(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, 6, __pyx_L1_error) + __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, 6, __pyx_L1_error) + __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); @@ -15867,53 +15012,110 @@ static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSE __Pyx_DECREF_SET(__pyx_t_2, function); } } - __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + 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, 6, __pyx_L1_error) + __PYX_ERR(1, 4, __pyx_L1_error) - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result + /* "(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)":7 + /* "(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, 7, __pyx_L1_error) + __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_4 = NULL; + __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_4)) { + __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_4); + __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } - __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + 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)":8 + /* "(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: # <<<<<<<<<<<<<< @@ -15921,22 +15123,22 @@ static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSE * return __pyx_result */ __pyx_t_1 = (__pyx_v___pyx_state != Py_None); - __pyx_t_6 = (__pyx_t_1 != 0); - if (__pyx_t_6) { + __pyx_t_7 = (__pyx_t_1 != 0); + if (__pyx_t_7) { - /* "(tree fragment)":9 + /* "(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, 9, __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, 9, __pyx_L1_error) + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(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)":8 + /* "(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: # <<<<<<<<<<<<<< @@ -15945,7 +15147,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSE */ } - /* "(tree fragment)":10 + /* "(tree fragment)":8 * if __pyx_state is not None: * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) * return __pyx_result # <<<<<<<<<<<<<< @@ -15959,8 +15161,8 @@ static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSE /* "(tree fragment)":1 * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result + * if __pyx_checksum != 0xb068931: + * from pickle import PickleError as __pyx_PickleError */ /* function exit code */ @@ -15969,6 +15171,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSE __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:; @@ -15979,7 +15182,7 @@ static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSE return __pyx_r; } -/* "(tree fragment)":11 +/* "(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): # <<<<<<<<<<<<<< @@ -15998,9 +15201,10 @@ static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__ PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; __Pyx_RefNannySetupContext("__pyx_unpickle_Enum__set_state", 0); - /* "(tree fragment)":12 + /* "(tree fragment)":10 * return __pyx_result * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): * __pyx_result.name = __pyx_state[0] # <<<<<<<<<<<<<< @@ -16009,9 +15213,9 @@ static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__ */ 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_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, 12, __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); @@ -16019,7 +15223,7 @@ static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__ __pyx_v___pyx_result->name = __pyx_t_1; __pyx_t_1 = 0; - /* "(tree fragment)":13 + /* "(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__'): # <<<<<<<<<<<<<< @@ -16027,36 +15231,36 @@ static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__ */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(1, 13, __pyx_L1_error) + __PYX_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, 13, __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, 13, __pyx_L1_error) + __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)":14 + /* "(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, 14, __pyx_L1_error) + __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, 14, __pyx_L1_error) + __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, 14, __pyx_L1_error) + __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, 14, __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))) { @@ -16068,15 +15272,45 @@ static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__ __Pyx_DECREF_SET(__pyx_t_7, function); } } - __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + 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)":13 + /* "(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__'): # <<<<<<<<<<<<<< @@ -16084,7 +15318,7 @@ static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__ */ } - /* "(tree fragment)":11 + /* "(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): # <<<<<<<<<<<<<< @@ -16100,6 +15334,7 @@ static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__ __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:; @@ -16814,15 +16049,6 @@ static struct PyModuleDef __pyx_moduledef = { NULL /* m_free */ }; #endif -#ifndef CYTHON_SMALL_CODE -#if defined(__clang__) - #define CYTHON_SMALL_CODE -#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) - #define CYTHON_SMALL_CODE __attribute__((cold)) -#else - #define CYTHON_SMALL_CODE -#endif -#endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_ASCII, __pyx_k_ASCII, sizeof(__pyx_k_ASCII), 0, 0, 1, 1}, @@ -16849,7 +16075,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__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_Wtv, __pyx_k_Wtv, sizeof(__pyx_k_Wtv), 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}, @@ -16860,7 +16086,6 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__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}, @@ -16871,7 +16096,6 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__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_kp_s_gensim_models_nmf_pgd_pyx, __pyx_k_gensim_models_nmf_pgd_pyx, sizeof(__pyx_k_gensim_models_nmf_pgd_pyx), 0, 0, 1, 0}, {&__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}, @@ -16879,12 +16103,9 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__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}, @@ -16894,9 +16115,11 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__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_permutation, __pyx_k_permutation, sizeof(__pyx_k_permutation), 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}, @@ -16907,23 +16130,6 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_pyx_type, __pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 0, 1, 1}, {&__pyx_n_s_pyx_unpickle_Enum, __pyx_k_pyx_unpickle_Enum, sizeof(__pyx_k_pyx_unpickle_Enum), 0, 0, 1, 1}, {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, - {&__pyx_n_s_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}, @@ -16934,7 +16140,6 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__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}, @@ -16948,82 +16153,92 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__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 CYTHON_SMALL_CODE 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, 133, __pyx_L1_error) - __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(1, 148, __pyx_L1_error) - __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(1, 151, __pyx_L1_error) +static int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 44, __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, 400, __pyx_L1_error) - __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(1, 609, __pyx_L1_error) - __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(1, 828, __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 CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { +static int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - /* "View.MemoryView":133 + /* "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, 133, __pyx_L1_error) + __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":136 + /* "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, 136, __pyx_L1_error) + __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":148 + /* "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__3 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_shape_and_str); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__3); - __Pyx_GIVEREF(__pyx_tuple__3); + __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":176 + /* "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__4 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_array_data); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 176, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__4); - __Pyx_GIVEREF(__pyx_tuple__4); + __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":192 + /* "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__5 = PyTuple_Pack(1, __pyx_kp_s_Can_only_create_a_buffer_that_is); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 192, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__5); - __Pyx_GIVEREF(__pyx_tuple__5); + __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): @@ -17031,76 +16246,76 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ - __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__6); - __Pyx_GIVEREF(__pyx_tuple__6); + __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__7 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__7); - __Pyx_GIVEREF(__pyx_tuple__7); + __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":414 + /* "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__8 = PyTuple_Pack(1, __pyx_kp_s_Cannot_assign_to_read_only_memor); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 414, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__8); - __Pyx_GIVEREF(__pyx_tuple__8); + __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":491 + /* "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__9 = PyTuple_Pack(1, __pyx_kp_s_Unable_to_convert_item_to_object); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 491, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__9); - __Pyx_GIVEREF(__pyx_tuple__9); + __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":516 + /* "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_ND: + * if flags & PyBUF_STRIDES: */ - __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_Cannot_create_writable_memory_vi); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 516, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__10); - __Pyx_GIVEREF(__pyx_tuple__10); + __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":566 + /* "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__11 = PyTuple_Pack(1, __pyx_kp_s_Buffer_view_does_not_expose_stri); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 566, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__11); - __Pyx_GIVEREF(__pyx_tuple__11); + __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":573 + /* "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__12 = PyTuple_New(1); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 573, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__12); + __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__12, 0, __pyx_int_neg_1); - __Pyx_GIVEREF(__pyx_tuple__12); + PyTuple_SET_ITEM(__pyx_tuple__13, 0, __pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_tuple__13); /* "(tree fragment)":2 * def __reduce_cython__(self): @@ -17108,40 +16323,62 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ - __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__13); - __Pyx_GIVEREF(__pyx_tuple__13); + __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__14 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__14); - __Pyx_GIVEREF(__pyx_tuple__14); + __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":678 + /* "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__15 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__15)) __PYX_ERR(1, 678, __pyx_L1_error) - __Pyx_GOTREF(__pyx_slice__15); - __Pyx_GIVEREF(__pyx_slice__15); + __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":699 + /* "View.MemoryView":698 * for suboffset in suboffsets[:ndim]: * if suboffset >= 0: * raise ValueError("Indirect dimensions not supported") # <<<<<<<<<<<<<< * * */ - __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_s_Indirect_dimensions_not_supporte); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(1, 699, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__16); - __Pyx_GIVEREF(__pyx_tuple__16); + __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): @@ -17149,107 +16386,95 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ - __pyx_tuple__17 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__17); - __Pyx_GIVEREF(__pyx_tuple__17); + __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__18 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__18); - __Pyx_GIVEREF(__pyx_tuple__18); + __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 + /* "gensim/models/nmf_pgd.pyx":18 + * return x if x > y else y * - * def solve_h(double[:, ::1] h, double[:, :] Wt_v_minus_r, double[:, ::1] WtW, double kappa): # <<<<<<<<<<<<<< + * def solve_h(double[:, ::1] h, double[:, :] Wtv, double[:, ::1] WtW, int[::1] permutation, double kappa): # <<<<<<<<<<<<<< * """Find optimal dense vector representation for current W and r matrices. * */ - __pyx_tuple__19 = 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__19)) __PYX_ERR(0, 23, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__19); - __Pyx_GIVEREF(__pyx_tuple__19); - __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(4, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__19, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_gensim_models_nmf_pgd_pyx, __pyx_n_s_solve_h, 23, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(0, 23, __pyx_L1_error) - - /* "gensim/models/nmf_pgd.pyx":68 - * return sqrt(violation) - * - * def solve_r( # <<<<<<<<<<<<<< - * r, - * r_actual, - */ - __pyx_tuple__21 = 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__21)) __PYX_ERR(0, 68, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__21); - __Pyx_GIVEREF(__pyx_tuple__21); - __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(4, 0, 22, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_gensim_models_nmf_pgd_pyx, __pyx_n_s_solve_r, 68, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 68, __pyx_L1_error) + __pyx_tuple__22 = PyTuple_Pack(14, __pyx_n_s_h, __pyx_n_s_Wtv, __pyx_n_s_WtW, __pyx_n_s_permutation, __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, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__22); + __Pyx_GIVEREF(__pyx_tuple__22); + __pyx_codeobj__23 = (PyObject*)__Pyx_PyCode_New(5, 0, 14, 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, 18, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__23)) __PYX_ERR(0, 18, __pyx_L1_error) - /* "View.MemoryView":286 + /* "View.MemoryView":285 * return self.name * * cdef generic = Enum("") # <<<<<<<<<<<<<< * cdef strided = Enum("") # default * cdef indirect = Enum("") */ - __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(1, 286, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__23); - __Pyx_GIVEREF(__pyx_tuple__23); + __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(1, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__24); + __Pyx_GIVEREF(__pyx_tuple__24); - /* "View.MemoryView":287 + /* "View.MemoryView":286 * * cdef generic = Enum("") * cdef strided = Enum("") # default # <<<<<<<<<<<<<< * cdef indirect = Enum("") * */ - __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(1, 287, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__24); - __Pyx_GIVEREF(__pyx_tuple__24); + __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(1, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__25); + __Pyx_GIVEREF(__pyx_tuple__25); - /* "View.MemoryView":288 + /* "View.MemoryView":287 * cdef generic = Enum("") * cdef strided = Enum("") # default * cdef indirect = Enum("") # <<<<<<<<<<<<<< * * */ - __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_s_strided_and_indirect); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(1, 288, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__25); - __Pyx_GIVEREF(__pyx_tuple__25); + __pyx_tuple__26 = PyTuple_Pack(1, __pyx_kp_s_strided_and_indirect); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(1, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__26); + __Pyx_GIVEREF(__pyx_tuple__26); - /* "View.MemoryView":291 + /* "View.MemoryView":290 * * * cdef contiguous = Enum("") # <<<<<<<<<<<<<< * cdef indirect_contiguous = Enum("") * */ - __pyx_tuple__26 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(1, 291, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__26); - __Pyx_GIVEREF(__pyx_tuple__26); + __pyx_tuple__27 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(1, 290, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__27); + __Pyx_GIVEREF(__pyx_tuple__27); - /* "View.MemoryView":292 + /* "View.MemoryView":291 * * cdef contiguous = Enum("") * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< * * */ - __pyx_tuple__27 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_indirect); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(1, 292, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__27); - __Pyx_GIVEREF(__pyx_tuple__27); + __pyx_tuple__28 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_indirect); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(1, 291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__28); + __Pyx_GIVEREF(__pyx_tuple__28); /* "(tree fragment)":1 * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result + * if __pyx_checksum != 0xb068931: + * from pickle import PickleError as __pyx_PickleError */ - __pyx_tuple__28 = 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__28)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__28); - __Pyx_GIVEREF(__pyx_tuple__28); - __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__28, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_tuple__29 = 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__29)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__29); + __Pyx_GIVEREF(__pyx_tuple__29); + __pyx_codeobj__30 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__29, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__30)) __PYX_ERR(1, 1, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -17257,7 +16482,7 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { return -1; } -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { +static int __Pyx_InitGlobals(void) { /* InitThreads.init */ #ifdef WITH_THREAD PyEval_InitThreads(); @@ -17275,13 +16500,13 @@ if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) return -1; } -static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ +static int __Pyx_modinit_global_init_code(void); /*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 @@ -17318,17 +16543,17 @@ static int __Pyx_modinit_type_init_code(void) { /*--- 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, 105, __pyx_L1_error) + 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, 105, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 105, __pyx_L1_error) + 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, 279, __pyx_L1_error) + 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, 279, __pyx_L1_error) + 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; @@ -17338,26 +16563,26 @@ static int __Pyx_modinit_type_init_code(void) { __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, 330, __pyx_L1_error) + 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, 330, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 330, __pyx_L1_error) + 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, 961, __pyx_L1_error) + 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, 961, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 961, __pyx_L1_error) + 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; @@ -17404,6 +16629,15 @@ static int __Pyx_modinit_function_import_code(void) { #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 @@ -17416,36 +16650,11 @@ __Pyx_PyMODINIT_FUNC PyInit_nmf_pgd(void) { return PyModuleDef_Init(&__pyx_moduledef); } -static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { - #if PY_VERSION_HEX >= 0x030700A1 - static PY_INT64_T main_interpreter_id = -1; - PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); - if (main_interpreter_id == -1) { - main_interpreter_id = current_id; - return (unlikely(current_id == -1)) ? -1 : 0; - } else if (unlikely(main_interpreter_id != current_id)) - #else - static PyInterpreterState *main_interpreter = NULL; - PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; - if (!main_interpreter) { - main_interpreter = current_interpreter; - } else if (unlikely(main_interpreter != current_interpreter)) - #endif - { - PyErr_SetString( - PyExc_ImportError, - "Interpreter change detected - this module can only be loaded into one interpreter per process."); - return -1; - } - return 0; -} -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { +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)) { - if (allow_none || value != Py_None) { - result = PyDict_SetItemString(moddict, to_name, value); - } + result = PyDict_SetItemString(moddict, to_name, value); Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); @@ -17454,10 +16663,8 @@ static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject } return result; } -static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { +static PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; - if (__Pyx_check_single_interpreter()) - return NULL; if (__pyx_m) return __Pyx_NewRef(__pyx_m); modname = PyObject_GetAttrString(spec, "name"); @@ -17467,10 +16674,10 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNU 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__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; + 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); @@ -17478,7 +16685,7 @@ static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNU } -static CYTHON_SMALL_CODE int __pyx_pymod_exec_nmf_pgd(PyObject *__pyx_pyinit_module) +static int __pyx_pymod_exec_nmf_pgd(PyObject *__pyx_pyinit_module) #endif #endif { @@ -17486,11 +16693,7 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_nmf_pgd(PyObject *__pyx_pyinit_mod static PyThread_type_lock __pyx_t_2[8]; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT - if (__pyx_m) { - if (__pyx_m == __pyx_pyinit_module) return 0; - PyErr_SetString(PyExc_RuntimeError, "Module 'nmf_pgd' has already been imported. Re-initialisation is not supported."); - return -1; - } + if (__pyx_m && __pyx_m == __pyx_pyinit_module) return 0; #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif @@ -17505,9 +16708,6 @@ if (!__Pyx_RefNanny) { #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_nmf_pgd(void)", 0); if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pxy_PyFrame_Initialize_Offsets - __Pxy_PyFrame_Initialize_Offsets(); - #endif __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) @@ -17562,7 +16762,7 @@ if (!__Pyx_RefNanny) { 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_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) } #if PY_MAJOR_VERSION >= 3 { @@ -17589,28 +16789,16 @@ if (!__Pyx_RefNanny) { if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif - /* "gensim/models/nmf_pgd.pyx":23 - * return a + /* "gensim/models/nmf_pgd.pyx":18 + * return x if x > y else y * - * def solve_h(double[:, ::1] h, double[:, :] Wt_v_minus_r, double[:, ::1] WtW, double kappa): # <<<<<<<<<<<<<< + * def solve_h(double[:, ::1] h, double[:, :] Wtv, double[:, ::1] WtW, int[::1] permutation, 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_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, 18, __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) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_solve_h, __pyx_t_1) < 0) __PYX_ERR(0, 18, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "gensim/models/nmf_pgd.pyx":1 @@ -17623,90 +16811,90 @@ if (!__Pyx_RefNanny) { 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":209 + /* "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, 209, __pyx_L1_error) + __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, 209, __pyx_L1_error) + 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":286 + /* "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__23, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 286, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__24, 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":287 + /* "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__24, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 287, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__25, 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":288 + /* "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__25, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 288, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__26, 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":291 + /* "View.MemoryView":290 * * * cdef contiguous = Enum("") # <<<<<<<<<<<<<< * cdef indirect_contiguous = Enum("") * */ - __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 291, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__27, 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":292 + /* "View.MemoryView":291 * * cdef contiguous = Enum("") * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< * * */ - __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__27, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 292, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__28, 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":316 + /* "View.MemoryView":315 * * DEF THREAD_LOCKS_PREALLOCATED = 8 * cdef int __pyx_memoryview_thread_locks_used = 0 # <<<<<<<<<<<<<< @@ -17715,7 +16903,7 @@ if (!__Pyx_RefNanny) { */ __pyx_memoryview_thread_locks_used = 0; - /* "View.MemoryView":317 + /* "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 = [ # <<<<<<<<<<<<<< @@ -17732,43 +16920,43 @@ if (!__Pyx_RefNanny) { __pyx_t_2[7] = PyThread_allocate_lock(); memcpy(&(__pyx_memoryview_thread_locks[0]), __pyx_t_2, sizeof(__pyx_memoryview_thread_locks[0]) * (8)); - /* "View.MemoryView":545 + /* "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, 545, __pyx_L1_error) + __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(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, 545, __pyx_L1_error) + 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":991 + /* "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, 991, __pyx_L1_error) + __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(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, 991, __pyx_L1_error) + 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): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result + * 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)":11 + /* "(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): # <<<<<<<<<<<<<< @@ -17783,9 +16971,9 @@ if (!__Pyx_RefNanny) { __Pyx_XDECREF(__pyx_t_1); if (__pyx_m) { if (__pyx_d) { - __Pyx_AddTraceback("init gensim.models.nmf_pgd", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("init gensim.models.nmf_pgd", 0, __pyx_lineno, __pyx_filename); } - Py_CLEAR(__pyx_m); + Py_DECREF(__pyx_m); __pyx_m = 0; } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init gensim.models.nmf_pgd"); } @@ -17806,9 +16994,9 @@ if (!__Pyx_RefNanny) { static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; - m = PyImport_ImportModule(modname); + m = PyImport_ImportModule((char *)modname); if (!m) goto end; - p = PyObject_GetAttrString(m, "RefNannyAPI"); + p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: @@ -18358,7 +17546,7 @@ static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, P 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 | METH_STACKLESS))); + 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, @@ -18366,15 +17554,16 @@ static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, P caller loses its exception */ assert(!PyErr_Occurred()); if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { - return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); + return (*((__Pyx_PyCFunctionFastWithKeywords)meth)) (self, args, nargs, NULL); } else { - return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); + 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; @@ -18392,7 +17581,7 @@ static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args if (f == NULL) { return NULL; } - fastlocals = __Pyx_PyFrame_GetLocalsplus(f); + fastlocals = f->f_localsplus; for (i = 0; i < na; i++) { Py_INCREF(*args); fastlocals[i] = *args++; @@ -18492,35 +17681,6 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, #endif #endif -/* PyObjectCall2Args */ -static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { - PyObject *args, *result = NULL; - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(function)) { - PyObject *args[2] = {arg1, arg2}; - return __Pyx_PyFunction_FastCall(function, args, 2); - } - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(function)) { - PyObject *args[2] = {arg1, arg2}; - return __Pyx_PyCFunction_FastCall(function, args, 2); - } - #endif - args = PyTuple_New(2); - if (unlikely(!args)) goto done; - Py_INCREF(arg1); - PyTuple_SET_ITEM(args, 0, arg1); - Py_INCREF(arg2); - PyTuple_SET_ITEM(args, 1, arg2); - Py_INCREF(function); - result = __Pyx_PyObject_Call(function, args, NULL); - Py_DECREF(args); - Py_DECREF(function); -done: - return result; -} - /* PyObjectCallMethO */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { @@ -18759,7 +17919,7 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_ if (wraparound & unlikely(i < 0)) { wrapped_i += PyList_GET_SIZE(o); } - if ((!boundscheck) || likely(__Pyx_is_valid_index(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; @@ -18777,7 +17937,7 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize if (wraparound & unlikely(i < 0)) { wrapped_i += PyTuple_GET_SIZE(o); } - if ((!boundscheck) || likely(__Pyx_is_valid_index(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; @@ -18793,7 +17953,7 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS if (is_list || PyList_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); - if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { + if ((!boundscheck) || (likely((n >= 0) & (n < PyList_GET_SIZE(o))))) { PyObject *r = PyList_GET_ITEM(o, n); Py_INCREF(r); return r; @@ -18801,7 +17961,7 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, } else if (PyTuple_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); - if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { + if ((!boundscheck) || likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, n); Py_INCREF(r); return r; @@ -18933,60 +18093,52 @@ static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject } /* GetModuleGlobalName */ -#if CYTHON_USE_DICT_VERSIONS -static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) -#else -static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) -#endif -{ +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); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { - return __Pyx_NewRef(result); + Py_INCREF(result); } else if (unlikely(PyErr_Occurred())) { - return NULL; - } + result = NULL; + } else { #else result = PyDict_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { - return __Pyx_NewRef(result); - } + Py_INCREF(result); + } else { #endif #else result = PyObject_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } - PyErr_Clear(); + if (!result) { + PyErr_Clear(); #endif - return __Pyx_GetBuiltinName(name); + result = __Pyx_GetBuiltinName(name); + } + return result; } /* RaiseTooManyValuesToUnpack */ -static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + 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) { + 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) { + 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) { + static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; @@ -18998,29 +18150,13 @@ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { return 0; } -/* GetTopmostException */ -#if CYTHON_USE_EXC_INFO_STACK -static _PyErr_StackItem * -__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) -{ - _PyErr_StackItem *exc_info = tstate->exc_info; - while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && - exc_info->previous_item != NULL) - { - exc_info = exc_info->previous_item; - } - return exc_info; -} -#endif - /* SaveResetException */ -#if CYTHON_FAST_THREAD_STATE + #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - #if CYTHON_USE_EXC_INFO_STACK - _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); - *type = exc_info->exc_type; - *value = exc_info->exc_value; - *tb = exc_info->exc_traceback; + #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; @@ -19032,14 +18168,13 @@ static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject * } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; - #if CYTHON_USE_EXC_INFO_STACK - _PyErr_StackItem *exc_info = tstate->exc_info; - tmp_type = exc_info->exc_type; - tmp_value = exc_info->exc_value; - tmp_tb = exc_info->exc_traceback; - exc_info->exc_type = type; - exc_info->exc_value = value; - exc_info->exc_traceback = tb; + #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; @@ -19055,12 +18190,11 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject #endif /* GetException */ -#if CYTHON_FAST_THREAD_STATE -static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) + #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) +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; @@ -19093,16 +18227,13 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) *value = local_value; *tb = local_tb; #if CYTHON_FAST_THREAD_STATE - #if CYTHON_USE_EXC_INFO_STACK - { - _PyErr_StackItem *exc_info = tstate->exc_info; - tmp_type = exc_info->exc_type; - tmp_value = exc_info->exc_value; - tmp_tb = exc_info->exc_traceback; - exc_info->exc_type = local_type; - exc_info->exc_value = local_value; - exc_info->exc_traceback = local_tb; - } + #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; @@ -19129,17 +18260,16 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) } /* SwapException */ -#if CYTHON_FAST_THREAD_STATE + #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; - #if CYTHON_USE_EXC_INFO_STACK - _PyErr_StackItem *exc_info = tstate->exc_info; - tmp_type = exc_info->exc_type; - tmp_value = exc_info->exc_value; - tmp_tb = exc_info->exc_traceback; - exc_info->exc_type = *type; - exc_info->exc_value = *value; - exc_info->exc_traceback = *tb; + #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; @@ -19164,7 +18294,7 @@ static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, #endif /* Import */ -static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; @@ -19211,7 +18341,7 @@ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, - name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); + name, global_dict, empty_dict, list, py_level, NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( @@ -19229,7 +18359,7 @@ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { } /* FastTypeChecks */ -#if CYTHON_COMPILING_IN_CPYTHON + #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { a = a->tp_base; @@ -19329,7 +18459,7 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj #endif /* PyIntBinop */ -#if !CYTHON_COMPILING_IN_PYPY + #if !CYTHON_COMPILING_IN_PYPY static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) { #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(op1))) { @@ -19451,12 +18581,12 @@ static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED #endif /* None */ -static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { + static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); } /* WriteUnraisableException */ -static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, + 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; @@ -19498,7 +18628,7 @@ static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, } /* ImportFrom */ -static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Format(PyExc_ImportError, @@ -19512,7 +18642,7 @@ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { } /* HasAttr */ -static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { + static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { PyObject *r; if (unlikely(!__Pyx_PyBaseString_Check(n))) { PyErr_SetString(PyExc_TypeError, @@ -19530,7 +18660,7 @@ static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { } /* PyObject_GenericGetAttrNoDict */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 + #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 @@ -19570,7 +18700,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj #endif /* PyObject_GenericGetAttr */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 + #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { return PyObject_GenericGetAttr(obj, attr_name); @@ -19580,7 +18710,7 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam #endif /* SetVTable */ -static int __Pyx_SetVtable(PyObject *dict, void *vtable) { + static int __Pyx_SetVtable(PyObject *dict, void *vtable) { #if PY_VERSION_HEX >= 0x02070000 PyObject *ob = PyCapsule_New(vtable, 0, 0); #else @@ -19598,7 +18728,7 @@ static int __Pyx_SetVtable(PyObject *dict, void *vtable) { } /* SetupReduce */ -static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { + static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { int ret; PyObject *name_attr; name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name_2); @@ -19674,8 +18804,8 @@ static int __Pyx_setup_reduce(PyObject* type_obj) { } /* CLineInTraceback */ -#ifndef CYTHON_CLINE_IN_TRACEBACK -static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { + #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 @@ -19688,9 +18818,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { #if CYTHON_COMPILING_IN_CPYTHON cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); if (likely(cython_runtime_dict)) { - __PYX_PY_DICT_LOOKUP_IF_MODIFIED( - use_cline, *cython_runtime_dict, - __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) + use_cline = __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback); } else #endif { @@ -19707,7 +18835,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { c_line = 0; PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } - else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + else if (PyObject_Not(use_cline) != 0) { c_line = 0; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); @@ -19716,7 +18844,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { #endif /* CodeObjectCache */ -static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + 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; @@ -19796,7 +18924,7 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { } /* AddTraceback */ -#include "compile.h" + #include "compile.h" #include "frameobject.h" #include "traceback.h" static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( @@ -19902,8 +19030,8 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { #endif -/* MemviewSliceIsContig */ -static int + /* MemviewSliceIsContig */ + static int __pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim) { int i, index, step, start; @@ -19925,7 +19053,7 @@ __pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim) } /* OverlappingSlices */ -static void + static void __pyx_get_array_memory_extents(__Pyx_memviewslice *slice, void **out_start, void **out_end, int ndim, size_t itemsize) @@ -19961,7 +19089,7 @@ __pyx_slices_overlap(__Pyx_memviewslice *slice1, } /* Capsule */ -static CYTHON_INLINE PyObject * + static CYTHON_INLINE PyObject * __pyx_capsule_create(void *p, CYTHON_UNUSED const char *sig) { PyObject *cobj; @@ -19974,7 +19102,7 @@ __pyx_capsule_create(void *p, CYTHON_UNUSED const char *sig) } /* IsLittleEndian */ -static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) + static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) { union { uint32_t u32; @@ -19985,7 +19113,7 @@ static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) } /* BufferFormatCheck */ -static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, __Pyx_BufFmt_StackElem* stack, __Pyx_TypeInfo* type) { stack[0].field = &ctx->root; @@ -20487,7 +19615,7 @@ static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const cha } /* TypeInfoCompare */ - static int + static int __pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b) { int i; @@ -20528,7 +19656,7 @@ __pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b) } /* MemviewSliceValidateAndInit */ - static int + static int __pyx_check_strides(Py_buffer *buf, int dim, int ndim, int spec) { if (buf->shape[dim] <= 1) @@ -20710,7 +19838,7 @@ static int __Pyx_ValidateAndInit_memviewslice( } /* ObjectToMemviewSlice */ - static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_d_dc_double(PyObject *obj, int writable_flag) { + 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) }; @@ -20733,7 +19861,7 @@ static int __Pyx_ValidateAndInit_memviewslice( } /* ObjectToMemviewSlice */ - static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dsds_double(PyObject *obj, int writable_flag) { + 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) }; @@ -20755,8 +19883,31 @@ static int __Pyx_ValidateAndInit_memviewslice( return result; } +/* ObjectToMemviewSlice */ + static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dc_int(PyObject *obj, int writable_flag) { + __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_BufFmt_StackElem stack[1]; + int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_CONTIG) }; + int retcode; + if (obj == Py_None) { + result.memview = (struct __pyx_memoryview_obj *) Py_None; + return result; + } + retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, __Pyx_IS_C_CONTIG, + (PyBUF_C_CONTIGUOUS | PyBUF_FORMAT) | writable_flag, 1, + &__Pyx_TypeInfo_int, stack, + &result, obj); + if (unlikely(retcode == -1)) + goto __pyx_fail; + return result; +__pyx_fail: + result.memview = NULL; + result.data = NULL; + return result; +} + /* MemviewSliceCopyTemplate */ - static __Pyx_memviewslice + 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, @@ -20823,7 +19974,7 @@ __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, } /* CIntFromPyVerify */ - #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + #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) @@ -20845,8 +19996,8 @@ __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, } /* CIntFromPy */ - static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { - const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; + 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))) { @@ -21034,8 +20185,8 @@ __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, } /* CIntFromPy */ - static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { - const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; + 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))) { @@ -21223,8 +20374,8 @@ __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, } /* CIntToPy */ - static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { - const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; + 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)) { @@ -21254,8 +20405,8 @@ __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, } /* CIntToPy */ - static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { - const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; + 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)) { @@ -21285,8 +20436,8 @@ __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, } /* CIntFromPy */ - static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) { - const char neg_one = (char) ((char) 0 - (char) 1), const_zero = (char) 0; + 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))) { @@ -21473,54 +20624,8 @@ __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, 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) { + 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()); @@ -21536,7 +20641,7 @@ __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, } /* InitStrings */ - static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { @@ -21645,13 +20750,6 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } -static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { - int retval; - if (unlikely(!x)) return -1; - retval = __Pyx_PyObject_IsTrue(x); - Py_DECREF(x); - return retval; -} static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { @@ -21729,7 +20827,7 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { if (sizeof(Py_ssize_t) >= sizeof(long)) return PyInt_AS_LONG(b); else - return PyInt_AsSsize_t(b); + return PyInt_AsSsize_t(x); } #endif if (likely(PyLong_CheckExact(b))) { diff --git a/gensim/models/nmf_pgd.pyx b/gensim/models/nmf_pgd.pyx index 01e9075cbc..dff480cdb4 100644 --- a/gensim/models/nmf_pgd.pyx +++ b/gensim/models/nmf_pgd.pyx @@ -6,7 +6,7 @@ # cython: nonecheck=False # cython: embedsignature=True -from libc.math cimport sqrt, fabs, copysign +from libc.math cimport sqrt from cython.parallel import prange cdef double fmin(double x, double y) nogil: @@ -15,19 +15,14 @@ cdef double fmin(double x, double y) nogil: 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): +def solve_h(double[:, ::1] h, double[:, :] Wtv, double[:, ::1] WtW, int[::1] permutation, 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 + Wtv : matrix WtW : matrix Returns @@ -47,8 +42,9 @@ def solve_h(double[:, ::1] h, double[:, :] Wt_v_minus_r, double[:, ::1] WtW, dou for sample_idx in prange(n_samples, nogil=True): for component_idx_1 in range(n_components): + component_idx_1 = permutation[component_idx_1] - grad = -Wt_v_minus_r[component_idx_1, sample_idx] + grad = -Wtv[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] @@ -64,103 +60,3 @@ def solve_h(double[:, ::1] h, double[:, :] Wt_v_minus_r, double[:, ::1] WtW, dou 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)