From 41a8bcebf7c1e32117b5a0f0ba8121389751aaf4 Mon Sep 17 00:00:00 2001 From: Ruiqi Li Date: Tue, 1 Sep 2020 11:17:17 -0400 Subject: [PATCH 1/7] Cleanup code --- .gitignore | 141 +++ Example.ipynb | 1041 ++++++-------------- requirements.txt | 4 + SDSS_MGS.train => resources/SDSS_MGS.train | 0 som.f90 => resources/som.f90 | 0 setup.py | 23 +- somsphere.py | 543 ---------- somsphere/__init__.py | 318 ++++++ somsphere/models/__init__.py | 14 + somsphere/utils/__init__.py | 184 ++++ test/test_models.py | 11 + 11 files changed, 983 insertions(+), 1296 deletions(-) create mode 100644 .gitignore create mode 100644 requirements.txt rename SDSS_MGS.train => resources/SDSS_MGS.train (100%) rename som.f90 => resources/som.f90 (100%) delete mode 100644 somsphere.py create mode 100644 somsphere/__init__.py create mode 100644 somsphere/models/__init__.py create mode 100644 somsphere/utils/__init__.py create mode 100644 test/test_models.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9016f7f --- /dev/null +++ b/.gitignore @@ -0,0 +1,141 @@ +.idea/ + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + diff --git a/Example.ipynb b/Example.ipynb index a66d81e..f4fa7cc 100644 --- a/Example.ipynb +++ b/Example.ipynb @@ -2,34 +2,23 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/Matias/Library/Enthought/Canopy_64bit/User/lib/python2.7/site-packages/IPython/kernel/__init__.py:13: ShimWarning: The `IPython.kernel` package has been deprecated. You should import from ipykernel or jupyter_client instead.\n", - " \"You should import from ipykernel or jupyter_client instead.\", ShimWarning)\n" - ] - } - ], + "execution_count": 8, + "metadata": {}, + "outputs": [], "source": [ "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "import somsphere\n", "import healpy as hp\n", - "import numpy as np" + "import numpy as np\n", + "\n", + "data = \"resources/SDSS_MGS.train\"" ] }, { "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": false - }, + "execution_count": 48, + "metadata": {}, "outputs": [ { "data": { @@ -37,23 +26,21 @@ "(5000, 9)" ] }, - "execution_count": 2, + "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#just read magnitudes and colors\n", - "Data_X=np.loadtxt('SDSS_MGS.train', usecols=(1,2,3,4,5,6,7,8,9), unpack=True).T\n", + "Data_X=np.loadtxt(data, usecols=(1,2,3,4,5,6,7,8,9), unpack=True).T\n", "np.shape(Data_X)" ] }, { "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": false - }, + "execution_count": 49, + "metadata": {}, "outputs": [ { "data": { @@ -61,35 +48,31 @@ "(5000,)" ] }, - "execution_count": 3, + "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#read zspec (or any other extra column)\n", - "Data_Y=np.loadtxt('SDSS_MGS.train', usecols=(0,), unpack=True).T\n", + "Data_Y=np.loadtxt(data, usecols=(0,), unpack=True).T\n", "np.shape(Data_Y)" ] }, { "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": false - }, + "execution_count": 54, + "metadata": {}, "outputs": [], "source": [ "#create an instance\n", - "M=somsphere.SelfMap(Data_X, Data_Y,topology='grid', Ntop=15, iterations=100, periodic='no')" + "M=somsphere.SOMap(Data_X, Data_Y,topology='grid', n_top=15, n_iter=100, periodic=False)" ] }, { "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": true - }, + "execution_count": 55, + "metadata": {}, "outputs": [], "source": [ "M.create_map() #This actually creates the map using only Data_X" @@ -97,10 +80,8 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": true - }, + "execution_count": 56, + "metadata": {}, "outputs": [], "source": [ "M.evaluate_map() # Will evaluate Data_Y, basically will take mean for every value of Y per cell" @@ -108,27 +89,19 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": false - }, + "execution_count": 57, + "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/Matias/Library/Enthought/Canopy_64bit/User/lib/python2.7/site-packages/matplotlib/cbook.py:122: MatplotlibDeprecationWarning: The matplotlib.mpl module was deprecated in version 1.3. Use `import matplotlib as mpl` instead.\n", - " warnings.warn(message, mplDeprecation, stacklevel=1)\n" - ] - }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcgAAAHQCAYAAAAlJPocAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nUDYAAAAAAAAAAAAAvAz9f4DEPx2A/p/qAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -138,31 +111,29 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": { - "collapsed": false - }, + "execution_count": 15, + "metadata": {}, "outputs": [], "source": [ "#We can evaluate other column, for example column 0 from X\n", - "M.evaluate_map(inputY=Data_X[:,0])" + "M.evaluate_map(input_y=Data_X[:,0])" ] }, { "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": false - }, + "execution_count": 16, + "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcgAAAHMCAYAAABRMDj8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nNJCmsqYAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -172,10 +143,8 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": true - }, + "execution_count": 17, + "metadata": {}, "outputs": [], "source": [ "#Every time the map is created it will be different given the random weights\n", @@ -184,19 +153,19 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": false - }, + "execution_count": 18, + "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcgAAAHMCAYAAABRMDj8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -207,45 +176,41 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": { - "collapsed": false - }, + "execution_count": 19, + "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcgAAAHMCAYAAABRMDj8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAAANwL/X+gtx+p8+h6ogAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ - "M.evaluate_map(inputY=Data_X[:,0])\n", + "M.evaluate_map(input_y=Data_X[:,0])\n", "M.plot_map()" ] }, { "cell_type": "code", - "execution_count": 14, - "metadata": { - "collapsed": false - }, + "execution_count": 20, + "metadata": {}, "outputs": [], "source": [ "#Spherical coordinates\n", - "M_sph=somsphere.SelfMap(Data_X, Data_Y,topology='sphere', Ntop=8, iterations=100)" + "M_sph=somsphere.SOMap(Data_X, Data_Y,topology='sphere', n_top=8, n_iter=100)" ] }, { "cell_type": "code", - "execution_count": 15, - "metadata": { - "collapsed": false - }, + "execution_count": 21, + "metadata": {}, "outputs": [], "source": [ "M_sph.create_map()" @@ -253,19 +218,19 @@ }, { "cell_type": "code", - "execution_count": 16, - "metadata": { - "collapsed": false - }, + "execution_count": 22, + "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlIAAAFaCAYAAADVZLODAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -276,24 +241,24 @@ }, { "cell_type": "code", - "execution_count": 17, - "metadata": { - "collapsed": false - }, + "execution_count": 23, + "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlIAAAFaCAYAAADVZLODAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ - "M_sph.evaluate_map(inputY=Data_X[:,0])\n", + "M_sph.evaluate_map(input_y=Data_X[:,0])\n", "M_sph.plot_map()" ] }, @@ -306,10 +271,8 @@ }, { "cell_type": "code", - "execution_count": 19, - "metadata": { - "collapsed": false - }, + "execution_count": 30, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -323,23 +286,21 @@ "source": [ "# To test with fixed weights, so answer is always the same (to be able to compare)\n", "# need more iterations to make sure it converges\n", - "M=somsphere.SelfMap(Data_X, Data_Y,topology='grid', Ntop=15, iterations=300, periodic='no')\n", - "print M.nDim, 'dimensions' #dimensions\n", - "print M.npix, 'cells' #cells" + "M=somsphere.SOMap(Data_X, Data_Y,topology='grid', n_top=15, n_iter=300, periodic=False)\n", + "print(M.n_dim, 'dimensions') #dimensions\n", + "print(M.n_pix, 'cells') #cells" ] }, { "cell_type": "code", - "execution_count": 20, - "metadata": { - "collapsed": false - }, + "execution_count": 33, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "dw = 0.0098814229249\n" + "dw = 0.009881422924901186\n" ] }, { @@ -348,26 +309,24 @@ "(9, 225)" ] }, - "execution_count": 20, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#weights are supposed to be random, but we can make them linear for testing\n", - "W = np.linspace(0,20,M.nDim*M.npix).reshape(M.nDim,M.npix)\n", + "W = np.linspace(0,20,M.n_dim*M.n_pix).reshape(M.n_dim,M.n_pix)\n", "#look carefully onhow this was created, elements go from 0 to 20 with a difference of \n", "#W[0][1]-W[0][0] = 0.009881422924901186\n", - "print 'dw = ', W[0][1]-W[0][0]\n", + "print('dw = ', W[0][1]-W[0][0])\n", "np.shape(W)" ] }, { "cell_type": "code", - "execution_count": 21, - "metadata": { - "collapsed": false - }, + "execution_count": 34, + "metadata": {}, "outputs": [], "source": [ "M.create_map(inputs_weights=W, random_order=False)" @@ -375,10 +334,8 @@ }, { "cell_type": "code", - "execution_count": 22, - "metadata": { - "collapsed": true - }, + "execution_count": 35, + "metadata": {}, "outputs": [], "source": [ "M.evaluate_map()" @@ -386,19 +343,19 @@ }, { "cell_type": "code", - "execution_count": 23, - "metadata": { - "collapsed": false - }, + "execution_count": 36, + "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcgAAAHMCAYAAABRMDj8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nJEl6Evp/wRd2HVn5kqgAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -408,19 +365,19 @@ }, { "cell_type": "code", - "execution_count": 24, - "metadata": { - "collapsed": false - }, + "execution_count": 37, + "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcgAAAHMCAYAAABRMDj8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nJEl6Evp/wRd2HVn5kqgAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -433,19 +390,17 @@ }, { "cell_type": "code", - "execution_count": 25, - "metadata": { - "collapsed": false - }, + "execution_count": 38, + "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([ 16.1580654 , 14.33966559, 13.50589005, 13.13014191,\n", - " 12.84625795, 1.81839981, 0.83377553, 0.37574814, 0.28388396])" + "array([16.1580654 , 14.33966559, 13.50589005, 13.13014191, 12.84625795,\n", + " 1.81839981, 0.83377553, 0.37574814, 0.28388396])" ] }, - "execution_count": 25, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" } @@ -457,28 +412,24 @@ }, { "cell_type": "code", - "execution_count": 26, - "metadata": { - "collapsed": true - }, + "execution_count": 39, + "metadata": {}, "outputs": [], "source": [ "# in spherical\n", - "M_sph=somsphere.SelfMap(Data_X, Data_Y,topology='sphere', Ntop=8, iterations=300)" + "M_sph=somsphere.SOMap(Data_X, Data_Y,topology='sphere', n_top=8, n_iter=300)" ] }, { "cell_type": "code", - "execution_count": 27, - "metadata": { - "collapsed": false - }, + "execution_count": 40, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "dw = 0.00289393720156\n" + "dw = 0.0028939372015627262\n" ] }, { @@ -487,7 +438,7 @@ "(9, 768)" ] }, - "execution_count": 27, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" } @@ -495,47 +446,40 @@ "source": [ "#weights, the number of pixels is different\n", "#weights are supposed to be random, but we can make them linear for testing\n", - "W = np.linspace(0,20,M_sph.nDim*M_sph.npix).reshape(M_sph.nDim,M_sph.npix)\n", + "W = np.linspace(0,20,M_sph.n_dim*M_sph.n_pix).reshape(M_sph.n_dim,M_sph.n_pix)\n", "#look carefully onhow this was created, elements go from 0 to 20 with a difference of \n", "#W[0][1]-W[0][0] = 0.009881422924901186\n", - "print 'dw = ', W[0][1]-W[0][0]\n", + "print('dw = ', W[0][1]-W[0][0])\n", "np.shape(W)\n" ] }, { "cell_type": "code", - "execution_count": 28, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mM_sph\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcreate_map\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minputs_weights\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mW\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrandom_order\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m/Users/Matias/Dropbox/GitHub/somsphere/somsphere.py\u001b[0m in \u001b[0;36mcreate_map\u001b[0;34m(self, evol, inputs_weights, random_order)\u001b[0m\n\u001b[1;32m 327\u001b[0m \u001b[0mtt\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 328\u001b[0m \u001b[0minputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mindex_random\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 329\u001b[0;31m \u001b[0mbest\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mactivation\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msom_best_cell\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 330\u001b[0m self.weights += alpha * h(best, self.distLib, sigma) * numpy.transpose(\n\u001b[1;32m 331\u001b[0m (inputs - numpy.transpose(self.weights)))\n", - "\u001b[0;32m/Users/Matias/Dropbox/GitHub/somsphere/somsphere.py\u001b[0m in \u001b[0;36msom_best_cell\u001b[0;34m(self, inputs, return_vals)\u001b[0m\n\u001b[1;32m 271\u001b[0m \u001b[0mIt\u001b[0m \u001b[0mcan\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mmore\u001b[0m \u001b[0mthan\u001b[0m \u001b[0mone\u001b[0m \u001b[0mvalue\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mneeded\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 272\u001b[0m \"\"\"\n\u001b[0;32m--> 273\u001b[0;31m activations = numpy.sum(numpy.transpose([self.importance]) * (\n\u001b[0m\u001b[1;32m 274\u001b[0m numpy.transpose(numpy.tile(inputs, (self.npix, 1))) - self.weights) ** 2, axis=0)\n\u001b[1;32m 275\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mreturn_vals\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/Users/Matias/Library/Enthought/Canopy_64bit/User/lib/python2.7/site-packages/numpy/core/fromnumeric.pyc\u001b[0m in \u001b[0;36mtranspose\u001b[0;34m(a, axes)\u001b[0m\n\u001b[1;32m 534\u001b[0m \u001b[0mtranspose\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtranspose\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 535\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mAttributeError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 536\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_wrapit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'transpose'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 537\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mtranspose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maxes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 538\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/Users/Matias/Library/Enthought/Canopy_64bit/User/lib/python2.7/site-packages/numpy/core/fromnumeric.pyc\u001b[0m in \u001b[0;36m_wrapit\u001b[0;34m(obj, method, *args, **kwds)\u001b[0m\n\u001b[1;32m 43\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mAttributeError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 44\u001b[0m \u001b[0mwrap\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 45\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 46\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mwrap\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 47\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmu\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndarray\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - } - ], + "execution_count": 41, + "metadata": {}, + "outputs": [], "source": [ "M_sph.create_map(inputs_weights=W, random_order=False)" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "M_sph.evaluate_map()\n", "M_sph.plot_map()" @@ -543,22 +487,31 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "M_sph.evaluate_map(inputY=Data_X[:,0])\n", + "M_sph.evaluate_map(input_y=Data_X[:,0])\n", "M_sph.plot_map()\n" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 44, + "metadata": {}, "outputs": [], "source": [ "M_sph.create_map(inputs_weights=W, random_order=False)" @@ -566,11 +519,22 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "M_sph.evaluate_map()\n", "M_sph.plot_map()" @@ -578,11 +542,21 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([20.09034726, 18.18745936, 17.18432217, 16.73921586, 16.40915885,\n", + " 1.9028879 , 1.00313718, 0.44510632, 0.330057 ])" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "#Weights for cell 0\n", "M_sph.weights[:,0]" @@ -591,26 +565,34 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "# hexagonal topology with periodic conditions\n", - "M_hex=somsphere.SelfMap(Data_X, Data_Y,topology='hex', Ntop=15, iterations=300, periodic='yes')\n", - "print M_hex.nDim, 'dimensions' #dimensions\n", - "print M_hex.npix, 'cells' #cells" + "M_hex=somsphere.SOMap(Data_X, Data_Y,topology='hex', n_top=15, n_iter=300, periodic=True)\n", + "print(M_hex.n_dim, 'dimensions') #dimensions\n", + "print(M_hex.n_pix, 'cells') #cells" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'M_hex' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mW\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinspace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m20\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mM_hex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_dim\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mM_hex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_pix\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mM_hex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_dim\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mM_hex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_pix\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mM_hex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcreate_map\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minputs_weights\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mW\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrandom_order\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mM_hex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mevaluate_map\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mM_hex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot_map\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'M_hex' is not defined" + ] + } + ], "source": [ - "W=np.linspace(0,20,M_hex.nDim*M_hex.npix).reshape(M_hex.nDim,M_hex.npix)\n", + "W=np.linspace(0,20,M_hex.n_dim*M_hex.n_pix).reshape(M_hex.n_dim,M_hex.n_pix)\n", "M_hex.create_map(inputs_weights=W, random_order=False)\n", "M_hex.evaluate_map()\n", "M_hex.plot_map()" @@ -619,12 +601,10 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ - "M_hex.evaluate_map(inputY=Data_X[:,0])\n", + "M_hex.evaluate_map(input_y=Data_X[:,0])\n", "M_hex.plot_map()" ] }, @@ -639,10 +619,8 @@ }, { "cell_type": "code", - "execution_count": 21, - "metadata": { - "collapsed": false - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "X_R=np.random.rand(45000).reshape(5000,9)" @@ -650,43 +628,26 @@ }, { "cell_type": "code", - "execution_count": 22, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(5000, 9)" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "np.shape(X_R)" ] }, { "cell_type": "code", - "execution_count": 23, - "metadata": { - "collapsed": false - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ - "M_sph_R=somsphere.SelfMap(X_R, X_R[:,0],topology='sphere', Ntop=8, iterations=100)" + "M_sph_R=somsphere.SOMap(X_R, X_R[:,0],topology='sphere', n_top=8, n_iter=100)" ] }, { "cell_type": "code", - "execution_count": 24, - "metadata": { - "collapsed": false - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "M_sph_R.create_map()" @@ -694,10 +655,8 @@ }, { "cell_type": "code", - "execution_count": 25, - "metadata": { - "collapsed": true - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "M_sph_R.evaluate_map()" @@ -705,119 +664,53 @@ }, { "cell_type": "code", - "execution_count": 26, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlIAAAFaCAYAAADVZLODAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "M_sph_R.plot_map()" ] }, { "cell_type": "code", - "execution_count": 27, - "metadata": { - "collapsed": false - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ - "M_sph_R.evaluate_map(inputY=X_R[:,0])" + "M_sph_R.evaluate_map(input_y=X_R[:,0])" ] }, { "cell_type": "code", - "execution_count": 28, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlIAAAFaCAYAAADVZLODAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "M_sph_R.plot_map()" ] }, { "cell_type": "code", - "execution_count": 29, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXsAAAEACAYAAABS29YJAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n6NChQ4cOHTp06HA5+H+/I8HWSprDBwAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "plt.plot(X_R[:,0],'k.')" ] }, { "cell_type": "code", - "execution_count": 30, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[525, 1796, 2251, 3143, 3165, 3185]" - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "M_sph_R.ivals[0]\n" ] }, { "cell_type": "code", - "execution_count": 31, - "metadata": { - "collapsed": false - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "HR=np.zeros(M_sph_R.npix)\n", @@ -832,207 +725,63 @@ }, { "cell_type": "code", - "execution_count": 68, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 68, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXUAAAEACAYAAABMEua6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "plt.plot(H)" ] }, { "cell_type": "code", - "execution_count": 69, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 69, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXgAAAEACAYAAAC57G0KAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nqFGjRo0aNfLx/wBH8aWv5j2pzwAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "plt.plot(MM)" ] }, { "cell_type": "code", - "execution_count": 70, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(6.510416666666667, 0.49416192027908679)" - ] - }, - "execution_count": 70, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "np.mean(H), np.mean(MM)" ] }, { "cell_type": "code", - "execution_count": 55, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "11.0" - ] - }, - "execution_count": 55, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "H[0]" ] }, { "cell_type": "code", - "execution_count": 56, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "2.7324050443499202" - ] - }, - "execution_count": 56, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "np.std(H)" ] }, { "cell_type": "code", - "execution_count": 72, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([ 13., 39., 47., 90., 94., 127., 100., 76., 66.,\n", - " 50., 35., 20., 5., 4., 2.]),\n", - " array([ 0. , 1.06666667, 2.13333333, 3.2 ,\n", - " 4.26666667, 5.33333333, 6.4 , 7.46666667,\n", - " 8.53333333, 9.6 , 10.66666667, 11.73333333,\n", - " 12.8 , 13.86666667, 14.93333333, 16. ]),\n", - " )" - ] - }, - "execution_count": 72, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEACAYAAABI5zaHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nVTUnSZIkSZIkSZIkSZIkSZIkSZIkSfw/UKQPPKNUKNUAAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "plt.hist(H, bins=15)\n" ] }, { "cell_type": "code", - "execution_count": 74, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([ 5., 14., 46., 60., 64., 61., 30., 33., 38., 25., 31.,\n", - " 31., 35., 34., 42., 43., 63., 61., 40., 12.]),\n", - " array([ 0. , 0.04798922, 0.09597844, 0.14396766, 0.19195688,\n", - " 0.2399461 , 0.28793533, 0.33592455, 0.38391377, 0.43190299,\n", - " 0.47989221, 0.52788143, 0.57587065, 0.62385987, 0.67184909,\n", - " 0.71983831, 0.76782753, 0.81581675, 0.86380598, 0.9117952 ,\n", - " 0.95978442]),\n", - " )" - ] - }, - "execution_count": 74, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXMAAAEACAYAAABBDJb9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nrkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "plt.figure()\n", "plt.hist(MM, bins=20)" @@ -1040,79 +789,35 @@ }, { "cell_type": "code", - "execution_count": 83, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([ 27., 92., 99., 83., 83., 85., 71., 101., 101., 26.]),\n", - " array([ 0.05620335, 0.14474298, 0.23328261, 0.32182224, 0.41036187,\n", - " 0.4989015 , 0.58744113, 0.67598075, 0.76452038, 0.85306001,\n", - " 0.94159964]),\n", - " )" - ] - }, - "execution_count": 83, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAEACAYAAABWLgY0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nH6HQEKFWLu7eAAAAAElFTkSuQmCC\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "plt.hist(M_sph_R.weights[4])" ] }, { "cell_type": "code", - "execution_count": 77, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "768" - ] - }, - "execution_count": 77, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "len(M_sph_R.weights[0])" ] }, { "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": false - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ - "M_sph=somsphere.SelfMap(Data_X, Data_Y,topology='sphere', Ntop=8, iterations=100)" + "M_sph=somsphere.SOMap(Data_X, Data_Y,topology='sphere', n_top=8, n_iter=100)" ] }, { "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": true - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "M_sph.create_map()" @@ -1120,10 +825,8 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": { - "collapsed": true - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "M_sph.evaluate_map()" @@ -1131,40 +834,17 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/Matias/Library/Enthought/Canopy_64bit/User/lib/python2.7/site-packages/matplotlib/cbook.py:122: MatplotlibDeprecationWarning: The matplotlib.mpl module was deprecated in version 1.3. Use `import matplotlib as mpl` instead.\n", - " warnings.warn(message, mplDeprecation, stacklevel=1)\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlIAAAFaCAYAAADVZLODAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQgghhBCiB/l/ZlJ6/4eK+K8AAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "M_sph.plot_map()" ] }, { "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": true - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "H=np.zeros(M_sph.npix)\n", @@ -1179,99 +859,27 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXUAAAEACAYAAABMEua6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "plt.plot(H)" ] }, { "cell_type": "code", - "execution_count": 14, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([ 33., 94., 182., 200., 71., 97., 62., 17., 8., 4.]),\n", - " array([ 0. , 1.8, 3.6, 5.4, 7.2, 9. , 10.8, 12.6, 14.4,\n", - " 16.2, 18. ]),\n", - " )" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXgAAAEACAYAAAC57G0KAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nX/4PPIzuqbxioFsAAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "plt.hist(H)" ] }, { "cell_type": "code", - "execution_count": 53, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 53, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAEACAYAAACwB81wAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nGP4fhLWUMhG25iUAAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "MM1=(MM-np.min(MM))\n", "MM1/=np.max(MM1)\n", @@ -1283,67 +891,18 @@ }, { "cell_type": "code", - "execution_count": 47, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 47, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXgAAAEACAYAAAC57G0KAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nERERERERERERERERERG5cP8PkzL422CizGQAAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "plt.plot(np.sort(MR))" ] }, { "cell_type": "code", - "execution_count": 54, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([ 0.22135417, 1.25 , 1.6015625 , 0.92447917, 0.83333333,\n", - " 0.87239583, 1.015625 , 1.22395833, 1.51041667, 0.546875 ]),\n", - " array([ 0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ]),\n", - " )" - ] - }, - "execution_count": 54, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAEACAYAAACnJV25AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nrkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "plt.hist(MM1, normed=True)\n", "plt.hist(MR1, normed=True, alpha=0.5)" @@ -1352,32 +911,30 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 2", + "display_name": "env37", "language": "python", - "name": "python2" + "name": "env37" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" + "pygments_lexer": "ipython3", + "version": "3.7.9" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..dce3e83 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,4 @@ +matplotlib==3.2.2 +numpy==1.19.1 +scipy==1.5.2 +healpy==1.14.0 diff --git a/SDSS_MGS.train b/resources/SDSS_MGS.train similarity index 100% rename from SDSS_MGS.train rename to resources/SDSS_MGS.train diff --git a/som.f90 b/resources/som.f90 similarity index 100% rename from som.f90 rename to resources/som.f90 diff --git a/setup.py b/setup.py index f0005a7..5a575bd 100644 --- a/setup.py +++ b/setup.py @@ -1,5 +1,6 @@ import sys -files_f90 = ['som.f90', ] + +files_f90 = ['resources/som.f90', ] from numpy.distutils.core import setup, Extension extra_link_args = [] @@ -7,16 +8,16 @@ library_dirs = [] exec(open('version.py').read()) setup( - name = 'somsphere', - version = __version__, - author = 'Matias Carrasco Kind', - author_email = 'mcarras2@illinois.edu', - ext_modules = [Extension('somF', files_f90, ), ], - packages = [], - py_modules = ['somsphere'], - license = 'License.txt', - description = 'somsphere : Self Organizing Maps in spherical coordinates and other topologies', - long_description = open('README.md').read(), + name='somsphere', + version=__version__, + author='Matias Carrasco Kind', + author_email='mcarras2@illinois.edu', + ext_modules=[Extension('somF', files_f90, ), ], + packages=[], + py_modules=['somsphere'], + license='License.txt', + description='somsphere : Self Organizing Maps in spherical coordinates and other topologies', + long_description=open('README.md').read(), url='https://github.com/mgckind/somsphere', install_requires=['numpy', 'matplotlib', 'scipy'], ) diff --git a/somsphere.py b/somsphere.py deleted file mode 100644 index d35790f..0000000 --- a/somsphere.py +++ /dev/null @@ -1,543 +0,0 @@ -""" -.. module:: SOMZ -.. moduleauthor:: Matias Carrasco Kind - -""" -from __future__ import print_function -from builtins import zip -from builtins import range -from builtins import object -__author__ = 'Matias Carrasco Kind' -import numpy -import copy -import sys, os, random -import warnings - -warnings.simplefilter("ignore", RuntimeWarning) -try: - import somF - SF90 = True -except: - SF90 = False - - -def get_index(ix, iy, nx, ny): - return iy * nx + ix - - -def get_pair(ii, nx, ny): - iy = int(numpy.floor(ii / nx)) - ix = ii % nx - return ix, iy - - -def get_ns(ix, iy, nx, ny, index=False): - """ - Get neighbors for rectangular grid given its - coordinates and size of grid - - :param int ix: Coordinate in the x-axis - :param int iy: Coordinate in the y-axis - :param int nx: Number fo cells along the x-axis - :param int ny: Number fo cells along the y-axis - :param bool index: Return indexes in the map format - :return: Array of indexes for direct neighbors - """ - ns = [] - if ix - 1 >= 0: ns.append((ix - 1, iy)) - if iy - 1 >= 0: ns.append((ix, iy - 1)) - if ix + 1 < nx: ns.append((ix + 1, iy)) - if iy + 1 < ny: ns.append((ix, iy + 1)) - - if ix - 1 >= 0 and iy - 1 >= 0: ns.append((ix - 1, iy - 1)) - if ix - 1 >= 0 and iy + 1 < ny: ns.append((ix - 1, iy + 1)) - if ix + 1 < nx and iy + 1 < ny: ns.append((ix + 1, iy + 1)) - if ix + 1 < nx and iy - 1 >= 0: ns.append((ix + 1, iy - 1)) - - ns = numpy.array(ns) - if not index: - return ns - if index: - ins = [] - for i in range(len(ns)): - ins.append(get_index(ns[i, 0], ns[i, 1], nx, ny)) - return numpy.array(ins) - - -def get_ns_hex(ix, iy, nx, ny, index=False): - """ - Get neighbors for hexagonal grid given its coordinates - and size of grid - Same parameters as :func:`get_ns` - """ - ns = [] - even = False - if iy % 2 == 0: even = True - if ix - 1 >= 0: ns.append((ix - 1, iy)) - if ix + 1 < nx: ns.append((ix + 1, iy)) - if iy - 1 >= 0: ns.append((ix, iy - 1)) - if iy + 1 < ny: ns.append((ix, iy + 1)) - if even and ix - 1 >= 0 and iy - 1 >= 0: ns.append((ix - 1, iy - 1)) - if even and ix - 1 >= 0 and iy + 1 < ny: ns.append((ix - 1, iy + 1)) - if not even and ix + 1 < nx and iy - 1 >= 0: ns.append((ix + 1, iy - 1)) - if not even and ix + 1 < nx and iy + 1 < ny: ns.append((ix + 1, iy + 1)) - ns = numpy.array(ns) - if not index: - return ns - if index: - ins = [] - for i in range(len(ns)): - ins.append(get_index(ns[i, 0], ns[i, 1], nx, ny)) - return numpy.array(ins) - - -def geometry(top, Ntop, periodic='no'): - """ - Pre-compute distances between cells in a given topology - and store it on a distLib array - - :param str top: Topology ('grid','hex','sphere') - :param int Ntop: Size of map, for grid Size=Ntop*Ntop, - for hex Size=Ntop*(Ntop+1[2]) if Ntop is even[odd] and for sphere - Size=12*Ntop*Ntop and top must be power of 2 - :param str periodic: Use periodic boundary conditions ('yes'/'no'), valid for 'hex' and 'grid' only - :return: 2D array with distances pre computed between cells and total number of units - :rtype: 2D float array, int - """ - if top == 'sphere': - try: - import healpy as hpx - except: - print('Error: healpy module not found, use grid or hex topologies') - sys.exit(0) - if top == 'sphere': - nside = Ntop - npix = 12 * nside ** 2 - distLib = numpy.zeros((npix, npix)) - for i in range(npix): - ai = hpx.pix2ang(nside, i) - for j in range(i + 1, npix): - aj = hpx.pix2ang(nside, j) - distLib[i, j] = hpx.rotator.angdist(ai, aj) - distLib[j, i] = distLib[i, j] - distLib[numpy.where(numpy.isnan(distLib))] = numpy.pi - if top == 'grid': - nx = Ntop - ny = Ntop - npix = nx * ny - mapxy = numpy.mgrid[0:1:complex(0, nx), 0:1:complex(0, ny)] - mapxy = numpy.reshape(mapxy, (2, npix)) - bX = mapxy[1] - bY = mapxy[0] - dx = 1. / (nx - 1) - dy = 1. / (ny - 1) - distLib = numpy.zeros((npix, npix)) - if periodic == 'no': - for i in range(npix): - for j in range(i + 1, npix): - distLib[i, j] = numpy.sqrt((bX[i] - bX[j]) ** 2 + (bY[i] - bY[j]) ** 2) - distLib[j, i] = distLib[i, j] - if periodic == 'yes': - for i in range(npix): - for j in range(i + 1, npix): - s0 = numpy.sqrt((bX[i] - bX[j]) ** 2 + (bY[i] - bY[j]) ** 2) - s1 = numpy.sqrt((bX[i] - (bX[j] + 1. + dx)) ** 2 + (bY[i] - bY[j]) ** 2) - s2 = numpy.sqrt((bX[i] - (bX[j] + 1. + dx)) ** 2 + (bY[i] - (bY[j] + 1. + dy)) ** 2) - s3 = numpy.sqrt((bX[i] - (bX[j] + 0.)) ** 2 + (bY[i] - (bY[j] + 1. + dy)) ** 2) - s4 = numpy.sqrt((bX[i] - (bX[j] - 1. - dx)) ** 2 + (bY[i] - (bY[j] + 1. + dy)) ** 2) - s5 = numpy.sqrt((bX[i] - (bX[j] - 1. - dx)) ** 2 + (bY[i] - (bY[j] + 0.)) ** 2) - s6 = numpy.sqrt((bX[i] - (bX[j] - 1. - dx)) ** 2 + (bY[i] - (bY[j] - 1. - dy)) ** 2) - s7 = numpy.sqrt((bX[i] - (bX[j] + 0.)) ** 2 + (bY[i] - (bY[j] - 1. - dy)) ** 2) - s8 = numpy.sqrt((bX[i] - (bX[j] + 1. + dx)) ** 2 + (bY[i] - (bY[j] - 1. - dy)) ** 2) - distLib[i, j] = numpy.min((s0, s1, s2, s3, s4, s5, s6, s7, s8)) - distLib[j, i] = distLib[i, j] - if top == 'hex': - nx = Ntop - ny = Ntop - xL = numpy.arange(0, nx, 1.) - dy = 0.8660254 - yL = numpy.arange(0, ny, dy) - ny = len(yL) - nx = len(xL) - npix = nx * ny - bX = numpy.zeros(nx * ny) - bY = numpy.zeros(nx * ny) - kk = 0 - last = ny * dy - for jj in range(ny): - for ii in range(nx): - if jj % 2 == 0: off = 0. - if jj % 2 == 1: off = 0.5 - bX[kk] = xL[ii] + off - bY[kk] = yL[jj] - kk += 1 - distLib = numpy.zeros((npix, npix)) - if periodic == 'no': - for i in range(npix): - for j in range(i + 1, npix): - distLib[i, j] = numpy.sqrt((bX[i] - bX[j]) ** 2 + (bY[i] - bY[j]) ** 2) - distLib[j, i] = distLib[i, j] - if periodic == 'yes': - for i in range(npix): - for j in range(i + 1, npix): - s0 = numpy.sqrt((bX[i] - bX[j]) ** 2 + (bY[i] - bY[j]) ** 2) - s1 = numpy.sqrt((bX[i] - (bX[j] + nx)) ** 2 + (bY[i] - bY[j]) ** 2) - s2 = numpy.sqrt((bX[i] - (bX[j] + nx)) ** 2 + (bY[i] - (bY[j] + last)) ** 2) - s3 = numpy.sqrt((bX[i] - (bX[j] + 0)) ** 2 + (bY[i] - (bY[j] + last)) ** 2) - s4 = numpy.sqrt((bX[i] - (bX[j] - nx)) ** 2 + (bY[i] - (bY[j] + last)) ** 2) - s5 = numpy.sqrt((bX[i] - (bX[j] - nx)) ** 2 + (bY[i] - (bY[j] + 0)) ** 2) - s6 = numpy.sqrt((bX[i] - (bX[j] - nx)) ** 2 + (bY[i] - (bY[j] - last)) ** 2) - s7 = numpy.sqrt((bX[i] - (bX[j] + 0)) ** 2 + (bY[i] - (bY[j] - last)) ** 2) - s8 = numpy.sqrt((bX[i] - (bX[j] + nx)) ** 2 + (bY[i] - (bY[j] - last)) ** 2) - distLib[i, j] = numpy.min((s0, s1, s2, s3, s4, s5, s6, s7, s8)) - distLib[j, i] = distLib[i, j] - return distLib, npix - - -def is_power_2(value): - """ - Check if passed value is a power of 2 - """ - return value!=0 and ((value & (value- 1)) == 0) - - -def get_alpha(t, alphas, alphae, NT): - """ - Get value of alpha at a given time - """ - return alphas * numpy.power(alphae / alphas, float(t) / float(NT)) - - -def get_sigma(t, sigma0, sigmaf, NT): - """ - Get value of sigma at a given time - """ - return sigma0 * numpy.power(sigmaf / sigma0, float(t) / float(NT)) - - -def h(bmu, mapD, sigma): - """ - Neighborhood function which quantifies how much cells around the best matching one are modified - - :param int bmu: best matching unit - :param float mapD: array of distances computed with :func:`geometry` - """ - return numpy.exp(-(mapD[bmu] ** 2) / sigma ** 2) - - -class SelfMap(object): - """ - Create a som class instance - - :param float X: Attributes array (all columns used) - :param float Y: Attribute to be predicted (not really needed, can be zeros) - :param str topology: Which 2D topology, 'grid', 'hex' or 'sphere' - :param str som_type: Which updating scheme to use 'online' or 'batch' - :param int Ntop: Size of map, for grid Size=Ntop*Ntop, - for hex Size=Ntop*(Ntop+1[2]) if Ntop is even[odd] and for sphere - Size=12*Ntop*Ntop and top must be power of 2 - :param int iterations: Number of iteration the entire sample is processed - :param str periodic: Use periodic boundary conditions ('yes'/'no'), valid for 'hex' and 'grid' only - :param dict dict_dim: dictionary with attributes names - :param float astar: Initial value of alpha - :param float aend: End value of alpha - :param str importance: Path to the file with importance ranking for attributes, default is none - """ - - def __init__(self, X, Y, topology='grid', som_type='online', Ntop=28, iterations=30, periodic='no', dict_dim='', - astart=0.8, aend=0.5, importance=None): - self.np, self.nDim = numpy.shape(X) - self.dict_dim = dict_dim - self.X = X - self.SF90 = SF90 - self.Y = Y - self.aps = astart - self.ape = aend - self.top = topology - if topology=='sphere' and not is_power_2(Ntop): - print('Error, Ntop must be power of 2') - sys.exit(0) - self.stype = som_type - self.Ntop = Ntop - self.nIter = iterations - self.per = periodic - self.distLib, self.npix = geometry(self.top, self.Ntop, periodic=self.per) - if importance == None: importance = numpy.ones(self.nDim) - self.importance = importance / numpy.sum(importance) - - def som_best_cell(self, inputs, return_vals=1): - """ - Return the closest cell to the input object - It can return more than one value if needed - """ - activations = numpy.sum(numpy.transpose([self.importance]) * ( - numpy.transpose(numpy.tile(inputs, (self.npix, 1))) - self.weights) ** 2, axis=0) - if return_vals == 1: - best = numpy.argmin(activations) - return best, activations - else: - best_few = numpy.argsort(activations) - return best_few[0:return_vals], activations - - def create_mapF(self, evol='no', inputs_weights=''): - """ - This functions actually create the maps, it uses - random values to initialize the weights - It uses a Fortran subroutine compiled with f2py - """ - if not self.SF90: - print() - print('Fortran module somF not found, use create_map instead or try' \ - ' f2py -c -m somF som.f90') - sys.exit(0) - if inputs_weights == '': - self.weights = (numpy.random.rand(self.nDim, self.npix)) + self.X[0][0] - else: - self.weights = inputs_weights - if self.stype == 'online': - self.weightsT = somF.map(self.X, self.nDim, self.nIter, self.distLib, self.np, self.weights, - self.importance, self.npix, self.aps, self.ape) - if self.stype == 'batch': - self.weightsT = somF.map_b(self.X, self.nDim, self.nIter, self.distLib, self.np, self.weights, - self.importance, self.npix) - self.weights = copy.deepcopy(self.weightsT) - - def create_map(self, evol='no', inputs_weights='', random_order=True): - """ - This is same as above but uses python routines instead - """ - if inputs_weights == '': - self.weights = (numpy.random.rand(self.nDim, self.npix)) + self.X[0][0] - else: - self.weights = inputs_weights - self.NT = self.nIter * self.np - if self.stype == 'online': - tt = 0 - sigma0 = self.distLib.max() - sigma_single = numpy.min(self.distLib[numpy.where(self.distLib > 0.)]) - for it in range(self.nIter): - #get alpha, sigma - alpha = get_alpha(tt, self.aps, self.ape, self.NT) - sigma = get_sigma(tt, sigma0, sigma_single, self.NT) - if random_order: - index_random = random.sample(range(self.np), self.np) - else: - index_random = numpy.arange(self.np) - for i in range(self.np): - tt += 1 - inputs = self.X[index_random[i]] - best, activation = self.som_best_cell(inputs) - self.weights += alpha * h(best, self.distLib, sigma) * numpy.transpose( - (inputs - numpy.transpose(self.weights))) - if evol == 'yes': - self.evaluate_map() - self.save_map(itn=it) - if self.stype == 'batch': - tt = 0 - sigma0 = self.distLib.max() - sigma_single = numpy.min(self.distLib[numpy.where(self.distLib > 0.)]) - for it in range(self.nIter): - #get alpha, sigma - sigma = get_sigma(tt, sigma0, sigma_single, self.NT) - accum_w = numpy.zeros((self.nDim, self.npix)) - accum_n = numpy.zeros(self.npix) - for i in range(self.np): - tt += 1 - inputs = self.X[i] - best, activation = self.som_best_cell(inputs) - for kk in range(self.nDim): - accum_w[kk, :] += h(best, self.distLib, sigma) * inputs[kk] - accum_n += h(best, self.distLib, sigma) - for kk in range(self.nDim): - self.weights[kk] = accum_w[kk] / accum_n - - if evol == 'yes': - self.evaluate_map() - self.save_map(itn=it) - - def evaluate_map(self, inputX='', inputY=''): - """ - This functions evaluates the map created using the input Y or a new Y (array of labeled attributes) - It uses the X array passed or new data X as well, the map doesn't change - - :param float inputX: Use this if another set of values for X is wanted using - the weigths already computed - :param float inputY: One dimensional array of the values to be assigned to each cell in the map - based on the in-memory X passed - """ - self.yvals = {} - self.ivals = {} - if inputX == '': - inX = self.X - else: - inX = inputX - if inputY == '': - inY = self.Y - else: - inY = inputY - for i in range(len(inX)): - inputs = inX[i] - best, activation = self.som_best_cell(inputs) - if best not in self.yvals: self.yvals[best] = [] - self.yvals[best].append(inY[i]) - if best not in self.ivals: self.ivals[best] = [] - self.ivals[best].append(i) - - def get_vals(self, line): - """ - Get the predictions given a line search, where the line - is a vector of attributes per individual object fot the - 10 closest cells. - - :param float line: input data to look in the tree - :return: array with the cell content - """ - best, act = self.som_best_cell(line, return_vals=10) - for ib in range(10): - if best[ib] in self.yvals: return self.yvals[best[ib]] - return numpy.array([-1.]) - - def get_best(self, line): - """ - Get the predictions given a line search, where the line - is a vector of attributes per individual object for THE best cell - - :param float line: input data to look in the tree - :return: array with the cell content - """ - best, act = self.som_best_cell(line, return_vals=10) - return best[0] - - def save_map(self, itn=-1, fileout='SOM', path=''): - """ - Saves the map - - :param int itn: Number of map to be included on path, use -1 to ignore this number - :param str fileout: Name of output file - :param str path: path for the output file - """ - if path == '': - path = os.getcwd() + '/' - if not os.path.exists(path): os.system('mkdir -p ' + path) - if itn >= 0: - ff = '_%04d' % itn - fileout += ff - numpy.save(path + fileout, self) - - def save_map_dict(self, path='', fileout='SOM', itn=-1): - """ - Saves the map in dictionary format - - :param int itn: Number of map to be included on path, use -1 to ignore this number - :param str fileout: Name of output file - :param str path: path for the output file - """ - SOM = {} - SOM['W'] = self.weights - SOM['yvals'] = self.yvals - SOM['ivals'] = self.ivals - SOM['topology'] = self.top - SOM['Ntop'] = self.Ntop - SOM['npix'] = self.npix - if path == '': - path = os.getcwd() + '/' - if not os.path.exists(path): os.system('mkdir -p ' + path) - if itn > 0: - ff = '_%04d' % itn - fileout += ff - numpy.save(path + fileout, SOM) - - def plot_map(self, min_m=-100, max_m=-100, colbar='yes'): - """ - Plots the map after evaluating, the cells are colored with the mean value inside each - one of them - - :param float min_m: Lower limit for coloring the cells, -100 uses min value - :param float max_m: Upper limit for coloring the cells, -100 uses max value - :param str colbar: Include a colorbar ('yes','no') - """ - - import matplotlib.pyplot as plt - import matplotlib as mpl - import matplotlib.cm as cm - from matplotlib import collections, transforms - from matplotlib.colors import colorConverter - - if self.top == 'sphere': import healpy as H - - if self.top == 'grid': - M = numpy.zeros(self.npix) - 20. - for i in range(self.npix): - if i in self.yvals: - M[i] = numpy.mean(self.yvals[i]) - M2 = numpy.reshape(M, (self.Ntop, self.Ntop)) - plt.figure(figsize=(8, 8), dpi=100) - if min_m == -100: min_m = M2[numpy.where(M2 > -10)].min() - if max_m == -100: max_m = M2.max() - SM2 = plt.imshow(M2, origin='center', interpolation='nearest', cmap=cm.jet, vmin=min_m, vmax=max_m) - SM2.cmap.set_under("grey") - if colbar == 'yes': plt.colorbar() - plt.axis('off') - if self.top == 'hex': - nx = self.Ntop - ny = self.Ntop - xL = numpy.arange(0, nx, 1.) - dy = 0.8660254 - yL = numpy.arange(0, ny, dy) - ny = len(yL) - nx = len(xL) - npix = nx * ny - bX = numpy.zeros(nx * ny) - bY = numpy.zeros(nx * ny) - kk = 0 - for jj in range(ny): - for ii in range(nx): - if jj % 2 == 0: off = 0. - if jj % 2 == 1: off = 0.5 - bX[kk] = xL[ii] + off - bY[kk] = yL[jj] - kk += 1 - xyo = list(zip(bX, bY)) - sizes_2 = numpy.zeros(nx * ny) + ((8. * 0.78 / (self.Ntop + 0.5)) / 2. * 72.) ** 2 * 4. * numpy.pi / 3. - M = numpy.zeros(npix) - 20. - fcolors = [plt.cm.Spectral_r(x) for x in numpy.random.rand(nx * ny)] - for i in range(npix): - if i in self.yvals: - M[i] = numpy.mean(self.yvals[i]) - if max_m == -100: max_m = M.max() - if min_m == -100: min_m = M[numpy.where(M > -10)].min() - M = M - min_m - M = M / (max_m - min_m) - for i in range(npix): - if M[i] <= 0: - fcolors[i] = plt.cm.Greys(.5) - else: - fcolors[i] = plt.cm.jet(M[i]) - figy = ((8. * 0.78 / (self.Ntop + 0.5) / 2.) * (3. * ny + 1) / numpy.sqrt(3)) / 0.78 - fig3 = plt.figure(figsize=(8, figy), dpi=100) - #fig3.subplots_adjust(left=0,right=1.,top=1.,bottom=0.) - a = fig3.add_subplot(1, 1, 1) - col = collections.RegularPolyCollection(6, sizes=sizes_2, offsets=xyo, transOffset=a.transData) - col.set_color(fcolors) - a.add_collection(col, autolim=True) - a.set_xlim(-0.5, nx) - a.set_ylim(-1, nx + 0.5) - plt.axis('off') - if colbar == 'yes': - figbar = plt.figure(figsize=(8, 1.), dpi=100) - ax1 = figbar.add_axes([0.05, 0.8, 0.9, 0.15]) - cmap = cm.jet - norm = mpl.colors.Normalize(vmin=min_m, vmax=max_m) - cb1 = mpl.colorbar.ColorbarBase(ax1, cmap=cmap, norm=norm, orientation='horizontal') - cb1.set_label('') - if self.top == 'sphere': - M = numpy.zeros(self.npix) + H.UNSEEN - for i in range(self.npix): - if i in self.yvals: - M[i] = numpy.mean(self.yvals[i]) - plt.figure(10, figsize=(8, 8), dpi=100) - if min_m == -100: min_m = M[numpy.where(M > -10)].min() - if max_m == -100: max_m = M.max() - if colbar == 'yes': H.mollview(M, fig=10, title="", min=min_m, max=max_m, cbar=True) - if colbar == 'no': H.mollview(M, fig=10, title="", min=min_m, max=max_m, cbar=False) - plt.show() diff --git a/somsphere/__init__.py b/somsphere/__init__.py new file mode 100644 index 0000000..f3a32ba --- /dev/null +++ b/somsphere/__init__.py @@ -0,0 +1,318 @@ +""" +.. module:: SOMZ +.. moduleauthor:: Matias Carrasco Kind + +""" +from __future__ import print_function + +from builtins import object +from builtins import range +from builtins import zip + +__author__ = 'Matias Carrasco Kind' + +import numpy +import copy +import sys, os, random +import warnings +from somsphere.models import Topology, DY, SomType + +from somsphere.utils import get_sigma, is_power_2, geometry, count_modified_cells, get_alpha + +warnings.simplefilter("ignore", RuntimeWarning) +try: + import somF + + SF90 = True +except: + SF90 = False + + +class SOMap(object): + """ + Create a som class instance + + :param float X: Attributes array (all columns used) + :param float Y: Attribute to be predicted (not really needed, can be zeros) + :param str topology: Which 2D topology, 'grid', 'hex' or 'sphere' + :param str som_type: Which updating scheme to use 'online' or 'batch' + :param int n_top: Size of map, for grid Size=n_top*n_top, + for hex Size=n_top*(n_top+1[2]) if n_top is even[odd] and for sphere + Size=12*n_top*n_top and top must be power of 2 + :param int n_iter: Number of iteration the entire sample is processed + :param str periodic: Use periodic boundary conditions ('yes'/'no'), valid for 'hex' and 'grid' only + :param dict dict_dim: dictionary with attributes names + :param float alpha_start: Initial value of alpha + :param float alpha_end: End value of alpha + :param str importance: Path to the file with importance ranking for attributes, default is none + """ + + def __init__(self, X, Y, topology='grid', som_type='online', n_top=28, n_iter=30, alpha_start=0.8, alpha_end=0.5, + periodic=False, importance=None, dict_dim=None): + if topology == 'sphere' and not is_power_2(n_top): + print('Error, n_top must be power of 2') + sys.exit(0) + + self.SF90 = SF90 + self.np, self.n_dim = numpy.shape(X) + self.X = X + self.Y = Y + self.topology: Topology = Topology(topology) + self.som_type: SomType = SomType(som_type) + self.n_top = n_top + self.n_iter = n_iter + self.alpha_start = alpha_start + self.alpha_end = alpha_end + self.periodic = periodic + self.dict_dim = dict_dim + self.dist_lib, self.n_pix = geometry(self.topology, self.n_top, periodic=self.periodic) + + importance = numpy.ones(self.n_dim) if importance is None else importance + self.importance = importance / numpy.sum(importance) + + self.weights = (numpy.random.rand(self.n_dim, self.n_pix)) + self.X[0][ + 0] + + def get_best_cell(self, inputs, return_vals=1): + """ + Return the closest cell to the input object + It can return more than one value if needed + """ + activations = numpy.sum(numpy.transpose([self.importance]) * ( + numpy.transpose(numpy.tile(inputs, (self.n_pix, 1))) - self.weights) ** 2, axis=0) + + return numpy.argmin(activations) if return_vals == 1 else numpy.argsort(activations)[0:return_vals], activations + + def create_map_f(self, inputs_weights=None, evol=False): + """ + This functions actually create the maps, it uses + random values to initialize the weights + It uses a Fortran subroutine compiled with f2py + """ + if not self.SF90: + print('Fortran module somF not found, use create_map instead or try' \ + ' f2py -c -m somF som.f90') + sys.exit(0) + + self.weights = inputs_weights if inputs_weights is not None else self.weights + weights_t = None + if self.som_type == SomType.ONLINE: + weights_t = somF.map(self.X, self.n_dim, self.n_iter, self.dist_lib, self.np, self.weights, + self.importance, self.n_pix, self.alpha_start, self.alpha_end) + elif self.som_type == SomType.BATCH: + weights_t = somF.map_b(self.X, self.n_dim, self.n_iter, self.dist_lib, self.np, self.weights, + self.importance, self.n_pix) + self.weights = copy.deepcopy(weights_t) + + def create_map(self, inputs_weights=None, random_order=True, evol=False): + """ + This is same as above but uses python routines instead + """ + self.weights = inputs_weights if inputs_weights is not None else self.weights + NT = self.n_iter * self.np + tt = 0 + sigma0 = self.dist_lib.max() + sigma_single = numpy.min(self.dist_lib[numpy.where(self.dist_lib > 0.)]) + for it in range(self.n_iter): + sigma = get_sigma(tt, sigma0, sigma_single, NT) + if self.som_type == SomType.ONLINE: + # get alpha, sigma + alpha = get_alpha(tt, self.alpha_start, self.alpha_end, NT) + index_random = random.sample(range(self.np), self.np) if random_order else numpy.arange(self.np) + for i in range(self.np): + tt += 1 + inputs = self.X[index_random[i]] + best, activation = self.get_best_cell(inputs) + self.weights += alpha * count_modified_cells(best, self.dist_lib, sigma) * numpy.transpose( + (inputs - numpy.transpose(self.weights))) + + elif self.som_type == SomType.BATCH: + # get alpha, sigma + accum_w = numpy.zeros((self.n_dim, self.n_pix)) + accum_n = numpy.zeros(self.n_pix) + for i in range(self.np): + tt += 1 + inputs = self.X[i] + best, activation = self.get_best_cell(inputs) + for kk in range(self.n_dim): + accum_w[kk, :] += count_modified_cells(best, self.dist_lib, sigma) * inputs[kk] + accum_n += count_modified_cells(best, self.dist_lib, sigma) + for kk in range(self.n_dim): + self.weights[kk] = accum_w[kk] / accum_n + + if evol: + self.evaluate_map() + self.save_map(itn=it) + + def evaluate_map(self, input_x=None, input_y=None): + """ + This functions evaluates the map created using the input Y or a new Y (array of labeled attributes) + It uses the X array passed or new data X as well, the map doesn't change + + :param float input_x: Use this if another set of values for X is wanted using + the weigths already computed + :param float input_y: One dimensional array of the values to be assigned to each cell in the map + based on the in-memory X passed + """ + self.y_vals = {} + self.i_vals = {} + in_x = self.X if input_x is None else input_x + in_y = self.Y if input_y is None else input_y + for i in range(len(in_x)): + inputs = in_x[i] + best, activation = self.get_best_cell(inputs) + if best not in self.y_vals: + self.y_vals[best] = [] + self.y_vals[best].append(in_y[i]) + if best not in self.i_vals: + self.i_vals[best] = [] + self.i_vals[best].append(i) + + def predict(self, line, best=True): + """ + Get the predictions given a line search, where the line + is a vector of attributes per individual object fot the + 10 closest cells if best set to False; otherwise return the + BEST cell. + + :param float line: input data to look in the tree + :param bool best: Set to True to get only the best cell; otherwise the 10 closest cells will be returned + :return: array with the cell content + """ + bests, _ = self.get_best_cell(line, return_vals=10) + if best: + return bests[0] + for ib in range(10): + if bests[ib] in self.y_vals: + return self.y_vals[bests[ib]] + return numpy.array([-1.]) + + def save_map(self, itn=-1, fileout='SOM', path=None): + """ + Saves the map + + :param int itn: Number of map to be included on path, use -1 to ignore this number + :param str fileout: Name of output file + :param str path: path for the output file + """ + path = os.getcwd() + '/' if path is None else path + if not os.path.exists(path): + os.system('mkdir -p ' + path) + if itn >= 0: + ff = '_%04d' % itn + fileout += ff + numpy.save(path + fileout, self) + + def save_map_dict(self, path='', fileout='SOM', itn=-1): + """ + Saves the map in dictionary format + + :param int itn: Number of map to be included on path, use -1 to ignore this number + :param str fileout: Name of output file + :param str path: path for the output file + """ + SOM = {'W': self.weights, 'y_vals': self.y_vals, 'i_vals': self.i_vals, 'topology': self.topology, + 'n_top': self.n_top, 'n_pix': self.n_pix} + if path == '': + path = os.getcwd() + '/' + if not os.path.exists(path): os.system('mkdir -p ' + path) + if itn > 0: + ff = '_%04d' % itn + fileout += ff + numpy.save(path + fileout, SOM) + + def plot_map(self, min_m=-100, max_m=-100, colorbar=True): + """ + Plots the map after evaluating, the cells are colored with the mean value inside each + one of them + + :param float min_m: Lower limit for coloring the cells, -100 uses min value + :param float max_m: Upper limit for coloring the cells, -100 uses max value + :param str colorbar: Include a colorbar ('yes','no') + """ + + import matplotlib.pyplot as plt + import matplotlib as mpl + import matplotlib.cm as cm + from matplotlib import collections + from matplotlib.colors import colorConverter + + if self.topology == Topology.SPHERE: + import healpy as hp + M = numpy.zeros(self.n_pix) + hp.UNSEEN + for i in range(self.n_pix): + if i in self.y_vals: + M[i] = numpy.mean(self.y_vals[i]) + plt.figure(10, figsize=(8, 8), dpi=100) + if min_m == -100: + min_m = M[numpy.where(M > -10)].min() + if max_m == -100: + max_m = M.max() + hp.mollview(M, fig=10, title="", min=min_m, max=max_m, cbar=colorbar) + + if self.topology == Topology.GRID: + M = numpy.zeros(self.n_pix) - 20. + for i in range(self.n_pix): + if i in self.y_vals: + M[i] = numpy.mean(self.y_vals[i]) + M2 = numpy.reshape(M, (self.n_top, self.n_top)) + plt.figure(figsize=(8, 8), dpi=100) + if min_m == -100: + min_m = M2[numpy.where(M2 > -10)].min() + if max_m == -100: + max_m = M2.max() + SM2 = plt.imshow(M2, origin='center', interpolation='nearest', cmap=cm.jet, vmin=min_m, vmax=max_m) + SM2.cmap.set_under("grey") + if colorbar: + plt.colorbar() + plt.axis('off') + if self.topology == Topology.HEX: + x_l, y_l = numpy.arange(0, self.n_top, 1.), numpy.arange(0, self.n_top, DY) + nx, ny = len(x_l), len(y_l) + n_pix = nx * ny + b_x, b_y = numpy.zeros(n_pix), numpy.zeros(n_pix) + kk = 0 + for jj in range(ny): + for ii in range(nx): + if jj % 2 == 0: off = 0. + if jj % 2 == 1: off = 0.5 + b_x[kk] = x_l[ii] + off + b_y[kk] = y_l[jj] + kk += 1 + xyo = list(zip(b_x, b_y)) + sizes_2 = numpy.zeros(nx * ny) + ((8. * 0.78 / (self.n_top + 0.5)) / 2. * 72.) ** 2 * 4. * numpy.pi / 3. + M = numpy.zeros(n_pix) - 20. + fcolors = [plt.cm.Spectral_r(x) for x in numpy.random.rand(nx * ny)] + for i in range(n_pix): + if i in self.y_vals: + M[i] = numpy.mean(self.y_vals[i]) + if max_m == -100: + max_m = M.max() + if min_m == -100: + min_m = M[numpy.where(M > -10)].min() + M = M - min_m + M = M / (max_m - min_m) + for i in range(n_pix): + if M[i] <= 0: + fcolors[i] = plt.cm.Greys(.5) + else: + fcolors[i] = plt.cm.jet(M[i]) + figy = ((8. * 0.78 / (self.n_top + 0.5) / 2.) * (3. * ny + 1) / numpy.sqrt(3)) / 0.78 + fig3 = plt.figure(figsize=(8, figy), dpi=100) + # fig3.subplots_adjust(left=0,right=1.,top=1.,bottom=0.) + a = fig3.add_subplot(1, 1, 1) + col = collections.RegularPolyCollection(6, sizes=sizes_2, offsets=xyo, transOffset=a.transData) + col.set_color(fcolors) + a.add_collection(col, autolim=True) + a.set_xlim(-0.5, nx) + a.set_ylim(-1, nx + 0.5) + plt.axis('off') + if colorbar: + figbar = plt.figure(figsize=(8, 1.), dpi=100) + ax1 = figbar.add_axes([0.05, 0.8, 0.9, 0.15]) + cmap = cm.jet + norm = mpl.colors.Normalize(vmin=min_m, vmax=max_m) + cb1 = mpl.colorbar.ColorbarBase(ax1, cmap=cmap, norm=norm, orientation='horizontal') + cb1.set_label('') + + plt.show() diff --git a/somsphere/models/__init__.py b/somsphere/models/__init__.py new file mode 100644 index 0000000..671805f --- /dev/null +++ b/somsphere/models/__init__.py @@ -0,0 +1,14 @@ +from enum import Enum + +DY = 0.8660254 + + +class Topology(Enum): + GRID = "grid" + SPHERE = "sphere" + HEX = "hex" + + +class SomType(Enum): + ONLINE = "online" + BATCH = "batch" diff --git a/somsphere/utils/__init__.py b/somsphere/utils/__init__.py new file mode 100644 index 0000000..c3d611e --- /dev/null +++ b/somsphere/utils/__init__.py @@ -0,0 +1,184 @@ +import sys + +import numpy + +from somsphere import Topology +from somsphere.models import DY + + +def get_index(ix, iy, nx, ny): + return iy * nx + ix + + +def get_pair(ii, nx, ny): + iy = int(numpy.floor(ii / nx)) + ix = ii % nx + return ix, iy + + +def get_neighbors(ix, iy, nx, ny, index=False, hex=False): + """ + Get neighbors for rectangular/hexagonal grid given its + coordinates and size of grid + + :param int ix: Coordinate in the x-axis + :param int iy: Coordinate in the y-axis + :param int nx: Number fo cells along the x-axis + :param int ny: Number fo cells along the y-axis + :param bool index: Return indexes in the map format + :param bool hex: Set the grid to hexagonal + :return: Array of indexes for direct neighbors + """ + ns = [] + + if ix - 1 >= 0: + ns.append((ix - 1, iy)) + if iy - 1 >= 0: + ns.append((ix, iy - 1)) + if ix + 1 < nx: + ns.append((ix + 1, iy)) + if iy + 1 < ny: + ns.append((ix, iy + 1)) + + even = iy % 2 == 0 or (not hex) + if even and ix - 1 >= 0 and iy - 1 >= 0: + ns.append((ix - 1, iy - 1)) + if even and ix - 1 >= 0 and iy + 1 < ny: + ns.append((ix - 1, iy + 1)) + if not even and ix + 1 < nx and iy - 1 >= 0: + ns.append((ix + 1, iy - 1)) + if not even and ix + 1 < nx and iy + 1 < ny: + ns.append((ix + 1, iy + 1)) + + ns = numpy.array(ns) + if not index: + return ns + ins = [] + for i in range(len(ns)): + ins.append(get_index(ns[i, 0], ns[i, 1], nx, ny)) + return numpy.array(ins) + + +def geometry(topology: Topology, n_top, periodic=False): + """ + Pre-compute distances between cells in a given topology + and store it on a dist_lib array + + :param Enum topology: Topology ('grid','hex','sphere') + :param int n_top: Size of map, for grid Size=n_top*n_top, + for hex Size=n_top*(n_top+1[2]) if Ntop is even[odd] and for sphere + Size=12*n_top*n_top and top must be power of 2 + :param str periodic: Use periodic boundary conditions ('yes'/'no'), valid for 'hex' and 'grid' only + :return: 2D array with distances pre computed between cells and total number of units + :rtype: 2D float array, int + """ + if topology == Topology.SPHERE: + try: + import healpy as hpx + except: + print('Error: healpy module not found, use grid or hex topologies') + sys.exit(0) + nside = n_top + n_pix = 12 * nside ** 2 + dist_lib = numpy.zeros((n_pix, n_pix)) + for i in range(n_pix): + ai = hpx.pix2ang(nside, i) + for j in range(i + 1, n_pix): + aj = hpx.pix2ang(nside, j) + dist_lib[i, j] = hpx.rotator.angdist(ai, aj) + dist_lib[j, i] = dist_lib[i, j] + dist_lib[numpy.where(numpy.isnan(dist_lib))] = numpy.pi + elif topology == Topology.GRID: + nx = n_top + ny = n_top + n_pix = nx * ny + map_x_y = numpy.mgrid[0:1:complex(0, nx), 0:1:complex(0, ny)] + map_x_y = numpy.reshape(map_x_y, (2, n_pix)) + b_x = map_x_y[1] + b_y = map_x_y[0] + dx = 1. / (nx - 1) + dy = 1. / (ny - 1) + dist_lib = numpy.zeros((n_pix, n_pix)) + for i in range(n_pix): + for j in range(i + 1, n_pix): + if not periodic: + dist_lib[i, j] = numpy.sqrt((b_x[i] - b_x[j]) ** 2 + (b_y[i] - b_y[j]) ** 2) + dist_lib[j, i] = dist_lib[i, j] + else: + s0 = numpy.sqrt((b_x[i] - b_x[j]) ** 2 + (b_y[i] - b_y[j]) ** 2) + s1 = numpy.sqrt((b_x[i] - (b_x[j] + 1. + dx)) ** 2 + (b_y[i] - b_y[j]) ** 2) + s2 = numpy.sqrt((b_x[i] - (b_x[j] + 1. + dx)) ** 2 + (b_y[i] - (b_y[j] + 1. + dy)) ** 2) + s3 = numpy.sqrt((b_x[i] - (b_x[j] + 0.)) ** 2 + (b_y[i] - (b_y[j] + 1. + dy)) ** 2) + s4 = numpy.sqrt((b_x[i] - (b_x[j] - 1. - dx)) ** 2 + (b_y[i] - (b_y[j] + 1. + dy)) ** 2) + s5 = numpy.sqrt((b_x[i] - (b_x[j] - 1. - dx)) ** 2 + (b_y[i] - (b_y[j] + 0.)) ** 2) + s6 = numpy.sqrt((b_x[i] - (b_x[j] - 1. - dx)) ** 2 + (b_y[i] - (b_y[j] - 1. - dy)) ** 2) + s7 = numpy.sqrt((b_x[i] - (b_x[j] + 0.)) ** 2 + (b_y[i] - (b_y[j] - 1. - dy)) ** 2) + s8 = numpy.sqrt((b_x[i] - (b_x[j] + 1. + dx)) ** 2 + (b_y[i] - (b_y[j] - 1. - dy)) ** 2) + dist_lib[i, j] = numpy.min((s0, s1, s2, s3, s4, s5, s6, s7, s8)) + dist_lib[j, i] = dist_lib[i, j] + elif topology == Topology.HEX: + kk, off = 0, 0.0 + x_l, y_l = numpy.arange(0, n_top, 1.), numpy.arange(0, n_top, DY) + nx, ny = len(x_l), len(y_l) + n_pix = nx * ny + b_x, b_y = numpy.zeros(n_pix), numpy.zeros(n_pix) + last = ny * DY + + for jj in range(ny): + for ii in range(nx): + off = 0. if jj % 2 == 0 else 0.5 + b_x[kk] = x_l[ii] + off + b_y[kk] = y_l[jj] + kk += 1 + + dist_lib = numpy.zeros((n_pix, n_pix)) + for i in range(n_pix): + for j in range(i + 1, n_pix): + if not periodic: + dist_lib[i, j] = numpy.sqrt((b_x[i] - b_x[j]) ** 2 + (b_y[i] - b_y[j]) ** 2) + dist_lib[j, i] = dist_lib[i, j] + else: + s0 = numpy.sqrt((b_x[i] - b_x[j]) ** 2 + (b_y[i] - b_y[j]) ** 2) + s1 = numpy.sqrt((b_x[i] - (b_x[j] + nx)) ** 2 + (b_y[i] - b_y[j]) ** 2) + s2 = numpy.sqrt((b_x[i] - (b_x[j] + nx)) ** 2 + (b_y[i] - (b_y[j] + last)) ** 2) + s3 = numpy.sqrt((b_x[i] - (b_x[j] + 0)) ** 2 + (b_y[i] - (b_y[j] + last)) ** 2) + s4 = numpy.sqrt((b_x[i] - (b_x[j] - nx)) ** 2 + (b_y[i] - (b_y[j] + last)) ** 2) + s5 = numpy.sqrt((b_x[i] - (b_x[j] - nx)) ** 2 + (b_y[i] - (b_y[j] + 0)) ** 2) + s6 = numpy.sqrt((b_x[i] - (b_x[j] - nx)) ** 2 + (b_y[i] - (b_y[j] - last)) ** 2) + s7 = numpy.sqrt((b_x[i] - (b_x[j] + 0)) ** 2 + (b_y[i] - (b_y[j] - last)) ** 2) + s8 = numpy.sqrt((b_x[i] - (b_x[j] + nx)) ** 2 + (b_y[i] - (b_y[j] - last)) ** 2) + dist_lib[i, j] = numpy.min((s0, s1, s2, s3, s4, s5, s6, s7, s8)) + dist_lib[j, i] = dist_lib[i, j] + + return dist_lib, n_pix + + +def is_power_2(value): + """ + Check if passed value is a power of 2 + """ + return value != 0 and ((value & (value - 1)) == 0) + + +def get_alpha(t, alpha_start, alpha_end, NT): + """ + Get value of alpha at a given time + """ + return alpha_start * numpy.power(alpha_end / alpha_start, float(t) / float(NT)) + + +def get_sigma(t, sigma_0, sigma_f, NT): + """ + Get value of sigma at a given timesure + """ + return sigma_0 * numpy.power(sigma_f / sigma_0, float(t) / float(NT)) + + +def count_modified_cells(bmu, map_d, sigma): + """ + Neighborhood function which quantifies how much cells around the best matching one are modified + + :param int bmu: best matching unit + :param float map_d: array of distances computed with :func:`geometry` + """ + return numpy.exp(-(map_d[bmu] ** 2) / sigma ** 2) diff --git a/test/test_models.py b/test/test_models.py new file mode 100644 index 0000000..ba293b2 --- /dev/null +++ b/test/test_models.py @@ -0,0 +1,11 @@ +import unittest + +from somsphere import Topology + + +class TestModels(unittest.TestCase): + def test_get_enum(self): + self.assertEqual(Topology.GRID, Topology("grid")) + self.assertEqual(Topology.SPHERE, Topology("sphere")) + self.assertEqual(Topology.HEX, Topology("hex")) + From 29f3eb34e187f71b5dade314ce269432878cbba2 Mon Sep 17 00:00:00 2001 From: Ruiqi Li Date: Tue, 1 Sep 2020 22:31:14 -0400 Subject: [PATCH 2/7] More cleanup --- Example.ipynb | 256 +++++++---------------------- setup.py | 9 +- somsphere/__init__.py | 309 +++++++++++++++--------------------- somsphere/utils/__init__.py | 116 +++++++------- test/test_somap.py | 9 ++ 5 files changed, 258 insertions(+), 441 deletions(-) create mode 100644 test/test_somap.py diff --git a/Example.ipynb b/Example.ipynb index f4fa7cc..ff8d2df 100644 --- a/Example.ipynb +++ b/Example.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 8, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -17,7 +17,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -26,7 +26,7 @@ "(5000, 9)" ] }, - "execution_count": 48, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -39,7 +39,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -48,7 +48,7 @@ "(5000,)" ] }, - "execution_count": 49, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -61,7 +61,7 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -71,7 +71,7 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -80,7 +80,7 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -89,12 +89,12 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -111,7 +111,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -121,12 +121,12 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -143,7 +143,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -153,12 +153,12 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnIAAAJzCAYAAACLcv4wAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de7RtV10n+O/vnpubNCGPIZBcIAYoYIDgAxMFQlMSDZQZilXoKDo02i2gbUexrIioyahSCUX7rqAShyVpKiRKIYWxYylKrKDEooyXEAiP4lE8DBIgwSTmBeZxzp39x95HNod7kn1C5lp33f35jLFGWHvPvebvhgA/vnPNtaq1FgAApmfX2AUAAHD/aOQAACZKIwcAMFEaOQCAidLIAQBMlEYOAGCiNHIAABOlkQMAmKjdYxcAAByaquqIJHtGmPru1tqdI8w7uPJmBwDggVZVRzw4+Yc7xpn++iSPWYVmTiIHAPSw544kP57k8AEnvSvJq5O9mSWBGjkAgPvr8CRHjF3EIUwjBwB0szvDNhur1tjYtQoAMFGr1rgCAAM6bH4MZWPAuQ4GEjkAgInSyAEATJSlVQCgG5sd+pLIAQBM1Ko1rgDAgHZn2M0O6wPOdTCQyAEATJREDgDoxj1yfUnkAAAmSiMHADBRq5ZAAgADGvrNDjY7AAAwCRI5AKAbmx36ksgBAEzUqjWuAMCAhn4g8D0DznUwkMgBAEyURg4AYKIsrQIA3djs0JdEDgBgolatcQUABjT0A4GHnOtgIJEDAJgoiRwA0I1Eri+JHADARGnkAAAmytIqANCNx4/0JZEDAJioVWtcAYABDf2u1VVrbCRyAAATtWqNKwAwIPfI9SWRAwCYKI0cAMBErVoCCQAMyJsd+pLIAQBMlEQOAOjGZoe+JHIAABOlkQMAmKhVSyABgAF5s0NfEjkAgIlatcYVABiQzQ59SeQAACZq1RpXAGBAHgjcl0QOAGCiNHIAwMqrqpdW1bVVdWdV7auqp97L2P+rqv5bVf39/Lh86/iaeWVVfbaq/mE+5vFbxnxVVb2hqm6rqluq6nVV9eCd1K2RAwC62T3CsVNVdUaS85Kcm+SkJO9NcllVHbfNT05N8sYk35rklCSfSvJnVfXIhTE/leTHkpyZ5GlJPj+/5hELY96Q5MlJnpPkuUm+Jclrd1R7a20n4wEA7lNVHZ3k1ncn2VHE9BW6I7NOLMkxrbXblvlNVe1LclVr7Ufn57sya85e01r7xSV+v5bk75P8aGvt4qqqJJ9J8u9ba786H3NMkhuSvKi19ntV9TVJPpjkm1tr75qPOT3JnyQ5obX2mWVql8gBAN1sPhB4qGOniVxV7UlycpLLNz9rre2fn5+y5GUeNJ/+5vn5Y5Ls3XLNW5PsW7jmKUlu2Wzi5i5Psj+zBG8pdq0CAIeio2bB2D+6q7V21wHGPTTJWmZp2aIbkjxxybl+KbMEbrNx27twja3X3Lsw5nOLX7bW1qvq5oUx90kjBwB0M+LjR67b8tW5SV7xQM9XVWcneUGSU1trdz7Q178vGjkA4FB0QpLbF84PlMYlyY1JNpIcv+Xz45Ncf28TVNXLk5yd5NmttfctfLX5u+OTfHbLNa9ZGPMlmymqaneSr7qveRct38j9kxp9V8Rff+Ibxi4hT//2945dQv7rZc8cu4Q855XvGLuEJMmP/Oy/H7uE/HTu8z7Y7h714b8bu4Rc8MTvG7uE/LNcNnYJ+an8ytgl5D9/8/ePXULyvLELmNn1g58fu4TsP/XIsUtI+1Dqvkcdcm5fZrNDa+3uqro6yWlJLk3+cbPDaUnO3+53VfVTSf5Nkm/fcp9bkvxNZs3YaZk3bvPNH09L8lvzMVcmObaqTm6tXT3/7Nsy27+wb6k/YSRyAEBHE3nX6nlJLqqqdyV5Z5KzkhyZ5MIkqaqLk3y6tXbO/Pynk7wyyQuTXFtVm/e03dFau6O11qrq15L826r6aGaN3b/L7D66S5Oktfahqnprkguq6szMVoXPT/J7y+5Y/Qr+vAAAh4bW2puq6mGZNWd7M0vRTm+tbW5WODGz3aSbfjjJniS/v+VSi/fh/XJmzeBrkxyb5B3zay7eR/e9mTVvb5tf/5LMnj23NI0cANDN7rXksAEXdne3zO5426HW2vnZZim1tXbqlvNHL3G9luRn58d2Y27OLNW73zxHDgBgoiRyAEA3u3cnuyeQyE2VRA4AYKI0cgAAE2VpFQDo5rCBNzscNvpTb4clkQMAmCiJHADQzSibHVaIRA4AYKIkcgBAN4etJYcNGBsdtv++xxxKJHIAABOlkQMAmChLqwBAP2sZNjYacGPFwUAiBwAwURI5AKCf3Rk2NrLZAQCAKdDIAQBMlKVVAKAfS6tdSeQAACZKIgcA9COR60oiBwAwURI5AKCfXZk9FJguJHIAABOlkQMAmChLqwBAP7sz7NKqd60CADAFEjkAoB+JXFcSOQCAiZLIAQD9rMXjRzqSyAEATFS11pYb+du15MB+fuv//v6xS8incuLYJeSmPGTsEnJLjh27hCTJvjxt7BJy7fd8zdgl5LY3HzZ2CVlb3xi7hHzj4e8eu4Q8Lh8fu4T86b7vGbuEg2e959KxC0jyqnvGriCtHTb4nWNVdXSSW2/9uuToARO52zaSY96fJDmmtXbbcDOP42D5jxoAcCiy2aErS6sAABMlkQMA+lmLbqMjiRwAwETpkQGAfoZ+/MjoWzOHJZEDAJgojRwAwERZWgUA+tkd3UZHEjkAgInSIwMA/UjkupLIAQBMlEYOAGCihJ0AQD+WVruSyAEATJQeGQDoZ1eGfbPD/gHnOghI5AAAJkoiBwD0M/Q9ct61CgDAFGjkAAAmytIqANCPpdWuJHIAABMlkQMA+lmLx490JJEDAJgoiRwA0I975LqSyAEATJRGDgBgoiytAgD9rGXYbsNmBwAApkAiBwD0M/TjR4ac6yAgkQMAmCiJHADQz9CPH3GPHAAAU7B0j/yKM3uWsWQNJ180dgn5r9/0zLFLyFo2xi4hp+37q7FLmDli7AKS//EH/2TsEvKT+ZWxS8gz1sb/Z+K7c+nYJeSXr/i5sUvISc96x9gl5Ovy/rFLSJJcdM0Pj11C8oLDxq6AQ5ilVQCgH0urXVlaBQCYKIkcANCPRK4riRwAwERp5ACAfnbliw8FHuK4n51NVb20qq6tqjural9VPfVexj65qi6Zj29VddYBxmx+t/X4zYUxbz/A9/9hJ3Vr5ACAlVZVZyQ5L8m5SU5K8t4kl1XVcdv85EFJPpHk7CTXbzPmm5M8fOF4zvzzN28Zd8GWcT+1k9rdIwcArLqXJbmgtXZhklTVmUm+M8lLkvzi1sGttauSXDUf+2Xfz8f83eJ5VZ2d5ONJrtgy9Autte2awfskkQMA+tk9wrEDVbUnyclJLt/8rLW2f35+yk7/uPcyx/cl+Y+ttbbl6++tqhur6gNV9QtV9aCdXFsiBwAcio6qqsXzu1prdx1g3EMzu7vuhi2f35DkiQ9QLc9LcmyS12/5/D8l+WSSzyT5+iS/lOQJSb5n2Qtr5ACAfoZ+/MgXX3503ZZvzk3yigErWfQDSf60tfaZxQ9ba69dOH1/VX02yduq6rGttY8vc2GNHABwKDohye0L5wdK45Lkxszav+O3fH58tt/IsLSqelSSZ2e5lG3f/K+Py+x+uvvkHjkA4FB0e2vttoXjgI1ca+3uJFcnOW3zs6raNT+/8gGo48VJPpfkLUuMfcr8r59d9uISOQCgn83nuw05386dl+SiqnpXkncmOSvJkUk2d7FenOTTrbVz5ud7kjxp/ts9SR5ZVU9Jckdr7WObF503hC9OclFrbX1xwqp6bJIXJvmTJDdldo/cq5P8ZWvtfcsWrpEDAFZaa+1NVfWwJK9MsjfJNUlOb61tboA4MV/68q9HJHnPwvnL58cVSU5d+PzZ89/+xwNMe/f8+82m8VNJLknyqp3UrpEDAPoZb7PDjrTWzk9y/jbfnbrl/NokdaCxW8b92XbjWmufSvKsnda5lXvkAAAmSiIHAPSzlmG7jfX7HnIokcgBAEyURg4AYKIsrQIA/Qy92WHFOhuJHADARK1Y3woADGoaDwSeLIkcAMBESeQAgH7cI9eVRA4AYKI0cgAAE7ViASQAMChLq11J5AAAJmrF+lYAYFC7MuwjQVYsolqxPy4AwKFDIgcA9OMeua4kcgAAEzWtvvX1YxeQHPdNN4xdQo7NLWOXkGc97a1jl5AkeVI+OHYJ+c68ZewS8sm3PXHsErLntLvGLiEfzJPGLiG5duwCknfvfubYJeTdx45fQ5Lkj8cuIMml7xi7guSNB8m/HzzgptXIAQDTYmm1K0urAAATtWJ9KwAwqLUM+/iRIec6CEjkAAAmSiMHADBRllYBgH5sduhKIgcAMFEr1rcCAINay7Ddhs0OAABMgUQOAOjHPXJdSeQAACZKIwcAMFErFkACAIPyZoeuJHIAABMlkQMA+rHZoSuJHADARK1Y3woADEoi15VEDgBgojRyAAATtWIBJAAwqF0Z9pEgKxZRrdgfFwDg0CGRAwD6sdmhK4kcAMBErVjfCgAMSiLXlUQOAGCiNHIAABO1YgEkADCotQz7+JEh5zoISOQAACZKIgcA9GOzQ1cSOQCAiVqxvhUAGNRahu023CMHAMAULN0jf3/PKpb1rLELSN6ebx27hNyQ48cuIUfl9rFLSJJ8LseNXUKOzS1jl5BP3jh2Bcljcu3YJWTjIFhk+Ogzv37sEpIj7hq7guT3jxi7gpmnjF1AkksfPXYFHMLG/289AODQZbNDV5ZWAQAmasX6VgBgUB4I3JVEDgBgojRyAAATZWkVAOjHZoeuJHIAABO1Yn0rADAob3boSiIHADBREjkAoB+PH+lKIgcAMFEaOQCAibK0CgD04/EjXUnkAAAmasX6VgBgUBK5riRyAAATpZEDAPrZPcJxP1TVS6vq2qq6s6r2VdVT72Xsk6vqkvn4VlVnHWDMK+bfLR4f3jLmiKr6zaq6qarumF/z+J3UrZEDAFZaVZ2R5Lwk5yY5Kcl7k1xWVcdt85MHJflEkrOTXH8vl/4fSR6+cDxzy/evTvJdSZ6f5FlJHpHkD3ZS+4qtJAMAfJmXJbmgtXZhklTVmUm+M8lLkvzi1sGttauSXDUf+2XfL1hvrR2w0auqY5L8QJIXttb+fP7Zi5N8qKqe3lr762UKl8gBAN20XUlbG/DYYWdTVXuSnJzk8n+subX98/NTvsI//uOr6jNV9YmqekNVnbjw3clJDtsy74eT/O1O5tXIAQCHoqOq6uiF4/Btxj00sxd73bDl8xuS7P0K5t+X5EVJTk/yw0kek+S/VdVR8+/3Jrm7tXbLVzKvpVUAoJuN3bNjyPnmrtvy1blJXjFUHa21P104fV9V7UvyyST/W5LXPVDzaOQAgEPRCUluXzi/a5txNybZSLJ1t+jxufeNDDvSWrulqv5nksfNP7o+yZ6qOnZLKrejeS2tAgDdbCZyQx5zt7fWbls4DtjItdbuTnJ1ktM2P6uqXfPzKx+ovw9V9eAkj03y2flHVye5Z8u8T0hy4k7mlcgBAKvuvCQXVdW7krwzyVlJjkyyuYv14iSfbq2dMz/fk+RJ89/uSfLIqnpKkjtaax+bj/nVJH+U2XLqIzJb2t1I8sYkaa3dWlWvS3JeVd2c5LYkr0ly5bI7VhONHACw4lprb6qqhyV5ZWYbDa5JcnprbXMDxIlJ9i/85BFJ3rNw/vL5cUWSU+efnZBZ0/aQJH+X5B1Jnt5a+7uF3/34/LqXJDk8yWVJfmQntWvkAIBu1tcq62s14HwtSdvx71pr5yc5f5vvTt1yfm2Se/1DtdZesMScdyZ56fy4X9wjBwAwURI5AKCbjd27s7F7uERuY3fLbA/BapDIAQBMlEQOAOhmY20tGwPeI7exJpEDAGAClk7kHvNdPctYzh8+/5+NXUJu+LIHPw/vwrxo7BJy/Se/euwSkiTXPeoreQ3eA+Nb8pdjl5CHnfG3Y5eQp+SasUvIB//xsU4jesdwycO2rjti7AqSpZ+C1dnzxi4gSR45dgEcwiytAgDd7M9aNu79SR0P8Hw7f/TIlFlaBQCYKIkcANDNetayPmAity6RAwBgCjRyAAATZWkVAOhmI2vZGDA32viSd9sf+iRyAAATJZEDALoZPpE7CJ7lOCCJHADAREnkAIBuJHJ9SeQAACZKIwcAMFGWVgGAbiyt9iWRAwCYKIkcANDNRtayLpHrRiIHADBREjkAoJuN7PaKro4kcgAAE6WRAwCYKEurAEA3G9mVjawNON9qkcgBAEyURA4A6Gb2QGCJXC8SOQCAiZLIAQDdrGct6wMmcuuDzXRwkMgBAEyURg4AYKIsrQIA3ezP7kE3O+z3rlUAAKZAIgcAdOPxI31J5AAAJkojBwAwUZZWAYBuLK32tXwj9+COVSzpWzf+YuwS8qm1rx67hNx000PHLiFZPzj+P8D/l+8eu4Q8IR8Zu4QcldvHLiEX5/8Yu4T8+eueO3YJ2fXcz49dQva/6sixS0jOv2fsCmZ+8LCxK0gOgv98JkePXQCdHBz/awwAHJI2smvgRK4NNtfBwD1yAAATJZEDALoZ/l2rEjkAACZAIwcAMFGWVgGAbjayOxsDthur9vgRiRwAwERJ5ACAbvYP/EDg/TY7AAAwBRI5AKCb4V/RJZEDAGACNHIAABNlaRUA6GY9uwZ+s8P+weY6GEjkAAAmSiIHAHQz/AOBbXYAAGACJHIAQDfDP37EPXIAAEyARg4AYKIsrQIA3Vha7UsiBwAwURI5AKCbjawN+kBgiRwAAJMgkQMAuvFA4L4kcgAAE6WRAwCYKEurAEA3G9k18ONHNgab62AgkQMAmCiJHADQzfAPBB5uroOBRA4AWHlV9dKquraq7qyqfVX11HsZ++SqumQ+vlXVWQcYc05VXVVVt1fV56rq0qp6wpYxb5//fvH4DzupWyMHAKy0qjojyXlJzk1yUpL3Jrmsqo7b5icPSvKJJGcnuX6bMc9K8ptJnp7kOUkOS/JnVXXklnEXJHn4wvFTO6nd0ioA0M1EllZfluSC1tqFSVJVZyb5ziQvSfKLWwe31q5KctV87Jd9Px9z+uJ5Vb0oyeeSnJzkLxe++kJrbbtm8D5J5ACAQ9FRVXX0wnH4gQZV1Z7MmqvLNz9rre2fn5/yANZzzPyvN2/5/Hur6saq+kBV/UJVPWgnF106kbvtdw7byXW7eMvad4xdwkHh0Q/5m7FLyEfveNLYJSRJ/tXb/t+xS0juHLuAJHeMXUCy69TPj11Cjvm++/1/ah8wDzn8prFLyCfuePLYJSQvGv9/M5Ik145dQJLcMHYBSY4ebebh37X6j3Ndt+Wrc5O84gA/eWiStXz5v1E3JHniA1FTVe1K8mtJ/ntr7QMLX/2nJJ9M8pkkX5/kl5I8Icn3LHttS6sAwKHohCS3L5zfNVYhmd0r97VJnrn4YWvttQun76+qzyZ5W1U9trX28WUurJEDALoZ/l2r+zf/5e2ttduW+MmNSTaSHL/l8+Oz/UaGpVXV+Umem+RbWmtbU8Kt9s3/+rgkSzVy7pEDAFZWa+3uJFcnOW3zs/lS6GlJrry/162Z85N8d5Jva60tc1/UU+Z//eyy80jkAIBVd16Si6rqXUnemeSsJEcm2dzFenGST7fWzpmf70myebP4niSPrKqnJLmjtfax+ee/meSFSf5Fkturau/881tba/9QVY+df/8nSW7K7B65Vyf5y9ba+5YtXCMHAHQzhcePtNbeVFUPS/LKJHuTXJPk9Nba5gaIE5MvrtkmeUSS9yycv3x+XJHk1PlnPzz/69u3TPfiJK9PcneSZ+eLTeOnklyS5FU7qV0jBwCsvNba+UnO3+a7U7ecX5uk7uN69/X9pzJ7aPBXRCMHAHSzkV0DJ3Krdfv/av1pAQAOIRI5AKCb9YEfCDzkXAcDiRwAwERp5AAAJsrSKgDQzfBvdtgYbK6DgUQOAGCiJHIAQDf7B34g8H6bHQAAmAKJHADQzRRe0TVlEjkAgInSyAEATJSlVQCgG+9a7Wu1/rQAAIcQiRwA0M161rLmXavdSOQAACZKIwcAMFGWVgGAboZ/1+pqtTYSOQCAiVqtthUAGJR3rfYlkQMAmCiJHADQjXet9iWRAwCYKI0cAMBEWVoFALpZz1p2ebNDNxI5AICJWjqRO/p37ulZx1JuetFDxy4hX8j/MnYJeVI+OHYJ+eh13zB2CTN7xy4gyevHLiDJr41dQPKEez4ydgn50L6Txi4ht/7+QfAP5deOXUCSy8cuYO66q8euIMk/jF1AksePNvNss8OQDwSWyAEAMAHukQMAuvH4kb4kcgAAE6WRAwCYKEurAEA3llb7ksgBAEyURA4A6Gb/wIncfokcAABTIJEDALpZz1rKK7q6kcgBAEyURg4AYKIsrQIA3WxkLbu8a7UbiRwAwERJ5ACAbmaJnAcC9yKRAwCYKIkcANCNRK4viRwAwERp5AAAJsrSKgDQjTc79CWRAwCYKIkcANDN/uzOxoDtxv4Va20kcgAAE6WRAwCYqNXKHwGAQW0MvNnBc+QAAJgEiRwA0M1Gdg2cyK1WRrVaf1oAgEOIRA4A6Gb2gF4PBO5FIgcAMFEaOQCAibK0CgB0s5HdqQHbjSHfInEwkMgBAEzU8m3rcR2rWNLxuWHsEvKrefnYJeTh+czYJeR3/td/OXYJSZJ/m1eNXUI++cwnjl1Csj52AcmHPnLS2CUcFH8fcv3YBSS5fOwCklw3dgGbjh+7gCS3jV3AqPZnbdCH9O632QEAgClYrYVkAGBQGwM/fsQrugAAmASNHADARFlaBQC6sbTal0QOAGCiJHIAQDfr2ZU2aCK3WhnVav1pAQAOoKpeWlXXVtWdVbWvqp56L2OfXFWXzMe3qjrr/lyzqo6oqt+sqpuq6o75NXf08EONHADQzUZ2D37sVFWdkeS8JOcmOSnJe5NcVlXbvQ7hQUk+keTsbPMY8CWv+eok35Xk+UmeleQRSf5gJ7Vr5ACAVfeyJBe01i5srX0wyZlJvpDkJQca3Fq7qrX2k62130ty1/25ZlUdk+QHkrystfbnrbWrk7w4yTOq6unLFq6RAwAORUdV1dELx+EHGlRVe5KcnIWX27XW9s/PT7k/Ey95zZOTHLZlzIeT/O1O5rXZAQDoZsTHj2x94++5SV5xgJ88NLMCt77Q/YYk9/dl2stcc2+Su1trtxxgzN5lJ9LIAQCHohOS3L5wvt0S6KRp5ACAbvYPnMjt/+Jct7fWblviJzcm2Uiydbfo8dlmI8MDdM3rk+ypqmO3pHI7mtc9cgDAymqt3Z3k6iSnbX5WVbvm51d2vObVSe7ZMuYJSU7cybwSOQCgm/WsZdc4idxOnJfkoqp6V5J3JjkryZFJLkySqro4yadba+fMz/ckedL8t3uSPLKqnpLkjtbax5a5Zmvt1qp6XZLzqurmJLcleU2SK1trf71s4Ro5AGCltdbeVFUPS/LKzDYaXJPk9Nba5maFE5PsX/jJI5K8Z+H85fPjiiSnLnnNJPnx+XUvSXJ4ksuS/MhOatfIAQArr7V2fpLzt/nu1C3n1yapr+Sa8+/vTPLS+XG/aOQAgG42spY2YLtxP5dWJ8tmBwCAiZLIAQDdzBK5g36zw2RJ5AAAJkojBwAwUZZWAYBuLK32JZEDAJgoiRwA0M3G/rW0/QMmcgPOdTCQyAEATJREDgDoZmN9LfvXh0vJ2oBzHQwkcgAAE6WRAwCYKEurAEA3G+u7U+vDtRttwLkOBhI5AICJWr5tvaJjFUv6uu94/9gl5K4cPnYJ+cNP/suxS8gf3vG/j11CkuRrn3zV2CUkjx67gCRPHLuAJK8fu4AcHH8fHjx2ATk4/pn82NgFzN3x6bErSPJVYxcwqo31XalBNzusVka1Wn9aAIBDyGotJAMAg9pYXxs4kfP4EQAAJkAjBwAwUZZWAYBu1tfXUvdYWu1FIgcAMFESOQCgm7axO21jwHZjyLkOAhI5AICJWq22FQAY1vra7BhyvhUikQMAmCiNHADARFlaBQD6sbTalUQOAGCiJHIAQD8blazXsPOtEIkcAMBEaeQAACbK0ioA0M/6/BhyvhUikQMAmCiJHADQj0SuK4kcAMBESeQAgH4kcl1J5AAAJkojBwAwUZZWAYB+1pPcM/B8K0QiBwAwURI5AKCfjfkx5HwrRCIHADBREjkAoB+PH+lKIgcAMFEaOQCAibK0CgD0Y2m1K4kcAMBELZ/IvbhjFUt6f75u7BLyY/mNsUvIzz3q3LFLyHX//fFjl5Ak+cDrvnnsEpK9YxeQg+P/gd4xdgFJfnfsAnJw/H1gwXFjF5DkirELSDLif2dL5LqSyAEATJR75ACAfjYybErmgcAAAEyBRg4AYKIsrQIA/djs0JVEDgBgoiRyAEA/ErmuJHIAABMlkQMA+rlnfgw53wqRyAEATJRGDgBgoiytAgD9bGTYty14swMAAFMgkQMA+vGu1a4kcgAAE6WRAwCYKEurAEA/3uzQlUQOAGCiJHIAQD8Sua4kcgDAyquql1bVtVV1Z1Xtq6qn3sf451fVh+fj319V37Hl+7bN8ZMLY649wPdn76RujRwA0M/6CMcOVdUZSc5Lcm6Sk5K8N8llVXXcNuOfkeSNSV6X5BuTXJrk0qr62oVhD99yvCRJS3LJlsv97JZxr9lJ7Ro5AGDVvSzJBa21C1trH0xyZpIvZNZ8Hci/TvLW1tqvtNY+1Fr7mSTvTvKjmwNaa9cvHkn+RZK/aK19Ysu1bt8y9vM7KVwjBwAcio6qqqMXjsMPNKiq9iQ5Ocnlm5+11vbPz0/Z5tqnLI6fu2y78VV1fJLvzCzB2+rsqrqpqt5TVT9ZVTvav2CzAwDQz3hvdrhuyzfnJnnFAX7x0CRrSW7Y8vkNSZ64zSx7txm/d5vx35/k9iR/sOXz38gsybs5yTOS/EJmy6sv2+Y6X0YjBwAcik7IrHnadNdYhWS2RPuG1tqdix+21s5bOH1fVd2d5Ler6pzW2lL1auQAgH7Ge/zI7a2125b4xY2Z5XjHb/n8+CIQB5EAAAwtSURBVCTXb/Ob65cdX1X/NMkTkpyxRC37MuvNHp3kI0uMd48cALC6Wmt3J7k6yWmbn1XVrvn5ldv87MrF8XPP2Wb8DyS5urX23iXKeUqS/Uk+t8TYJBI5AKCnezK7A23I+XbuvCQXVdW7krwzyVlJjkxyYZJU1cVJPt1aO2c+/teTXFFVP5HkLUlekOSbkvzQ4kWr6ugkz0/yE1snrKpTkjwtyV9ktgR8SpJXJ/nd1trfL1u4Rg4AWGmttTdV1cOSvDKzDQvXJDm9tba5oeHEzJKyzfF/VVUvTPKqJD+f5KNJntda+8CWS78gSWX2zLmt7pp//4okhyf5m8waufMOMHZbGjkAYOW11s5Pcv423516gM/enOTN93HN1yZ57TbfvTvJ03dc6BYaOQCgn40sPhJkmPlWiM0OAAATtXwi9z87VrGkjz3xcWOXkI/nsWOXkG/PZWOXkNc9+PFjlzCz3cbwIV0zdgFJTh27gCRvH7uAJA8eu4D452HTX49dwKZ3j11A7u/d94eM8R4/shIkcgAAE+UeOQCgn/Fe0bUSJHIAABOlkQMAmChLqwBAP+sZ9s0ONjsAADAFEjkAoJ97MmxstGJPe5HIAQBMlEYOAGCiLK0CAP1412pXEjkAgImSyAEA/XizQ1cSOQCAiZLIAQD9rGfY2MgDgQEAmAKNHADARFlaBQD6uSdJDTzfCpHIAQBMlEQOAOjHA4G7ksgBAEyURA4A6MfjR7qSyAEATJRGDgBgoiytAgD9eNdqVxI5AICJksgBAP0M/YBeDwQGAGAKJHIAQD8bGTY2co8cAABToJEDAJgoS6sAQD/rSWrg+VaIRA4AYKKWTuQ+/+3j93wfz2PHLiH/Jf987BLy7Fw+dgk55xt+duwSkiR/9A3fNXYJ+dRdXz12Cbn1mr1jl5A8c+wCklwzdgFJHj12AUn+eOwCkuS2sQuYe8jYBST55NgFjEsi19X43RkAAPeLe+QAgH6GTsgkcgAATIFGDgBgoiytAgD9bGTYzQ7e7AAAwBRI5ACAfmx26EoiBwAwURo5AICJsrQKAPRjabUriRwAwERJ5ACAftaTtAHn8/gRAACmQCIHAPQzdEImkQMAYAo0cgAAE2VpFQDox2aHriRyAAATJZEDAPqRyHUlkQMAmCiJHADQz3qS/QPON+RcBwGJHADARGnkAAAmytIqANDPRobd7GBpFQCAKZDIAQD9rGfY2EgiBwDAFEjkAIB+JHJdSeQAACZKIwcAMFGWVgGAfu6JpdWOJHIAwMqrqpdW1bVVdWdV7auqp97H+OdX1Yfn499fVd+x5fvXV1Xbcrx1y5ivqqo3VNVtVXVLVb2uqh68k7qXTuQ2dq/t5LpdnJE3jV1C/jL/dOwSsid3jV1C/ijfNXYJSQ6OvxfHHn7L2CXk1r0PGbuE5PTDxq4g2Tt2AUmOGLuAJNeOXUCSY48eu4KZ648bu4Ikt41dwLj2Z9gHAt+PuarqjCTnJTkzyb4kZyW5rKqe0Fr73AHGPyPJG5Ock+SPk7wwyaVVdVJr7QMLQ9+a5MUL51v/R+sNSR6e5DlJDktyYZLXzq+3FIkcALDqXpbkgtbaha21D2bW0H0hyUu2Gf+vk7y1tfYrrbUPtdZ+Jsm7k/zolnF3tdauXzj+fvOLqvqaJKcn+cHW2r7W2juS/KskL6iqRyxbuEYOAOhnfYRj5qiqOnrhOPxA5VXVniQnJ7l887PW2v75+Snb/KlOWRw/d9kBxp9aVZ+rqo9U1W9V1eLyySlJbmmtvWvhs8szyzCfts28X0YjBwAciq5LcuvCcc424x6aZC3JDVs+vyHb37Cxd4nxb03yfyY5LclPJ3lWkj+tqs171fYm+ZJl29baepKb72XeL2PXKgBwKDohye0L54PeVN1a+72F0/dX1fuSfDzJqUne9kDNo5EDAPpZT1IDzvfFzQ63t9aW2WlyY5KNJMdv+fz4JNdv85vrdzg+rbVPVNWNSR6XWSN3fZIv2Y1TVbuTfNW9XWcrS6sAwMpqrd2d5OrMlkCTJFW1a35+5TY/u3Jx/Nxz7mV8quqEJA9J8tmFaxxbVScvDPu2zHqzfcvWL5EDAPq5J2MlcjtxXpKLqupdSd6Z2eNHjszscSCpqouTfLq1tnmf3a8nuaKqfiLJW5K8IMk3Jfmh+fgHJ/m5JJdklq49NskvJ/lYZpsi0lr70Py5chdU1ZmZPX7k/CS/11r7zLKFa+QAgJXWWntTVT0sySsz22hwTZLTW2ubGxpOzMI7I1prf1VVL0zyqiQ/n+SjSZ638Ay5jSRfn+T7kxyb5DNJ/izJz7TWFu/V+97Mmre3za9/SZIf20ntGjkAYOW11s7PrKk60HenHuCzNyd58zbj/yHJty8x583ZwcN/D0QjBwD0s5EpLK1Ols0OAAATJZEDAPpasZRsSBI5AICJ0sgBAEyURg4AYKI0cgAAE6WRAwCYKI0cAMBEaeQAACZKIwcAMFEeCAwAdHTP/BhyvtUhkQMAmCiNHADARFlaBQA6Wp8fQ863OiRyAAATJZEDADqy2aEniRwAwERJ5ACAjtwj15NEDgBgojRyAAATZWkVAOhoPcNuQLC0CgDABFRrbewaAIBDTFUdneTW5INJjhpw5tuTPClJjmmt3TbgxKOQyAEATJRGDgBgomx2AAA68hy5niRyAAATJZEDADry+JGeJHIAABMlkQMAOnKPXE8SOQCAidLIAQBMlKVVAKCjezLsZoch5xqfRA4AYKIkcgBARzY79CSRAwCYKIkcANCRBwL3JJEDAJgojRwAwERZWgUAOrLZoSeJHADAREnkAICOPBC4J4kcAMBESeQAgI7cI9eTRA4AYKI0cgAAE2VpFQDoyJsdepLIAQBMlEQOAOjIZoeeJHIAABMlkQMAOvJA4J4kcgAAE6WRAwCYKEurAEBHllZ7ksgBAEyURA4A6MjjR3qSyAEATJRGDgBgoiytAgAdeddqTxI5AICJksgBAB3Z7NCTRA4AYKIkcgBAR/dk2HbDA4EBAJgAjRwAwERZWgUAOrLZoSeJHACw8qrqpVV1bVXdWVX7quqp9zH++VX14fn491fVdyx8d1hV/dL8889X1Weq6uKqesSWa1xbVW3LcfZO6tbIAQAdbT4QeKhj54lcVZ2R5Lwk5yY5Kcl7k1xWVcdtM/4ZSd6Y5HVJvjHJpUkuraqvnQ950Pw6/27+1+9J8oQk/+UAl/vZJA9fOF6zo9pbazsZDwBwn6rq6CS3Jv9PkiMGnPnOJP8mSY5prd22zC+qal+Sq1prPzo/35XkU0le01r7xQOMf1OSI1trz1347K+TXNNaO3ObOb45yTuTPKq19rfzz65N8muttV9b/s/3pSRyAEBH6yMcy6uqPUlOTnL55mettf3z81O2+dkpi+PnLruX8UlyTJKW5JYtn59dVTdV1Xuq6ierakf7F2x2AAAORUdV1eL5Xa21uw4w7qFJ1pLcsOXzG5I8cZtr791m/N4DDa6qI5L8UpI3bkkJfyPJu5PcnOQZSX4hs+XVl20z75fRyAEAh6Lrtpyfm+QVQxdRVYcl+c9JKskPL37XWjtv4fR9VXV3kt+uqnO2aTq/jEYOAOjonswCryHnS5KckOT2hS+2a4xuTLKR5Pgtnx+f5PptfnP9MuMXmrhHJfm2Je7Z25dZb/boJB+5j7FJ3CMHAByabm+t3bZwHLCRa63dneTqJKdtfjbf7HBakiu3ufaVi+PnnrM4fqGJe3ySZ7fWblqi5qck2Z/kc0uMTSKRAwC6msQDgc9LclFVvSuznaVnJTkyyYVJUlUXJ/l0a+2c+fhfT3JFVf1EkrckeUGSb0ryQ/PxhyX5/cwePfLcJGtVtXn/3M2ttbur6pQkT0vyF5klh6ckeXWS322t/f2yhWvkAICOlrrVa9T5WmtvqqqHJXllZhsWrklyemttc0PDiZklZZvj/6qqXpjkVUl+PslHkzyvtfaB+ZBHJvnn8399zZbpvjXJ2+eFviCz+/YOT/I3mTVy52UHPEcOAHjAzXdq/k222cnZ2fVJHtNau3OEuQelkQMAupg3c3tGmPruVWjiEo0cAMBk2bUKADBRGjkAgInSyAEATJRGDgBgojRyAAATpZEDAJgojRwAwERp5AAAJkojBwAwURo5AICJ+v8B21V0sttt/mkAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -176,12 +176,12 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlwAAAJzCAYAAADa5s1TAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAeUUlEQVR4nO3dbYylZ3kf8P+9Z+w13l2vyya22RhUpxgrEVQ0sVoaUUNUtUJKwksrlARVDSRSA7Uilb6pVr8QRQ2qIhlKsFSlbRQqRW0/QEhQa0JR7aDQEBHUUlEgVVuKsRbbYGvXg1/WO2fufjjH9XRYx+fs7vU8j8/5/aSj8cx55tyXZmdnL/+ve+6n9d4DAECdI2MXAACw6TRcAADFNFwAAMU0XAAAxTRcAADFNFwAAMU0XAAAxTRcAADFNFwAAMU0XAAAxTRcAMDWaq3d1Vr7fGttt7X2SGvt46212w5d87daa/e31h5vrfXW2vVrr+NeigBAhdbaNUmuHmHpZ3rvT69yYWvtk0n+bZLPJ9lJ8stJXp3kB3vvTyyv+TtJrll+yvuT/Kne+9l1CtJwAQBXXGvtmuPJU98ZZ/mHktyyatN1UGvte5M8kuQNvffPHHrujUnuyyU0XDvrFgIAsIKrv5PkvUmODrjo+SQfSG5Kcqq1tnvwqd77+RVe4uTy7WNXsi4NFwBQ5miem8UN7MFD7/9ikvf9SZ/QWjuS5INJPtt7/9KVLEbDBQCU2cmwzcaBtW5O8v8lXCt8+j1Z7N96/RUtKhouAGAz7fbeH1/14tbah5P8eJI7eu+H07HLpuECAMpctXwMZb7m9a21luRXk7wtyRt771+78lVpuACA7XZPknckeUuS3dbaTcuPn+u9P5Uky4/dlOSVy+des9yQ/0DvfaXN9Q4+BQC22Xuy+M3E+5N888DjJw9c8+4k/yXJv1i+/5nl+29edREJFwBQZsRN8yvpvbcVrnlfXuA3HF+IhAsAoJiECwAos5NhN83vDbjWOiRcAADFJFwAQJmp7+EaioQLAKCYhgsAoNhUkzcAYAMMfdK8TfMAAFtKwgUAlLFpfkHCBQBQbKqNIACwAYY++PTCgGutQ8IFAFBMwwUAUMxIEQAoY9P8goQLAKDYVBtBAGADDH3w6ZBrrUPCBQBQTMIFAJSRcC1IuAAAimm4AACKGSkCAGUcC7Eg4QIAKDbVRhAA2ABD30txqo2NhAsAoJiGCwCg2FSTNwBgA9g0vyDhAgAoNtVGEADYAE6aX5BwAQAUk3ABAGXs4VqQcAEAFNNwAQAUm2ryBgBsACfNL0i4AACKTbURBAA2gE3zCxIuAIBiU20EAYAN4ODTBQkXAEAxDRcAQDEjRQCgjE3zCxIuAIBiU20EAYAN4ODTBQkXAECxqTaCAMAGcCzEgoQLAKDYygnX+1rrlYWs4ofGLiDTqOHmG8auIMktYxcwIU+MXUCSU2MXkGQK35e3jl1A/N2YmnNjF5DkkbELSPJPexu7hG1npAgAlHEsxIKRIgBAsak2ggDABtiZJVcNONDc6Unmw623KgkXAEAxCRcAUGZnJ9mRcEm4AACqabgAAIoZKQIAZa4aeNP8VaOfGnpxEi4AgGISLgCgzCib5idIwgUAUEzDBQBQzEgRAChz1Sy5asB456r94dZah4QLAKCYhAsAqDPLsPHOgBv01yHhAgAoJuECAOrsZNh4xx4uAIDtpOECAChmpAgA1DFSTCLhAgAoJ+ECAOpIuJJIuAAAykm4AIA6R7I4/HTLSbgAAIppuAAAihkpAgB1djLsSNG9FAEAtpOECwCoI+FKIuECACgn4QIA6sziWIhIuAAAyq2ccP1QZRUr+r6xC0hy3dGxK0hyeuwCkhwbu4ClKdRxfOwCklw3dgFJbhy7gCS3jF1AkpNjFxBpwkFT+BlxauwCmAIjRQCgjk3zSYwUAQDKSbgAgDqz6DYi4QIAKKfhAgAoJuQDAOoMfQ5XH3CtNUi4AACKSbgAgDo70W1EwgUAUE7PCQDUkXAlkXABAJTTcAEAFBPyAQB1jBSTSLgAAMrpOQGAOkcy7MGn+wOutQYJFwBAMQkXAFBn6D1cbu0DALCdNFwAAMWMFAGAOkaKSSRcAADlJFwAQJ1ZHAsRCRcAQDkJFwBQxx6uJBIuAIByGi4AgGIaLgCgzizPjRWHeKy5Qb+1dldr7fOttd3W2iOttY+31m47dM01rbV7WmuPtta+01r7aGvtxnXW0XABANvsDUnuSfK6JH8lyVVJPtVaO3bgmg8k+Ykkb19efzrJx9ZZxKZ5AKDO0MdCPLfWidbawWfO997PH7689/6mg++31t6Z5JEkP5zkM621k0l+Lsk7eu//aXnNu5J8pbX2ut7751YpS8IFAGyiB5OcO/C4a8XPO7l8+9jy7Q9nkXp9+tkLeu9fTfJAkr+4ajESLgCgztDHQjx38OnNSXYPPPNd6dZhrbUjST6Y5LO99y8tP3xTkmd672cPXf7w8rmVaLgAgE2023t/fM3PuSfJq5O8/koXs3LD9Reu9MqX4CVHx64gOXHsha8ptzd2AUmuGbuApZMvfEm5KdRweuwCkrxi7AIyja/DBH5OTaIGnvPYC1/C+FprH07y40nu6L0/eOCph5Jc3Vq7/lDKdePyuZVIuACAOuONFFfSFjvrfzXJ25K8sff+tUOXfCHJhSR/OclHl59zWxb/m/kHq66j4QIAttk9Sd6R5C1Jdltrz+7LOtd7f6r3fq619q+S3N1aeyzJ41k0aH+w6m8oJhouAKDSxBOuJO9Zvr3/0MffleQ3lv/93uUrfzSLof3vJvnb6yyi4QIAtlbvva1wzdNJ7lw+LolzuAAAikm4AIA6RzLsSfMTjZImWhYAwOaQcAEAdYbeND8fcK01SLgAAIpJuACAOhKuJBIuAIByGi4AgGJGigBAnVmGPRZiyLXWIOECACgm4QIA6tg0n0TCBQBQTsIFANSZZdhuY2/AtdYg4QIAKKbhAgAoZqQIANQZetP8RDsbCRcAQLGJ9oEAwEZw8GkSCRcAQDkJFwBQxx6uJBIuAIByGi4AgGITDd4AgI1gpJhEwgUAUG6ifSAAsBGOZNijGiYaJU20LACAzSHhAgDq2MOVRMIFAFBu5T7wxlsry1jR0bELSHLN2AUkuWHsApK8fOwClk6OXUCSU2MXkGl8T1w3dgFJXjp2AUmOjV1ApvFzaiKeuGH8XOHY1/bHLoEJmGjwBgBsBCPFJEaKAADlJtoHAgAbYZZhj4UYcq01SLgAAIppuAAAihkpAgB1bJpPIuECACg30T4QANgIswzbbdg0DwCwnSRcAEAde7iSSLgAAMppuAAAik00eAMANoKT5pNIuAAAykm4AIA6Ns0nkXABAJSbaB8IAGwECVcSCRcAQDkNFwBAsYkGbwDARjiSYY9qmGiUNNGyAAA2h4QLAKhj03wSCRcAQLmJ9oEAwEaQcCWRcAEAlNNwAQAUm2jwBgBshFmGPRZiyLXWIOECACgm4QIA6tg0n0TCBQBQTsMFAFBsosEbALARZhm225jopvnVvwS3FlaxqmNjF5BptKjXjV1AkleMXcDS0bELSHJ67AKSnBy7gEzj6zCBGp6ews+pCTh6fuwKFuY7E/jX96X7Y1fABEyhfQAANpVN80ns4QIAKDfRPhAA2AgOPk0i4QIAKKfhAgAoZqQIANSxaT6JhAsAoNxE+0AAYCM4+DSJhAsAoJyECwCo41iIJBIuAIByGi4AgGJGigBAHcdCJJFwAQCUm2gfCABsBAlXEgkXAEC5ifaBAMBGkHAlkXABAJTTcAEAFJto8AYAbIJ+JOkDnv7eJxolTbQsAIDNIeECAMrMdxaPIdebIgkXAECxifaBAMAmkHAtSLgAAIppuAAAik00eAMANsHerGVv1gZcryfpg623KgkXAEAxCRcAUGa+s5P5znAJ13ynJ7kw2HqrknABABTTcAEAFDNSBADKzGezzAfcND+fTXOkuHrDdXthFat6YuwCkgx4A87ndWzsApIcHbuApdNjF5Bp/G/LBL4nnr517AqSh49979glTMJ8Aj+oZsfmY5eQJHlmAj+svn3D3tgl5PvHLoBJ/FMBAGyo/cwyz3AJ1/4Ej4RI7OECACgn4QIAyuxllr0BE649CRcAwHbScAEAFDNSBADKzDPLfMB8Z579wdZah4QLAKCYhAsAKDN8wjXcBv11SLgAAIpJuACAMhKuBQkXALC1Wmt3tNY+0Vo701rrrbW3Hnr+xtbabyyff7K19snW2to3M9NwAQDb7FiSLya58/ATrbWW5ONZ3I7yLUn+XJKvJ/l0a22tu9gaKQIAZUYcKZ5Y9Ev/z/ne+/nD1/fe701yb5Icuj5Jbk3yuiSv7r3/9+U170nyUJKfTvIvV61LwgUAbKIHk5w78LjrEl7j6PLt089+oPe+n+R8ktev80ISLgCgzDyz7I2TcN2cZPfAU9+Vbq3gq0keSPL+1trPJ3kiyXuXr/2ydV5IwgUAbKLd3vvjBx5rN1y99wtJ/lqSVyV5LMmTSX40ixHkWkfaS7gAgDLz7Lyob+3Te/9Ckte21k4mubr3/q3W2h8m+aN1XkfCBQDwAnrv55bN1q1Jbk/y2+t8voQLANharbXjSV554EO3tNZem+Sx3vsDrbW3J/lWFnu5XpPknyX5eO/9U+uso+ECAMrMcyTzzAZcb223J7nvwPt3L99+JMk7s9gcf3eSG5N8M8m/TvJL6y6i4QIAtlbv/f7k+e8H1Hv/UJIPXe46Gi4AoMzi4NNJJ1yDsGkeAKCYhgsAoJiRIgBQZi+z7A04UtwbbKX1SLgAAIpJuACAMvvZGXTT/P7z/8LhqCRcAADFJFwAQBnHQixIuAAAimm4AACKGSkCAGWMFBdWb7hOF1axqikcrjGFGo6NXUCSk2MXsHRq7AIyjb8bLx27gOTMsZvGLiFnJvCHsTPZH/fDOp+jY5eQJJlN4of2+L5/7AKQcAEAdeY5MnDC1Qdbax32cAEAFJNwAQBlhr+1j4QLAGArabgAAIoZKQIAZebZyXzAdmOqvycs4QIAKCbhAgDK7A988Om+TfMAANtJwgUAlBn+1j4SLgCAraThAgAoZqQIAJTZy5GBT5rfH2ytdUi4AACKSbgAgDLDH3xq0zwAwFaScAEAZYY/FsIeLgCAraThAgAoZqQIAJQxUlyQcAEAFJNwAQBl5pkNevCphAsAYEtpuAAAihkpAgBlnDS/IOECACgm4QIAysxzZOBjIeaDrbUOCRcAQDEJFwBQZviDT4dbax0SLgCAYhouAIBiRooAQBkjxQUJFwBAsdUTrpcVVvFiMoXfNp1C83587AKWTo9dQPLELeP/f8uZo+N/IR7NqbFLyDM5OnYJ+U6uHruEPJlrxy5hMqaQdgx5H8EpGv5eitP8eo//LwUAwIazhwsAKDP8rX32B1trHRIuAIBiGi4AgGJGigBAGcdCLEi4AACKSbgAgDLzHBk44ZpmljTNqgAANoiECwAoszfwwadTPWhWwgUAUEzDBQBQzEgRACgz/EnzU7jp8XeTcAEAFJNwAQBl9gc++HTfpnkAgO0k4QIAyri1z4KECwCgmIYLAKCYkSIAUMa9FBemWRUAwAaRcAEAZfYyy8y9FCVcAADVNFwAAMWMFAGAMsPfS3GarY2ECwCg2DTbQABgI7iX4oKECwCgmIQLACjjXooLEi4AgGIaLgCAYkaKAECZvcxyxEnzEi4AgGovroTrmrELSPLSsQtIMh+7gCSnxy5g4bGXj/9N8VSuHbuEPJpTY5eQs7l+7BLycG4cu4RJbNjdzYmxS8hsEj+opvJ9ecPYJeSnR1x7sWl+yINPx/87eDESLgCAYi+uhAsAeFFxLMSChAsAoJiGCwCgmJEiAFDGSHFBwgUAUEzCBQCU2R844dqXcAEAbCcJFwBQZi+zNLf2kXABAFTTcAEAFDNSBADKzDPLEfdSlHABAFSTcAEAZRYJl4NPJVwAAMU0XAAAxYwUAYAyRooLEi4AgGISLgCgjJPmFyRcAADFJFwAQJn97GQ+YLuxP9HWRsIFAFBMwwUAUGyauRsAsBHmA2+adywEAMCW0nABAGXmOZJ5ZgM+1mttWmt3tNY+0Vo701rrrbW3Hnr+eGvtw621B1trT7XWvtxae/e6XwcNFwCwzY4l+WKSO5/n+buTvCnJ30jyA0k+mOTDrbU3r7OIPVwAQJnFQaTTPfi0935vknuTpLV2sUt+JMlHeu/3L9//tdbazyf580l+Z9V1JFwAwCY60Vq77sDj6CW+zn9O8ubW2ve1hR9N8qokn1rnRTRcAMAmejDJuQOPuy7xdX4hyZeXr/dMkk8mubP3/pl1XsRIEQAoM89O2oDtxoFT7W9OsnvgqfOX+JK/kOR1Sd6c5OtJ7khyT2vtTO/906u+iIYLANhEu733xy/nBVprL0nyy0ne1nv/98sP/7fW2muT/P0kBQ3Xq9YpscilTl+vpEvtj6+kl45dQPKtG46PXUKS5NGcGruEPJlrxy4hZ3J67BJyPlePXcIkvg67OTF2CZM4+PFsrh+7hCTT+J44Ool/OMazvzyuYcj1rqCrlo/9Qx+fZ81tWRIuAGBrtdaOJ3nlgQ/dskywHuu9P9Ba+70kv9JaeyqLkeIbkvzNJH93nXU0XABAmfnAx0JcQpp2e5L7Drx/9/LtR5K8M8lPJXl/kt/MYsb09ST/OMk/X2cRDRcAsLWW52td9ACu5fMPJXnX5a7jWAgAgGISLgCgzItgpDgICRcAQDEJFwBQZi9H0gdNuKaZJU2zKgCADSLhAgDKLG61M8qtfSZFwgUAUEzDBQBQbJq5GwCwERwLsSDhAgAoJuECAMrsD5xw7Uu4AAC2k4YLAKCYkSIAUGYvsxwxUpRwAQBUk3ABAGXmmaUP2G5IuAAAtpSECwAos0i47OGScAEAFNNwAQAUM1IEAMoYKS5IuAAAikm4AIAy8/1Z+v6ACdeAa61DwgUAUEzCBQCUme/Nsr83XOrUB1xrHRIuAIBiGi4AgGJGigBAmfneTtrecO1GH3CtdUi4AACKrdwGXnhZZRms4+zJ42OXkDOZxjfEbk6MXUK+mdNjl5AzE6jhyVw7dgl5NKfGLmESfxZT+DpM4fshSc7m+rFLyLV5cuwSRjXfO5I26Kb5aWZJ06wKAGCDTHPQCQBshPnebOCEy7EQAABbScMFAFDMSBEAKLO3N0u7YKQo4QIAKCbhAgDK9PlO+nzAdmPItdYg4QIAKKbhAgAoNs3cDQDYDHuzxWPI9SZIwgUAUEzCBQDUkXAlkXABAJSTcAEAdeYt2WvDrjdBEi4AgGIaLgCAYkaKAECdveVjyPUmSMIFAFBMwgUA1JFwJZFwAQCUk3ABAHUkXEkkXAAA5TRcAADFjBQBgDp7SS4MvN4ESbgAAIpJuACAOvPlY8j1JkjCBQBQTMIFANRxLEQSCRcAQDkNFwBAMSNFAKCOkWISCRcAQLmVE65HT56srGMlZ3P92CXkyVw7dgnZzYmxS5jEn0WSPJOrxy4hZ3J67BLyjbx87BIm8T3hz2LhzHz8r8Pu2fF/TiXJbGf8uGO+N4Fh0qkR15ZwJZFwAQCUm0DbDQBsrHmGTZ0cfAoAsJ00XAAAxYwUAYA6Ns0nkXABAJSTcAEAdSRcSSRcAADlNFwAAMWMFAGAOheWjyHXmyAJFwBAMQkXAFBnnmFPf3fSPADAdpJwAQB13EsxiYQLAKCchgsAoJiRIgBQx0nzSSRcAADlJFwAQB0JVxIJFwBAOQkXAFBHwpVEwgUAUE7DBQBQzEgRAKjjpPkkEi4AgHISLgCgjk3zSSRcAADlJFwAQJ0LSWYDrzdBEi4AgGIaLgCAYkaKAECdeYY9qsGxEAAA22nlhGs3JyrrWMm3c2rsEvJovmfsEvJkXjJ2CXkq145dQpLkbK4fu4Q8nBvHLmESfze+mdNjl5A/zm1jl5Azj47/dbhw/3Vjl5A8OHYBCxf+9NgVZBpfiztHXNuxEEkkXAAA5ezhAgDquLVPEgkXAEA5DRcAQDEjRQCgzl6GPWnepnkAgO0k4QIA6lzIsPGOeykCAGwnDRcAQDENFwBQZz7CYw2ttTtaa59orZ1prfXW2lsPPd+f5/EP1llHwwUAbLNjSb6Y578B0ssOPX42SU/y0XUWsWkeAKgz8ZPme+/3Jrk3SVprF3v+oYPvt9bekuS+3vv/XmcdDRcAsIlOHGqgzvfez1/OC7bWbkzyY0l+Zt3P1XABAHX2MuwGpufStAcPPfOLSd53ma/+M0l2k3xs3U/UcAEAm+jmLJqjZ11WurX0s0l+s/f+9LqfqOECADbRbu/98Sv1Yq21v5TktiQ/eSmfr+ECAOpcSPLde9Fr16vxc0m+0Hv/4qV8soYLANharbXjSV554EO3tNZem+Sx3vsDy2uuS/L2JH/vUtfRcAEAdS7hMNLLXm89tye578D7dy/ffiTJO5f//VNZ5HT/5lLL0nABAFur935/XmDo2Xv/tSS/djnraLgAgDrjHQsxKW7tAwBQTMMFAFDMSBEAqDPxeykORcIFAFBMwgUA1Kk7iHQa661IwgUAUEzCBQDUmWfYeMceLgCA7aThAgAoZqQIANTZywvcOKdgvQmScAEAFFs54ZpNtWUc2JN5ydgl5GyuH7uEPJrvGbuEJNP4Wnw7p8YuIY/kxrFLyJmcHruEfOPhl49dQvb/57GxS0juH7uAJF8au4Clp8cuIMl3xi4gyZ0jri3hSiLhAgAop+ECAChm0zwAUGfoEZ+RIgDAdpJwAQB15hl207yT5gEAtpOECwCoYw9XEgkXAEA5DRcAQDEjRQCgjpFiEgkXAEA5CRcAUGcvSR9wPcdCAABsJwkXAFBn6MRJwgUAsJ00XAAAxYwUAYA6Ns0nkXABAJSTcAEAdSRcSSRcAADlJFwAQJ29JPsDrjfkWmuQcAEAFNNwAQAUM1IEAOrMM+ymeSNFAIDtJOECAOrsZdh4R8IFALCdJFwAQB0JVxIJFwBAOQ0XAEAxI0UAoM6FGClGwgUAUG7lhOv6nK2sYyXfyCvGLiH/J7eMXULuzxvHLiEvzzfGLiFJcianxy4hD+eGsUvIU7l27BLyla+/ZuwSks9dNXYFyR+NXUCSz41dQKbxdUiS/MexC0jy2bELSPK+8Zbez7AHnw651hokXAAAxTRcAADFbJoHAOrsJWkDrmekCACwnSRcAEAdCVcSCRcAQDkJFwBQ50IkXJFwAQCU03ABABQzUgQA6sxjpBgJFwBAOQkXAFBroqnTkCRcAADFNFwAAMU0XAAAxTRcAADFNFwAAMU0XAAAxTRcAADFNFwAAMUcfAoAFLqwfAy53vRIuAAAimm4AACKGSkCAIX2lo8h15seCRcAQDEJFwBQyKb5RMIFAFBOwwUAUMxIEQAoZNN8IuECACgn4QIACu1l2I3sEi4AgK3Ueu9j1wAAbJjW2nVJziVfTnJiwJV3k/xgkpzsvT8+4MJ/IgkXAEAxDRcAQDGb5gGAQo6FSCRcAADlJFwAQCHHQiQSLgCAchIuAKCQPVyJhAsAoJyGCwCgmJEiAFDoQobdND/kWquTcAEAFJNwAQCFbJpPJFwAAOUkXABAIQefJhIuAIByGi4AgGJGigBAIZvmEwkXAEA5CRcAUMjBp4mECwCgnIQLAChkD1ci4QIAKKfhAgAoZqQIABRy0nwi4QIAKCfhAgAK2TSfSLgAgC3WWrujtfaJ1tqZ1lpvrb31Itf8QGvtd1pr51prT7TWPt9ae8U662i4AIBtdizJF5PcebEnW2t/JsnvJ/lqkjcm+bNJfinJ0+ssYqQIABSa9knzvfd7k9ybJK21i13yT5L8h977Pzzwsf+1blUSLgBgE51orV134HF03RdorR1J8mNJ/kdr7Xdba4+01v7wYmPHF6LhAgAKXRjhkSR5MMm5A4+7LqH4G5IcT/KPknwyyV9N8ltJPtZae8M6L2SkCABsopuT7B54//wlvMazwdRv994/sPzv/9pa+5Ek707ye6u+kIYLACg02rEQu733xy/zxb69fMEvH/r4V5K8fp0XMlIEALiI3vszST6f5LZDT70qydfXeS0JFwCwtVprx5O88sCHbmmtvTbJY733B5L8SpJ/11r7TJL7krwpyU9kcUTEyjRcAEChyd9L8fYsGqln3b18+5Ek7+y9/1Zr7d1ZbLr/UJI/TvLXe++/v84iGi4AYGv13u9PctEDuA5c8+tJfv1y1tFwAQCF3EsxsWkeAKCchAsAKHQhw7YbQ+4XW52ECwCgmIYLAKCYkSIAUMim+UTCBQBQTsIFABSa/MGng5BwAQAUk3ABAIXs4UokXAAA5TRcAADFjBQBgEIXkswGXm96JFwAAMUkXABAIZvmEw0XAFDq/Iavt5rWex+7BgBgw7TWrknytSQ3jbD8Q0lu6b0/PcLaF6XhAgBKLJuuq0dY+pkpNVuJhgsAoJzfUgQAKKbhAgAopuECACim4QIAKKbhAgAopuECACim4QIAKPZ/AZEdVfP5s/y1AAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -199,7 +199,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -209,7 +209,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -218,12 +218,12 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -241,12 +241,12 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -271,15 +271,18 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 17, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "9 dimensions\n", - "225 cells\n" + "ename": "AttributeError", + "evalue": "'SOMap' object has no attribute 'n_dim'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;31m# need more iterations to make sure it converges\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mM\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msomsphere\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mSOMap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mData_X\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mData_Y\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtopology\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'grid'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_top\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m15\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_iter\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m300\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mperiodic\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mM\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_dim\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'dimensions'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#dimensions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mM\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_pix\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'cells'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#cells\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAttributeError\u001b[0m: 'SOMap' object has no attribute 'n_dim'" ] } ], @@ -293,27 +296,9 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "dw = 0.009881422924901186\n" - ] - }, - { - "data": { - "text/plain": [ - "(9, 225)" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "#weights are supposed to be random, but we can make them linear for testing\n", "W = np.linspace(0,20,M.n_dim*M.n_pix).reshape(M.n_dim,M.n_pix)\n", @@ -325,7 +310,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -334,7 +319,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -343,44 +328,18 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "M.plot_map()" ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# If I create the map again, results should be the same\n", "M.create_map(inputs_weights=W, random_order=False)\n", @@ -390,21 +349,9 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([16.1580654 , 14.33966559, 13.50589005, 13.13014191, 12.84625795,\n", - " 1.81839981, 0.83377553, 0.37574814, 0.28388396])" - ] - }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# To compare, we can use the resulting weights for cell 0\n", "M.weights[:,0]" @@ -412,7 +359,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -422,27 +369,9 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "dw = 0.0028939372015627262\n" - ] - }, - { - "data": { - "text/plain": [ - "(9, 768)" - ] - }, - "execution_count": 40, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "#weights, the number of pixels is different\n", "#weights are supposed to be random, but we can make them linear for testing\n", @@ -455,7 +384,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -464,22 +393,9 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "M_sph.evaluate_map()\n", "M_sph.plot_map()" @@ -487,22 +403,9 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "M_sph.evaluate_map(input_y=Data_X[:,0])\n", "M_sph.plot_map()\n" @@ -510,7 +413,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -519,22 +422,9 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "M_sph.evaluate_map()\n", "M_sph.plot_map()" @@ -542,21 +432,9 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([20.09034726, 18.18745936, 17.18432217, 16.73921586, 16.40915885,\n", - " 1.9028879 , 1.00313718, 0.44510632, 0.330057 ])" - ] - }, - "execution_count": 46, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "#Weights for cell 0\n", "M_sph.weights[:,0]" @@ -576,21 +454,9 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'M_hex' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mW\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinspace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m20\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mM_hex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_dim\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mM_hex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_pix\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mM_hex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_dim\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mM_hex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_pix\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mM_hex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcreate_map\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minputs_weights\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mW\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrandom_order\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mM_hex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mevaluate_map\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mM_hex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot_map\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mNameError\u001b[0m: name 'M_hex' is not defined" - ] - } - ], + "outputs": [], "source": [ "W=np.linspace(0,20,M_hex.n_dim*M_hex.n_pix).reshape(M_hex.n_dim,M_hex.n_pix)\n", "M_hex.create_map(inputs_weights=W, random_order=False)\n", @@ -918,9 +784,9 @@ ], "metadata": { "kernelspec": { - "display_name": "env37", + "display_name": "env38", "language": "python", - "name": "env37" + "name": "env38" }, "language_info": { "codemirror_mode": { @@ -932,7 +798,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.9" + "version": "3.8.2" } }, "nbformat": 4, diff --git a/setup.py b/setup.py index 5a575bd..dcac1ab 100644 --- a/setup.py +++ b/setup.py @@ -1,18 +1,11 @@ -import sys +from numpy.distutils.core import setup -files_f90 = ['resources/som.f90', ] -from numpy.distutils.core import setup, Extension - -extra_link_args = [] -libraries = [] -library_dirs = [] exec(open('version.py').read()) setup( name='somsphere', version=__version__, author='Matias Carrasco Kind', author_email='mcarras2@illinois.edu', - ext_modules=[Extension('somF', files_f90, ), ], packages=[], py_modules=['somsphere'], license='License.txt', diff --git a/somsphere/__init__.py b/somsphere/__init__.py index f3a32ba..0883e7a 100644 --- a/somsphere/__init__.py +++ b/somsphere/__init__.py @@ -3,29 +3,21 @@ .. moduleauthor:: Matias Carrasco Kind """ -from __future__ import print_function - -from builtins import object -from builtins import range -from builtins import zip - __author__ = 'Matias Carrasco Kind' -import numpy -import copy -import sys, os, random -import warnings -from somsphere.models import Topology, DY, SomType +import os +import random -from somsphere.utils import get_sigma, is_power_2, geometry, count_modified_cells, get_alpha - -warnings.simplefilter("ignore", RuntimeWarning) -try: - import somF +import healpy as hp +import matplotlib as mpl +import matplotlib.cm as cm +import matplotlib.pyplot as plt +import numpy +from matplotlib import collections +from matplotlib.colors import colorConverter - SF90 = True -except: - SF90 = False +from somsphere.models import Topology, DY, SomType +from somsphere.utils import get_sigma, is_power_2, compute_distance, count_modified_cells, get_alpha class SOMap(object): @@ -50,11 +42,8 @@ class SOMap(object): def __init__(self, X, Y, topology='grid', som_type='online', n_top=28, n_iter=30, alpha_start=0.8, alpha_end=0.5, periodic=False, importance=None, dict_dim=None): if topology == 'sphere' and not is_power_2(n_top): - print('Error, n_top must be power of 2') - sys.exit(0) + raise Exception("Error, n_top must be power of 2") - self.SF90 = SF90 - self.np, self.n_dim = numpy.shape(X) self.X = X self.Y = Y self.topology: Topology = Topology(topology) @@ -65,82 +54,54 @@ def __init__(self, X, Y, topology='grid', som_type='online', n_top=28, n_iter=30 self.alpha_end = alpha_end self.periodic = periodic self.dict_dim = dict_dim - self.dist_lib, self.n_pix = geometry(self.topology, self.n_top, periodic=self.periodic) + self.n_row, self.n_col = numpy.shape(X) + self.dist_lib, self.n_pix = compute_distance(self.topology, self.n_top, periodic=self.periodic) - importance = numpy.ones(self.n_dim) if importance is None else importance + importance = numpy.ones(self.n_col) if importance is None else importance self.importance = importance / numpy.sum(importance) - self.weights = (numpy.random.rand(self.n_dim, self.n_pix)) + self.X[0][ - 0] - - def get_best_cell(self, inputs, return_vals=1): - """ - Return the closest cell to the input object - It can return more than one value if needed - """ - activations = numpy.sum(numpy.transpose([self.importance]) * ( - numpy.transpose(numpy.tile(inputs, (self.n_pix, 1))) - self.weights) ** 2, axis=0) - - return numpy.argmin(activations) if return_vals == 1 else numpy.argsort(activations)[0:return_vals], activations + self.weights = (numpy.random.rand(self.n_col, self.n_pix)) + self.X[0][0] - def create_map_f(self, inputs_weights=None, evol=False): + def create_map(self, inputs_weights=None, random_order=True, eval_map=False): """ This functions actually create the maps, it uses random values to initialize the weights - It uses a Fortran subroutine compiled with f2py """ - if not self.SF90: - print('Fortran module somF not found, use create_map instead or try' \ - ' f2py -c -m somF som.f90') - sys.exit(0) + self.__update_weights(inputs_weights) + + t, total_t = 0, self.n_iter * self.n_row + sigma_0 = self.dist_lib.max() + sigma_f = numpy.min(self.dist_lib[numpy.where(self.dist_lib > 0.)]) - self.weights = inputs_weights if inputs_weights is not None else self.weights - weights_t = None - if self.som_type == SomType.ONLINE: - weights_t = somF.map(self.X, self.n_dim, self.n_iter, self.dist_lib, self.np, self.weights, - self.importance, self.n_pix, self.alpha_start, self.alpha_end) - elif self.som_type == SomType.BATCH: - weights_t = somF.map_b(self.X, self.n_dim, self.n_iter, self.dist_lib, self.np, self.weights, - self.importance, self.n_pix) - self.weights = copy.deepcopy(weights_t) - - def create_map(self, inputs_weights=None, random_order=True, evol=False): - """ - This is same as above but uses python routines instead - """ - self.weights = inputs_weights if inputs_weights is not None else self.weights - NT = self.n_iter * self.np - tt = 0 - sigma0 = self.dist_lib.max() - sigma_single = numpy.min(self.dist_lib[numpy.where(self.dist_lib > 0.)]) for it in range(self.n_iter): - sigma = get_sigma(tt, sigma0, sigma_single, NT) + sigma = get_sigma(sigma_f, sigma_0, t, total_t) if self.som_type == SomType.ONLINE: # get alpha, sigma - alpha = get_alpha(tt, self.alpha_start, self.alpha_end, NT) - index_random = random.sample(range(self.np), self.np) if random_order else numpy.arange(self.np) - for i in range(self.np): - tt += 1 - inputs = self.X[index_random[i]] - best, activation = self.get_best_cell(inputs) + alpha = get_alpha(self.alpha_end, self.alpha_start, t, total_t) + random_indices = random.sample(range(self.n_row), self.n_row) if random_order else numpy.arange( + self.n_row) + for i in range(self.n_row): + inputs = self.X[random_indices[i]] + best, activation = self.__get_best_cell(inputs) self.weights += alpha * count_modified_cells(best, self.dist_lib, sigma) * numpy.transpose( (inputs - numpy.transpose(self.weights))) elif self.som_type == SomType.BATCH: # get alpha, sigma - accum_w = numpy.zeros((self.n_dim, self.n_pix)) + accum_w = numpy.zeros((self.n_col, self.n_pix)) accum_n = numpy.zeros(self.n_pix) - for i in range(self.np): - tt += 1 + for i in range(self.n_row): inputs = self.X[i] - best, activation = self.get_best_cell(inputs) - for kk in range(self.n_dim): + best, activation = self.__get_best_cell(inputs) + for kk in range(self.n_col): accum_w[kk, :] += count_modified_cells(best, self.dist_lib, sigma) * inputs[kk] accum_n += count_modified_cells(best, self.dist_lib, sigma) - for kk in range(self.n_dim): + + for kk in range(self.n_col): self.weights[kk] = accum_w[kk] / accum_n + t += self.n_row - if evol: + if eval_map: self.evaluate_map() self.save_map(itn=it) @@ -150,7 +111,7 @@ def evaluate_map(self, input_x=None, input_y=None): It uses the X array passed or new data X as well, the map doesn't change :param float input_x: Use this if another set of values for X is wanted using - the weigths already computed + the weights already computed :param float input_y: One dimensional array of the values to be assigned to each cell in the map based on the in-memory X passed """ @@ -160,7 +121,7 @@ def evaluate_map(self, input_x=None, input_y=None): in_y = self.Y if input_y is None else input_y for i in range(len(in_x)): inputs = in_x[i] - best, activation = self.get_best_cell(inputs) + best, activation = self.__get_best_cell(inputs) if best not in self.y_vals: self.y_vals[best] = [] self.y_vals[best].append(in_y[i]) @@ -168,128 +129,62 @@ def evaluate_map(self, input_x=None, input_y=None): self.i_vals[best] = [] self.i_vals[best].append(i) - def predict(self, line, best=True): - """ - Get the predictions given a line search, where the line - is a vector of attributes per individual object fot the - 10 closest cells if best set to False; otherwise return the - BEST cell. - - :param float line: input data to look in the tree - :param bool best: Set to True to get only the best cell; otherwise the 10 closest cells will be returned - :return: array with the cell content - """ - bests, _ = self.get_best_cell(line, return_vals=10) - if best: - return bests[0] - for ib in range(10): - if bests[ib] in self.y_vals: - return self.y_vals[bests[ib]] - return numpy.array([-1.]) - - def save_map(self, itn=-1, fileout='SOM', path=None): - """ - Saves the map - - :param int itn: Number of map to be included on path, use -1 to ignore this number - :param str fileout: Name of output file - :param str path: path for the output file - """ - path = os.getcwd() + '/' if path is None else path - if not os.path.exists(path): - os.system('mkdir -p ' + path) - if itn >= 0: - ff = '_%04d' % itn - fileout += ff - numpy.save(path + fileout, self) - - def save_map_dict(self, path='', fileout='SOM', itn=-1): - """ - Saves the map in dictionary format - - :param int itn: Number of map to be included on path, use -1 to ignore this number - :param str fileout: Name of output file - :param str path: path for the output file - """ - SOM = {'W': self.weights, 'y_vals': self.y_vals, 'i_vals': self.i_vals, 'topology': self.topology, - 'n_top': self.n_top, 'n_pix': self.n_pix} - if path == '': - path = os.getcwd() + '/' - if not os.path.exists(path): os.system('mkdir -p ' + path) - if itn > 0: - ff = '_%04d' % itn - fileout += ff - numpy.save(path + fileout, SOM) - - def plot_map(self, min_m=-100, max_m=-100, colorbar=True): + def plot_map(self, min_m=-100, max_m=-100, cbar=True): """ Plots the map after evaluating, the cells are colored with the mean value inside each one of them :param float min_m: Lower limit for coloring the cells, -100 uses min value :param float max_m: Upper limit for coloring the cells, -100 uses max value - :param str colorbar: Include a colorbar ('yes','no') + :param bool cbar: Include a colorbar True/False """ - import matplotlib.pyplot as plt - import matplotlib as mpl - import matplotlib.cm as cm - from matplotlib import collections - from matplotlib.colors import colorConverter - if self.topology == Topology.SPHERE: - import healpy as hp M = numpy.zeros(self.n_pix) + hp.UNSEEN for i in range(self.n_pix): if i in self.y_vals: M[i] = numpy.mean(self.y_vals[i]) plt.figure(10, figsize=(8, 8), dpi=100) - if min_m == -100: - min_m = M[numpy.where(M > -10)].min() - if max_m == -100: - max_m = M.max() - hp.mollview(M, fig=10, title="", min=min_m, max=max_m, cbar=colorbar) + min_m = M[numpy.where(M > -10)].min() if min_m == -100 else min_m + max_m = M.max() if max_m == -100 else max_m + hp.mollview(M, fig=10, title="", min=min_m, max=max_m, cbar=cbar) if self.topology == Topology.GRID: M = numpy.zeros(self.n_pix) - 20. for i in range(self.n_pix): if i in self.y_vals: M[i] = numpy.mean(self.y_vals[i]) - M2 = numpy.reshape(M, (self.n_top, self.n_top)) + M_new = numpy.reshape(M, (self.n_top, self.n_top)) plt.figure(figsize=(8, 8), dpi=100) - if min_m == -100: - min_m = M2[numpy.where(M2 > -10)].min() - if max_m == -100: - max_m = M2.max() - SM2 = plt.imshow(M2, origin='center', interpolation='nearest', cmap=cm.jet, vmin=min_m, vmax=max_m) - SM2.cmap.set_under("grey") - if colorbar: + min_m = M_new[numpy.where(M_new > -10)].min() if min_m == -100 else min_m + max_m = M_new.max() if max_m == -100 else max_m + + M_plot = plt.imshow(M_new, origin='center', interpolation='nearest', cmap=cm.jet, vmin=min_m, vmax=max_m) + M_plot.cmap.set_under("grey") + if cbar: plt.colorbar() plt.axis('off') if self.topology == Topology.HEX: + ptr = 0 x_l, y_l = numpy.arange(0, self.n_top, 1.), numpy.arange(0, self.n_top, DY) nx, ny = len(x_l), len(y_l) n_pix = nx * ny b_x, b_y = numpy.zeros(n_pix), numpy.zeros(n_pix) - kk = 0 - for jj in range(ny): - for ii in range(nx): - if jj % 2 == 0: off = 0. - if jj % 2 == 1: off = 0.5 - b_x[kk] = x_l[ii] + off - b_y[kk] = y_l[jj] - kk += 1 - xyo = list(zip(b_x, b_y)) - sizes_2 = numpy.zeros(nx * ny) + ((8. * 0.78 / (self.n_top + 0.5)) / 2. * 72.) ** 2 * 4. * numpy.pi / 3. - M = numpy.zeros(n_pix) - 20. + for y_idx in range(ny): + for x_idx in range(nx): + b_x[ptr] = x_l[x_idx] + 0. if y_idx % 2 == 0 else 0.5 + b_y[ptr] = y_l[y_idx] + ptr += 1 + fcolors = [plt.cm.Spectral_r(x) for x in numpy.random.rand(nx * ny)] + M = numpy.zeros(n_pix) - 20. for i in range(n_pix): if i in self.y_vals: M[i] = numpy.mean(self.y_vals[i]) - if max_m == -100: - max_m = M.max() - if min_m == -100: - min_m = M[numpy.where(M > -10)].min() + + min_m = M[numpy.where(M > -10)].min() if min_m == -100 else min_m + max_m = M.max() if max_m == -100 else max_m + M = M - min_m M = M / (max_m - min_m) for i in range(n_pix): @@ -297,22 +192,78 @@ def plot_map(self, min_m=-100, max_m=-100, colorbar=True): fcolors[i] = plt.cm.Greys(.5) else: fcolors[i] = plt.cm.jet(M[i]) - figy = ((8. * 0.78 / (self.n_top + 0.5) / 2.) * (3. * ny + 1) / numpy.sqrt(3)) / 0.78 - fig3 = plt.figure(figsize=(8, figy), dpi=100) - # fig3.subplots_adjust(left=0,right=1.,top=1.,bottom=0.) - a = fig3.add_subplot(1, 1, 1) - col = collections.RegularPolyCollection(6, sizes=sizes_2, offsets=xyo, transOffset=a.transData) + fig_y = ((8. * 0.78 / (self.n_top + 0.5) / 2.) * (3. * ny + 1) / numpy.sqrt(3)) / 0.78 + fig = plt.figure(figsize=(8, fig_y), dpi=100) + ax = fig.add_subplot(1, 1, 1) + col = collections.RegularPolyCollection(6, + sizes=numpy.zeros(nx * ny) + ((8. * 0.78 / ( + self.n_top + 0.5)) / 2. * 72.) ** 2 * 4. * numpy.pi / 3., + offsets=list(zip(b_x, b_y)), + transOffset=ax.transData) col.set_color(fcolors) - a.add_collection(col, autolim=True) - a.set_xlim(-0.5, nx) - a.set_ylim(-1, nx + 0.5) + ax.add_collection(col, autolim=True) + ax.set_xlim(-0.5, nx) + ax.set_ylim(-1, nx + 0.5) plt.axis('off') - if colorbar: + if cbar: figbar = plt.figure(figsize=(8, 1.), dpi=100) ax1 = figbar.add_axes([0.05, 0.8, 0.9, 0.15]) cmap = cm.jet norm = mpl.colors.Normalize(vmin=min_m, vmax=max_m) - cb1 = mpl.colorbar.ColorbarBase(ax1, cmap=cmap, norm=norm, orientation='horizontal') - cb1.set_label('') + cb = mpl.colorbar.ColorbarBase(ax1, cmap=cmap, norm=norm, orientation='horizontal') + cb.set_label('') plt.show() + + def predict(self, line, best=True): + """ + Get the predictions given a line search, where the line + is a vector of attributes per individual object fot the + 10 closest cells if best set to False; otherwise return the + BEST cell. + + :param float line: input data to look in the tree + :param bool best: Set to True to get only the best cell; otherwise the 10 closest cells will be returned + :return: array with the cell content + """ + bests, _ = self.__get_best_cell(line, return_vals=10) + if best: + return bests[0] + for ib in range(10): + if bests[ib] in self.y_vals: + return self.y_vals[bests[ib]] + return numpy.array([-1.]) + + def save_map(self, filename='SOM', path=None, itn=-1): + """ + Saves the map and its dictionary format + + :param int itn: Number of map to be included on path, use -1 to ignore this number + :param str filename: Name of output file + :param str path: path for the output file + """ + som = {'weights': self.weights, 'y_vals': self.y_vals, 'i_vals': self.i_vals, 'topology': self.topology, + 'n_top': self.n_top, 'n_pix': self.n_pix} + + path = os.getcwd() + '/' if path is None else path + if not os.path.exists(path): + os.system('mkdir -p ' + path) + if itn >= 0: + ff = '_%04d' % itn + filename += ff + + numpy.save(path + filename, self) + numpy.save(path + filename + ".txt", som) + + def __update_weights(self, inputs_weights): + self.weights = inputs_weights if inputs_weights is not None else self.weights + + def __get_best_cell(self, inputs, return_vals=1): + """ + Return the closest cell to the input object + It can return more than one value if needed + """ + activations = numpy.sum(numpy.transpose([self.importance]) * ( + numpy.transpose(numpy.tile(inputs, (self.n_pix, 1))) - self.weights) ** 2, axis=0) + + return numpy.argmin(activations) if return_vals == 1 else numpy.argsort(activations)[0:return_vals], activations diff --git a/somsphere/utils/__init__.py b/somsphere/utils/__init__.py index c3d611e..8104cde 100644 --- a/somsphere/utils/__init__.py +++ b/somsphere/utils/__init__.py @@ -1,5 +1,4 @@ -import sys - +import healpy as hp import numpy from somsphere import Topology @@ -59,7 +58,17 @@ def get_neighbors(ix, iy, nx, ny, index=False, hex=False): return numpy.array(ins) -def geometry(topology: Topology, n_top, periodic=False): +def get_map_size(n_top, topology: Topology): + if topology == Topology.SPHERE: + return 12 * n_top ** 2 + elif topology == Topology.GRID: + return n_top * n_top + elif topology == Topology.HEX: + x_l, y_l = numpy.arange(0, n_top, 1.), numpy.arange(0, n_top, DY) + return len(x_l) * len(y_l) + + +def compute_distance(topology: Topology, n_top, periodic=False): """ Pre-compute distances between cells in a given topology and store it on a dist_lib array @@ -72,87 +81,76 @@ def geometry(topology: Topology, n_top, periodic=False): :return: 2D array with distances pre computed between cells and total number of units :rtype: 2D float array, int """ + n_pix = get_map_size(n_top, topology=topology) + dist_lib = numpy.zeros((n_pix, n_pix)) + if topology == Topology.SPHERE: - try: - import healpy as hpx - except: - print('Error: healpy module not found, use grid or hex topologies') - sys.exit(0) - nside = n_top - n_pix = 12 * nside ** 2 - dist_lib = numpy.zeros((n_pix, n_pix)) for i in range(n_pix): - ai = hpx.pix2ang(nside, i) + ai = hp.pix2ang(n_top, i) for j in range(i + 1, n_pix): - aj = hpx.pix2ang(nside, j) - dist_lib[i, j] = hpx.rotator.angdist(ai, aj) + aj = hp.pix2ang(n_top, j) + dist_lib[i, j] = hp.rotator.angdist(ai, aj) dist_lib[j, i] = dist_lib[i, j] dist_lib[numpy.where(numpy.isnan(dist_lib))] = numpy.pi elif topology == Topology.GRID: - nx = n_top - ny = n_top - n_pix = nx * ny - map_x_y = numpy.mgrid[0:1:complex(0, nx), 0:1:complex(0, ny)] + map_x_y = numpy.mgrid[0:1:complex(0, n_top), 0:1:complex(0, n_top)] map_x_y = numpy.reshape(map_x_y, (2, n_pix)) - b_x = map_x_y[1] - b_y = map_x_y[0] - dx = 1. / (nx - 1) - dy = 1. / (ny - 1) - dist_lib = numpy.zeros((n_pix, n_pix)) + b_x, b_y = map_x_y[1], map_x_y[0] + dx, dy = 1. / (n_top - 1), 1. / (n_top - 1) for i in range(n_pix): for j in range(i + 1, n_pix): if not periodic: - dist_lib[i, j] = numpy.sqrt((b_x[i] - b_x[j]) ** 2 + (b_y[i] - b_y[j]) ** 2) + dist_lib[i, j] = calc_distance(b_x[i], b_x[j], b_y[i], b_y[j]) dist_lib[j, i] = dist_lib[i, j] else: - s0 = numpy.sqrt((b_x[i] - b_x[j]) ** 2 + (b_y[i] - b_y[j]) ** 2) - s1 = numpy.sqrt((b_x[i] - (b_x[j] + 1. + dx)) ** 2 + (b_y[i] - b_y[j]) ** 2) - s2 = numpy.sqrt((b_x[i] - (b_x[j] + 1. + dx)) ** 2 + (b_y[i] - (b_y[j] + 1. + dy)) ** 2) - s3 = numpy.sqrt((b_x[i] - (b_x[j] + 0.)) ** 2 + (b_y[i] - (b_y[j] + 1. + dy)) ** 2) - s4 = numpy.sqrt((b_x[i] - (b_x[j] - 1. - dx)) ** 2 + (b_y[i] - (b_y[j] + 1. + dy)) ** 2) - s5 = numpy.sqrt((b_x[i] - (b_x[j] - 1. - dx)) ** 2 + (b_y[i] - (b_y[j] + 0.)) ** 2) - s6 = numpy.sqrt((b_x[i] - (b_x[j] - 1. - dx)) ** 2 + (b_y[i] - (b_y[j] - 1. - dy)) ** 2) - s7 = numpy.sqrt((b_x[i] - (b_x[j] + 0.)) ** 2 + (b_y[i] - (b_y[j] - 1. - dy)) ** 2) - s8 = numpy.sqrt((b_x[i] - (b_x[j] + 1. + dx)) ** 2 + (b_y[i] - (b_y[j] - 1. - dy)) ** 2) + s0 = calc_distance(b_x[i], b_x[j], b_y[i], b_y[j]) + s1 = calc_distance(b_x[i], b_x[j] + 1. + dx, b_y[i], b_y[j]) + s2 = calc_distance(b_x[i], b_x[j] - 1. - dx, b_y[i], b_y[j] + 0.) + s3 = calc_distance(b_x[i], b_x[j] + 0., b_y[i], b_y[j] + 1. + dy) + s4 = calc_distance(b_x[i], b_x[j] + 0., b_y[i], b_y[j] - 1. - dy) + s5 = calc_distance(b_x[i], b_x[j] + 1. + dx, b_y[i], b_y[j] + 1. + dy) + s6 = calc_distance(b_x[i], b_x[j] - 1. - dx, b_y[i], b_y[j] + 1. + dy) + s7 = calc_distance(b_x[i], b_x[j] - 1. - dx, b_y[i], b_y[j] - 1. - dy) + s8 = calc_distance(b_x[i], b_x[j] + 1. + dx, b_y[i], b_y[j] - 1. - dy) dist_lib[i, j] = numpy.min((s0, s1, s2, s3, s4, s5, s6, s7, s8)) dist_lib[j, i] = dist_lib[i, j] elif topology == Topology.HEX: - kk, off = 0, 0.0 + ptr = 0 x_l, y_l = numpy.arange(0, n_top, 1.), numpy.arange(0, n_top, DY) nx, ny = len(x_l), len(y_l) - n_pix = nx * ny b_x, b_y = numpy.zeros(n_pix), numpy.zeros(n_pix) - last = ny * DY - - for jj in range(ny): - for ii in range(nx): - off = 0. if jj % 2 == 0 else 0.5 - b_x[kk] = x_l[ii] + off - b_y[kk] = y_l[jj] - kk += 1 + for y_idx in range(ny): + for x_idx in range(nx): + b_x[ptr] = x_l[x_idx] + 0. if y_idx % 2 == 0 else 0.5 + b_y[ptr] = y_l[y_idx] + ptr += 1 - dist_lib = numpy.zeros((n_pix, n_pix)) + last = ny * DY for i in range(n_pix): for j in range(i + 1, n_pix): if not periodic: - dist_lib[i, j] = numpy.sqrt((b_x[i] - b_x[j]) ** 2 + (b_y[i] - b_y[j]) ** 2) + dist_lib[i, j] = calc_distance(b_x[i], b_x[j], b_y[i], b_y[j]) dist_lib[j, i] = dist_lib[i, j] else: - s0 = numpy.sqrt((b_x[i] - b_x[j]) ** 2 + (b_y[i] - b_y[j]) ** 2) - s1 = numpy.sqrt((b_x[i] - (b_x[j] + nx)) ** 2 + (b_y[i] - b_y[j]) ** 2) - s2 = numpy.sqrt((b_x[i] - (b_x[j] + nx)) ** 2 + (b_y[i] - (b_y[j] + last)) ** 2) - s3 = numpy.sqrt((b_x[i] - (b_x[j] + 0)) ** 2 + (b_y[i] - (b_y[j] + last)) ** 2) - s4 = numpy.sqrt((b_x[i] - (b_x[j] - nx)) ** 2 + (b_y[i] - (b_y[j] + last)) ** 2) - s5 = numpy.sqrt((b_x[i] - (b_x[j] - nx)) ** 2 + (b_y[i] - (b_y[j] + 0)) ** 2) - s6 = numpy.sqrt((b_x[i] - (b_x[j] - nx)) ** 2 + (b_y[i] - (b_y[j] - last)) ** 2) - s7 = numpy.sqrt((b_x[i] - (b_x[j] + 0)) ** 2 + (b_y[i] - (b_y[j] - last)) ** 2) - s8 = numpy.sqrt((b_x[i] - (b_x[j] + nx)) ** 2 + (b_y[i] - (b_y[j] - last)) ** 2) + s0 = calc_distance(b_x[i], b_x[j], b_y[i], b_y[j]) + s1 = calc_distance(b_x[i], b_x[j] + nx, b_y[i], b_y[j]) + s2 = calc_distance(b_x[i], b_x[j] - nx, b_y[i], b_y[j] + 0) + s3 = calc_distance(b_x[i], b_x[j] + 0, b_y[i], b_y[j] + last) + s4 = calc_distance(b_x[i], b_x[j] + 0, b_y[i], b_y[j] - last) + s5 = calc_distance(b_x[i], b_x[j] + nx, b_y[i], b_y[j] + last) + s6 = calc_distance(b_x[i], b_x[j] - nx, b_y[i], b_y[j] + last) + s7 = calc_distance(b_x[i], b_x[j] - nx, b_y[i], b_y[j] - last) + s8 = calc_distance(b_x[i], b_x[j] + nx, b_y[i], b_y[j] - last) dist_lib[i, j] = numpy.min((s0, s1, s2, s3, s4, s5, s6, s7, s8)) dist_lib[j, i] = dist_lib[i, j] return dist_lib, n_pix +def calc_distance(a, b, c, d): + return numpy.sqrt((a - b) ** 2 + (c - d) ** 2) + + def is_power_2(value): """ Check if passed value is a power of 2 @@ -160,18 +158,18 @@ def is_power_2(value): return value != 0 and ((value & (value - 1)) == 0) -def get_alpha(t, alpha_start, alpha_end, NT): +def get_alpha(alpha_end, alpha_start, curr_t, total_t): """ Get value of alpha at a given time """ - return alpha_start * numpy.power(alpha_end / alpha_start, float(t) / float(NT)) + return alpha_start * numpy.power(alpha_end / alpha_start, float(curr_t) / float(total_t)) -def get_sigma(t, sigma_0, sigma_f, NT): +def get_sigma(sigma_f, sigma_0, curr_t, total_t): """ - Get value of sigma at a given timesure + Get value of sigma at a given time """ - return sigma_0 * numpy.power(sigma_f / sigma_0, float(t) / float(NT)) + return sigma_0 * numpy.power(sigma_f / sigma_0, float(curr_t) / float(total_t)) def count_modified_cells(bmu, map_d, sigma): diff --git a/test/test_somap.py b/test/test_somap.py new file mode 100644 index 0000000..0d5e2a1 --- /dev/null +++ b/test/test_somap.py @@ -0,0 +1,9 @@ +import unittest + +from somsphere import SOMap + + +class TestSOMap(unittest.TestCase): + def test_init_error(self): + som = SOMap([], [], n_top=0, topology="sphere") + From 57408f8eef95d731d4d054b45be6ea8fcb2dc3b0 Mon Sep 17 00:00:00 2001 From: Ruiqi Li Date: Tue, 1 Sep 2020 23:12:21 -0400 Subject: [PATCH 3/7] Try Cython --- Example.ipynb | 147 +- pyptoject.toml | 2 + setup.py | 2 + somsphere/__init__.py | 27 +- somsphere/cython/core.c | 3772 +++++++++++++++++++++++++++++++++++++ somsphere/cython/core.pyx | 12 + 6 files changed, 3835 insertions(+), 127 deletions(-) create mode 100644 pyptoject.toml create mode 100644 somsphere/cython/core.c create mode 100644 somsphere/cython/core.pyx diff --git a/Example.ipynb b/Example.ipynb index ff8d2df..0940de9 100644 --- a/Example.ipynb +++ b/Example.ipynb @@ -4,7 +4,16 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: WrongDBMModuleWarning: Existing astropy cache is in an unsupported format, either install the appropriate package or use astropy.utils.data.clear_download_cache() to delete the whole cache; db type is dbm.gnu, but the module is not available [astropy.utils.data]\n", + "WARNING: leap-second auto-update failed due to the following exception: WrongDBMModule('Existing astropy cache is in an unsupported format, either install the appropriate package or use astropy.utils.data.clear_download_cache() to delete the whole cache; db type is dbm.gnu, but the module is not available') [astropy.time.core]\n" + ] + } + ], "source": [ "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", @@ -71,7 +80,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -80,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -89,29 +98,16 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "M.plot_map()" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -121,29 +117,16 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "M.plot_map()" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -153,22 +136,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmkAAAJwCAYAAADSqPaBAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de7RmZX0n+O+vTlEgCNhpoFhCUDvd0ajpIaC0OHZCRA0xJqOTNtgk03acicHGrNBqWsmthVzERU+pSZmbK9LgpJWoLXEwLd1kRTKJNLcI0agZjZYKTpWBxKI03M45z/xx3tMeD3Wot15qX3jP57PWu+Dd59n7+R0pXD++z372rtZaAAAYly1DFwAAwENp0gAARkiTBgAwQpo0AIAR0qQBAIyQJg0AYIQ0aQAAI6RJAwAYoa1DFwAAzKeqOiLJtgGmfqC1dt8A8x5S5Y0DAMChVlVHPDa592vDTL87yZMe7Y2aJA0A6MK2ryX5t0kO73HS+5O8JTkxKwmeJg0AYH8OT3LE0EU8SmnSAIDObE2/zcY8NTZ2dwIAjNA8NZwAwMgcNvn0ZanHubomSQMAGCFJGgDQGfekzU6SBgAwQpo0AIARmqdUEAAYma3pd+PAYo9zdU2SBgAwQpI0AKAzNg7MTpIGADBC89RwAgAj0/fDbN2TBgBApzRpAAAjZLkTAOiMjQOzk6QBAIzQPDWcAMDI9P0w2wd7nKtrkjQAgBHSpAEAjJDlTgCgMzYOzE6SBgAwQvPUcAIAI9P3Gwf6nKtrkjQAgBGSpAEAnZGkzU6SBgAwQpo0AIARstwJAHTGIzhmJ0kDABiheWo4AYCR6fvdnfPU2EjSAABGaJ4aTgBgZNyTNjtJGgDACGnSAABGaJ5SQQBgZLxxYHaSNACAEZKkAQCdsXFgdpI0AIARmqeGEwAYGQ+znZ0kDQBghDRpAAAjpEkDADqzdYDPLKrqgqraVVX3VdWNVXXGw4x9WlW9fzK+VdWF+xmzUFW/VFWfr6p7q+qvq+oXqqqmrUmTBgBsalV1bpIdSS5OclqS25NcW1UnbHDKkUk+l+QNSXZvMOb1SV6V5NVJvmPy/d8l+amp62qtTTsWAGAqVXVMkr03JXlsj/N+LckkAju2tXbPNOdU1Y1Jbm6tvXryfUuSLyX59dbapQc4d1eSt7bW3rru+DVJ9rTW/vc1x96f5N7W2o9NU5ckDQDYtKpqW5LTk1y3eqy1tjz5fuYjuPRHk5xdVd8+med/SvKcJP9l2gvM005VAGBkBnyY7dHrbv+6v7V2/35OOS7JQpI9647vSfKUR1DKpUmOSfLpqlqazPFzrbXfm/YCkjQAYB7dkWTvms9FPc//I0l+NMl5WbnP7eVJXldVL5/2ApI0AGAenZxk35rv+0vRkuSuJEtJtq87vj0bbwqYxmVJLm2tvWfy/eNV9YSsNItXTHMBTRoA0JkB3ziwb5qNA621B6rq1iRnJ7k6+R8bB85OsvMRlHJkkuV1x5ZyEKuYmjQAYLPbkeSKqrolyU1JLkxyVJLLk6SqrkxyZ2vtosn3bUmeOjl3W5KTqurUJF9rrX12cvz/TvJzVfXFJH+Z5LuSvCbJO6ctSpMGAHTmsPSbpM0yV2vtqqo6PsklSU5McluSc1prq5sJTsk3p2KPT/KxNd9fN/lcn+SsybGfSvJLSX4jyQlJvpzktydzTMVz0gCAQ271OWmfSnJ0j/Puy8qTY3MQz0kbq6mTtI9UDd7NPTh0AUn+bOgCkrzxW4euICvPTx6DJw1dQJIvDl1AVv7bbGjPHbqAZPdvHTt0CflAXjx0CXnVp6e6J7lTf/CUFwxdQpLkffkXQ5eQd13yyqFLSH6xTf0qIsbDcicA0JkBn5P2qOc5aQAAIzRPDScAMDJbF5LDelxs3dqy8qCLOSBJAwAYIUkaANCZrVuTrZK0mUjSAABGSJMGADBCljsBgM4c1vPGgcMGf6rroSNJAwAYIUkaANCZQTYOzAlJGgDACEnSAIDOHLaQHNZjJHTYcn9zdU2SBgAwQpo0AIARstwJAHRnIf1GQj1uUuiaJA0AYIQkaQBAd7am30jIxgEAALokSQMAuiNJm5kkDQBghDRpAAAjZLkTAOiO5c6ZSdIAAEZIkgYAdGdLVh5oy0GTpAEAjJAkDQDoztb0m6R5LRQAAF3SpAEAjJDlTgCgO5Y7ZyZJAwAYIUkaANCdhXgEx4wkaQAAI1SttelG/qOacmCHfmvoApLsHbqAkfjg0AWs+Ny7Thy6hByZe4cuIfty9NAl5HH56tAl5Dfyb4YuIXflHw5dQpZGsEjyz/MnQ5eQZBz/W/zYZ94/dAnJP2m936lVVcck2bv3O5NjekzS7llKjv14kuTY1to9/c186A3/pxcAmF82DszMcicAwAhJ0gCA7ixEtzEjSRoAwAjpbQGA7vT9CI7htzkeMpI0AIAR0qQBAIyQ5U4AoDtbo9uYkSQNAGCE9LYAQHckaTOTpAEAjJDeFgDojiRtZpI0AIAR0qQBAIyQABIA6M6W9PvGgeUe5+qYJA0AYIQkaQBAd/reOODdnQAAdEmSBgB0R5I2M0kaAMAIadIAAEbIcicA0J2FeATHjCRpAAAjJEkDALpj48DMJGkAwKZXVRdU1a6quq+qbqyqMx5m7NOq6v2T8a2qLtxg3ElV9X9V1d1VdW9VfbyqnjFtTZo0AGBTq6pzk+xIcnGS05LcnuTaqjphg1OOTPK5JG9IsnuDa/6DJH+W5MEk35/kqUlem+Tvpq3LcicA0J2F9NttzLZx4DVJ3tFauzxJqur8JD+Q5BVJLl0/uLV2c5KbJ2Mf8vOJ1yf5Umvtx9cc+/zBFCVJAwDm0dFVdcyaz+H7G1RV25KcnuS61WOtteXJ9zMfwfw/lOSWqnpvVX2lqj5WVT9xMBfQpAEA3VkY4LPijiR713wu2qDC4yZn7Vl3fE+SE2f7pZMk/yjJq5J8Jsn3JfnNJL9WVS+f9gKWOwGAeXRykn1rvt/f8/xbktzSWvvZyfePVdXTk5yf5IppLqBJAwC60/cjOL5xT9q+1to9U5xxV5KlJNvXHd+eDTYFTOn/S/LJdcc+leSHp72A5U4AYNNqrT2Q5NYkZ68eq6otk+83PIJL/1mSJ6879u1JvjDtBabvbf/z1CO787dDF5Bc/9INH5vSm0/mO4YuIdtf+pWhS0iSXJvvG7qEPO8b95oO5uhvSvSHcc6Xrx+6hJz++FuGLiH/KT86dAn5aJ49dAn5x/ns0CUkSZ76kCBjAMcOXQBT2JHkiqq6JclNSS5MclSS1d2eVya5s7V20eT7tqw8UiNJtiU5qapOTfK11trqH/63JPloVf1skt9PckaSV04+U7HcCQB0Z7jlzqm11q6qquOTXJKVzQK3JTmntba6meCUdVd+fJKPrfn+usnn+iRnTa55c1W9JMmbkvxiVh6/cWFr7femrUuTBgBseq21nUl2bvCzs9Z935WkprjmNUmumbUmTRoA0J1HQZI2VjYOAACMkCQNAOjOlqx9wGw/882JOfpVAADmhyYNAGCELHcCAN3pe+PAUo9zdUySBgAwQpI0AKA7krSZSdIAAEZIkgYAdGch/T6Co8+5OiZJAwAYIU0aAMAIWe4EALpj48DMJGkAACMkSQMAurOQfruNxR7n6pgkDQBghCRpAEB3+r4nbY46G0kaAMAIadIAAEZojkJBAGB0vHFgZpI0AIARkqQBAN2xcWBmkjQAgBHSpAEAjNAchYIAwOhY7pyZJA0AYITmqN8EAEZnS/p9LMYcxU9z9KsAAMwPSRoA0B33pM1MkgYAMEJT95tXnPojXdYxlZf/4e8PXULuzWOGLiH35sihS8gH84NDl5AkeSCHD11CfiU/N3QJ2Z49Q5eQ7/+bjwxdQr5l+51Dl5B/tnDj0CXkcfnq0CXkj/O9Q5eQJHnNJb85dAm577VDV5AcMXQBzGSOQkEAYHQsd87McicAwAjNUb8JAIzOQvp9BEefc3VMkgYAMEKSNACgO+5Jm5kkDQBghDRpAAAjNEehIAAwOgvpt9uwcQAAgC5J0gCA7tg4MDNJGgDACM1RvwkAjI6H2c5MkgYAMEKaNACAEbLcCQB0x8aBmUnSAABGaI76TQBgdCRpM5OkAQCMkCYNAGCE5igUBABGZ0v6fXbZHMVPc/SrAADMD0kaANAdGwdmJkkDABihOeo3AYDRkaTNTJIGADBCmjQAgBHSpAEA3VkY4DODqrqgqnZV1X1VdWNVnfEwY59WVe+fjG9VdeEBrv2Gybi3HkxNmjQAYFOrqnOT7EhycZLTktye5NqqOmGDU45M8rkkb0iy+wDXfmaSn0zyFwdblyYNAOjO1gE+B+81Sd7RWru8tfbJJOcn+fskr9jf4Nbaza21n2mtvSfJ/RtdtKoem+T3kvxEkr872KI0aQDAplVV25KcnuS61WOtteXJ9zMf4eXfnuRDrbXrDjhyP+ZooyoAMDoL6bfb+MY9aUdX1dqf3N9a21/qddzkrD3rju9J8pRZy6iql2Vl6fSZs15DkgYAzKM7kuxd87mor4mr6luTvC3Jj7bW7pv1OlP3tk/OX806xyHzzhf+y6FLyC15xtAl5Dc+/9qhS8h7n/SioUtIknw5jx+6hCz1+ubg/fv9W18+dAk57In3DF1C9n316KFLyLWL3zd0CVleHP7P5AMnbRu6hCTJub/4H4cuIS/MHw5dQob/f4hBnJxk35rvG907dleSpSTb1x3fngNsCngYpyc5Icmfr0nzFpJ8d1W9OsnhrbWlA13EcicA0J3h3jiwr7V2wP96bK09UFW3Jjk7ydVJUlVbJt93zljFHyX5znXHLk/y6SRvnqZBSzRpAAA7klxRVbckuSnJhUmOykpjlaq6MsmdrbWLJt+3JXnq5NxtSU6qqlOTfK219tnW2r4kn1g7QVV9PcndrbVvOv5wNGkAQHcewQNmZ57vILXWrqqq45NckuTEJLclOae1trqZ4JQky2tOeXySj635/rrJ5/okZx18BfunSQMANr3W2s5ssLzZWjtr3fddSWp/Yx/m+mcdcNA6mjQAoDvD3ZP2qOcRHAAAI6RJAwAYoTkKBQGA0RnujQOPepI0AIARkqQBAN15FDyCY6wkaQAAIyRJAwC64xEcM5OkAQCMkCYNAGCE5igUBABGx3LnzCRpAAAjNEf9JgAwOpK0mUnSAABGSJMGADBCcxQKAgBj07Ykrce3ALQ5ip/m6FcBAJgfkjQAoDNLW1c+fc43LyRpAAAjNEf9JgAwNpK02UnSAABGSJMGADBCcxQKAgBjs7hQWVyoHudrSVpv83VJkgYAMEKSNACgM0tbt2Zpa39J2tLWluTB3ubrkiQNAGCEJGkAQGeWFhay1OM9aUsLkjQAADo0dZL2rM/f3mUdU/nSk7516BJycf790CXkbU965dAl5PL8+NAlJEkuyNuHLiFXvf5fD11CTn/zLUOXkHflXw1dQj5x1TOHLiF5+tAFJFuO+/rQJeTv8rihS0iSnJrbhi4h/ynnDV1CXj50AczEcicA0JnlLGQp/S13Ls/J4zcSy50AAKMkSQMAOrOYhSz2mKQtStIAAOiSJA0A6MxSFrLUYya0lOXe5uqaJA0AYIQ0aQAAI2S5EwDoTP/Lnf1tUuiaJA0AYIQkaQBAZyRps5OkAQCMkCQNAOiMJG12kjQAgBHSpAEAjJDlTgCgM0tZyKLlzplI0gAARkiSBgB0ZilbvbtzRpI0AIAR0qQBAIyQ5U4AoDNL2ZKlLPQ43/yQpAEAjJAkDQDozMobByRps5CkAQCMkCQNAOjMYhay2GOSttjbTN2TpAEAjJAmDQBghCx3AgCdWc7WXjcOLHt3JwAAXZKkAQCd8QiO2UnSAIBNr6ouqKpdVXVfVd1YVWc8zNinVdX7J+NbVV24nzEXVdXNVbWvqr5SVVdX1ZMPpiZNGgDQmdUkrc/Pwaqqc5PsSHJxktOS3J7k2qo6YYNTjkzyuSRvSLJ7gzHfk+TtSZ6V5PlJDkvyX6vqqGnrstwJAGx2r0nyjtba5UlSVecn+YEkr0hy6frBrbWbk9w8GfuQn0/GnLP2e1X96yRfSXJ6kj+Zpqipm7QnPulT0w7tzDNyy9Al5KXvvWboEvKBl75k6BJy+x89a+gSkiQ3nj38n4ltb35g6BJyeIav4RN/+cyhS0hOHLqA5AVP+4OhS8gf3/29Q5eQ3V/41qFLSJLsesIThy4h/zB3D13CZnV01Tft9Ly/tXb/+kFVtS0rjdObVo+11par6rokZx7Ceo6d/PVvpz1BkgYAdGYpW3reONBW//aOdT+6OMkb93PKcUkWkuxZd3xPkqccipqqakuStyb5s9baJ6Y9T5MGAMyjk5PsW/P9ISlaj96e5OlJnnMwJ2nSAIDO9P/uzv+RpO1rrd0zxSl3ZeXJHdvXHd+ejTcFTK2qdiZ5UZLvbq2tT/celt2dAMCm1Vp7IMmtSc5ePTZZnjw7yQ2zXrdW7EzykiTPba19/mCvIUkDADqzlK1Z6rHdmPFhtjuSXFFVtyS5KcmFSY5Ksrrb88okd7bWLpp835bkqZNztyU5qapOTfK11tpnJ8ffnuS8JP9Lkn1Vtbq1aW9r7d5pitKkAQCbWmvtqqo6PsklWdknfluSc1prq5sJTkmyvOaUxyf52Jrvr5t8rk9y1uTYqyZ//ci66X48yX+cpi5NGgCw6bXWdibZucHPzlr3fVfy8G9yb6094je9a9IAgM4s9/zuzuVvbBx41LNxAABghCRpAEBnZn2f5uzzSdIAAOiQJg0AYIQsdwIAnVnMlp7fOLB84EGPEpI0AIARkqQBAJ3p/40DNg4AANAhSRoA0Jn+H8HhnjQAADqkSQMAGCHLnQBAZyx3zk6SBgAwQpI0AKAzS1no9WG2kjQAADolSQMAOuNhtrOTpAEAjJAmDQBghCx3AgCdWcqWnh/BsdTbXF2TpAEAjJAkDQDoTP8Ps+1vrq5J0gAARkiSBgB0RpI2O0kaAMAIadIAAEZo6uXOL1z1lC7rmMqzz/3o0CXk1h8ZuoLkI9d+/9Al5LwX/O7QJSRJnphdQ5eQD+TFQ5eQZ2f4fzfe9bR/MXQJ+et829Al5D98/XVDl5AjH/v3Q5eQvbcdM3QJSZLfue+nhy4hz3nyfxu6hEH1/+5Oy50AAHTIxgEAoDP9v7tzube5uiZJAwAYIUkaANAZj+CYnSQNAGCENGkAACNkuRMA6MxStvS83Dk/+dP8/CYAAHNEkgYAdGax54fZ9jlX1yRpAAAjpEkDABghy50AQGf6f+PAUm9zdU2SBgAwQpI0AKAzyz2/cWDZxgEAALokSQMAOuPdnbOTpAEAjJAmDQBghCx3AgCd8e7O2c3PbwIAMEckaQBAZxazkAXv7pyJJA0AYIQkaQBAZ/p/LdT8tDaSNACAEdKkAQCM0PxkggDA6Hh35+wkaQAAIyRJAwA6492ds5OkAQCMkCQNAOjMYhayxcNsZyJJAwA2vaq6oKp2VdV9VXVjVZ3xMGOfVlXvn4xvVXXhI73m/mjSAIBNrarOTbIjycVJTktye5Jrq+qEDU45Msnnkrwhye5DdM2HXqO1NtXAf5s3TTewQ2+55GeHLiH5ytAFJO/c+S+HLiGPy1eHLiFJ8ld58tAl5GcvesvQJeS0N/3p0CXk/Pz20CXklXe+Y+gSkp8/YugKkscNXUCSk4cuYOIpQxeQUfzzaP9zqu85q+qYJHv/t72XZdsxj+lt3gfuuTfvOvZnkuTY1to905xTVTcmubm19urJ9y1JvpTk11trlx7g3F1J3tpae+uhuuYqSRoAsGlV1bYkpye5bvVYa2158v3MIa9p4wAA0JkBH8FxdNU3BYj3t9bu388pxyVZSLJn3fE9mT2LPSTXlKQBAPPojiR713wuGracgydJAwDm0clJ9q35vr8ULUnuSrKUZPu649uzwaaAKRySa0rSAIDOrC539vmZ2Ndau2fNZ79NWmvtgSS3Jjl79djkJv+zk9wwy+98qK4pSQMANrsdSa6oqluS3JTkwiRHJbk8SarqyiR3ttYumnzfluSpk3O3JTmpqk5N8rXW2menueY0NGkAQGeWe944sDzDXK21q6rq+CSXJDkxyW1Jzmmtrd74f0qS5TWnPD7Jx9Z8f93kc32Ss6a85gFp0gCATa+1tjPJzg1+dta677uSAz977uGuOQ1NGgDQmcUspLy7cyY2DgAAjJAmDQBghCx3AgCdWcpCtvTYbvS5SaFrkjQAgBGSpAEAnVlJ0gZ5d+ejniQNAGCEJGkAQGckabOTpAEAjJAmDQBghCx3AgCd8caB2UnSAABGSJIGAHRmOVuz1GO7sTxHrY0kDQBghOan3QQARmep53vSPIIDAIBOadIAAEbIcicA0JmlbOl5uXN+8qf5+U0AAOaIJA0A6MzKw2U9zHYWkjQAgBGSpAEAnVnK1lSP7UafD87tmiQNAGCENGkAACM0dSb4w3lfl3VM5W9+8bFDl5B/n4uHLiHfmb8YuoR8LKcOXUKS5B/kq0OXkPwfbegKclzuHrqEvPLadw1dQnLi0AUkec7QBSS5a+gCMo4akuSzQxeQfMur7xy6hCQnDTbzchZ6fQvAso0DAAB0aX7urgMARmep50dweHcnAACd0qQBAIyQ5U4AoDOWO2cnSQMAGCFJGgDQmcVsSes1SZuf/Gl+fhMAgDkiSQMAOrPyLk3v7pyFJA0AYIQ0aQAAIzQ/mSAAMDoewTE7SRoAwAhJ0gCAziz3nKQtS9IAAOiSJA0A6MxiFrJFkjYTSRoAwAhp0gAARshyJwDQmaUspPXYbljuBACgU5I0AKAzK0majQOzkKQBAIyQJA0A6IwkbXaSNACAEdKkAQCMkOVOAKAzS8sLacs9Lnf2OFfXJGkAACMkSQMAOrO0uJDlxf7SrdbjXF2TpAEAjJAkDQDozNLi1tRif+1G63GurknSAABGSJMGADBCU2eC/yGv67KOqfxKfn7oEvKBvHjoEvKbd/6boUvIH5303KFLSJKcc/eHhy4hL/q29w1dQq658weHLiF54tAFJNk9dAFJFocuIMl9QxeQ5LahC5g4YugCkr+976ShS0heP9zUS4tbUr1uHJif/Gl+fhMAgBlV1QVVtauq7quqG6vqjAOMf2lVfXoy/uNV9cJ1P39sVe2sqjuq6t6q+mRVnX8wNc3P3XUAwOgsLS70nKQd/FxVdW6SHUnOT3JjkguTXFtVT26tfWU/45+d5N1JLkpyTZLzklxdVae11j4xGbYjyXOT/FiSXUlekOQ3qurLrbUPTlOXJA0A2Oxek+QdrbXLW2ufzEqz9vdJXrHB+J9O8uHW2mWttU+11n4hyZ8nefWaMc9OckVr7SOttV2ttd9JcnuSh03o1tKkAQDz6OiqOmbN5/D9DaqqbUlOT3Ld6rHW2vLk+5kbXPvMteMnrl03/qNJfqiqTqoV35vk25P812l/AcudAEBnFhcXUg8Ostx5x7ofXZzkjfs55bgkC0n2rDu+J8lTNpjmxA3Gn7jm+08l+Z1JHYtJlpP8RGvtTzau/ptp0gCAeXRykn1rvt/f8/w/leRZSX4oyReSfHeSt0/uSVufwu2XJg0A6Exb2pq21GO78Y259rXW7pnijLuSLCXZvu749mz8YJ/dDze+qh6T5FeTvKS19qHJz/+iqk5N8ro8dKl0v9yTBgBsWq21B5LcmuTs1WNVtWXy/YYNTrth7fiJ568Zf9jks7xuzFIOoveSpAEA3VlcWPn0Od/B25Hkiqq6JclNWXkEx1FJLk+SqroyyZ2ttYsm49+W5Pqqem2SDyV5WZJnJHllkrTW7qmq65NcVlX3ZmW583uS/Kus7CSdiiYNANjUWmtXVdXxSS7Jys3/tyU5p7W2ujnglKxJxVprH62q85L8claWNT+T5MVrnpGWrDRub0rye0m+JSuN2s8l+a1p69KkAQCbXmttZ5KdG/zsrP0ce2+S9z7M9XYn+fFHUpMmDQDozqNjuXOUbBwAABghSRoA0J2lShar3/nmhCQNAGCEJGkAQHcWJ58+55sTkjQAgBHSpAEAjJDlTgCgO5Y7ZyZJAwAYIUkaANAdSdrMJGkAACMkSQMAurOY5MGe55sTkjQAgBHSpAEAjJDlTgCgO0uTT5/zzQlJGgDACEnSAIDueATHzCRpAAAjpEkDABghy50AQHcsd85MkgYAMEJTJ2n7cnSXdUzlab/9uaFLyCk/+aWhS8jhJz0wdAl5/p7/NnQJSZLlq48auoRc86IfHLqE5Lojhq4gx7/8i0OXkL953ylDl5B8eugCkpw4dAEZRw1JctfQBSS5begCBiZJm5kkDQBghNyTBgB0Zyn9plseZgsAQJc0aQAAI2S5EwDojo0DM5OkAQCMkCQNAOiOJG1mkjQAgBGSpAEA3Xlw8ulzvjkhSQMAGCFNGgDACFnuBAC6s5R+3wLgjQMAAHRJkgYAdMe7O2cmSQMAGCFJGgDQHQ+znZkkDQBghDRpAAAjZLkTAOiO5c6ZSdIAAEZIkgYAdEeSNjNJGgDACEnSAIDueJjtzCRpAAAjpEkDABghy50AQHdsHJiZJA0AYIQkaQBAdx5MstDzfHNCkgYAMEKaNACAEbLcCQB0Zyn9PrvMc9IAAOjS1Ena/3P3d3dZx1Re+JPvH7qE3HTnPxu6hOTqI4auIHne0AVMPK8NXUHy30fwz+OzQxeQ/M3PnDJ0CckdQxeQZPfQBSR5z9AFJFkcwb+bSfKPa+gKkpOHLmBgHsExM0kaAMAIuScNAOiOd3fOTJIGAGx6VXVBVe2qqvuq6saqOuMA419aVZ+ejP94Vb1wP2O+o6o+WFV7q+rrVXVzVU19b4gmDQDY1Krq3CQ7klyc5LQktye5tqpO2GD8s5O8O8nvJvmuJFcnubqqnr5mzLcl+dMkn05yVpJ/muSXktw3bV2WOwGA7iym3zcOzLa0+pok72itXZ4kVXV+kh9I8ookl+5n/E8n+XBr7bLJ91+oqucneXWS8yfHfiXJH7bW/t2a8/76YIqSpAEAm1ZVbUtyepLrVo+11pYn38/c4LQz146fuHZ1fFVtyUqT9/9W1bVV9ZXJEuqLDwRsx3gAAAqHSURBVKY2TRoA0J0HB/isOLqqjlnzOXyDCo/LSta3Z93xPUlO3OCcEw8w/oQkj03yhiQfTvKCJB9I8p+r6ns2uOZDaNIAgHl0R5K9az4X9Tj3an/1B621t7TWbmutXZrkmnxjOfSA3JMGAHRnuNdCnZxk35qf3L/BGXdNztq+7vj2bPx46t0HGH9XVu6O++S6MZ9K8pwNrvkQkjQAYB7ta63ds+az3yattfZAkluTnL16bHJP2dlJbtjg2jesHT/x/NXxk2venOTJ68Z8e5IvTPsLSNIAgM1uR5IrquqWJDcluTDJUUlWd3temeTO1trqkunbklxfVa9N8qEkL0vyjCSvXHPNy5JcVVV/kuSPk5yT5Aez8jiOqWjSAIDuPAreONBau6qqjk9ySVZu/r8tyTmttdXNAackWV4z/qNVdV6SX07yq0k+k+TFrbVPrBnzgcmjPC5K8mtJ/irJD7fW/nTaujRpAMCm11rbmWTnBj87az/H3pvkvQe45juTvHPWmjRpAEB3FtPvHfB9pnYds3EAAGCEJGkAQHceTFI9zzcnJGkAACOkSQMAGCHLnQBAd4Z748CjniQNAGCEJGkAQHc8gmNmkjQAgBHSpAEAjJDlTgCgO4+Cd3eOlSQNAGCEJGkAQHf6fgOANw4AANAlSRoA0J2l9BsJuScNAIAuadIAAEbIcicA0J3FJNXzfHNCkgYAMELVWptu4M9kuoHz7rihC0hyy9AFJLlr6AImXjR0AUk+MnQBSU4duoAk7xm6gCRHDF1Akq8NXUCSXUMXkCR3DF3AxGFDF5DkMUMXkNaO6TPLSpJU1TFJ9uZ5e5PDjulv4gfvSa47NkmOba3d09/Eh54kDQBghNyTBgB0p+97xNyTBgBAlzRpAAAjZLkTAOjOUvp9BIc3DgAA0CVJGgDQHRsHZiZJAwAYIUkaANAdSdrMJGkAACOkSQMAGCHLnQBAdxaTXt/+7REcAAB0SZIGAHSn72RLkgYAQJckaQBAd9yTNjNJGgDACGnSAABGyHInANAdy50zk6QBAIyQJA0A6M5ikuUe5+tzro5J0gAARkiTBgAwQpY7AYDuLKXfjQOWOwEA6JIkDQDozmL6jYQkaQAAdEmSBgB0R5I2M0kaAMAIadIAAEbIcicA0J0HY7lzRpI0AIARmj5JO6u7Iqb2nqELSPLZoQtIcvUbh64gedwbh65gxZ8OXUCSxw5dQJJrhi4gSf5+6AJG4sihC0jyX4YuIMkJQxcw8amhC0hy79AFJPmJ4aZeTr8Ps+1zro5J0gAARsg9aQBAdxaTVI/zSdIAAOiSJg0AYIQsdwIA3bHcOTNJGgCw6VXVBVW1q6ruq6obq+qMA4x/aVV9ejL+41X1wocZ+1tV1arqwoOpSZMGAHTnwQE+B6mqzk2yI8nFSU5LcnuSa6tqv8+SqapnJ3l3kt9N8l1Jrk5ydVU9fT9jX5LkWUm+fLB1adIAgM3uNUne0Vq7vLX2ySTnZ+Xhj6/YYPxPJ/lwa+2y1tqnWmu/kOTPk7x67aCqOinJryf50czQPmrSAIDuLA3wWXF0VR2z5nP4/sqrqm1JTk9y3eqx1try5PuZG/xWZ64dP3Ht2vFVtSXJu5Jc1lr7yw2u87A0aQDAPLojyd41n4s2GHdckoUke9Yd35PkxA3OOXGK8a/PyraJX5u+5G9mdycAMI9OTrJvzff7+5q4qk7PypLoaa21mfebStIAgG61Hj/fsK+1ds+az0ZN2l1ZWSTdvu749iS7Nzhn9wHG//OsvMD2i1W1WFWLSZ6Q5P+sql0bXPMhNGkAwKbVWnsgya1Jzl49Nrmf7OwkN2xw2g1rx088f834dyX5p0lOXfP5cpLLknzftLVZ7gQANrsdSa6oqluS3JTkwiRHJbk8SarqyiR3ttZW72t7W5Lrq+q1ST6U5GVJnpHklUnSWrs7yd1rJ6iqB5Psbq391bRFadIAgE2ttXZVVR2f5JKs3Px/W5JzWmurmwNOSbK8ZvxHq+q8JL+c5FeTfCbJi1trnziUdWnSAIBNr7W2M8nODX521n6OvTfJew/i+k882JrckwYAMEKaNACAEdKkAQCMkCYNAGCEbBwAADr0YGZ4t/gjnG8+SNIAAEZIkwYAMEKWOwGADi1OPn3ONx8kaQAAIyRJAwA6ZOPArCRpAAAjJEkDADrknrRZSdIAAEZIkwYAMEKWOwGADi2m35v5LXcCANChaq0NXQMAMGeq6pgke5NPJjm6x5n3JXlqkhzbWrunx4kPOUkaAMAIuScNAOiQR3DMSpIGADBCmjQAgBGy3AkAdMgjOGYlSQMAGCFJGgDQIRsHZiVJAwAYIUkaANChB9PvPWl9ztUtSRoAwAhp0gAARshyJwDQIRsHZiVJAwAYIUkaANAhD7OdlSQNAGCENGkAACNkuRMA6JCNA7OSpAEAjJAkDQDokDcOzEqSBgAwQpI0AKBD7kmblSQNAGCENGkAACNkuRMA6JA3DsxKkgYAMEKSNACgQzYOzEqSBgAwQpI0AKBDHmY7K0kaAMAIadIAAEbIcicA0CHLnbOSpAEAjJAkDQDokEdwzEqSBgAwQpI0AKBDXgs1K0kaAMAIadIAAEbIcicA0CEbB2YlSQMAGCFJGgDQoQfTb7vhYbYAAHOjqi6oql1VdV9V3VhVZxxg/Eur6tOT8R+vqheu+dlhVfXmyfGvV9WXq+rKqnr8wdSkSQMAOrQ4wOfgVNW5SXYkuTjJaUluT3JtVZ2wwfhnJ3l3kt9N8l1Jrk5ydVU9fTLkyMl1fmny1/81yZOTfPCg6mqtHfQvAwDwcKrqmCR7kzcneUyPM9+b5PVJcmxr7Z5pzqiqG5Pc3Fp79eT7liRfSvLrrbVL9zP+qiRHtdZetObYf09yW2vt/A3meGaSm5I8obX2xWnqkqQBAJtWVW1LcnqS61aPtdaWJ9/P3OC0M9eOn7j2YcYnybFJWpKvTlubjQMAQIcGe+PA0VW19gf3t9bu388JxyVZSLJn3fE9SZ6ywSQnbjD+xP0NrqojshIpvnvadC+RpAEA8+mOJHvXfC4aooiqOizJ7yepJK86mHMlaQBAhwZ7mO3JSfat+cH+UrQkuSvJUpLt645vT7J7g3N2TzN+TYP2hCTPPZgULZGkAQDzaV9r7Z41n/02aa21B5LcmuTs1WOTjQNnJ7lhg2vfsHb8xPPXjl/ToP2TJM9rrd19sL+AJA0A2Ox2JLmiqm7Jyg7MC5McleTyJKmqK5Pc2VpbXTJ9W5Lrq+q1ST6U5GVJnpHklZPxhyV5X1Yev/GiJAtVtXq/2t9OGsMD0qQBAB16MCv35fc538FprV1VVccnuSQrN//fluSc1trq5oBTkiyvGf/RqjovyS8n+dUkn0ny4tbaJyZDTkryQ5O/v23ddN+b5CPT1OU5aQDAIfeN56T9fJIjepz5vqz0TtM/J22sJGkAQIcG2zjwqKdJAwA6tNGmynmZrzuWOwGAQ27yANfPZ4MHvHZsd5IntdbuG2DuQ0aTBgB0YtKobRtg6gce7Q1aokkDABglD7MFABghTRoAwAhp0gAARkiTBgAwQpo0AIAR0qQBAIyQJg0AYIT+f7FIvAZLYTCQAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "M.evaluate_map()\n", "M.plot_map()" @@ -176,22 +146,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "M.evaluate_map(input_y=Data_X[:,0])\n", "M.plot_map()" @@ -199,7 +156,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -209,7 +166,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -218,22 +175,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxQAAAHgCAYAAAA8Hyu3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOy9WZBk2Xnf98/Mylp7X6ZnxazEYABi5YDkMCTCECmRkogHPpgOUl4YdsgPtsM2aYdCUtD2gxk0g2GCtkPyixwKy7KIsMIPjqAI2WGaNEGZAAGQxMbBOgswM43p6b2ra83KTD9kf1knT51z71n+382bVecXMdHVPVUns3K59/7y/33f6YzHYxQKhUKhUCgUCoVCCt1534FCoVAoFAqFQqGwuBShKBQKhUKhUCgUCskUoSgUCoVCoVAoFArJFKEoFAqFQqFQKBQKyRShKBQKhUKhUCgUCskUoSgUCoVCoVAoFArJFKEoFAqFQqFQKBQKyRShKBQKhUKhUCgUCskUoSgUCoVCoVAoFArJLCX8TNlau1AoFAqFQqFQON50Qr8xRSgKhUKhoMCPf+I3aGutfXeTttbw9AptLQC4/6412lqf+9R/RlurUCgUCml0xuPowKEkFIVCoeCBKQV1MKWhCrZQVMGUjTqKjBQKhUIlwQlFEYpCoVCooElBcNGUNFTRpFBU0aRsuCgCUigUThhFKAqFQsHHvCXBRxvkwUVbhMLFvCXDR5GPQqFwDChCUSgUTiZtlQUXbRUImzYLhU1bBcNFkY5CodByilAUCoXjy099+L+c+fvO46fmdE+qGa7MTubu3x/O/H3l6v0m704Ug8vr06/7N7dn/t9wo72CsXRn9r4enFuf+XtbhWPZem185nf+zpzuSaFQKEwpQlEoFBYXWxh8zFMkbFnwYUuEzbylwhQHH7ZQ+Ji3aNgyYWPLhY95SoctFj6KcBQKhQYoQlEoFNpNqDS4aEIkQoXBpk4gfDQhFiHy4CJUKFw0IRl1IuEjVDBsmhCOULFwUWSjUCiQKEJRKBTaQY442DBFIlUYXKRKhA1bKlIFwiZHKGzYgpEqEzapcuGCKRw5YmFTRKNQKERShKJQKDQLUxxsUkWCKQ02LImwyZUKlkSYMIXCJFcuWDJhw5QLm1TZYIqFTRGNQqHgoQhFoVDIR1MSqvAJhKYg+NAShzp8YqEhDHVoCUUdPuHQEok6NEXDh09ANAWjiiIfhcKJoghFoVCIY17yYCIiMQ9xsJmXSJisXL0/F4GwmZdQ2Aw3VuYmEybzEAsbEY15iYVJkYxC4dhShKJQKPj5yL//SQDA5S/cmev9eOOnzwMAzn97vhdFf+39WwCA3/3OYTKyfv1gXncHe+eWAABr1/fndh+EnUt9LO1MDvvr37s353sDdO9Onqvx+ur87kTHOMcOJq+Tg0un53RnJmw/Nnk8lnZGc70fW1cmr90//Z9+ea73o1AoUChCUSgUJog82DQtEyIPJk2LhIiDjSkSJk1KhUiETdNSsXOpf+TfRChsmhYMkQmbRuWi4zm/DtyvlaZFQ8TCpGnJEKmwKZJRKCwcRSgKhZOITx5stGXCJQ8m2iLhEwcbn0iYaEqFTyJstKXCJREmPqEw0ZYLn0zYqMqFTyZMPGJhoy0aLrEw0ZYMn1TYFMkoFFpNEYpC4aQQKhGAjkjUyYMNWyZC5UEIkQgTDaEIFQmBLRR1AmETIhQ2bMEIFQpBRSxChMIkUC4EtmTUSYWNhmSEigVQ5KJQaCFFKAqF40iMPNgwZCJWHmxyZSJWHkxiRcKEIRWxEmGTKxWxEmGSIhQmuXIRKxM2FLmIlQmTSLEwyZWMWKmwYUhGjFTYFMkoFOZKEYpC4TiQIxAmKTKRKw8mKSKRIw8mOSJhkioVuSIhpAhFjkSY5AqFSYpc5AqFkCwWOTJhkiEWJimSkSsWJimSkSMVJkUwCoVGKUJRKCwiLIEwCZUJpkAIoSLBkgcTlkiYhEoFSyJsQqSCJREmTKEwCZELlkzYBMsFSyZMSGJhEioZTLEQQgWDJRUmRTAKBVWKUBQKi4CGQJhUyYSGQJj4ZEJDHkw0RMKkSiq0REKoEgoNkRC0hEKoEgstoRAqxUJDJkwUxMLEJxkaUmFSJRgaUmFSBKNQoFKEolBoI9oCYWLKhLY8mNgioS0QgrZImJhSoS0RJrZQaEqEibZQmNhyoS0UJjNyoS0TJspiIdiCoS0WJqZkaEuFSRGMQiGLIhSFQltoUiKAiUg0KRAm/8bqfDY+a1ImgIlQNCkSM8Qfs7NpUihMTn31+3O53fH6arNCATQmFTb3Pnh5Lre7tDNqVCyAIheFQgJFKAqFefGD//lvAQCW7zX3Vhl3J3/unW/2Iujsx98GAPz0Z9cbvd1/ujr5pPXSlyeP8ajX3G0PVyaP8fL9Zg+FN94/ud1LX2l2k7KlnTFGy5Pb7u43+ztvfPsWAKCzu9fo7YpMNLlhXufufQDA6PyZyd/3mt3QcO+JyYcQexeavcjvPHg5757rNnabOw9Nnt+Xf+2XGrvNQmFBKUJRKDSFCIRJEzIxts6/TciECISJtkyIPJiISJhoS4WIhIm2VIhEmDQhFHYiIUJh0oRciFCYqMuFI5nQFguRCRMRi5nvU5YMkYqZf2tAMDrWS7oJuRCpMCmCUSgcoQhFoaCJSyJMNITCFggTDZlwyYOJlki4BEJwiYSgJRQukTDRkAqXSJhoSEVVWZNLKEw05MIlEyYqYlFT5qQlFi6hEFxiMf05JcFwicXM/1eQDFsqTDQEwyUUJkUuCgUARSgKBS51AmHCkokqgTBhykSdRAgsmaiSB5sqmRDYUlEnEwBXKOpEQmAJRWhvRJ1QmLDkok4oBKpYBPRNsKWiSiaEKqk4sh5JMuqkYvp9JLmoEgoblmDUSYVJEYzCCaUIRaGQS4xECLkyESoRJjlCESoQAkMkYiQCCBMJE4ZUhIiESY5UhEqESa5QxDZZxwiFkCsWoUJhkiUXkU3YDLEIkQmTGLEAOHIRKhbT788QjBipEHLlIkYqhCIXhRNEEYpCIZUUkQDSZCJFIExiZSJWIExSZSJWIIRYkTBJlYpYkRBShCJFJExipSJnUlOKUJjEykWKTJgkiUXiVKdUsYiVCZNYsZjeZqJgxErFzM9GCkaKVJikCEaKVABFLAongiIUhUIoqQJhEioTuQJhEiITOQJhEiMTqQJhkiMTQoxUpIqESYxU5MoEEC4UjJGvuUIhhIpFrlAAkVJBGBEbIxY5MiGkSsXM/YgQjBypmFknQDBypcIkVDBSpcKkCEbhGFKEolCogiERJnVC0aRIsCQCCBMJhkAIDJEwqZMKhkgIIULBEAmhSijY+0awhMKkSi4YQiEEiQVxz4k6sWDIhAlDLIQQwWCJBVAvF02KBUMoTIpcFI4JRSgKBRu2RAg+mWBKhOCSCaZAmPhkgikQAlskBJ9QMEXCxCcVTJEQfEKhsQmdhlAAfqlgCoXgFQulDex8YsEWCoEpFoJPMJhSMV3TIxdMqRB8csGWCqHIRWGBKUJRKAB6EiGYMqEhECa2TGiJhCBCoSEQJloyIZhSoSUSgi0UGiJhYkqF5m7WWkIhmGKhIRMmR8RCeUdsUyy0ZELQkAoTEQwNoTCx5UJDKkxMwdCSCqHIRWHBKEJROLloS4SwfG+sLhHC3vmOukAIP/3ZdXWJAPRFwmTU05cJYfn+WF0khEtfGamKhKAtFEJ3f6wuFEJnd09dJoTx+qq6TJhoiwUwkQttsRD2LiypS4Wwe66rLhVCkYvCAlCEonAyePa//eT067W39U4Cm88dzPz9wpd0dlFrMoW484cPz/x9cEbvrb16/fD3Gliucv6bOlcK7/zQ7GN5/usqNwMAuPP87N+7uhsaT3n4T4Zqay9tH65ti/PgjN7uyct3Z99rK2/eVbmdcX/2d+je31a5HQAY39+a+XtnZUXndvZm05fO6VPTr0cbayq3CRwtjdIUjY51zbJ3vq9yO/eemD3GD/UePmy8dfg7feGf/LLeDRUK8RShKBxfTIkwYQuFLRECWyZ8TdZsmbAFwoQtE6ZAzNyOI/jQEApbJqa3RZYKWySEpoQC4EuFKRKCL4lji4UtEyZssbCFQmCLhS0TgoZU2EIBzEqFCVswqhq62YJhS8X0dshyYUuFwJYLUyhMilwUWkARisLxwicRAlMmfCIB8GSiqUlNVRIhMGTCJxAzt1NRRcWSCp9ITG+HJBQ+kTBZpJTCJREmIaV9DLmoEgqBIRY+mTBhiYVPKASWWLhkYnobHqkwYQhGk1OifFIxvR2SXPikAuCKhU8qhCIXhTlRhKJwPKgTCYAjE1USITBkoom9I0IkAsgXiRCJAKpFwiRXKupkYno7GVIRIhLCIghFnUgIMb1COWIRIhRCjliECIWQIxZ1MiHkSkWVTMzcToBYAPlyEbq/Ra5c1EkFwBGLKqkQGHJRJxVAEYtC4xShKCwuIRJhkioUIRJhkioUMbtZp8hEqECYpMhEqEDM3E5kb3eqVITKxPR2EqQiRiaAdgtFqEgIKcMHUsQiRiiEFLGIEQogTSpCZUJIlYpQmZjeTqBUmKQIRuyu3KlyESIV09tIlIsQoTBJlYsQoTApclFogCIUhcUiViKEWJmIlQghViZiJEKIlYkUkQDiZCJFIqa3kzgoKkYqYkViehsRQhErEiZNSEWMUMSKhJAzzSxGLFKEQggVi1iZMIkRi1ihEGLEIlYmpreRIBVCjFzESoUQKxcxUjG9jUi5iJUKIVYuYqVCKHJRUKIIRWExSBUJIUQoUiVCCJWJFIkwCRGKVIkQQmQiRyKAdJEQQoUiVSamtxMgFTkyAbQnpUgVCYExHrlOLHJkQgiRihyhAMKkIlUmhFCpSBWK6e1kiAUQJhepUiGEyEWKUMzcRqBcpEqFECIXqUIhFLEokClCUWgvuRJh4hOKXIkQ6mQiVyKEKpnIlQihSiZyJWJ6G6TtK6qkIlckprdRIxS5MiHMM6XIFQmBud+KTywYQiH4xCJXJoQ6qcgVCqFKLHJlYnobmVIhVMlFrlQIVXKRKxXT26iRi1ypEHxykSsUJkUuCgSKUBTaB1MkBFsoWCIhuISCJRGCSyZYEiG4ZIIlEdPbIO+F55IKlkxMb8MhFSyREOYhFCyREDQ2cLTFgikUgFsqWEIhuMSCJROCSypYMjG9DZJUCC65YEmF4JILllRMb8MhFyyhEGyxYAqFUMSikEERikJ70BAJ4FAm2BIhmDLBlgjBlAm2RAimTLAlYnobChtr20LBlglgVijYIiE0LRRsmQB0hAKYlQq2UAimWLCFQjDFgi0UwFGpYAsFwJcKwZQLtlQIplywpWJ6G4ZcsKVCELnQkAqgiEUhiSIUhfmjJRLC2tsdVZnQkgjh7MffVpMIYXBmrCYRgI5ImJz/5khFJGZu4+t6MiFoS8XDfzJUEQlBSyiEwZklNaEAJlKhJRNC9/62ikyYdFZWVGRi5jaUxAKYyIWWVAh7T5xXk4rpbZzvq0qFllAIRSwKERShKMyHZ37rN9EZ6l4AaoqEsPFdvYuP4ar+BeZwbYzlO3rPw3AVWH3pBra/eEntNgBg7doY957VW3/ldgf7Z3UPaQenh1i+qXPxAQCXvjrG6o2B2voA0B2MMFzRtYqlnSGGq3qP0/KNbWCo+1x3b9zG+EDx2LQ/AJa5u0EfodPF+MpFdLd21G7i4MpZ9G7eV1sfALafu4ilXT3Jvv6BVbW1AWC0DKy/rft6vf0C8J2/W+SiUEkRikKzPPNbvzn9WkMozF4JLZl45DOHF0z3nuRfPA0fnH+0ZGK4dvjW1JCJoXH+XH3pxvRrDalYu3b4u2gJxcrtw8dIQyoOTh9ezGgJxaWvGuVsClKxd2Ei1mvXDl+0GmKxtHP4WGlJxfINo99BQSy6N25Pv1aTin3jOdYQi87hczu+cnH6tYZcHFw5O/1aSy62n5v8Dhpicf2DxgFR6apotHz4tYZc3H7h8OsiFgUPRSgKzWCKhMAUCtcUJ6ZQmBIhMGViaH2IpSETpkgAXJmw7z8wKxMCUypMmRCYUmGKhMAWClMmBKZUmCIhMIVCREIwhUJgioUpFNP1iWIxIxPTG+A+56ZQCFSx2Hc8v0yp6Bx9Pk2pEJhyYUoFoCMWIhUCUy5mpEIgvqxMoRCYYmEKhVDEomBRhKKgh0siBJZMaI+DdYkEwJMJ14U4wBMKWyIElkz47r9LJgSGVLhkQmBIhUsmBIZUuERCYAiFSyQEhlDYIiG4hEJgiIVLKKbrE8TCKRTTG8h/3l0yIVCkwiUTAkMqHDIhuKQC4ImFLRUCSy5soRBYYuGUCoB2peSSCoAnFi6pEIpcFBAhFLpdaoVjRZVIMIjd9ToWn0Sw8F2E09b3SISQKxN1979KJhhUyUQuVSLBoEokGFSJBAOfSITQ25tM49Lqseg9uPBT66/oPXhtKPVXdJYmj61qGZRiX0Xn2k2nVJjTm3LkYunaXadUDC8eNodrJBcHxutJpdfCPOQovLS2Hz68Aa1ei+d+fTJYpYhFIYSSUBRqiRGJlIQiVCRS04lQkUhJJ2IkIiWdqJMIIVUmQu9/qEykpBQxIpGSUsTIREpKESoTqQlFqEykJBShIlGVUNikiEVVQjGzdqJUVCYUMzcQ//xXpRM2SVJRlU7YpIhFRTph4ksqbFLlwpdU2KTIhS+lcJEiF96Uwibx6smXUtikiEVVQmFTxOJEUkqeCvnEJhIxMpGSRsQIRWwaESsTsWlEjEyESoQQKxMx9z0llYiRithUIlYoYpOJGKFISSVipCI2lYgViphUIkYogHipCBWK6foRYhEsEzM3EP7YxwgFkCAVMUIBxElFoEyYhIoFECcXoUJhEiMXMVIBxItFsFQIEW/vUKEwiZGLGKkAilicMIpQFNJJLW0KEYrUsqZQmUgtawoRitSSplCZiBUJIUQoUu57aolTqFCkljiFSEVqiVOoUKSWOIUIRWp5U6hQpJQ3xQqFECoWsUIxXT9ALJKEAgiWilihEILEIlYmhFCpSBAKIE4qhBC5SJEKIFwsYqVCCJGLaKEQAt/uKVIBhIlFrFAIRSxOBEUoCmloyURuf0SVUOT2RtTJRG5vRJVQpEqEUCUTufc7p2eiTipy+yWqpCK3X6JKKnJ7JeqEIrdXokoqcvokUoVCqBKLVJmYrl0jFclCMb0B/3OSKhNCpVSkyoRQJxWJMgGkCYVJlVykSoVQJRepQiHUiUWyVAgVb/9UoRDqxKJIRcFDEYpCOIxm6yqhaLNMAG6hYDVYu2QiVyIEn0ww7jujAdsnFYzma59QMJqvfULBarx2SQWr6dolFDkiIeQKheASi1yhmK7tEItsmZgu7n5+coUCqJCKXKEA/FKRIRNCrlQAfrHIlQrBJRe5UiG45CJbKIC5SUWqUJgUuTiWFKEo1MOc2uQSCtbUJpdQsCY2HReZYE6YYk5zsqWCOcnJlgrmJCdbKphTnGyhYE5wsoWCIRMATyiAo1LBEgrgqFTQhAI4IhUMmRCOSAVDJgRbKggyITCkQrDl4kRLBeC80soVCsElFgyhEIpYHCuKUBSOojX2tTPsqI183XzuQG3c670nu2qjXrv7PHkwEZHQuN9aY2G3v3hJbSTsvWd1RsKKUGiMgxWh0BgFu3pjQJMIE6ZQmAxXulShmK77QCyoQjFdfPK8MYVCGB8ccGXCZLlPlQkTplgIIhgssTDp3bxPkwqbpd0hTypsxjypsFl/e0yVCpMiGAtNEYrCIU//d7+JjtKzNloCTn1X5yR16upIZV0AuP28zn3uDoDhqs6D3dvV20th+/EDXHjijsra49/VOXEDwN4FncfkYG2M/Ys6e0tc/PMeVu4q7Xkw0llXSygAvfvc29wFOjqvj/2L61h9+U2VtcfbvJ2oj7CyorLseHcXePIxlbUBYHRK5yp699IqOkr7j9x+Xm9vkJHS0t0DYOey0rFpDHz77xWxWECKUBQmIiGwhWL04ENQDZlYuTO5s/1t7p2++bOTTyu7L5+q+c54ug8+VGTLROfg8L3cJe+Ltf3EgwUf3GUNodj5k0nJ0+oN7uOye/HwcWG/tg8eJEsaQnHxzyefnLOF4v4jk/fh6bf493nU62D19uS10lNIE7p7k7XHfe7Gdb3N3ckXClKxf3EdAOhScfDUlenXvZdfp6790i+9CwDw2f/xGnVd4IFQAOhcmbzfx6tccdl7eGP6df8+N8HZvTRJEzTEYuvhyYly/yz3NTh48HD0FDxfzjNssTCP00UsFooiFCcdLZkYWdUULKEQiRCYMiEiIbCEomud15gyYYoEwJOJqUQI1l1mSoXIhMCSClMmAO7r+8AqU2NJhYiEwBQKkQmBJRWj3uHjLEIhsMRCZEJgSsVUKASSWIhMCEypMIUC4EmFyITAlAqRCUGkYvr/SXJhSgXAFQuRCoElFyIUAlMsBrMPB00u7HMNUyyKVCwkRShOKqZICIwLLlskhFyhsEVCYAiFLRIARyZskRByhcKWiOntEWTiiEgA3ncyQypsmQA4QmHLhJD7GrdFQmAIhS0TAEcobJEQcoXCFAnBFgohVyxsoRAYYnFEKACKVNhCIeSKhS0TAkMqbKEAOFJhy4RgSwXAEQtbKoRcubCFQmCIhS0VAEcsbKEQcsXCd75hiIXrOF3EovUUoThpuERCyLnY8okEkCcTPpEA8mXCJRJCjlD4RALIkwmfSAB5MuGUCKHm7uZIhUsmhByp8MkEkPca98kEkCcULpEwyZEKn0wAeULhkgnALxRAnlT4hALIkwqnTJhkiIVPKIA8qfAJBZAnFS6ZEHKkwicTgksqpj+bIRc+qQDyxMInFUCeWLiEQsgVC59UAHliUXXeyRGLquN0EYvWUoTipFAlEkLKxVaVSAgpQlElEkKKUFRJhJAiE1USIaTKRJVIAOkyUSkSQNA7OFUoqmQCSBeKKpkQUl7nVTIhpEhFnUwAaUJRJRJCilD4REKoEgohRSyqhEJIEYtaoQCSpKJKJoQUqaiSCSFVKqqEAkiXijqhAKqlAkgXiyqpANLFokoqhBS5qJIKIUUuqoRCSBGLkHNPiliEHKOLWLSOIhTHnRCRAOIvskJEQogRihCREGKEIkQkhBihCBEJIUYo6iRi5j5ECEWtRJgE3t1YqaiTCSFWKkJkAoh/rYfIBBAvFCEyAcQLRYhMAPFCUScTQJhQAPFSESIUQLxUBAkFEC0VIUIBxEtFiFAA8VJRJxNCrFSEyARQLxQza0bIRZ1QmMTIRYhQCDFiESIUQoxYhAiFECMWMeeeWLEIPU4XsWgNwS9IndmZBVVCZSKWIhMPvrfIRDShMhHD7sVOsEzEcLA2DpaJGC7+eS9YJmK4/0g3WCZiGPU6QTIRw3Cth+Ea/zHoDIboDBTG+I7Hk//I7L73cey+93H6usP3PoXhe5+ir/vSfxAmNLGMr4XvbdPZ3Qv+3pW3t4K/d3AqfMbq6o1AEQUwjnjvbLwdfoxejvigoR/+MGAYMXk35lpg7brOaOYf+G8+qbJuQY8iFAuGhkyMluIOIKGs3BlHyUQoN392W0UmugMdmegcdOgysf3EwfS/YBZMJjTQEAkgPJWIRUMkgLBUIgcNqQCgIxWAilQAUJEKAMdaKuS/OmKlIlQsYqUiVCxipSJGLEIZLseJRShr1zsqYlGkYrEoJU8LQqpI1MWLqSJRlVCkSkRdOhEjESZ1QhEjESZVQhEjEDP3peacEyUQJonv2rqyp1SZqCp7SpWJutd6qkzUlTylykRVyVOOSFSVPKWKRGjJk4uqMqjQkicXVWVQwSVPNjUlUKElTzZ1JVChJU82VSVQoeVONnXlT6HlTjYx5U8zt1dTChVT/mRSVQoVU/pkUlcGFVP6ZFJXBhVT+mRSVQaV2sNXVwKVOkCjlEDNjdJDcVzITSR8b96cRMInE7lphE8oUkUC8MtEqkQIPplIFQmg+gCeLBJA9jvWJxU5yYRPKHKTCd/rPSeZ8AlFbirhE4rcVMInFDmpRI5QAH6pyBEKwC8VyUIheMQiVSgAv1SkyoTgk4pUoQD8UpEqE0KqVADVYpEqFYBfLFKlQvDJRapUAH6xSBUKwScWOVMGfWKRO+K7iEXjFKFYdBilTa43LqO0yRYKRlmTSyZyREKwhSJXJAC3TOSIhGAfvLMkQiC8W11CwShzsqWCUebkes0zypxsqWCUOLmEglHiZAsFo7wpVygEWyxyhQJwS0W2UABHpCJHJgSXVOQKBXBUKnJkQnBJRa5QAHlSMb0fllzkCIXgEotcqQCOikWOUAgusciVCuCoWDD2QHKJBWNvrCIWjVGasheZRemTaEuPhA9TJmL7I0KJ7Y/wYR64o3sjfJCemltvnJv5e5t7JsbGMprN12w0G6/bxMI1bJOxm7UZMgE001PBkAkgrqfCh91nEdNP4SOmzyIGu88ippfCxyL1WJT+ipNDSShaBFskOmO+REg6wRQJSScYEmHSffkUXSKGq2OKQJiITFAkwoT4TpWUgi0TqzfG9AbszpjffC0JBVMmJKFgi8Tpt4Z0kWAlFCa9nSEloTCRtIKSUAgPkgpGQmGy+vKbNKEQei+/TkknTCSpYAkFwEkpTCSxYCQVJv37A0pKYdIZjikphYkkFoyUQpC0gpFSmOxcHlMSCpOSVqhSSp4Wied+/ZNZOy37GCsMWrn4Zf4nDfd+Kv/TJZulL6fviO1DYxLW3qUhxn2Ft5TCkmtXFR4Ahfup8V46/T36kgCAwTr//bTx9oi+poZQAED/Tvio0FC6uwpRJID9S9yLVQBY2ubf17/0U/zn/48/+V36mmypAID777uMpS1+WjVc5Z9Mty/z19x6lH886XM/5wMA7F5SOEa/CvzZPypioUARikVBQybWrk0+8dx+lHdiOf3aZM3le7z7evNjk4uJ/ir/YoUpFIMzk9+5t807WO9dmpz0mDLRWZ88juOdBxf+xOuK069M1jxY4605XOM/rrIm9Sj14O6dZl9TjYHBBvcCYGmXX4bY2x9PZXrlLvdibdTrYOUmMU14AFsqBg/SiXHC7to+lm9OrtRGa7wym97N+wCAl36Bly8gI7EAACAASURBVKZ87n/ZBACMbtyirfljv/zkZO1/cg8AMF7iXVzff99lAKCKxfaVyXO0cpd3UJXxtLde4Inqnecnf/Y3ea/TnQfJ+Zlv8j5Q6j+4jth8hrYkgCIVShShaDvP/fph/R9LKEQkAJ5MiEgAPJkQkQDaLRMiEgDvoldEAuDJhIgEYMgEQBMKkQmAJxTDNf5ja67ZeqF4cP+YQrG0O1mUKRS9/claZjrHlAopzWq7VGgKBcCTChEKgCcVIhQATypEKABdqQB4YiFSAfDEwtzzgiUWIhUATyx2jHJcllj0jesJllicfvXw6yIWNEpTdpsxZYKFKRMMTr/WnZEJBjc/tjcjE23GlAkWjcoEQHl3mzIBAEs7+WsOrf6G4brCZxSs6z6NnmaFX1dkgkVvfzyVCZu9sz3sneWWa+xd5NapA8Bold9g2yE1apsywcKUCQD47G/n34YpEwDQvXQhe01TJgDgR/+dMwCAzsEQnQPOxf+pv7g+/fpgg19atHeWf+l04etbuPB1bvnv4PQYg9PcY8O95w9w73nuB4GmCLD4yN8uTdtNU4SiQZ779U/SZWLtWldFJti4RKKN6cTgzPiITOR+gr53aTgjEww66wczMuEl46m0ZaLN2JJCwXraN590f1swY9BlYml3rCITIWhIBVssRqv9bLEYWM3YLKkw6e7o9H1okCMVtky4YIqFcLDRyxaL9Wuzz9He2W62WLgavnOl4tw3j/4bWyoAqEgFWyw+8rc/WcSiQYpQNMQiiATgl4mccqdFSCVcIgHkyYRPJFLTCZEIl0gcSScUyUkpfBf+OSlFEzKRjecu9rfS7ztbJIBwmRDYUgEsRlrRNqmw0wkhJ6Ww0wlNJKUwEbFIlQszpRByxcKWCoAjFjZaaUUqa2+4zy9sqQD0xKKgTxEKZTRSiTpS+ieOQ4lTSjrhE4kcqhKJFJmoSyNqZaIl73KNC//KNVOkoJP4c1UseIlTHSe1BKozHieJRVW5k0ZSwSh9YhCSTvhIFQuXVACcxMImVSyqxtKyxaJNJVCDM83ukVOkQp+WXGoUQlmEEqcQkdAod4ohRCRi0wl2aVNwWZMCdeVOsSlF4zKRwgL0S8yzxKmORSmBYsNOK9ogFXXpBKOXwsaVUtiwy6FSxMKVUphoJRYxuMqeTLTEgklJKhaPMuVJgdhEom7KU6xA1CUUsQIRUu4Um0SwhaIunYhNIUJkIkUeqhKKFHmILnWqCa9i+ybqpj7FXvSHPO7RIlH37ZEiUTvtKfLuhUx6ipWIuklPsRKRsgdL3TSo2M335jEJyu6fqKNuClRsM3bI9CdfuZOPuulPsaVOdZOfYpMJmfoUQ9WEKHPiUyghk6HMqU8h1E2GMic+hVA3Fcqc9hRCyESoncjNV+smQvUjS6nrpkHFCkiZBBVEGRs7D1JKm6pkIjWJqBKKlDSiSihSSpqalInUcqaqC9vUFMInE6kpRFLfRMU5LbUJu0oqUlKEqsc+KZWo+pGEVKJSKBKPjlVSkZJIVAlFSiKRuqljlVSk7ObdtFTECgVQLRUp052qpCJWJoBqoUjtm6iSipRSpxSpAPxikSIVQLVYxAqFUCUWsVIBVItFrFQA1WIRKxRAtVTECoVQJRYpqUYRi0rK2Nim0Wi6ZsLukViEEbBN9kbU4ZKJnJKm5CbsBt/x7JKktpQ4eac9tby8KadPIhV2f0WTZVApMgG0vwSqyZ6K1L6JkPInF76SKF8vRR1avRZM2t5nsQhjZkspFIeSUGSSKxKuhCJHJlzpRI5IuNKJHJFoYlQsQyTMT8kZfRGmUDD6IrKnOlkvk9wRsXZKkXvxb6cU2TJh/3hmv8SRlCLz7tkJRa5I2AlFrkikJhQmdlqRklDMrEdOK+ykIlUoBDupyN17wk4qUtIJEzupyJ3qZKcUOU3YQHpKYWImFqkphYmZWKQmFCZ2WpGSUJi40oqUlEJwpRUpKYXgSitSUwrAnVTkykZJK45QEoomaPso2JOQSpgywZrYJBezrCbr1smEBXu/ieOaTHhRSCaYNJ1K+Gj7JKi2j5Zte1LBbtROTSlMzLQiNaUwMROLuubsEOwG7qqJTyGctLSiNG63iyIUiSxCiROLNoqEidboVwYiE6yJTTSZePDyYMmETH1iXfzLvhRFJvJoi0wIRSryEKnITScEkQrWnhMiFbnphMCSChELhlQA/N232ZOhFkEsmBSpaAel5CkStkgs3+Ve4fTI1/2bH+aVFWiUO41fq550EcvBevweHpWc5X6qyEwnTn+bm0zsXSAfGlp+pDn9Om+twUaHKhPr73Bfx4ySJ5v+fd59ZJc/DTe4YtG/lbEbpIPONvdAz96Z+kf/7dO0tRilTyabH3yYut7+Ke6HgWdf4SZHt17YyCp7sjk4x32tXPwCf3NMJqUEqpQ8qfDsb/BkYuVWByu3eDIxXOHKxNZjY6pM9PrkC3UAva/Fb2RXxdp77lDXe/q936et1fv+CnrfX6Gtt3qVe4U44F0/AAD2H92nrjcmH+m6+9wPAtjJBFsAxpn9DjYd8uGAnVQMV8ifQF/O68ew2X/8HHW90ema+c+RfPaf8T4d33rhCrZeuEJb79R37tLWAoBz3+DuKH7vGe5r5cLXtzB6nHcuX7rTA7q849XNjw5x5wXeenvnO9g7zzteMa/7jjtFKAJ59jc+STkJmiIxJpyzhiuT/1hsPTbG1mPksguyTPS+dooqE2vvuUOViaff+326TDARmRiQwh2Rie6AcxA/aTLBOA6YrN7iy7sGB+vcJ6ZIRRrjtWUAPKkY9ybPK1MqANClgikW576xSRWLe8+s08WCKRUAJlJBFIs7L4wpYrFye7IGSyzOfrtIRShFKGp49jc+SZUJgSUTwjI3FaahIRNM2pxKAHoywUIzmdh/LF8sTJlgiIUpE1uP5p+s2DJhwkophivyAQhHpNjphAlDKvYvHK7BkApzmhVDKgYXDi/8T1JSAXClAjh5aQVdKkgMTx0eFJhSAYAqFUUsqilCUQHrxcMubwK4qQRwNJkYPZRXP9Xrj2ZkotvLu4pwpRIHG+kHnkVIJU6yTDA4ackEcDSdyJUKkQkhVypsmWCnFEBJKnJZBKk4zmnF2HqLMdKK5/7BYd/D6PHdbLFYumUcWMhJBcCRChNmGVSRCj9FKDyYL5qcT9RcIpFzIdH2EidbJChrNpRKbH4vbaLIIqQSRSaq/70On0wwUgoWi1LqZKMhFamY6YRJqlT49to4iVJxXNOK7cfdtaOLkFZQE4uWlUCZKYWQIxVnv334dZEKN+05krcIxotFo+naJxIp5U6lV4LDIsgEk8HpZmUipeyp7ckEoFvqZJOaUtjphJCaUmiWOtmwUwqgHUmFWe5koyEVi5BWMNEogSq9FWGYZU8mrN4KgZVWFKk4Shkba+B6gcSeBEMkIuZiIiSNiBWKOpGILXcKEYmYkqdQiYgpeQoRiZiEIlQkXnvrUtD3hYpEzMi+EJnoR5zfQ0Vi1A9/XkKSieW3loPXC5GJ2Pd0iFBsXI07LDbdiN2NnNjskwmTzjDud6573Je2ucYRO0rWl06Y9PbiRmaG7Aa+cj18TGiVUAjLb4Z/aCIN2XV0N8PH3kpTdhUv/a3wiRD/z+fDpGbj69eCvm+8Ebbe/efOBn0fAKy/WX8gvfOe8E9iOoFvrTOvhr92vvMf1R90um/GifjBhZoDyyjuwr13v/61c+7r4WuGiIMryaji7g8c/bdX/s6xHi1bxsY2TWgiwZaJGE5qedNJSyWA8GQidNKTRioxr56JmARjEdKJkFInjX0kYgiRuLZPfQLiUooQmQB0yp/mVQIVIhMAP6kATl5aAZy8Miggrr8iRBbYY2ZPMkUoHpCaTmg1XIfKREg6cRLLmwCdCU5tl4nj2C/BmPaUQoxMhPZSzHNEbKhUhKQTQHjpU0wiNC+pCEknBHbpUygh6YRJ6avIh92wDej0VhyXMihf2ZMNuwwKCBcLs5dCKOVPE4pQIP3FECsSdRcT7IZroL68KZaSSvBoe78EkCYTrP0oYojtm6j7/kVIJjQIlQmBveGdBvNIKkLTCYGdUoQQWu5kwpYKoP19FUBJK2gopBV1YhFb0pSaVhSpKELhfRFUfarWZMN1KqmpRFX/xElMJQCdEqdUmVi6476QaYtM1MEucwLa04RdlVI0MSI2hKqUIlYmhCqpSGnEbnqUbEw6YdKGJu062CkF0KxUhPZP2LBHywJ8qQAWP62YGR8bilIZVJON266UAihScaKFIvbJb9t+Eq5yJ63yppOaSrS9xAk4GTLhK3vKkQnXzy5KMpEzIrapfoqcqU6LsD8F4JaK2HTCxCcVseVOJosiFRosSgnUiU0rHGIRWvbkog37V5xkqTiRU55CnnDzZMiQCPuigpFI2ELBEAkzoWBKhEx5YoqETHliiYQ55YklEvaUJ4ZQmJOeWDJhTntiyIQ96YmRTNjTnhjJhPk+Z8mEOfGpbTIh2FOfUtMJE3vqE2NMLHvyEzA7/Sk1nbAxpz/lCIVgT37KEQrBnv6UUvJkY05/Cm3IrsOcAJWaUJjY059CpzzVYU6BCpnyFIJMggqd8hSCTIIKmfIUijkNqnbSUwjWNKiQaU912NOgGI3XZvmUa9qTzTGZ/lSmPPmIkYl5N1yHsghN1wA/lQAWo8QJWIydrwFeMmH2UbDKnMyUglXmxC6Xmlm7pTIBzKYUDJkAZkufWHtOLEpSITBkAphNKhgyAcwmFQyZABanp2IR+ioAfgkUwE8rgPbsXVGFduO2r+zJ5KSlFSdKKEKf3JMuEkUmuJQyJy4aEsAsddp6tNNqmRBGSzyZEMa9Dn0DOy2pYKUTgM7kp9JTwaVIBZcmy6BymOdEKOBkScWJKHkKfUIPzg5x6hXuhdr+2TF96s3uYwP07nHv5/Qi4InwDYzqGA4OLwRWv8M5eXc+dHgAX4rYLK+K5aXDcoUzq5wD5OtvX5x+HbtZkI+xUUbUv8u5yNp95DCuXr3GeU0Nnz+8GBjsEl+nw8n7qP9On7bkhb+YPKZ3n+VdtK69M1mTWbYgn3yvX4/bWK1yzf5kTaYALG9O7t/BKu/xXNp9cAeJ97O/PXndH6zxXp8iPv17hBKQByxtTdYarfKEpTM6fGEu3eYc78f9w/vXvRu+2VoVnYPD1zpLBtY//8rhXx6+TFnz4Ozh8b27x3nuh2uHx7j77+KcP3bPHb4n7/0Y7zzfe2Ny/wYXea97AOje79E/nBitjbHxGlf+f+LnP4/f/b8/GvS9C1oCVUqehBCZODg7xMFZ3okamIjE/lmue+0+NsDuYwPqmp0R94JCMGWChSkTLEyZYGHKBItxxO7ToZgywcKUCd6inalMMBGZAICzr3DeBCITADAm3WWzjGb7MudkKDIB8BIfkQnAkIBMZtYh3U+RCQBY2uG8B8wUZXCGnx52d4fo7vKPVQfn+enC6Cz/0/DQXbCjePs6fcnRCv+5P/U9cgoA4Mwf85/3/s0l9G9yf/9xl59Ibz09xNbT3PfS3/yrX8Df/KtfqP2+455WHGuhqHvyNEQCAF0kANBFAtATCbZMdD50ly4Ty0vDIhP2v13Ju7hyyUR/NfOCzSESg4fy3wumTLAwZYIFqyZ/Zs3+0TVzT9qmTAgsqZhB4YzFkgoThlRIOmGSKxVmOiHkSoWZTggnXSrYYnHqe7t0sTjzx2tqYsFGo8yVLRVAmFgcZ6k4tkIRIhNsSipxslOJJmVicDb9CVyoZEIBn0zkpBQ+mchJKXwykZNSuGRCkxyp8P5sxmHGTCdmbitDKnw9HhpJBZAvFS7allSY5U4malJR0goqJzmtAHBipeJY9lBUPVlVIpHaP1EnESk9FHUSkdpDUSsSCT0UISIR20MRIhIpPRR1MpHSQxEiErF9FCGpREofRZ1MpPRRhMhEdC9FgEyk9FLUJRMpvRR1yURKL0VIMpHST1EnFCkfNLjSCZOUfoogEUm4rz6hEFJ6KuqaxlN6KlzphE1sX4UrnThyuwk9Fa6EwiSlp8InFCaxfRUz/RM+EvoqzB4KFyl9FWYPhY/Y3gqzh8JHSm+F9FD4SO2t6N6vfl2lHKtGa9XvgdT+ip/4+c97/19Vf8WC9FSc3B4Kn0wsSp8EoFfedNJTiZNe4hSSTMSWPR2HZMIkNqUIKXOKTSk0ypyAsHQi9hPAOpkAlEqfgOizV51MAPFJRcgEquOcVNTJBDBJKkoJVEkr2GiVQTXZX3HckopjJRSuJ2fefRIx6YRGeROwOL0SwPxLnO7thn3q03SJk4vQsieNEidg/jIR00sx754JVoO2SUzpU0ypU+iJOkQmhBip0BCQEJmY3v6ceypC0gmhDVIRSqhUhKQTwrxLoOrSCZNFkopF6q1Y9P6K4yQVx0YofDLBpqQSeqnEvGUiFA2RABZnkhMQLxNBzdlzTCZMQlIKjQZsID6dCJGKpvsmfISIQrRMKJ3BQqQidn+MeSYVIeVOJvOWihhUpAJYqL6KklbQl2y0v+K4SMWxEAr7yVi08qaSSqSJxMHQf1/aVuJUtQHQuD9ulUxUlT0Nn9+aezJhUpdSzDuZMKlLKVJLnaqkIlUm6k7QMemESZUwJCcTNfc1Jp0wmUdSEZNOmGglFVViEVLu5EJLKqrEIqh/wsUcSqBC+idclLRiccTClVYcB6lYeKEwn4R5lzfFoCkSJZXgvwaAdvZL+Mqe2jjJyZtStCSZMPGlFLnJhE8qmhoPG4Pv5JwqE0KT42RTZULwSUXO7t1NJxWx6YRNkxOgYsqdXCxKXwVQ0grNtGJRy6AWXSoWWijkwdcUiUUpbwJORipRB0Mm7D6KNvRLxMCQCTulUEklAIpMuFIKRjJhS0VbypxcsDa8s7FPzLky4YMiGQ2VP+XIhOCSitR0wkQjqQCOSkVqOmGikVQAzfVVxPRP+NCQCqCkFcDipBXArFgsslQsrFCYMqFBSSUWL5VoU4mTC7PsaZ6TnGJhysRMSkFMJkypaFOZkwszpWAmE6ZUtKVvwocpENTEwjhk5aYTJtrlTwyZEEypyE0nTLSSCu2+iuRyJxcLNgWqpBWLk1YAWHipWEihePY3PllSCeiKxElLJVxopRJt6peoo83JhAu2TJx9ZaSSTIw78x0PG4OckNnphOY4WaZMCEs7B5R0wmSRRsoCus3aueVONnV9FcksUAkUsHhpRWnanqQViygVCykUJZXQEQlAJ5UAikxoUmRigkYysWholT61utRpwSlSsYAUqQCgk1YAek3bGminFYvEQgqFBucf07ng1eDUQzoXes//yOsq644PdF5m27d1DmZbu8sq644206Z31NE/t6eybgEYK6UIXZ02Kixv6khVym7XQSg54L3IXYSDKc6qxuiMTk/FnZ98t8q6nT/+ssq6o2WdDwV6+zov3t6ezjHyIYXr6f4tnePY73zmRZV1F42FE4pf/drPUNc7/9hdFZnojCf/sSkyMaHIxITuozsq6z7xzHU8fOEefd2N9T2cu3yfuubytT6Wr/Vx+73kUp8HMtHfpi47lYneHvcAITLBLqWS+0mXirH1J4mdC5NPN9lSsXvhwbGBfH+X7x5guL6E4Tr3U9n9c8sYkNcEgN69fUApWCpSMaFIxQQtqdAQi9/5zIt0sWBf72qjk68pwXxwtRIJDYkAikgIRSQmaIqEBhvrOinK8jWdx7ckExNs6TlY7eqUKY0BKDzk9961ijMa5R5K93e4voQeuf9DpILeVyIvA/KhXqSie49r8iIV537vW9R1RSrGP/ZB6roiFd19bkmNSMVwmf3Bw2S94Qr3WCRS8c5HqctOpWJwgXs8E6n4xI9/kbLer37tZ/ArP/gvKGtpszAJRZGJWVbfnf87uGTivU9+P3tdl0xs38kXAZdM3Hj7TPa6LplYWc2/8nPJxHA9/+DlkglG2ZNLJhgphUsmGCmFSyYYKYVLJtgphcBOKQSthm8aSsdKSSfYTNMJE8LvsHz36EU+I6nYP3f0/jLSit69/aP/SLge6wyOXjQz0orbP/LokX9jpBXDm7eO/BsjrRiuHn2OGGnF7fccPXcy0ordh47+GyOtuPiVo/dNI60AFqMMalGSioUQCtaDOY/yppVr6QfxUw9tlWTiASWZmHCckokcqahKJtilT0KuVPjSiVyp8KUTuVLhu1/ZpU++Xzfz+sYnE7mlT06ZIOCSCSFHKlwyIWiUQAEoJVAPKCVQD9ZVLIE6qWVQiyAVrRcKpkxosIglThoyMT7oqsjE9u21uclEakpRJxOpKUWdTKSmFHUykZpSLFqZEzC/UqdUqagrdUqVirr7kywVdb9m4vG0LplYxCZtdk+FkCoVznTCJFEqXOnEzLKJUuFKJ0xSpcKVTphoSoWGWPT2xypi0dvrLFRvBdD+tKLtUtF6ochlEZuuSyoxIVQkYsuetnaXVZKJ0Wb/2CYTsVIRKhOxKUWoTKSkFCEykZJSzLtvIlYqQuUmWipCj5ctmvwUlE4k3N+qdMIkViqq0gmTWKmolQlhAZMKjbSi88dfjhYLV7mTi5JWTDjJaUVbabVQ5NiYlkgAxz+VCO2jiE0lYvoojnuJU0xKESMTMSnFcW/AjpGKmGQiRipiZCImpWiqCbuONoyTjembiJGKqFKniPsbKhNC25KKWiKkoi6dmFk2Qirq0gmb41wC5eqf8BGTVrj6J7zrlrRiSq5YtDmlaK1Q5MqEBiWVOEQzlWiTTISUPWmmEvNOJkxCUooUmQhJKdpW5hQiFSnJRMgFfYpMhKQUqWVXQVKRsnTAz6Q0YYdIRVLfxJzLn0LTCZMQqQhOJ0wUk4p59lXUlTu5WLQSKKCkFYJWWgHklUG1VSo643H0C0d9a5+6B+sf/X8fO/JvDInY+vKFI//GEoi9K0c/lWJIxO63zh75N4ZEvPzdR478G0si1s8dvUhmSMSlh49e8LISib3doxe0DJHobR99TBkSMbizcuTfWInE27eOlpgxUok7108d+TeWSJx/+egbmdEvMXBc2zBKnIYrR+8bK5XoDo+uw5g25RwnyzpbOJ4qxkQn10hZShO24/7GJhM+XGNlU2TCxjVWNkkmXDhOHTHphHdZx2jZ2HTChWu0bIpMuHCNlw0td6rCNV42Jp2owjViNiah8K7rGDHrmvAUi2vE7NIWR2ZcY2Y7+/lru8bMPtTfrPyZhsbJBv9yrUsoYs1rUUub2p5I2GVPi5BI2L0UmuVNbe+VsEuftMqbAF6Jk51UtC2VcGEnFax+CfsCn1niZKcVrNG1R5IK5vHTWos1HtZOK2gTnRpMKxgyASiWQAFHEguGTACL11sBHE0sGDIBNJtYMGQCWLzEAmhXKVTbkopWCUWKTGigVdoEtKdPIoZ5N12n0JZeiTrMXoo2lTdVYZY+taVfog6zn2JRNq3T2qNC8zbUeioM2HtNNDEBipVOCE30VdDSCaGBhm1GOmGyaL0VwGI2bS9if0VbSqHaJBWtKXmKeVD+99c/pHEXAADbXzpa9sSg/34d+QGAJ8/fVln3L155TGVdAGqf4K2dU9gV9wE713U+DWNsSueDsTGdi8Goi919nQRh+2vnVdYFgHPf1Fl3qBemoEe+rhP620pXeACWdnTW3rmo9yn68n2d+7x8j7xDtcFwWeeiZvnOPrq7Ove7M+Tu/Gxy94VzKuue/t8+p7IuABz8lR9SWffuMzofqgHA1uM6AnDum3rHpFtK+xMdnNL74Off+4k/CP5exfKnxS15miebL+vIRO99Ohd1Lz7yBl585A2Vtb/zziWsnOZf6D7/9Pfx/NP5u3G76Gz3sHt1Q2Xt/T2dK8YLj9/B6VM6ycQzV25gvc+/Gh2M9A4bm1urGD6t83h0lT4F23qkg91LSjtTd4GhwgfovcEYo77Ofe6MgOEK/zXS2xvh1FUdu7r4+es4/fJNlbW1ErGVN+9i/VWdD5MAYEQqxTHpbu2is6szR7kzGOLcV3Sew6Unn1BZt/fuZ7Hy5h2VtbsDnZHV+2c66Otc0uDGhzq48SGd98vgnI6sdPT8eOFohVCEphOr3QFWuwP8m8/wcyxtmRiNuG8SLZEAJjKhgSkSzz/DlYrOtk7Mu7/Xn8pE7wz36Hzh8cMTCVsqnrlyg7qeYMrE6jL38djcUio9waFM3HuK+z7ceuRwPbpUKB2de4PDT9TYUtExztkaUgGALhUXP39YEsiWiv7W5GpDSyoA0KVi+c7h46shFQDoUmH2ZLCl4vzn3gIwkQotsWBLxeYTh+mE1j44WlIBgC4V135scsxbJKl45IV38Omr78Onr74v6PvbUPo0d6GIkQkNNl++sHDJhM3l1bjNwapoQibY2DLBSim0UglgVibY2DLBSim0kwkTZkphJxMsqTBlgo71UGukFAJLKjp61Qro7c0urpVUADypEJkQmFKx8uZsCe0iJBXdrdlyVK2kAuBLhQlLKnrvfnbm71pJBbAYUnGwpt8zBuhKhVZasShSMXehqENSCQ1cIjEklB323ndvYcucbDTKnphoJhMuGCmFTyZyU4pnrtxoJJkwYaQUvmSCIRWaZU4uKCmF56jMkAoznTDJlQqfTDBSClsmBIZUmOmESZvLn2yZEBhSYaYTJppJRa5Y+CZGMaRC0gmbRUkq2OyfOfr6XdTyJ4ZYDB0SpCkVoWIxL+YqFFU2pS0S80glcsueFrXMyZdO5JY9VcmEVi9FLlrJRJ1I5KQUdclEjlQ0UebkIielqEsmsqSi5oicIxU+mdAmRyp8MiHkSIVPJoQcqbDTCZO2lj/5ZELIkQo7nbDRSis0k4oc7HTCJFcqzHInE62eCqDd5U9S7uRiUdOKKrGYZ0oxN6GokwkttEQCmG/zdWrZ03feuVQrE6kpRZNlTkzqSp1SU4oQmUhJKUJTiRSpaLLMyUVqShGSTKRIRWiZU5JUBD7UKVIRIhOpKUVIQYLF4gAAIABJREFUqVOKVNTJhJAiFXUyIaRIRZVMCKlS4UsnTNpW/lQnEzmE7GeRKhW+dELQSimAdpY/udIJk/69dLGoK3daxGZtQLdhu41S0bqSp1CZiG3MjkklYsuetEuctNBKJYBwmYhNKTrbvWCZiE0pzAbsOmKlQrNnQosYmYhNKWKSiRip6O51osqcYqQitmciSioUj8QxyUSsVMT0TWg1aQNxUhEqE0KMVITIhDDudaLEIkQmhFipqEsnTBalUdskVirqZEJIadSuSidMVt68Ey0WvnTCRvEz21anFT5SSqBc5U4uUtKKR154J+j72lYCNRehcNlT070SLGJFIqbsKVYmYlKKeZQ45TLPVCKHWJmISSlieyY0xsgKoVKRUuYUIhVa/RJAsw3YIYSmFCllTqFSkdKEHSoVoemEySI0arsIkYoYmRBCpSJGJmKJTSdipCJ2t+1FaNR2sWhjZYE4qYhtxo6RiqpyJxeLmFb4SqDmkVI0LhQ+mdBAu1diURuvU2QipOwpVSRCUopUmQhJKVJlIiSlSE0mQqRCqwEb0C11aht1KUWOTNSmFBkPc51U5PRM1ElFzkSnOqlIkQmhTipi0wmTOqmISScWHa2UAgiTiliZEEKkIjSdsAmRitB0wiZEKkLTCZuQy6+6cicXOSVQdSxCw7aLpidBNS0Vc71qyE0lqsqeckWiquxJcxzscS9xSuGkJBMx5MhEXUqRIxNVKcXm1mpWE3ZVSpGbTrD3pzDxSgXh6OuTCkYDtk8qGONhfVKRIxOCTypyZKKOXJmoSilS0glh/dXblUlFTjpRJxU5vRNtKn+KYRGTCqCUQLmokorQcicfVVIRWu7kYt6ToBoVCtOWTnLjta/siSETvrInhkz4UgqGTPhSCoZMuFKKmH6JKlwpxYXH71BkwpVSsEbDuqRiMOpSkgmXVLCmObmkglXq5JIKVqmT2k7aOCoVzGlOtlQw95qwpYIhEz5YMuFKKVjJhEsqcmTCxCUVjFKn0eqSUywYjdi+kbKp6YTJua/cdIpFajph4uurSE0nTHxSkZpOmPguyVLSCRufVDD2nvBJRWy5k4tFLIECZtOKJlMKvdzSw0kWCR8llThKSSWOsqglTvMaDZsLu29i91IHqzcenOTID/dwFegpDdMZ9TvoDsaNblyXy6mr+7j/6OQii51MnH75Jjbfe5G6pjDuddAZ6oz3XX/1NrafOa+y9mh1Cd3dA5W1O7sDjFd1jtnnvnITdz6g81wuPfkEDr7LP7eLVOw9fo6+tlyejRQebpGKwRn+2iIVl77Ef++IVPTv8M+RIhVjhcsdkYq/8ehf8Bf30FhC8atf+xkVmZCyJw2ZkLInDZmQlEJDJiSl0JAJSSk0ZEJSCg2ZkJRCQyYkpdCQCUkpNGRCUgoNmZCUQkMmJKXQkAlJKdrWhF2Ip4kmbY2+CUkqWOmEiSQVGo3YklRojImVpIKRTthIUsFIJ2wkqWCkEzYiFox0wkYu1RjphI2IhcbO2CIWjHTCRsQit9zJhYhFTrmTj09ffV9jKUVjpzatZOJTr7+olkws7XRKMuFgUZOJpSW9jPHD73tNbe1PvPuramv3e3qPSV/x8d6/qLf2nXerLa1e+qS1eZ1WOjFc6S5EqZOLpW291+DOZb0UtTvQe7xVm7W30/ZDCuHcV2+prf2X/qsfVFu79FUcRbuvonOgs35nCLz1us51W1N9FY0IxQd/579QWfdTr7+osi4wkQktdjZXsbO5ij/8Bv/K5Y9eeQ5/9MpzOBjwD+wba3vYWNvD9S2dXai/ffUhdC7ofKp46l16R7APPPGm2tr/2qPfUVt7MNKTt+GD1OPC2S3+2vcmn8jtPsovsRgtTy7IB6d1LszXro/Vamc7Q2CwrjT5RGnd+4/1cOuFFZW1tx7u49aLOifonacm5SZjhYdl98Lk2H3nw/z7vvvEWQDAwYbehf/BxVNqa2OgU1YFAOONNbW1X/p5nbVf+vk1fOKpTZW1e/tjbHx/hI3v8wV07foYF74GXPgafWks3+lg7WoPa1f1zm9aUgHoSYXWdbhJYwnFP33lh6nrmTJx7ge5UxtMmRh95Sx17Z1NvXryP3rlObW1N9b0Ph369tWH8O2rD03/zpSKU++6NyMT6xvcON6UiSfPcneoNWXifWe5qZApE+t97kdRQ8V+DJEJDUQmBLZUrF0/XI8tFZoNfvJS0ZIKAHSp2Hr48BN+tlSITAgaUiFoSIWwUFIxMi5q2VLROXwC2VLxo794eP3w0s+vUcXCXOsTT22qiQUAFakQNKRCYEtFb+vw3MaWiuGpw8eYLRVbe3rnTRN1odCwIq1kYmmno55M2LBSCpdMsFIKl0ywUgpTJNhopxJNJxMsqXAlEyypcMkEK6VwyQQrpbBlgo0pE2xsmWBe+NsvFeba9x+bXVwrqQD4UmHDkgpJJ0xYUiHphMlCSMXIcTGrnFQsYloBgCYVvf2jxyuWVLiOhSypWL5z9I2onVRopRUaSYV2SqEqFE3KBDulMMlNKaTESQMpcdJCO5nwkZtSVMlEbkpRJRKMlGJeZU65UlGVTORKRVUykSsVVTLBSCmalAmBceHve6kw1rZlQmi7VNjphEmuVLhkQsiVCpdMCAshFS4YUtHxP2m5UmGmEza5UlH184ucVGilFYwSKDOdYGOmEyaLJhWd8Tj6ZBf8A647/m89+/nY24tKJO58LW4EXEwi0f1A/NSNUJH42Hu+FbVujEQs9eMOvLEScXkj/GIxNpEY34qL6mJSie3ICUQxicR378aNZ4yViL+4+0jU98f0S2wP4hpCY0qcbt2NS7ZiSpxWr8ZdGMWkEv3N+KvFUJFIGRkYWuLU346XmZjWmpT1fTJhc+Hr8R9mmKVOlWt/MX5qWpVM2HQiH5YqmbA59+dx971KJmyWtvQ++V+66d4jyYsrmaiiHylGFTJx5Fu3/JtquqiSCZvPfipu7VgZ+Z3XTwd/ryuZqGLrkbiL7JgPV25F9rK70gkXO4/G14fGyMR4Ke4x9MmEi8eeij9uucqdvvyJ/zpmieA3SuMDDGN7KRa98ToUjQZtIab0aV6JhI+YpCK2xCkmqYgtb4pJKjQTCSC++TomqYjtl4hJKprsl6gjNqmIOXHG9j/EfH9smhDbpx+7fqhMAPFpRahMAPFpRYxMAO3pq4iRCWCB0wogLrGIkAkgLq2IkQkgThBSko22JBaaSW2oTACctKKKNjVsN9U7IbR2IvqnXn+xdTIRWvqk3XitWeKUQkg/hXavRBunOIVIRapMhPRTDEa95ElOIVLRtubr0NKn1H6JUKlIOXGGSkJK83XoRX/q0K/Q9WNkQgiVihiZmK4dKBWxMiGESkVMOiEscrN2kFjEphNCiFREyoSg3Vcx796K2HRCG80SKCC8tyKl1ElbKrQmQeWidkVQVadVl1LkiERdL8U8Gq9DqUspckSiLqWQkbBtpCqlyBWJupQit/G6Sipyk4kqqdAcCQvkyURdSpGTTNRJRZubr+tkIWeSk+aEphBSZEKok4oUmZiuPedm7RSZEOqkIjadMNGUCqAmrUiVCaFKKhJlQqiTith0wqZKKjSFI4eQ0bI5x8U6qYhJJ2zm3bAdU+5kUycVVemEVh9F6xKKtqUSNr6UQrPxGuCMhPVJBUMkqlIKzXSCgUsq5jHFKQWXVLRZJmrXJpQ5+aSCIRNVKQUj0vdJA2MsbJVU5L5kqtbOkQnBJxU5MjFdu0IqUtMJE59U5MiEsKhJBeCRilyZEOYwBSpXJrSpSikY6YRPKhjHRe2kwicWjEbsNpVAaaPSlB1qP2aDNlsk7OZsZiphN2ezRcJu0GaWONkN2uxUwmzQZouE3aDNLnMym7TZMmE2abN7JswGbbZM2A3aTJmwG7TZPRNmkzY7mbCbtJn1wXaTNnuPCbuRmvmSsddmyISJ3ajNEIrp2lajNkMmTMxGbYZMmNiN2jnphI1mozZgNWuzhEIwG7Uz0wkbs1GbLRN2ozY7nTAbtdmlTnajNvPYaDdq56QTLuyGbeZkJ7tZOyedcGE2bIf2TgQ2Z7e3KduFRiohpU8aJU5mSrFo/RJmStG2Buw6zNKnNvZMVCGlT4u287XZS8FOJszSpzY1YIdgJhXsZkNTIDQ2rDPTBPZLxlybLRPAbFLBlAlgNqlgywTQXKM2UyaABpMKtkwAh0kFWSaA5nbW1ih1aqpRm31sbLKvgj0m1iyBYssE0I60gp5QxNZmLfX05hrf/4LuA7z3tN4Febev97gs9Q9UZeJO5GjQGMa3llVl4rkL8WPZQvnu3fNqQvGl24+rrAsAm3t6ewMAwPU34kbsxrB8Q7f868yrqsur0tvT6yfZO6/7WdXKbb3j49oN3U/k987rXaCv3uDuem+jOlb2utJxvb+kIhTCS/+63ochn/3UjmrvxKe/pTd5a+uRrupkp/uP6z2n+2d1e+0Ozil8UvSAc4/EvY8CUor2JxRb2yvY2ta7ULl58xT2nsnbwMzLGBG7cSSwtYTRHZ2D1A8/9To+8pheb8AvPvMn+E8//Psqa587u4XzT+dvHOfj8qkt3N3XO3gzNr1z8bEz38B/8uTvqaytLRN3vnwJ/Vs6F/2rV5fQ3dc76fR2O9h6VGf9cXfynxZ75zrYvqJzAzuXuvTkw+TU1SH6OzoH4NXbQ4x7ikM7Li2pPTYHqx3cf1zv4rZ/bx+doY7I9bbzNjKt4uD8Og7O6RzXO5vb+Nw/vqOyNgAMrpzBZ36fm8QJf/iHy9j4vt7jDgA7l3XeSwfrwOotvYswzeE93QPdD7ruXD2DO1fPqK1fxVyEwhSJu5v8N/rNm4rzro3X8MqrChdbW3qfXv3wU69Pv37+wnX6+r/4zJ/Q1xTOGeUx/R7f7i+fytvJ+TjShExoYfZPaEhFb1fvotMUCQ2p2Dt3eN/ZUrFz6XA9jQvnU1cP3/taUgFARSp2Lhk9PYrCpSEV/XuHF55aUjHe0CsfBqAmFQBUpMIUCS2pAKAiFWYfhZZUADpSMTLePpoTQVWkwng45iEV1LNJSLmTdiphywQ1pVBOJWyZYKYUpkxoYMsEM6U45xgzypQKWyY0U4rXtuJ2cq/jY2e+Mf1aK6XQwJYJZkrh2jGbKRW2TDBTCpdAMKXClIkmYF44mzIhMKVi9fbs+kypMGVCYD42B6uz95UpFaZMaGCmE2ypOHho9qKKKRWdze2ZvzOlwiUQTKn4wz+cfX0sUlJxsD7799VbY/W0gkXXqhhcvtFTTyvqYI6QbTSh8MkEI6VQTSUAr0xQUoqKVIIhFT6ZYKQUv/jMn3iTCYZUuGSCySInE6ZMCCyp0EwnfMkEQypcMiEwpMKXTGiVPgkMqfDJBCulMNMJE8aFs0smmNgyITCkwiUTAuOxsWVC0Cx/YqUUrlKnklT4YUiFLRPCxvf3KWJhT3kSGFJhy4QJQypGnreMZlIBkNIKz6/fZFLRiFA00S9RRVZKEdAvkSUViiVOQH0ykSMVmiVOQL1M5KQUl09tVcpE21MKl0wIuVKhXepURY5UVMkEg7oyp1ypqJOGHKmoSyZypcInE0LOhXOdTOSmFD6ZEDR7KoC8x8YnEyyq0olcqajqm2BIhZ1OzPy/TKmw0wmTz/3jO1liUScNmuVPQF5a4ZMJQbP8CciTCp9MCLl9FXY6YXMc+ipoQuGLTUJFIjWlCE0mkqRCeyf6QJlISSl++KnXVcucQmUiNaXQTCbakErkSEWVTAipUtGGvgmtJm0gPaUI7ZlIlYpQWUiRitAyp1SpqJMJIeXCOTSZSJWKOpkQUqWiKp3IJUQmclKKkFKnVKkIacLOkYoqmZh+j2JSAeimFalS4UsnbDRLoHYud5LEoiqdMNEsfwLS0oo6mRCSpSLwV/ZJBavsSTWhiE0lYqTC1S9BJfI1GZ1SNNR8HUJsShGbTMRKRVtkQjOlAOKl4mNnvhEkE6m0QSaEWKmISSdipSK2ATtWKrSnOcUQKxWhMiFoNiPHSkWoTAixUhEjE7GPS0wykSIVMX0TWk3awEQqYsUiRCam35sgFVXphE2bpCJUJoRYqahLJ2za1Kxdl07YaDdrR4lF5LWqZlKhdiqbZ4mTj+CUIlFwg6TC0XwdQmhKkZpKhEqF9iSnWJmIKXtKSSa0pSKUFJGISSnaJBOxpJQ6aY6TBcKlIkUmQn8mtQE7VCpiZUIIvXhO6ZsIlYpYmYglJZloy+SnlCbsGKlIGRGr2VcRIxUxMiHESEWsJHzm9/utmAAVKxNCqFSEphMmoc3asTIhhEpFaDphM+9m7RQoQmHHJTkyoTFG1qRWKrQnOWVQJxW5JU51UtHUWNhYQqQip8xp3v0UOalEiFS0VSZCUoqcvokQqcgZD1snFTnJRN3P5k5zqpOKVJkQ6i6ec5qw66QiRyZCUoqcMqcQqUjtmwiRipyJTiFSkbPfRIhUxKQTMz8XIBUpMiGESEWOGMxTKlJlQqiTihSZMJnnBKhUmQgm41ezpYJR9kRPKDSTCaC5PSZS8aYUpBInn1Ro90vkykRV2ROjxKlKKtrQM1FFlVQwSpyqpKKtMiFUSQWjCbtKKhh7TWhOf/JJBWs0rE8qcmVC8F08a050YiQTVVLB6JmokorcJmzNyU9AtVQwNq+rkopUmZj+/Bx7KhhCULVGbLmTDWsClA+fVOTKhOCTitR0wmTh9qowYCcVVKFgyYQrpWD2TDhTCqLEHpGKOU9yyoGZSrikYlHGws6jn4LZL+GSirbLhOCSCuZEJ5dUaG5cB/D6JjT7L4CjUsGSCR8smdDc9A5wSwWzAdslFayJTj6pYO034ZIK5k7YLqnIlYnpOufWnGKRk06YzGOsbK5MmMxDKljYUsGQCcElFax0wttTQTrEMaUi++wgMQk7mTClQiOVmJGKFpc5uZCUQmOSk1n2NO+xsLHYKQU7mWhSKjSbr4HFkQnBlAqN8bCmVLBlwk4p2BJgrqexcZ1IhYZMmBfO7GTClgp234QpFRrTnMzHhj0e1pYK9uZ1mo3awKxUsGTCxJQKlkwItlSwy5WaHCubW+5kY06AYqUTTWFKhUap04xUkK9ZRSpyy56yXw3z3mMiGyWZoGx4V0HTO1+zkJRCK5kQqdAqc2qiSVtLJiSlWDSZEPq3enPfayIVkQqtREE7qViUZMJGpEKrCbuJPSq09poQqdDaCVukgplOmDSxAR5bJgSRCq2Lf1mXmU6YLNLO2iaSUjDTCZOF2ADPA2OvikZ3yo7lxtu6G3HsXdKr1e196C7Wz2RsqDdHnjx7W3V9xg7aPsbjDpa6ep+OvXjxe/iB0/k7jPv46KnX1NYGgLfvnlZd//4fX1Zbe/leBz3F81hvT/dkMDilu/7Srl7U2h2oLY3Tb+h2LmpPdBqu6Z1GR33d18xwTbdGW0smhM6e3guzuz/E8Mo5tfUB4Mf/iuIbS5nBuu5rU4uDU2OMlvWOlT/0l7+ptjYArH9P90O1HLKPhP2vbjDuxxEGWxPDHg8UDtb3+pP/AOxd5p9seh+6S1/TZOnCLr74vXeprL07nLxY/+Dmu1XWFzQSkPH48AB3e5ufJLx48Xv0NU1+7soXAQDbI50E4e995WcBAFu7Oh/PiEwsbfFPNMv3dE9eHTm/KN3M8r3JnwdKJ+H+9uQX2HibL9O9B5+LaEjF2dcnMtEZ6pzge7u6pTej5cnzubylezsarN2cnPt2r+ikrt09XVHs3toEAPTfuKl6OxpS8aP/7uGaGlIha37sYzpCd+fZyTlq+a7O+3bnyhj3nlFZeoqGVHzwr02qCz788W/iwx/ni8XS9uR4s/6GjlTkrtsZj6Mf1OkPvPArvzXzPwbvzyszEYlw0ekTDtj3/OuvXM//pMYnEtvf55RtLV1wJx4vvotzoSsyYfPxi9+irO/if371R7LXMEXC5vz6Tvb6VSLx7c38T+RFJFysd/ey1xeRcLGxmnfCqUokDjbyD9hVIjEkeFGn6i4SzjciEi6WtvNvoO9ZY+thzgcxPcchZ0Sq0hCZsGGUETUlEi72N/Ife+1kQmTCxeq1vGNmUyLhYvBE3GahzvX3/Y9N71p+U7UpEzaMEiifoDDKn0QkbPbPcl6vO1fcx7Mzr1KWx33P57CMfYlEJlz8+R88n72+yISL7Sfy3nO2SHz9V3/J/Gvwg9OakqcqmQAISUWFTAD5SUVVKrH+yP2stQG/TACgpBU+mdAmN6mokgkgP6moSyVyy5+qZALITyuqZCKXuvKm3KSiLpXILX+qlAkgO62okgkGPpkAOEmFSyYATlLhkwlAL61gUSUTQH5aMU+ZAPQSCwZVMgHkpxVVMgHkpxVVMgHkpxVVP6+VVgCcpMInEwAoaYVPJoD8tKJKJgBkpxVVMgHoJRaxUIUitfypTiaEZKmokYlcmihx0mJ3uFQrE4tY/mSSKhWhJU6pUlEnE0KqVITIRGr5U2ivRKpUhJY4pUpFrUxMvzFt/RCZyCl/qpIJIUcqfDIh5EhFlUwIOVKhmU7UyYSQKhXzlgkhVSo004k6mRBSpaJOJoRUqaiTiVxCZCRHKnzphLB8d6xWAgVwpKIKzb4KIF0q6mRCSJUKpowkC4Vd7iTESkWoTAjRUtESmUhJKZYu7AbLREpKEZNKtFEq6tIJk1ipiO2XiJWKUJlIJSaZiJWK2MbrWKmI7ZeIlYpgmUgkJplIkYoQmcihTiYEzUZtIE0qtEudYoiVirbIhBArFdqlTjHESkWoTAixUhEjEykpRczPpEhFnUyYpEhFVTphcu+ZNLGoSidM2iYVoTIhxMqB7/t91/d1zLXkKVYmoomUidiyp9hkIkYqUlKJGKlIKXFqk1TEyISg0aidQopMxKQUKWVOoVKROsUpVCpSm69DpSJJJiLuUkqZU4xUxMpEbEoRKhNCrFSEpBMmMVIxz74JH6FS0TaZEEKlYp59Ez60m7VDSUkmYgQhRUBipCJGJoQYqQiVCZMYqQiVCSFWKurKnWw0mrVN5ln+pCIUISlF22RCCJGK3ofuJpc5hUhFTolTiFTk9Eu0QSpSZCKG1GlOISlFTjIRIhU5PRN1UpE7ErZOKhqb5JT0w/XfMs+eiSpCpSJWJoRQqYiVCaENPRUpMiHMewJUqkwIdVLRRpkQQqQiNp0Q2jBSNqfnIkQqUmRCCJGKFJkQQqQiViaE0XLYaNlYmRDaIBUa4qGWUFRJRa5MVJY9GSNhU6mSCka/RJVUMPolqqRiXs3XLHJloi6lyB0Nq7lHBVAtFYwGbJ9UsPaX8EkFQyaqUgpKmVPFXcyVibqUIrfMqU4qUmVCqJOKVJkQ6qSiDX0TVVRJhWY6kSsTgk8q2iwTQesnyoRQJxW5fRPa+1RoNmoD1VKRIxNClVSkyoRJlVSkyoRQN1o2ttzJpkoYtFKMRkueBlt9WjLhlApiv4RLKpjN1y6p0Gy+BngyMa+UgpVM+KSCtc+ETypYfRMuqWBOc7KlQnOzOoCbTLikok09E1X4pILVM+GTilyZEHxSkSsTgk8q2tQ3UYVLKrRLnZjYUrEoMuFLKXJlQvBJBasJ2ycVLNnwSUVOOmGi2agNuKWCIROCSypyZcLEJRW5MiGsv7HUaAmUqlCYKYVGidOMVLSk+ToVtkzYKQU7mWhaKthlTrZUsDets6WC3YRtSoXGaFiRCg2ZMFOKVpc5ORec/Su7zMmWCnYDti0VLJkQbKlgyYRgS0Ub+yaqaLL8iZVOmIhULIpMCLZUsGRCsKWCPdHJlgd2cmFLBUsmBFsqGOmEyXGaAMWSCRNTKjQFI0koYjvA29ovUYekFFoyISmFVjIhUqFV5tSUVGj1TIhUaO2ALVKhNdFpe7Qy130mctGSCUkp1JKJB3dbq2dCpEJrmpNIBVsmBJEKtkwIIhWLJhOCSMUipRMm2vtUaJU5iVSwZUIQqdAaDysSoVUGJVLBlglBpIItE4JIBTOdMBGpYKYTJm3oqzBJmfSkX/L02rrq8uPd/B2uqxiu65rpuKe7/sFY9yn+kfXvqK5/5VT+poBVvP/8VdX137VxW23tf/Dax3F+I38n8HnQv697MTXWPSzg1Ju679uRckq9ekv3/p9+U+eiTbj/qO4TrN0IPlrSff0v7c6/kT2Fu+85i9s/9rja+trJyu4PXFFdv/9V0pbRHm4/ryMTQkf3sIDhiu77av+c8ocYysf9tbd0b0D1anNwanJQ67+jlFAMJy+e8bLOk7y0NXl49r91RmX9rXcmJWGDuzpv4g898SYAYKmr8/j83Sc+DUBPKv7lO+8DADx8WucTqx9/7BUAwJ7Su1jW/dz9Z+lr/4PXPk5f02RnawW7z+t8hC3JgZbrHjz4AFXr4HzqjckvsHxP56Ktuz9Zd++MzslxuKycgFybXDVoXTRvPjF5Yu8+o3NemSYgOzrHzd2zD2RI6ZpfZGKwofMGGy11cP8ZnXOioCEVw4fOTr4Y6zzwgzOT8/j/+0c65/PP/vdvzPzJ5v94+zQAYKx03BycmhwP1q/qHBc23pqsu3ZNZ/2DBx8uf+HzOpUZf/pHzwMA9s/ovD7lfKv5GXNjTdl0qRjOvmjYUiEyIbClQmRCYEuFyITAlgqRCYEtFSITAlsqRCYEtlRoSQrQjEwIWlIhsA9uB1Y1BvtpEJkQ2FIhMiGwpWK4rNyjcW32I0i2VIhMCGypONKjQZaKqUwI5GsH7WTCfD7ZUnH3PWdn/q6ZVLClQmRCYEuFLRFsqRCZENhSITIhsKVCZEJgS8WBVanClgqRCYEtFcqFKlPUbkbSCROaVAzdLxaWVNgyIbCkwpYJgSUVtkwILKmwZUJgSYUtE2xsmWDjkglWSuGSCWbZkykTAlMqXH0NrIOdLRMCSypsmRBYUmHLhMCSClsmBNoUqWvuegaWVNgyIbCkwjtFiiQVR2RCIF07uGSCmVK4nsdFSSqm6YSJUlIhaCUVAksm4uuXAAAgAElEQVQqbJkQWFJhy4TAkgpbJgSWVNgyIbCkwpYJgSUVrvOrlmCoLOuSCUGt/OkBuVLhkwkhVyp8MiHkSoVPJlj4ZIJFlUwwUooqmWCkClVr5EpFVTLBkAqXTAgMqahqktb+BCX3qfXJhJArFT6ZEHKlwicTQvY+Fx6ZEHKlwicTQq5U1O5zkSkVXpkgUZVMMKSi6vljSIWdTpjkSoVTJgSCVNjphAlDKqrEQav8SdAqfxJypcInE0KuVPhkQsiVCp9MsKg6r2qcc+lLVsmEkCUVnnTCJFUq6mQilzqZyCVEJnJSihCZyEkpQpKJHKkISSZypEKzzCmEHKmokgkhRypCJi7lHOB86YRJ6tNTJxNCqlTUyYSQKhV1MiEk78RdIxNCqlTUyYSQKhWhDdipUhEkExnXtSFlTjlSEfK85UhFlUw0QoZUVMmEkCMVIcKQIxW+dMIkRyp86YSJVk+FoNVTIaRKRYhM5KQUIedTtlRQlwuRiSwCZKIJUlKKGJlISSlikokUqYhJJlKkIqbMKUUqYsqcUsQg9GdSU4rQvokUqQiRCSFFKmLGt6Yc4EJkQtB2vlipCJUJIVYqQmVCiJWKUJkQYqUiVCaEWKnQnuYUlUwk3JWYnokUqYh5vlKkIlQmUlOKynTCJEEqQmRCSJGKGFFIkYoQmRBSpCJEJoQUqahLJ0xSpKIunWgKrSZtgSkVtKViZSI6pYiUidiUIjadiJGKlGQiRipSypxipCKlzClGKlJ6JmKkYh49E1XESkVsE7b2KNkYqUjZCyLmABcjE0LM0xWaTpiESkWsTAihUhErE0KoVMTKhBB6kRorE0KoVKTIRExKkVTmFHGXUhqwY6RCe7RtbDIRKxXBMiG0qKciRRBifiZGJoQYqYiRCSFGKmJkQoiRiliZiE0pYkudYqUiVhJYUkFZJjWZCJaKxGQiVCpSS51CpCKnzClEKnJ6JkKkIqdnIkQqchqwQ6QiVSZCJSG1zClUKlInOoVKRUw6YRIiFTkby4Uc4FJkQgh52lJkQtAaKSvUSUWqTAh1UpEqE0LdxWqqTISSk0yESEVWz0TAXcuZ5hQiFakyEZpSpJY5hUpFtEwIgVIRk06YhEhFTglTyM+myIQQIhUpMiGESEWKTMSQmkyESkVq30SoVKTKAUMqspfILXOqlYrMMqc6qcjtm9Dao0KokgpGA3aVVDAasKukou3TnOpkIbdnok4qcsfD1klFqkwI8xwpmyMTQtXTlyMTQpVUpKYTJj6pyJUJwScVuTIh+C5aGTJRlVIwypyqpILSgF1xF5scDZtCnVTk9kzUSUWyTAg1UpEqE8I8pz/lyIRQJRU5MiFUSUWuTNSlFLllTnVSkduEXScVuVKQ+/NZP87qmfBKBalnwicVrCZsn1SwmrBdUsGc5uSSCuY0J5dUsGTCl1Kwypx80sBqwPZJBWuvCZ9U5MqE4JOKnHTCZB7TnxgyIbikgiETgtbmd4ItFSyZ8MFMJlxSweyZcEnFPKc5xeBLKVhlTj6pYDVg+6QiWyYEj1TkyoTgkwrW1CbXOgyZEFxSwZAJwSUVrGTCJxWsngmfVLAmOvmkgnWuzFkn+UfZDdhHpILcgG1LBXuiky0V7IlOWrtpC6ZUzHM0bAq2VLB7Jmx5YE9zsqWCvXGdLRUsmRBsqWDJhGAf4BjphEmTjdpMmRBMqWClEyYiFRoyYV7AapQ5mVLRqgbsEKy7y04mbKlg90zYUsGe5mRLBU0mBEsqWDIh2FLBHgHb5EhZpky4YJc52VLBbsC2pYI9HtaWCvYHb6nrJf2Y1jSnqVQoTXMSqdAaDytSoTUeVqRCa6+Jpe5ITSYkpdAqcxKp0GrAFonQGg0rUqG1C7ZIBVsmBJEKtkwIcoBjy4QgTysznTCZd09FLouUTLjQkglJKdSSiQd3W6vMSaRCqwFbpEJrNKxIBV0mhAdSwZYJQaRC6+Jf1mWmEybjJT2ZkJRCq2dCpEJrmpNIhdZeEyIVWil+yrqdcfxkg/HTv/1r6H1vNf7Wajj9/pvTr29d5R8gPvFDX5p+/X/+3ov09X/up//V9Ot/9rmX6OuvXDj8pPkDj16lr/8rj/8uAGB3zD85/q83f2z69Xc2L9PXf+709enXXYWr2o9svD79+s+2nqKv/+n/66PTrx/6yDX6+jfuHUru/q7C5pKbh2uuvcV//exdOEzQND4Q6N8//HrtukKKcHZy8urt6Zy8Vm9P1j1Y0xOL5U3OjtE2clG7ryRF6w9kaPkeX4pW3zp84dz8ofP09c3PL5a3+K+dwfrhY756m//89vYO19w/zT8unHrzMB3t7g7o6w/XDo9ro2X+/e8ODx+f/pdfpa+PzuGx8trPvYe+/JV/dQsA8NZPXqSvPVo+/Lq3R18eQ8MRtx/lv/bHS4fv157KOUv3Q6S99+zgtV/4+wAQfEPJv+XwXdyGTFMmAODCo3ep65syAQA//ZNfpK5vygQA/K0f/Sx1fVMmNBCZAIDVju6nkebFv8Z6ozH3jWbKhOvvuZgyAQDv/NkV6vqmTADA8ir5xLs5Kyg7j3FfP6ZMAMDBBvfgb8qEBiITADBc4Z8ERCYAYGlHLwnZP80/KZplNxopzrqRrOyf0e1vuPint6nr2WHo/gb3tWPKBADsnuc+v6ZMAMDyJve4YMoEAIxWuR+UmDIBAN197v03ZQIABh98hrq+KRMaiEwAwGO/d7PiO/MZkgMie731q9zHypQJABjSz1n6MpFC1qPIkgpbJgSWVNgyIbCkwpYJgSUVLpn4ytVHKWsDszIhMKXCTCcEllT41mFJhU8eWFJhy4TAkgpbJgSaVGy6T+IsqbBlgo1LJnYu8w7WpkwITKkwZaIJNKTChCkV644yLaZUmOmEwJYKG5ZU2DIhsKTClgmBJRW2TAgsqbBlQmBJhS0TAk0qHDJx5Z9/g7M2ZmVCYEqFmU4ILKnwrcOSClsmprdLkoq2ygRAGBubKxU+mRBypcInE0KuVPhkgkVVMsGQCpdMCAypcMmEwE4qbHKlok4acqXCJxNCrlT4ZELIlgqPTLCokglGSlGVTDCkwiUTAkMqfDKhmVIAPKnwTRpiSIVLJgSGVLhkQmBIRVWrFjupsMmVCp9MCLlS4ZMJIVcqfDIh5EqFTyZoVCQTDKlwyYTAkAqXTAi5UlH387lS4ZOJ6e1nnrfaLBMAaWO7VKmokwkhVSrqZEJIlYoQmchJKULKnHKkokomhBypqJIJIUcqQn42VSpCZSFVKupkQkiVijqZEJKlIkAmclKKkGQiRypCypxypKJKJhjUJRNtl4q6zdW0m9hzpKJKJoQcqQiZ+5AjFb50wiRVKupkQkiVijqZEFKlok4mhFSpCJGJrJQioMwpRyqqZELIkYoqmRDY5U82qVJRJxNCqlS0XSYAklAA8VIRKhNCrFSEyoQQKxUxyUSKVMT0TKRIRYhMCClSESITQopUxPwMu6fCJlYqQmVCiJWKUJlIJiKZSJGKmDKnFKmI6ZlIkYpQmUhNKULLnNoqFSE7NQPpUlGVTpikSEWITAgpUhEzRC5FKkJkQmD3VNjESkWoTAixUhEqE6nEJBNJUhHRM5EiFSEyIaRIRYhMCClSEfMzsVIRKhPT+xJ53loEmQCIQgHwG7Vt2I3aqaSUOcVIRUoDdoxUxMiEECMVMTIhxAhCioDESEVK6hD6M7EyIYRKRYpMRKUUCWVOMVKR0jMRIxVNNmCHECsVsT0TbZOKUJkQYqUiVCaENjVqp0ykjpGKGJkQYqQiNJ0wCZWKWJkQQqUiRSZiUoqUMqcoqUhowI6RihiZEGKkIkYmhBhBSBEQdqN2KosiEwBZKIAwqYhNJ0xCpCI2nRDYk59s2JOfbEKkIkUmhBCpSJEJIUQUckqkQqQipy+CPf0plpxkIkgqMnomQqQipwE7RCpSZSI0pUgtcwqVitQG7LZIRaxMCKFSESsTQqhUxKQTJiFSkbO9TYhUpMiEECIVKTIhsKc/xZKTTIRIRU7PRJBUZExzCpGKFJkQQqQiRSZi0C6Rik0nhJCUYpFkAlAQCqBaKnJkIoRUmRDqpCK3CbtOKnLHwzKnP7mY50hZRhN3lVQwhKBqjdR0QqhKKRhlTpVSQWjArpKKeUxziqFOKnJ7JuqkInea07ylIlUmhDqpSJUJoU4qUmVCmOf0pxyZEKqkIkcmhCqpSE0nhKqUglHmVCUVjAbsSqlocDSsBrkyUScLuTJRl1KkyoTAHicbA1smACWhANxSwZIJX0qRKxOCTypYE518UsHaa8InFTnphIlPKnLSCZO2T3+qwyUVuTIhuKSC2TPhlAriNCeXVLBkwpdSsMqcfFLBasD2SQVrNOy8pCJXJgSfVOTKhOCTilyZEHxSkZNOmLikgiETgksqGDJRRa5MCC6paFPPRBIkmfClFCyZ8KUUrGTCJw2sZMInFbkyIfikQjOd0JAJQFEobNjJhC0VLJkQbKlgj4e1pYK9cZ0tFSyZEGypYMmEYEsFWzJsqWCXK2mWP7E3vrOZkYo5joZNwZYKds+ELRXsaU62VLD3mWhaKlgyIdhSwZIJwZYKlkwItlSwZEJocqQsWybslIIlEy7YMmGnFGyZOJJSkJMJWyrYyYQtFewyJ1se2GVOtlSwZEKwpUK71EkLVaGQlEKrzEmkgi0TgkiF1l4TIhVau2CLVLBlQhCpYMuEIBKhlViIVGhd/Mu6rHTCpBGpUJIJSSm0ypxEKrQasEUqtEbDilRobVrXlFSwZUIQqWDLhCBSwZYJQaSCLROCSAUznTDZPd9dmGTCRFIKrWRCpEIrmZhKhVKZk0iFVpmTSIVWz4RIhFbPhEgFWyaE4fS8tVh9EybqCcXP/Q3djd+efFq3PObFv8zbXdJF/5zuZKzzy9uq6//wiu4n2O8/d1V1/cdWdGubr+6cVVv7nT+7oj8iVonuge762tOcDtZ01+/t666vLRWjJd2TovY+FYNTutOfxtpn3mY3UKexvDlUTSa6d3XPh7095QbzSxdUl3/oc3dU1+9v6b4wd64ov/CVlx8+uqe6fke5Ci/psPbaL/z9qO//6098PeVmgvnKrcdU1r2xdwoA8OrWJZX1//k3PgwAGI10Tr4fe+o7AIB/+M7HVdb/wPIqAOB/ePQLKuuv9QYzf7J5YnXyScy1A52L/n9x44MAgA/9+LdU1h89uYuDgdLHnACWL+uefNfe0bmqWrume7XWvz85q/T2dc4uy5uTdQfK5StaUiHr9vZ0z74HazrPs5x0N5/XOS7c+Oj5mdths3xf93E/8109213aGWK0rPO8Ll2bVDT039YZP9958LB3DnQe//5bDy72L55TWX/8rocnfy7pPP7vvDSRoRWl5HX/3HjmTzbbj0zesJ2B0nH5rM51jhB7vIm9zgeUE4qf/8HDPgQNqTi9cnhg05IKQUsqBLZUiEwIbKkQmRDYUmFLBFsqRCYEtlSITAhsqRg9efgp3qJJxcZ3Dz/91ZIKLfrWxRpbKkQmhEWTCnu9RZMK+6TLlgqRCS1MmdD4NFhkQqPkaWnn8NN9tlSITAhsqehYDzVbKqYyIZClQmRi+neyVIhMCGyp0JIIQWRCDUMmdt/NT+jM49rqy3rxeqNn87/+xNdpYmHKhMCUCkknTJhSIemEiVZSIbCkwpYJgSUVPnlgSYUtEwJLKmyZEFhSYcqEsGhSYcKUCu10wgVLKmyZEBZFKnzrLIpUaJcDuGSCeZtNJxNMqTBlQmBJhS0TAksqbJmY/jtJKo7IhECSClsmpv9OkgpbJti4ZIIpGC6ZoKYUjmSCJRWdkf5xzUTt7GumEza5UuGSCeErtx7LFguXTAgMqXDJhMCQCjudMNEqfxK0yp+EXKnwyYSQKxU+mWDhkglhEaTCTCdMGFLRVKmTi1yp8MmE0HapqPv5tktF1UmXkVJUJROME75PJlgpha/MiSEVLpkQtMqfhFyp8MnE9P9nSoVXJkj4ZIJFlUwwUooqcWBIRVUykS0VZweVZU65UlF1XNFKKVTerVUyIbS1r6JKJoRXty4li0WVTAg5UlElE0KOVPjSCZMcqQgRBq2eCiFVKkJkIielqJIJoc1S4ZMJoc3lT1UyIWj1VAhtlYrQn9OWilRCLuhzpKLJMicXuVJR1zORIxVVMiHkSIUvnTBJlYo6mcglSCYyUooQmchJKUKSiRypCBGGVKnYfmQUVOaULBUt6JfQkIq5nsHbJhUhMmESKxUhMiGkSEWITAgpUhEiE0KKVMSIQopU1KUTTZEiFSEyIbRRKupkQkiVCs10IkQmhBSpqEsnTNomFbHfrykVKSlFTDqQIhWhMpGaUoSWOaVKRWgDdopUhMiEkCIVITLRBCkpRVQykSAVMclEilTElDmlSEWMKMRKRWy/RLRUtEAmtEg+C/s6wEPSCZNYqagqd3LRlmbtGJkQRqNOsFjEyIQQIxUxMiHESEWKIMT8TKxMxKYUsaVOWpOfhDZJRahMCLFSMY++iSpipCJGJoS2SIX26NkUYqRiHj0TVcTen9ieiVipiJ3mFCMVMTKRQqxMxKYUselEjFQklTlFSEVKmVOMVKT0TIRKxf65cVLqEPozTTZfhxBb9hR7DPGlFCkTngByQhErE0KoVMTKhNAWqUhFs1n7H77z8VqxSJEJIUQqtEuYUpOJUKlI7ZsIlYqYdMKkDVIRKxNCqFTMs2+iihCpSJEJYd5SkSMTbeinSJWJ0JQitcwp9H6lNmCHSkXqaNgQqUiVidCUIjWZCJWK1FInrXGyUwKkIqdnok4q3nnpgmoD9nGa5BRDqFSkHtOYpU+t+WivTipSZUKok4rYciebKqlISSdsqqQiJZ2w0WzWrpKKXJmo+/ncMqc6qchtwq6TilSZEOYpFakyIdRJRVtlQjiuPRWMZGKe/RS5yUSdVOT2TNTdv9xpTnVSob3PRA51UpFb5lQnFbl9E3VSkd2EXSEVmg3YDJGoSikYMlG1Rq5M1JY9ZZY51UnFPMucTDrjcfQTNfMDT//2ryUnE1X8yzdemH6dKxM2H7jw1szfc2XC5pmNG9OvGTJh0+1OngKGSNj8hw/9wfTrnGTCx3989aPTr9nJxM5wdtduds/ElaXDk43GNKcvfebd069zRcLFUl93e+r96+vTr3NlwmbnocMjZttFwsVw+fCEk5NM+NDcgfZg7fC+s8uchivaUnT4utE46Z7+5uExQaP52txRmz0W1hRSDYkYrhzeeY0Sp+7+4ROq0S8xePhQHNkN2GNrJ3n6NKebh+tpiETn4PCx10gl9s5PHh+NVGL5zuFjz04lxn3r/pL7JVa/dXhNpnE8233vjqvc6f9v782jLcvu+r7vvvfN79XYXVU90Wo1tCSkFkJCYIRxIGAGARlMgk2cxcJGtoNtcJAwQrKJYwQxFoug4GGFhHjF2PGAnchaBjkgSJCXGYQRYZDaQuqW1K3u6q7q6uoa3qt68z3549x933777XPOHn6/O7z3/azVq2/dd+6+507n7s/9/n77RB+ki7+ZNWQCOEgspGUCOLy0rLRMAOMpgdKQCeAgqdCQCeAgrdAoc3LH1GjA1jqjtsWmFRoyAeimFcBBYiEtE8D4VoDSkAngIK3QkAlAN62wEqHRMzGu8ietX/BsWjHplZxysBKqlUjY8ietfgmbVmg3X2us5uQmFSpLww6TCq1UwpY/aZU4Ld7I65VIQaPEaZRUdCwJm4tNKrSOZ6XlT1NT8hTiTz7yu6rj9xTXffvMnXvxr59+XG18TX762lerjv81Z/RW91ru7+LR5Wtq41/dO6N6ronl1+quOz74tLxAu/Q29Sa2yy/2VNMJ7dh48z7dL8hK8Wiu2YC9eFu3QXcwr5uCXHuLnkyYge4J6zTfMwBQ9XWfe83zVMxfuaW6NOz+fE/1PBPm7Gm1sQFg86FTquNrsXY5bknYXKq+7nF++54pqW8KUPxpfP9Tb8D7n9KbYL31/ifUxgaAi0vrKuN+/JruCWN+7dlHVcf/S5e/XGXcD9ypJ7RvWdNJWO5fqA/Q80ZnkvKhq6/Fje2V7g0LWF3VSSh6n6tTJy2p2PvcKoDD5UmSDPrAQDdkwd6KzgRo4+H6/7ceUxlefcUlt2RLAy2p6A1/CdYqrdo6rzsjn9uq1Cb9O6fq5+TWKxdUxt9bqZPK3TXlD60S1coi+utKafFy/dxsPaLzC7/Zr4/BvdsyJyT12bpvVWVcy/J1ne+Q80/Ux4OLOoU1GCzpTvbNdZ3PKgBUb7qN6k23i8YoPlT94bf+9wAgLhWn+gcfZA2p+OJ7nhtd1pIKAFhako+95ufrL99fe/ZRcbHoOz/JaEmFRVoqrExYpKXiQ1dfO7qsIRWffOni6LKWVFikpcLKhEVaKgZOFZWGVLjphLRUWJmwSEuFKxMak08rExpSMeesCiQtFT2vAVZaKlyZqBTek3Nbeq+rlQmLtFRYmRgHO5+n0Luysji6LC0VViYs0lJhZUILVyZOPSs7v1m+PhjJxMWPTu8v8SFcmag25A8IrkxsXRDu/RiKhJ3P5yJ6mJKSClcmLG+9/wkxsXBlwiIpFX46oSEVLppphaRU2HTCRSupsEhJhSsTlhvbK2Ji4cqERVIqbDrhIiUVvkxYpKRiEJibSEpFqNRJK6mwSEnFuJOJWUkqfJmQJpRMSEqFKxOj8YW+rX2ZsEhJRUgmtFMKKamoVhYPyYRFSip8mZAmJBOSKYVmMqGVSlhsOmGRTClCyYSUVJjrC8FkQkoqSlMJF/HfszTLnwDdEigJqWgqdZKSCptO+GhLRalYhGTCIiEVfjrholX+ZCmVipBMWCSkIiQTFu2eilKpCMnE6G8Cx+u2vgkJqfDTCUmaZEJq4tkkD1JSMddwzgLNngqJlKKtzElCKkIyMRq/8LVtkgkp2pKJaZeKkEhI0iYTEilFWzJRKhVb961ORCakUgpfJg7GLx9bs8xJs8QJkJUJQEgo/JikRCpC6YQkoXTCZZrLn5pkwlIqFf2ODjTNEqgSqWiTCUuJVITSCZ9cqWiTCUuJVLTJhKVEKprSCZdcqWiTidE2BXOUmCbsEqnokomSlKIrmSideHZJQ6lUNMmEpUQqutKJEqmI6ZkokYo2mRiNn/naxshESUoRU+Y0rVIRIxMlKUVMMlEiFZplTl0iUVr21JVMlEpFk0xI0CUTGqVPLiUphS8TpeVOgOIqT9PYqN0lE5ZcqYhpxF5a2s0Siy6ZsORKRZdMWLSlIlUsYmTCkiMVMTJh0WzWzpGKGJmw5EhFjExYtBq1gTyp0F7RKTaZyJGK2DKn3IlnrCzkSkWXTFhypCK21En7/Bc5UhEjE7mkJBM5UpHSMzFtTdopyUSOVKSUOaVKhdkfTFQmLLlSEVvmlCMV55+oomQiN6WITSZypUK7AVsD1SUqUqUiJZ2Q7KkIkSoVqas6afZVpEpFrExYUqWirdwphGZfRYpUpMiEJUUqYtIJl9XVLdVm7RSpSJEJS4pUxKQTh7ZPOGanykRqSpFa5qS18hOQLhWpkpC6faxM5JDaN5EqFakrOqVIRapMpLyuOWVOKVIxzgbsGFJSipwypxSp0OyZSBWJ1LKn1BKnVKnQ7JlITSVSpUK7zClFJlJTCi2ZAASFoikuiZWK3FKnWKmITSdcNMufgHipiE0nXDRWgHKJlYpUmbBMi1TkECMVqTLhEiMVKemES4xU5MiEJUYqUmUihdxkIlYqcnsmYqUipwk7dvKZmzjE3i5HJmJTitwm7FipyF0eVmP1p9HYEbtU0jMRIxW5MjENpU+T7JkoJTeViJUK7X6JHJmITSk0S5yAPJmITSlyU4lYqWiSCYlyJ2BMJ7ab9LkqcmTCcnFpvVMsSs45MekVoFLTCZdJLyubUu7kM2/2W8UiJ51waZOKEpmwtElFrkxY2qSiRCai7rvgO3jS56gobcDukoqSFZ26Jp+lPRFdty9JJrqkonRFpy6pGMe5JnLRPjFdm1SUJhOTlIpSmWhLKfaW+0Uy0VX2NM5lYVPpSinGvZJTCl0pxWBpUJRMdEnFtJ9jIoaxnim7SSokGrEndQI8iRPYtUlFTjrh0yQVJTJhaVsBKjedcJmVZWVDTOIEeKUyYdFc/akppZBIJtqkQqJvokkqNFdzAmSWh22afEqt2tQ0jkSZk/bZtJukQkIm2lIKib6JptdVc0UnqTKnSfRTaCYTk1gWNpWmlEJqJacmqZCQibaUQiKZaJKKWThhXVNKMQ6RsIgKRUxsop1U+GJRkk74aK8A5YuFhExYxn1mbQmZsISkoiSd8PGlojSdcPGlQiKdcHGlQkommpBMJ3ypkCxzCkmFZBO2LxWSMhFKKSTPNaH9i7aPZM9ESCokzzfhS4VkMhGSCskmbP91lZQJrTNpWzSlwk8pJGXCTykkZSKUUkgmE75UzNKZr32piG2+zkVSJvyUIrVfIvn+ImRCqtwJGHNCYXGlQmOZ2HE1a0ukEz7jataWSCd8xrWsrKRMWGY5qdDCTSk0Sp3GtfKTxopOmie+c6VC48R17uRT+kR17ngaDdiuVGievE6jzMmVimlZ0SkWVyqmrQk7lllLJlypmIaVnFJwU4ppar6OwU0pZu0cE25KMc5kwmKqKvkFab3Ba97/w0mDfeerfyv1/qN5YeeM2tgA8P8+q7c8y/6+nut94cWruLi0oTb+15/9uNrYj8xdx4fvvlpt/A9eeb3a2E99+j6cvqjzvG9+4qzKuAAwmNdtclu8rvde7++oDQ0A2LpX77m55w+Umwvn9KRocV23RGl3Re89s7uqu6Ts/Ibe66q976tX9V7X+Y09lXF3zsxh9TN6k6vti3q/7i89/bKqTNx91QW1sZcub2DjMb052N6y3nv9ylfqljj1tvWOX4uflzbHiEgoop9o8UeVEp9oygQAfOTqI2pj/5tf/lJs/aHOJO4Lzr+EV194UUHH1rsAACAASURBVGVsy4tbOjXy337PR3C+rycrAPDVK59UGfdDL74W8z3diZAGt19cw+49Ol/GADBYrDBY1JkEDRYqbN6veGZkxWqN/UVgfl3nS+38ExUqxR+Cqz5g0n9MisIMKuys6n1hLtzaw+oLOqZYGWDurt6Ef+nGAP1dnfHntiq1X4PPfGYHZz6jZ+eb52cz9dg7t4z+rs5zvvT0yyrjWrYevVct5Vu6rDsH6G8PsHhT53vjpS8ymLut936cv6k39mNveBYPn78Rvb1kuRMwoZKncfCvnq3Lqj5y9RFxsfg3v/ylo8taUgEAr77worhYfOHFq6PLWlIBQEUqHpm7PrqsJRUAVKTiqU/X5XG3X9R7zjWkYm/t4MtSWioGCwfjzZpU7DvVE9JS4cb4GlLhjiktFWZwMJ6GVCzcOniPS0tF5byMGlKxdEPvV0+3hEpaKlyRmLsj/zm1MnH7YfmSpJ0zdZ3ZnUdPi4+9d25ZfEyLKxNVX/5ztPXoveJjWlyZWHvylujY/e0B+ornsnnpi5ySTWGpmL/ZH8lEf1P+h6jH3vCs+JipqAhFjPVophNWJlw00wpJqfiC8y8duU4zrZCUim+/5yOH/n2+vyEmFq5MWCSl4kMvyjVi+1iZsMyKVLgyYZGSClcmLLMiFfuBeY9WUgHISkVoLCmpcGXCIikVrkxIUwVePkmp8GVCMqUI9WNISUUolZCUCs1kwsqERUMqLJIpRSiZkJKKrUfvPSITkimFZjIREgnJlMKVCWlCqYSUVDz2hmePyERMSiGdTgDHOKEIISEVbjrhsvWHZ9XTilLcdMJFQip8mXDRLoEqJSQT87191fInKakIjaNZ/gTIJxUu0y4VIZmwSEhFU5OhhFS0jVEqFSGZsEhIRZNMSKQUIZmwSEhFUzIhIRWazd2aJU5AWCakUgpfJiTZO7ccTCe0Sp+kaEslJKSiSSYkUgrtVKJJJiRSCu0Sp2lCTSja7Gfc6YSLRgmUS4lUhNIJlxKpaJIJy4tba6olUCWE0glLaUrRlUyUSoWfTriUSkXb7adZKkLphMu0S0UbJVLRtWJJiVRo9mPEUCIVXclEiVS0yYQEXWVOJVLRJRMlKcUkZMJSKhVtMlGaUnSVOZVKRVvfhEbpkwRLlzc6k4kSqeiSiZKUQjuV6JKJkpSiSybaUgqNdAI4YQmFS45UNKUTPrPWV1FKWzph0Uwpvnrlk1PZU9EmE5ZcqYi53e49e9liESp38jlpSUVbOuGSIxWxyx/miEHsbXJTirZ0wiVHKmLLnHKkIlYmclOK2J6JHKmYdDKRW/a0eb4fVeaUKxUxyUSuVGj3TGg2Ycf0TGguw5zDOPsl2shJKbRTiWlLJixjFwrtlZ1S0E4qUsSiK50ooSudcJm2Ru22dMInVSpS+iZSpSJGJiyaPRVAeloRIxOWVKnoSidcpkkqYmXCkiIVqWupp0hFqoCkSkWsTFhSpCK1ZyJFKlKTiVSpGFcDdhepKUVKMpEqFdorOaWUOaVKRYpMpKYUKSKRk1KMqwG7C+kGbZeUlKKtxEmCaSpxSlnxSQLx81C4+Oek0JaJrnKnLr780tONf4tNJ0Isvab9RGwlMvHJa+1nXk6RiRBt56uISSbaeHm/fSKdIhM+XeeqKGnC3u04rXOKTIRoO1dFqXzMX2//0k2RCZ/edvtBOkUmfJZf0DtId52rIlUmfHZPhR+3xEmZ2s7HWFrmVJnm1zNVJHwW7jS/zySar+/cHzbG0hKnrhMalojE/nz72CWpxOY97RPRkhKnvdX2N1qpSJz+3Hbj30p7JbrOT1GSSuzPtz/nJYlE17kpSiWi7Rw1pY3XXeemKEklts+2v9dKRGLvdPPBtlQi9pebP9sSacTnXj58xvjEkqfJnYfCRatOK0SpTLRRIhOAbsO2dgnUpBKLEpkA2tOK0hWd2tKKUpkAJrcKVIlMAO1pRYlMAJNLK0plApjMClASPRNNaUWpTADNScW4V3JKpS2pKE0l2kqfSkuc2pKK0n6JtqRinKs45dCWVJSWOLUlFaXlTW1JxbQkEqloljhJpBKa56Zo6qXQKG3SnJerlzyNUypKmUTDtlSpU0gqStMJS0gqStMJi3ZvhRaTWAVKSjRCUlEqE5aQVJTKhGWaSqBSGadUSDZg+1IhIRMWXyqmXSbakCpxCkmFVL9ESCqkmq9DUiElE6F+ikms4iTFpHslYgj1U0jJRKj0SUokQqVPk268zmXWZAIYYw/FJFd2SsWVitJ0wmfal5ZtQjupcMWiNJ1w8Ru2pc834UqFRDrh4gqEdGrhSoWUTFiOS7O2RDrh4kqFRLmTi+YqTlYqJGXCR1om3H4KaZnwU4pp6ZdIRXolJ1cqpJMJVyqkZcJNKaRFwk0ppBuv3ZQidH4JScZ9fgkppGXCTSmkRcJNKaRlYly9FGMRillKKSzjaNjWaMS2JVBS6YSLXVpWKp3wOd/fEJUJl2lcBSqGWTkJno+VCql0wmUcUiEtE5b5dSMuE5aqrycWWjKxs9pTSyZWX9hRSyasVGjIhE0pNGTCphSay8JOe5lTE7OYSlT9nppI9PaqqCVhc1h78pZaidPizf0T1Xgdyzjm4WNLKH7+8uvVxv6GBz+hMu5Hrj7S2VBdwhMv3K829gPLeisqfGanvRG8hB997pvVxv7Hn/kytbGfuXaue6NM1p9pb2IrQbMUR+pMoCH2VvR+ud3RO6Eu+lt6Y++uGuyu6jznRunpXr6+j/1FzYZ7vffJ2mU9Id8+q/fZ2V/U/Mzryf7uqp5M7N6zojb24ot31Ma++eZLamPPrSuei6Sv9x588Y3zamPvnd1Xk4m9B3bUZGJjR+kXMo+xCcVvfP17VaTi7qD+SVFDKu7u1G9MDakwr6wPMhpS8dBKvb8aUvEtF/4AgI5U/J3LfxyAjlS87ePfAQC4uiH/i/9TV+tfiOZPN69GkovZ7B/6vyQrT9fvb40VlOZv1oeW+Vvyhxg7poZU7C8N/694/L178cSe/mesbN6rN7FYulFPnOfuyv/CevdC/f64c5/8+2Tjgfqz/vIXyr/Bq+Hurl2Wn4guX6+fb6PgcDYhq3ryk9y5G5v12Cvyz7eVic0L8u9zKxODFYXP0FAmlhWSDysTGj+U7Z2t34O75+Wlee+B+vn+1Odky6aBWiZ+4+vfKz5uCD3lb8BKxX/y4MfEx7ZS8UuXv1B8bCsVGj0QViped/8L4mNbqXh+U/5XbisVjy7I925Yqfihhz4oPvbVjTVcWtOpCZ0/vY3d2zqzUbPZR7Ws8wvg8gt9tVKi+Vs97J7RqZPdW6kwd1fn1679RaAv6IhuOnH3Yg8rL8o9J1rJBACY4W6aSq+5eX+xj/623PvPlYn+ToX9BbkdtzKhgZUJDaxMaFApOrKVCQ00FwKwMiENU4mjaKcSamM/oPd8jyuVcBnrT2WuJc1iCRQgk1bYdMJHIq2w6YSPRFph0wkfibTCphM+EmmFTSdcrm6siaQVNp1wmT+9LZJWhFIJs9kXSStsOuGy/EJfJK2w6cSh64SSitA4UkmFTScOXSd0TNYudWr7dwnGcx7J0id/ojgLpU8hmZBKKUIyIZVShGRCIqWoemGZkEgplq/vB2VCIqVYuLUXlAmJlGLuxmZQJiRSiiaZkEgpmmRCJKVokAmJlKJJJiRSiuMgE+NKJ4AJnCnb5ecvv75ILGy5U4hSqbDlTiHYV3GUWe2r0CiBsmiUQFlKpCIkEy4lUhGSidHfbvWKxKLttqVSEZIJKZpkQqL0qUkeJKTCl4nR9QJz86ZfnSWkoqnUSbOfolQq2pKJEqnYeKDfmkyUSEVXKlEiFUwljsJk4iiTSiZKy57aZKKk7GljZ3EiyYRl7EIRsiWttOIbHvyEWlqx9JqbamLxxAv3q4nFA8u3ssSiKZ1wyZWKpnTCJVcqQumET65UhNIJn1ypiBEGjb4Ki+aZqaeNLpkoSSm6kokSqeiShhKpaJKJ0d8L5uZdk8USqejqmyiRiq5SJ41+imll0iVOuSlFjEzkphQxMpGbUsTIRG5KESMTWSlF36jJxItvnFeTib2z+2rJxN4DO2rJREgkxplOABNKKJqkQlMstEiViqZypxCpUtFU7hRCK634zM5FtbTipCQVKaKQKhVd6UQJbenEoe0yUoqY22iu/DRtTdqxspAjFV0yMdou4+mO/eU5RyrG0YStQUzfRE5KEdszodGgbUlNKVKSiVSpYDJxmLn1Hb1kIkEkUsueUkQitexpFkucmlKJccsEMOGSpxCxUtFW7hQiJa1oK3cKoZ1WaDENJVAx6YTLjz73zdFiEZNOuKT0VcSkEy6a5U9apKQUsTIx2j5BKlK23VupksQipdQpVSpS+iY0V35KkYpYmRhtnyAVmmUsKTKRmlKkyERKSnH3Qi+pCTtFKlIbsFOkQiudmKYyp9iUoqlfonXsyJTi5psvJctEbErBEqfD5KQSsWVPOalEbNnTJMubQkxMKNrs6SQ3bIeIKYFKSSdcYkqgYsqdQhzXvopUmbDESEVOGVPsbXLSCc3SpxhRyO25iJGKnL6JWKnIacKOlYqc1CHmNqkyMbpdxPw8Z7IYm1LkJBOxUpGTTMRIRe5qTjFSMW2rOWksI2uJSSlyk4kuqZjFVALIl4nOsqeCEqeulEK7xEmLSa3iNIl0AphwQtElFbPaW9FESrlTiFlMK9pKoFLTCZ82qUhNJ8aFVlLRJRUlpU5dUpGaThy6rcJ5KixtUlHShN0lFSUrOnVJRUlfhObSsm2U/PLcJRUlZU5dUlFS5tQmFdO6NGxXSlGSTHRJhVY6oVnmVEJbSlEqE00pxbSUOKVSKhJtZU+z2isxjTIBTGHJk8+4eytSy51CzHLDtk9uOjEutJKKppQiN51waZKK0iZrqSVlQzRJRYlMjMZokAoJ2dDqq2iSConlYZukQkIImsbITSdGt294miUmik1SIdEz0SQVWj0TEjLRlFJIJBNNUqFZ5lT6HmlKKSRkoimlmMVzTEgQTClOcON1qOxpUiIxDUxcKGJt6rilFZLkljuF0EwqtPClQiqdmKZG7RR8qZBqxB5n+ZNkcuFLhdQSseNs1B7HieuKx9HriT8iFbPQgO2nFJLJhC8V01bmFMJPKaapZyIFKZnwU4ppLHPqRFAmNM6cHWJWU4kYJplOAFMgFECaVPz85dcnN2THoC0VpeVOPrNa/mQpLXfy0UwqrFhIpBMurlRIJwvjSCok0gmXcZQ/SZ9vwpUK6ZPXaTVqu3IiJROj8Ryp0JowSsuEm1JIJxNWKqa1zCmEm1LMSgO2m1JIy4RNKXIasGORlgm37GkWZMJHOpmwZU+aMiHNpz53X1IqMWmZAIC5Se/ANPEND34C/+qzXyQ+7tJrbmJ7W/4XNSsVD32+fBLywPItvGntGfFxtZOKz948rzK2Vloxf3obe1dXVMY2m30sX5WfESy/0Mfm/ToHZm2pMAP5L8H9RWBBacG0uxd7mL8j/9P/7qrBwrpOpGAqYOll+ffH/mIfO6d03h/9nQrzd3TOI6ElE3fu64mc2bkJDZlYu7yD/SWdHzvMHjB/RyeZ0BKJamURt157VmVsLZEYrMyjt63zPE/qRHVF4yo2Xs8apqqSv1TUgu2v+NAPRm33/JVzAIDveONHRO//X3zqTQCA+Xn5D8t7XvfzAIAf/P++VXTc3c36A/gtj8v3OvzSp78QAPDuN/yi6Lh/+w++AQDw+P0viI4LAE9evwAAmOvLHjwW5urxrt9aFR0XAObm6onM1mVZaVm4VU82+lvyk47d0/VhwOzKjnv2yfr/Nx+THRcAquF3VW9b9vk49Uz9XGyflX+e+8MQq7cne9jdvLfe1zOflZ9Eb95bz0TPfUr2zbF9tp6Imn35r6D+bj1mT/hs2nsr9XOhIRWbl+rXcOma7Li94XNx5jPyE6W7l+oP4eIt2ffd3GZ9fDYD+ffGzun6d9fVz94WHffuw6cBALtr8u+NxRv1HGbhhmxp7WC5fi7mbgrHsQCqufp5+Nw3nhEd99yT9Xvt+a+RP9Zd/PX6mHTta2U/K0tP1anE+a+8ErW9cjoR/cU2FSVPltQn5R//7per7Mfu7hx2d3XCm/e+6f0q4/7Cx78Iv/Bx+XQFAH7s979RZdyPK5Zt7e3r/Ap2zxnZ0jUrEwCw9KBODen+kuyXrJUJ4GCSLo0VCync/Rws6vwmsnhTdtz+GE5dcuuVsl8BViY0qYRLLaxMSGNlAgBWrslOZqxMSNNznotbj8qWFluZkMbKBJB/lusmrExIY2VCAysT0liZkKaa641kQhorE9Jc/PX+SCaksTIRyzSUOlmmSiiAPKnQFAsN3vum96uKhQQ2nbBoSoWUWNh0wqIpFdJiYZGSCptOWKSlwkVKKnyJkJYKFympsOmERUoqfJkYzMlNlGw6YZGSCl8mbrxKbgJp0wmLlFT4MjFYkBnXlQlpfJnYutCwYSI9JbECjsrE9hmZ58eVCUl2Ts+NTSbmN2QmvYs39sYmE3tnZZrRNEVCUyY0WHpqcaZlApiykieXtvInW/LURG4plC15aiK3FMqWOzWRWwZly53ayC2F8oXCJ7cMypY7NZFbBuXLRIjcMihb7tREbhmUm06EyC2B8mUiRG4ZlJtOhMgtgeqSh9wSqBjZyS2B8mXCJ7cEqiuZyC1/8kXCp6T8qSuZyC1/8kXCJ7f8qSuVyC19ihGJ3PKnrlQit/SpSyRyS59iEonc0qcukcgtfeqSiNyyp5hEIrf0qUsicsueuhKJ3LKnGInILXvqkojcsqcuicgteeoSiLaSpzHKxGyWPLmUPFmzVgo1C4mFzywkFj45iUWXTADyZVCWpQc3pqoMqksmgLy0IiaJmLa0oksmgLy0IqbMKSet6JIJID+piClzykkrumQCyEsqYkqccpKKcaYSIXKSiphUIqf0SbO8STOV6OLOK9NLlbTKm8aZSEgxa4nENJU2uUxbMmGZWqEAyqViFkuhNEjtr+hKJyw/9vvfmCQWXemEyzRJRQypUtGVTrikSEVMOmHRKoOalr6KlP1IkYoYmbCkSEVKz4RkCZRLqlRo9UzEyIQlRSpS+iVSpCJFJlL7KcbRLyFJikyklD6liERqL8Ws9UqkiMTOufiJ62B5LlomUsqeZrVPQoOc0iaXaZUJYMqFQgItsWBaccCkm7Zjyp1c9vb7KmIxC70VPrFSEZNOuMRO5lMlIXb7HKmJkYoUmbBIN2tbYqUiJp1wiZWKVJmITSlSZCKFnObrGKnISSZipSJVJmJTilSZiE0pxtF4LYlWr8Tdh08ny0RsLwVTiZpZSyVKRWIWmHqhkLIxphU1WqtBpaYVsUyyBCqm3ClEl1SkpBMuXVKRkk64dElFqkxYpiWpSGFSK0DlrujUJRWpMmHpkorcZKJLKnJloiulGMdKTtJMWzLRJRW5MtGVUuTKRFdKkSsSXWVPs1bilJJKpMBU4gApkZjmdAKYAaEAZKVi3GlFV0N2G0wrDjjuJVCxTDqpSKVNKkrEoO22WiKTk064NElF6fKwTVKRKxOWJqkoLXNqkorSZKJJKkplQmrlJ5+2lKJEJtpSimkoc0phkv0SOUxDiVMKTCVqZiGVmHaZAGZEKADZJ/M4pBUxKzx1EZKK2P6JNkJSkdI/0URIKlLLnUKEpCI3nXAJSUVuOuESkorcdMIlJBW56YRLaIIvkTKExpCQiVBKUSoTTWida6JUJrSRXFLWRfocFZaQVEikEyGpkEgmQlIhIROhlEJCJkIphYRMhFIKCZkIpRQSMhEqe5KQiVAfhYRMhPooJGTi4V+8deS6k5pKALMhE8AMCQUgLxXsrWAJlGXW+iq0VoDaX6pU0opqXic50Cp/mpWT31nG1aQ9DU3YKcxaqZNGmVNvt1JJJu5emldJJrRWcpqmfokYWOJUc5JTCWB2ZAKYMaEA5J/cWRQLDVgCVcMSqJr9pUoknfCp5uUl4OyT9X/SwmKlQjqdsFIhnU5YqZBOJ6xUSMuETSmkZcKmFNIyYVMKaZlYuTbA5iUjLhNbF3RKnG49usASpyEscaqZpV6JWREJYLZkAphBodBCqwxKA0pFDaWiRqLciYRhUlHDZKJGswn7pEOZqKFM1GjJhAbHffWmWGby6Dh/Of1EOzFs3ZJ/U7zzd74V7/ydvDNht7FyOu8slV3sXI9fWzqF7ZeXVcZdf1bnoJ579utJsPf5Ou+F3TM6X/B37teZ9C5foVht3aMz7tJ1nfrlvUW+ZjurOl/Dq8/qSNWp53QmvLNE6nkuosfVme9mn1G+i7kbmyrj7iac4yKWm5+v8znbukfnvbC/rPOaaTKTQvHku9+B+csLKmKxdWtRTSykWTm9pSIWO9eXVMSCUgEMBgaDgfwBiFJRIy0VvR1g/RHRIUfMbSqtrCU8KTn9dC0T0lKxcEvn8c9vDGAU5rwrlzex9sxd0TEpEzVVz2DjAdnv872VPvZW5GfolIlaJDRkYvfs0szIxNY9RkUm9pcr7C9XePLd7xAfW5uZFAoAoyebaYWuWEiz/fKyilisP3taRSwkpeLG+srospZUaIiFpFQs3Dh43JJSsXX+YCyNpGIWpMJNJ7QmJ1K4MiGZUrir5EhKxcpl+cmTKxOnPiv3PnBlwgj+HqAhE1XPqEzQXZEwgh6ssa9VX+fzavYrNZmQRlMktGRCA5tKzKJMADMsFMBhqTjpaQWgUwZ1EtOKza3DDYfXb62qpRUaSEjF9oXDM5FpTipcmbBISEVv5/C/p1kqtEqdbDphmebSp9gzDafiy4REShFKJiSkYlzJxNINnSVdJdBKJfz9HcyX7z9TCZ3yJmA2UwlgdmUCmHGhAA4/+ZpiIQ3TCt20QoNplIqd7fBqK9OYVLjphMs0lj/5MmGZZqnwKZ2s+DJhKZUKjVKnJpkoTSmakokSqRh3mVNpSqGVTIQoLXs66SVOTCVmK5VwRQKYbZkAAFNVyW++qewUeezHfvLIdbsPNswKGqj2ut8wS2fS1nrc3497E/74l6St3PRDH/vPOre5ezv9w1rd7T7KLdyTPlndudG+L4vn0w9YO1dXOrc59Xm3k8f1EwqfnNWa3HKnJnq99I9Wk1BY5j6d/h7w04kQ87fSvw2bhMKy+kL64w+lEz6b96WP2yQUllNPJw8Zxd5y+pdWVzqRM6FskonD95v+pd0lE3Pb6a9VTDJRZSxw01XmtPGK7s+0T4xMrL8y/T3QlUzkTF5jRGLrXPrAXRP0tefTvreBOJGoMuaYXfuasyxvzGvR30qX9i6R6O+mjxkjEtV8+nsgRiS27klbmjhGItaey/iOiRCJ3bW0MUMN11MsE9EHpJlPKCyhF+Okl0ExrdBJK7RWgDrOzdpdMgFMT1LRJRPA9CQVMaVO09JPEZNMpJY+javMKURqSjHJBuxUqdRsvpZGI5UA9PolpGEqMXvlTT5TLBNJHBuhAJqlYpJlUP1+/Ad9lpaYnaXeihSp6EonLNPQV9GVTlimRSpiSJGKmHTCMkuN2rGk9E2kTGRi0gkgrfQppcxJYynZlNIn7QbsLlJ6KTR6JiYtEyllT+Pql2gipY9CSyakmaVeiVkub7IcF5kAjplQAM0vjoZYMK3QSyukmYVVoCyTXAEqptzJZdJSkUKMVMSkEy4aUjHJ5WRjZcISIxWay8OmECMVqTIRk1LM0tKwqTIR05w9jpWcpJi1VZykYSohn0o0iQRwvGQCOIZCAbS/SG1iYebyPqAaYnHS04rjVAIV0z/hM0vnq+iSiphyJ58uqUhJJ1xmJanokgqNVZ1SZcKisfJTV0qhUeo06WTCpSulyJGJrrKncTZfl5B7fomu5WNPconTSU8lSkSiqX+iTSSA4ycTwDEVCqD7xZqV/goNsWBaoSMV40wrYsudQkzjClAhxp1UpKYTLuOUihKZGHc/RUk60SQVJTLRlFKUyERTSnGck4kYSiboTWVPky5xShqXqYTomNMmEm10neX6OMoEcIyFAoiTillaZlaak5xWsATq6GufWu7kE5KKnHTCJSQVuemEy3FJKnIITXRy0wlLKKUY5/KwJUxTMuESSilKZSKUUpTKRKjsiSVOsmMylZjtPgmX4yoTwDEXCiDuxZuV/gqmFbOTVkhzXMqfcrhzv1FJK1ypKEknXLSlQqrUyZ3wlMqExZUKKZlwUwopmXBTCimZcFMKjWRi9dnqRCQTTcySTEjDVGL6U4kYkQCOt0wAx+g8FDGEzlURYufSrvh9z68JzVgcFhYUJm9XdJZE1VBXsyv8hTAwmLtUfhZcl91bi1g8Jztx3355Gf1Tsu/R/fV58U92/04PS9dkX3izD/SE50B3Hhpg7q7se0njPBUbD8lPgM58Wv4X/8Gcgvxdlz/WLV+VnVTdemwV+wJnT3ZZvbqH9QczTqLRwv6iwZmnZY8fdy7NiX8ud9eAU8/Jvu57y72sc0e0cedSD2svyO7n3B359/vii+nnT4ph54L8nOHKl8lXeczJOxS2LsS9l2ZcJE7eeShiiH1Rl55bwNJzsonFuQ+u4twHZT94u0+cxu4Tsr+wrzw3h5XnZL/AAMBsy7/V5m/Kj7kXcbK8VLY7TuqXw/56fg9FIwotC1sXNCas4kNib0V2kiGdVNx6FbAvvI8aMjG3VWFBuCxp42GDa2+UfdEXb+xgsCD3c/Ktx+QnVatX5dODfYUlee9ckv9App4oLIa9ZfnvizuX5MfcOSU/5u1H5Eu7r/7Rc7j6R8+JjnnnvnncuU/2u62ayzuxZRt3769w9/4TIRNJnCihAOJe3MF8/UY56WIhzUmXCmmxmGap6N85eF2kpMKt/5aSijsP6ZwYDdApf5KSCi2ZsEhJxcbD8hPgxRvyabGlL/TrtysTpy7LiIUrE7cekTl2zIJM7C33KBPCUCTikvKTJBPACSt58mkrgeoFymm2Hir7YduABgAAIABJREFUIrr4b49+YG58c34MaZ48Kibzr7udPR4AVB89c+S6uw+Vf6GZ3cMHymqxfMKxcO3gF8bdswITGK9PQaL8adfro5Eof/J7SUrLn4JiUvgpd4XCUlr+FGooLS2z8IVCuvQJKC9/uvWqo9f1C/dTWihcmbDsrJW93iGZuPC7ZS94SCZ6O2XlJX46UVr2FEomSsueQslEadlTSCZKPo8hkZAoefJlQqLkyZcJiZInVyZWrpSXpPkiceHf3ygeMyQS5z5VNi8KicT6w/nHjpBEzK9nDwcAwTSi7b1+zESCJU8xpL7oWolFLtVjR2VkVsqgpNOK+Zs98bRi7+qKeFrB8qc8mtbQL0kqQumEdOkTUJZUhGQCKEsqNNKJECUpRVMyUVL6pJFMhEqdSlKKpjKnkpRiVsqcNJBOJu5c6oknEzuneuLJhHQqMc7yJmmZKCGltMlyzGQiiRMtFEDzi2/LnkJIi8U0lUGZN99q/JuGVGiIhTQaUpErFk0rXZ0EqWhCuqdi2qSiiRyp0C518smRinGXOeX2Ukj3TbBn4ijrD+W9NhplTrNQ4nT7kQUVmWgiJ52YhfKmLpFoSidOskwAFAoA+W+CVKl48avaY0wtsZDkJKcV0hzXnopQuZM2qVLR1TsxDVLRlE5ME20yoUVqSjGuZMIlNaXQkIkucvooZqVnQhqmEjJMQiRSy51SEwnLSZcJgEIxIvRmaEspLJNu3A6VPfnMQtP2LKQVs1ACtb8+Ly8Wwj9ypqYUTeVO2kyDVHSRklKMo28iREpKIZ1OxMpESkqhsaJTDKllT9LphLRM7K5Nv0xolThJMu5UIofYVCK23GmSKzeF0gnKRA2FQohYsehKKVympQyqCaYVMkyyryJaPhSkQrr8KTalSFnZaVJSkZJOxEjFuPommoiRihSZiEkpJpFMuMSmFNLpxP6imZhMxH4GZ2FZWKYS5WiVN8USk07k9EmQMCd6lacm/NWfQis+ddG2IlRotacu2laDCq321EXXalCh1Z66aFsNyl/lKYaulaDcVZ5i6FwJKuNs1F0rQfmrPHXRtQpU6tnCu1aASk4zOj79OeVOXas/pSYUXSvNpC4VO+6Vn3JLndpWfppUOuHStupTbjLRtupTjlB0rfiUmk50rfiUKhNdqz3liETXak+pyUTX5y9VJrpWekoVia5VnnJEomuVp1SR6FrlKUck2lZ5ypGIrv6JHJFoSyhyEok2ociRCP+9fUKSCa7yVILEm2ScjdsxZU8+J7EM6iSmFSrlT2MsgcopdzqpTdpNTINMAHLnpohh0ulEDDnJRFvZk0YqoVHmJMlJSyWOU3mTT5NMjLvhOpYTIhNJUCgacN8sMb0UTYSkIqXsyUe6cfuklkEF6eW9zrMgFcetr6KLJqnIPZGdhlSEKGnElj6T9rgo6ZuQPoN2Uy9Frkw0lT1plDlJclL7JXJoSidY3lRGqUiE0okSkXDTCcpEGApFC1Jvmmk7f0UIXyzalo+NwReLar5swhhKK3Yu5HfrSqcV0g3bM3Fm7RmVilykpWIcS8lOSzph8VOKWTgT9jQkE23MgkxIIr0krHTjdWkq4Zc7SaQSbrmThEi45U6T7pOIQbJPgjLRDIWigyff/Q48+e53FKUUFlcqSlIKiysVOWVP42Bm04pMZiGtEEVRKiRWd3KlIjedcNGUCullYqdNJizSpU9uSiEhE25KISETbkohIRNu2dNJlAlJZmEFJ0mky5ukcMudJGTCTSckRKK3dzAXJM1QKCKRlAorFlJSMc0lUMDJ663QSCsksVIhJhfDOY3U+SeYVJQxK6VPk1oiNpaTkkzY81FIyYT9vE2zTExbKuFznHslmpDqlbAyIZVKWJkg3XCVp0Re/Z73iY53+tOyT+dN4V855zblvvQ3H9gH9mUnEfO3ZcfbPS37elRLwidRqBROXy1Ef0P294nlK7Ljbd4n/Iu94OpPyy8a3HlI7r13/mOy72ONE9i9/Nq8syCHWLpW4d6PbYqNt/4KWYlfeln2OHDzUdmkcW5T9vXdF3z6lq/L7tvmedlj6MKG7P7tLcnu3/LLA1F5Wrgt+3hvPyp7nN9dk92/T//AiZeJ6DckhSITKbGY26j/v3JV5mldH/7qt78kM97uuQGWn5f74peWiuUrPfFfjM3AYKdridlY+vW+lfaQjBAUCrNrUAmkbqPxtnvolYduIwaLFVafkXnvbXx+/euwVIqyeL0eZ39Z5vlbfrF+XaWk4vST9f+lREBSKHZX6udu/RGZ9/LStXrfpITi5dfWSzPP35F5zIN+/ThXrskkFC89Po+59tWqk9h4RYWzfyg3nqRMAHJCsf5Q/b6buysznqnk3iOWjQd7WBIUKGmZ2DljsPaszHfZnfvtMVRkuNE8oBJ6uBSJEVw2VptP/o23i45395LsrxL9LdlkYfMBwV/Y+tVooi3B3F0jfq6ABakSqKE8md1e1rk4jmCEvgx3zaH/F483LEEbCP1wOlisH+edV8j+sru/KptS9AUTPABYfU52POlfO0uxMiGFlQkprExIYWVCipcerz9ge0IVlRuvqJ+/m6+RGW8aZWL9oZ6KTEiy8WAPGw/KfTaWXx5g+WW5Y93OGYOdM3LvZSsTUkj/qEiZyINCUYCGVEiKRX/LHHuxcMtYpMSiGi4fu3CzJyMWTiIzTVIxGk5IKixSUmGhVJQxLVJBmSjDyoQUViakmFaZsEjIhKkODr8S6YQvEqXpxCyIhKRM7K1UlIkpgiVPQuSWQNmSJ5+SEqj1QLNjSQnU7rmjB6iSMqiglBSUQTXV2pccaEzgrNlFZVABcSoqgyoofWoSiNzyp6YG+dzyJ5tO+OSWP9lyJ5+S8idb8uRSUv5kS55cSsqfbMmTS0nZUmnJU0gmSkqeQjJRUvIUkomSCWOTTOSWPTXJRG7pU5NM5JY+ScsEUCYUrkhYSoQi9BtOyfujKY0oEYqQSJSUO4VEoqTcKSQSJeVOTd/vuSVPFIlGWPI0bmahBOq4pxU+GmVQ2YlFQJiKyqAyUwrpNKKN45pUhGQC0EkqJNOKvSUz9rRid6UnmkwsXavGlkzsruY9VyctmdAgVybc8iaXXJlwEwkpJEubgJOXSgAscZpWmFAokJpWNKUUltS0IpRQuKSmFaGEwic1seiUkcTEomtFoNQDUCih8MlKLFqkKSuxSEwquoQiNaXoWr43NaVoSidcUpOKpoTCkppUNAmFJTWpCKUTPqlpRSihcElNHHISii6RSE0oYkQiNaXoKnNK/RW6SyZSE4oYmUhNKbqEIjWlmIZSp5BEWHJkIkYiUt8bXSKRmk50SURqOhEjEakJRZdIpCYUXd/jqekERSIKrvI0LcTIRZdQuMTIRZdQ+MQIRoxUWGLkIjndiBCMlGVGYwQjRipcogQjIYWJFowIqUhNJmLEIuVcIDFiESMTLjFi0SUTLjFi0SUTPjFyESMUlhix6JIJnxhZiBWK1DQiRipSEokYoUjtlYiZOKakEjFSkZpKxEhFSjIRIxWTLHNqEwifGKFITSFi3hMpSUSMTKSmEDFCkZJExMhEahIRIxQpPwbGCAUlIhmWPB1XpBu3AdkVoYC4cqjkHgyFcqiukijbnB2LWBP3ELGVobLuu/25ST2xoHT5EzA9JVBtTHsZFCDXtK3RdD3tjdfA9Jc4AellTl2rPk1KJppKmnLJKWnqkgnpFZsAeZmQLmsCdFZuYmnTbEGhUOaTf+Pt4v0VXZz6XPqHULrHAhh/n0XOicu0lpxtFIuM5vNOsej4Rhxn30Qb45aKlHTCsr86mPpVoACdlaByxUK6TwKQX8EJ0FnFKUcm7l5oPh3wNMjENJIrEk3phFZvRI5ItKUT094fAeT3SEidfyIWyoQ+FIoxMe1LzFqapGL+Rv5bRVQqALUG7pBYpKYULo1ikbmilRWLoFxIfzu27UdiOuHSJBWp5U4u0kkFML6lZVPKnXykpQJITyukRQIok4mXXh+epUz7krBAmUw0nZeiRCakzk0RQyidsBKRm0iEZKJUJELphFYiISkSQFp5k09TuZN0KgEwmZhl2EMxAfy+ipQeiib83orUPgqfUF9FSh9FiFCZU7FsBCbnKb0UTfgHtNR+ihCHeiyEhOhQn0Wgl6I0nQj1UpQIBRDupygRCovfU5GTUPi4fRWp/RNNuH0VJULh4vZWpPZQhPB7JkI9FBIy4fZQSKUSbh+FlEi4E0kJmfD7KCSSiVAfRWk6Eeql0C53kippcoVC4vcWXyYkJCKUTpSKRKjcqTSVCAlFqUz4CYWERPg9FBQJEdhDMc1olEBN+zKzgEIJFKCSVgDyS84C3tm3C8674XIorfC+NSVKnfwxSmUCOJpSSMiEj4RMALPRVwGMtwTqpJY4AXLJRFvZUy5+SiFR6uSnFJoyIdkfIS0TPtKJBKCXSkxLiVMb0okEQJmYBEwoJsyr3/M+kYTCxaYVpSmFi00sSlMKF5tYiErGcKIukVJY7MFOIqWwjNIKQRkapRXDpEKyd8ImFRJCYbFJhaRQ2JRCSiiAg5RCKqGw7C9XYgmF5c5DlUhC4TK3VY0SCmmRWH/EiMvEvR/bFJcJ++u0ZKmTTSkk+yZsSiHZN2FTCm2ZkMLKhKRI2NdfUiRsOiEpETadkJQIm05ISoRNJ6RFoupRJBTgsrGzhIZUAMD+ovyYW/fL16trsHw5/0zeTWh8oe6cHagkLCqfUkGhGlHQo9JENSc/5srn5H9RBoCFdfkx+5vyj7+/Iz4kAGB3VX7MntIhqr8lP6ZGH9zWBfnX/9TT4kNib1n+sc/drVQSie2z8vt67kn5N+qNV8l/7xm532ZGbN+jcNynTGhBoZhFXvfOtBPidXHvx3Zw9c0LomP2hgeXu58ndzBc+8zwV+VHZQ+w/Ts9LNwUXsHpFrB5SXTIUfojXl4j+Eldulq/RlsXZPdx/rbBbs4JAltYutrH5oOy34Jmb5h8pS533IL9LM2lnYutk6XrA+yuCJdAKghFb7/C9mnZ/azm6vH623JvfvuLd9WT3df1Rwz6wq/94o0Kt14lO+bKC/LPqbRM2F/7pX/06W/LS9+l397GzlnZHyg2HqiPS7trcmPalrzUk5N2sX2+SpiixvHUD1IkFKFQzDJSYnHvxw5mAZJioSkVgJxYuA21kmKxcOvgspRcuE3wYmKhIBSAnFTM3z54TSSlwu6rpFRYoQDkpKLn7J6kVCxdP3gupcRCUih6+wdvTEmhsDIByE1+3Vp8SaGwzeiSQrF442BfpaTCygQwnULhNjVLyUR/++CypExc+u2DgaWEwooEMP0ysX3eef8IPa0UibFAoZh1JKTCFQqLhFj0vHmahFi4QmGREAv/7McSYuEKhUVCLPyVtUTEQuDT6sqERUIqXKEAZKQitK8SYuEKBSAjFf7nCJARC1coABmpkBIKVyYAGaFwRcIiMfn1lx2VEIrQmcElpMKVCUBGKFyZsEg8rxIy4a+OJCETrkhYJITCFQlARiZckbBICIW/UKCEUBwSCYuAUFAmxgaF4rhQKhYhqQDKxCI0EQLKxSIkFUCZWPhCYSkVi5BUAGViEVqqd/S3Erko/MSGJulAmVT4MmEplYqmfS2RCl8mLKVS0fQ5KpUKXygsJWJRKhS+SFhKhSIkE0D5xLfphGglUhGSCaBcKHyZsJRIRUgmgPLntUQm2k4AVyIUIZEAymXCFwlLiVCERAIol4nAiuMAyoQiKBJAsUxQJMYOheK4kSsWTUJhyRWLpskQkC8WTUJhyRWLJqmw5MpFk1QA+WLRJhVAgVhkfmqbJuiWXKloEgogXyq69jVXKpqEwpIrFm2foRKpaBIKIF8qSoSiSSaAMqFokgkgf+LbJBKj+8wUiiaZsORKRZNMAPlC0SQTltznNlcm2kQCyJeJJpEA8mWiSSIsuTLRJBKWXKFoEgkgXyYaRcKS+ZGnSEwMCsVxJVUsuoQCyJOKtsmQJUcsuqQCSBeLLqGwpIpFm1C4pMpFl1QAmWKR+MntmqBbUqWiTSYsOVIRs785UtElFECeVMR8hnLEok0oLKlikSMUbSJhyRGKNpGw5Ex6u2QCyBOKLpkA8oSiTSYsqVLRJROW1Oc3Rya6RAJIl4k2iXBJFYoukbCkCkWXSAB5MtEmEpYcoeiUCSBZKCgSE4dCcZxJkYoYobCkiEXMZMiSIhYxQmFJEYtYqQDSxCJWKoA0sYiRitG2KXKR8OmNFQogTSpihAJIl4rY/U2VihihANKlIvYzlCoVMUIBpElFqlDEyASQLhQxMgGkT3hjZAJIF4oYmQDShSJGJoA0oYiVCSDt+U2RiRiJsKTIRKxIAGkyESsSQJpMxIiEJUUoYkTCkiIUUSJhSdgHysRUwDNlH2ee+HH5M20DwKWPxs8aBgk/tKw8qyMJKfKRMuneORt/cNw5E70plq/Gb5tylvIUWZJers+ydE3+UDJ/s4f5mwpnpL08h+XL8ueVUDkTPIC95fo/aebvVpiPnEjH0tuvomUihWrORMtECnN3q2iZSGH9ERMtEyks3qiiZSKFFJlIgTJRQ5lIhzIxezChmHFi0oqUlMISk1akpBSWmLQiRRQsMSKSNPEeEpNWpKQULl2JRUpKceh2XfIUMWxKOuHSlVTEphM+MWlFzj7HpBWxCYVLTFqR8/mJSStiEwqXrrQiJqHIEYmYhCJHJGJ+Qc8RiZiEIkckYhKKXJHoSilyZSLmOe4SihSJcOkSihSJcIkRihSRsMQIRYpIWGKEIkUkLDFCkSUSEftCkZg6WPJ00mgTixyhsLSJRc6EyNImFjlC4dImFzlSYWmTi1ypANrFIlcqgA6x6Bg2VyiAdqnIFQqgXSpK9rdNKnJkwtIlFSWfnzaxyBEKS5NYtAlFSSLRJhQliUTXZLcklWiTipJUok0qSlKJNqEoSSa6nuM2mcgVCaBdJnJFAmiXiRyJsLTJRI5EuLQJRY5IWNqEoiiRaNknisTUQqE4qYTEokQoLE1iUTIpAprFolQqgLBYlAiFpUksSqQCaBaLEqkYjRGSi4ZhSybnlpBUlMiEpUkqSve5SSpKhMISEovSzw3QLBUlQgGEpaJJKErLm5qEQqK8KTThlShvahKK0hKnJqGQKHEKSYVEmVOTVIRkokQiLE0yUSISQLNMlIiEJSQUpSIBNMtEiUgAzTIhUtoU2DeKxNRDoTjpuGIhIRQWXywkJkbAUbGQEAqLLxYSUgEcFYtSoXDx5UJCKoCAWHjDSsiExZcKCaEAjkqF5D77YiEhFMBRqZD63ABHxaJUKCyuWPhCIdUn4QuFZJ+EP9mV6pXwhUKyV8KXCql+CV8oJHsm/OfZlwkJkQCOykSpRLj4QiEhEsBRmZAQCYsvFKUiYfGFQrRHwtlHisTMQKEgelIBHIiF5MTIYuVCUiqAA7GQEgoXKxeSUgEcFgspqRiNZ+ViOKzkxNxipUJKJiyuVEjvt5UKKZlwsWIh/bmxUiElEy67K2YkFBoN11YqpJuu7URXo+naSoV047UrFNLN11YqNBqw7XNtZUJKIiyuTEiKBHAgE1IS4WKFQlIkgAOZkJIIFysU4s3WlIlZhUJBDnjdO98nLhSWq29eUJEKoOwsnV1sXtJ5Gy/cNOJSYdl4hd5Hb39loCIUALC/qLff/W2d1Wk2H9xTEQqglgqtz8zac/JCAUBtdTAA2Dqvs9hgf1tnBSegFgqNVZwAYOV5vc/L7imdfa6fa5Wha5Tef3cvGRWRAICXX7uoMi4A7JzSGbe3q7dqEwxFYkahUJCjfNVb36sy7ktvWFD5pQQAll6usKP0Jbi3Auye0nk7rzxvVIRo/dF6wmj25Z+T+XWd53nrwkA8obDsL1dYUFhathpWKmzfI78M7IXfrvc392y8rVTA2mUFqVD6fG+f1lkO1n5LLd6Ufy5uP6q32np/Uz6ZsGxdMOhvqQytss+bF+r3xfJL8mPvLwBnn9L5ke3mYwsYzOt8YE4/s4eXHpdf8hoAti4O0N/U2e+n3kWRmGEoFKQbScF46Q1Hm7alJGPp5aNvOSnJ2Fs5ep2UZKw8f3QfpSTDioVFUjAkxUKrjwKoZcJFUiwq7ztbUiysUFhExcJ764rJheAuavZN+I9fUii0RcJFcoK+deHw8yspFZL7uentp5RI7AfWE5GSiZuPHR1cSiZOP3M0xpSSia2LRz8XkjJBgThWUChIPBJiERIKS6lYhITCIiEWx0UqLBJyISEVTcvHSkiFLxMWCanwZcIiJRW+UACCUhF4WkSkQmj3Qqs6iQlF4LFLCcU4ZcIiMVn3ZWJ0nwJSIbF/vkRYTrJMhETCUioUIZGwSAgFReJYQqEgeeTKRZtQANMtFSGhcCmVi5BUWErlokkqgHKxKJEKrRPcWZqEAiiXiiahAMqlIiQTLsVi0fJWLRKLwt3SOt9EPUD7n0ulYhIyAZRP2JtkYnTfBVJRum9NIgGUy0RIIiylMhGSCJdSoZiUTAD5QkGJOPZQKEg+WlIB5ItFm1C45MpFl1QA+WLRJhQuuXLRJhWWHLnIFYoumRiNnykVbTJhyZWKNplwyRWLLqEACqQi8u2ZJRaZuxRzJmygQCoiHnOuUGiKBKB7duwumRjtQ6ZU5OxXm0RYcmWiTSJccoWiSySAfJlokwiXXKHoEgmAMkFaoVCQclLFIkYoLDliESsVQLpYxAiFS6pcxEoFkC4WMULhkiIXOVIRKxRAulTEyIRLqljECgWQJxUxQmFJFovEI3OSWCTuSqxIWJKFIuGx5gjFpFKJEKmT91iZAPKEImV/YiTCkiMTsSIBpMtEjES4pApFrEgAeTIRIxKWVKGgSJwoKBREjhSxSJEKS6xcpAiFS6xcpEoFkCYWKVJhiZWLVKmwxMpFrFikyMRo7ASpSBUKIE0qUoTCEisWKTLhEi0WGR+PaKlIeOumygSQIBSZ3z6xUjENqYRPygQ+RSYssVIRux8pEuESKxQpEmFJkYlUkQDiZSJFIlxihSJFIiwpMkGROJFQKIg8MWKRIxSWGLHIlQogTixypMISIxc5UmHpkotcqbB0yUWXVOTIxKHxO8QiRyYsMVKRIxOWGKnIFQogUioKjsydYhFx9zkiYYkSioLHFyMU0ygTlq7JfI5IuHRJRdf950qEpUsmciTCEiMTORJhiZGJXJEA4mQiRyQsMUJBkTjRUCiIHm1iUSIULk1yUSIULk1yUSIULk1yUSIULk1yUSoVlia5aJOKUqEA2qWiRCgsbWJRIhSWNrEoEQpLq1gIfDQaxaLlbktEwtIqFAKPq00oplkkLG0T+lKZANqFoum+SyXC0iQTJRLh0iQUJRLh0iQUJRLh0iQUJRLh0iYUFAkCCgUZFyG5kJIKICwWUlIBhMVCSiqAo2IhJRQuvlxISQUQFouQVEjIxGj8gFRIyIQlJBUSMuESEgsJobAExULwyHxELAJ3JyESlqBQCD6ekFBoiwQgIxOW0MReQiYsIakI3aeUSABHZUJKIlx8oZASCSAsE1IiAYRlQkokgLBMUCKIB4WCjBdXLCSFwuKKhaRQuLhyISkVFisXGlIBHBYLSamwuHLhSoWkTIzGd6RCUiZcXLGQFgrgsFRIyoTLIbFQeJpGYuHcjaRIWA4JhdI3jCsVs5BKhHAn+JIyYXGlwr0vSYmwuDKhIRLAgUxISoTFlQlJiXBxhUJSJCyuUFAkSAMUCjIZvuqt71URCpfK6EmFRfTsxR67pyo1qbD0dnWkwmL2DebXjYpMuMzfNmpCAdRSoSETLtv37KsJBTB8ryofldeeH6iIhEs1p/s4Fm8OZi6V8Fm8UamIhEt/q74fDYmwLL9UqUmE5exTOyoiYVl7XuZEl0289PicikS49DcNRYJ0QaEgk+d173qf6vh3HtrH+Y/pTBBufz4wt6E8geoDCzdV7wI754DdNb0vpcG82tAAgKWXetg5o/ulunCrh6qvehdYvA4s3tI7dO6cNthbUhse8xu6h/3BgoFRnJ/Nb1TYeFj38zyYA+bXVe8Cdx8aYPmKrhQZnR/bAQDL1yrsL+qNDwBmXydxdFlYr7CwrnNceuEtfdUfUQDgs//t96uOT44VFAoyPWiJxZ2H6hmIplRYtOTCnchqycXOuYPLWnKhIRZLLx1+XTXEYuGWU/akJBWL153LSlKx46QHGmKhJRSDhYP91hIKd9+1pGLgTGA1pOLuQ4ff+xpSoSUSy9ec0iYlmXDfO1oysbBeOZf1ZALQK/OkSJAMKBRk+tAQCysVFmm5cKXCIi0XoYmstFy4UmGRlgtpqfCFApCXClcoLNJi4QrF6DphsdjxypGkpUJDKFyZAOSFIrTP0kIxCExepYXClwlAXiikZcKVCIu0TITeL9Iy4UrEwXWyxyArERYNmaBIkAIoFGR6kRQLXygsUmIREgoXKblom8RKyUVIKixSciElFSGZsEhJRUgmXKTEIiQUgKxU+EJhkRILSaHwRcIiKRRN+yslFCGROHT/QlIRkgmLlFRIyURIIixSMtH2HpGSiZBEHP67zPHHFwmLpFBQJIgAFAoyG5TKRZNQuJTKRZdUWErlImYCWyoXbVJhKZWLUqlokwmXUrHoEgqgXCqaZOLQNgJi0SQUllKxkBCKJpGwSAhFzH6WSkWXTADlQtEmEi6lUlEqE20SYSmViZj3RalMdEnEwXZlx5wmiXApFQpKBBGGQkFmi1yxiBEKl1y5iJUKS45cpE5ec+UiRiosJXKRKxaxQgHkS0WMTFhKpCJGKIAyqeiSCZdcsSgRii6RcCmRith9LBGKGJmw5EpFrEwA+UJRIhIxEmHJlYnU90GOUMRKxMH2eceaGIlwyRUKigRRgkJBZpdUuUiVCkuqXKRKhSVFLnImrzlikSIVlhy5SJWKFJlwSRWLFKGwpL42sTJx6DYZYpEiFJZUscgRihSRsOQIRc6+pUpFikh/xJy1AAAYi0lEQVRYUoUiRSRcUqUiRyZSJMKSKhO5MpkiE6kScXC7tNcmVSIsqTJBiSBjgEJBjgcxcpErFC4xcpErFC4xclFaZhMrGDlS4RIrGLFSkSsTllipyJEJS8prkyMUo9smiEWOUFhixSJl0p4jEpaUSWVJapIiFDkyYYmVilyZsMRKRaxM5AiES6xMlJa5xchErkQcHqP79cmVCJcYoaBEkDFDoSDHiy6xkJAKS5tcSEgF0C0WUg3BMXJRKhZAnFy0iUWpTFi6pKJEJlxiXp8SoRiNESEWJUJh6RKLmMl7iUhYYiaYEv0cMUJRIhIuXVJRKhOWNqmIEYlSiQDiREKq+b5LJiREoh6n+fWRkAhLl0xQJMiEoFCQ40uTXEhKBdAsFlJSYWmSC+nlS9vkQkIqXJoEIyQVUjLh0iQWUkJhaXqNJGTi0HgtYiEhFC4huWiaxEtIhEvbZFN66domqZASCUuTUEiJhEtIKppkQkIgXNpkQnpJ4CaZkJKIg/HCr5GkSADNMkGJIFMAhYKcDFy5kBYKF18upKXC4suF5hmcfcGQlgoXVzB8qdAQCuCoVEjLhIv/OkkLxWhcTyykZcLFFQt/Mi8tEi7+5FPrpHq+UEiLhIsvFRoyARwVClcmpAXCxZcJzbOe+zIhLREH4x5+jaQlwsUVCkoEmTIoFOTk8sjf+4mx3M/aM31sXRjPx2HhhsG+whmQQyxfrbB5n96E0aI56fBZvA5s3zOe+1q5UmFvSf/5A+rJ9t6q/n1Vei52iNUrA+wuj+e521012Lw0lrvC3kqFan58X533/K7+cziYx9hmA6sv7mPn1HjehLcf6WF3bTwP7Kl3vWMs90NIARQKQgB9uVh75uBXK225WLhx+HOtLRjLV+vHoy0X2mLhpgXaUrFy5fB7QFss3F/vNcVCWyhWrxz8GqwtFLve86QtFXsrB6+RtlRoi8QoXVSeBay+ePigoC0Ttx85GF9bJigRZMagUBDioyUXrlS4aAiGLxWAnlhYofDREAwtqWgqPdISC18oLBpi0VQKpCEWWkLhioSLhlT4ImHREgpXJFy0pEJDJhoXUlB4CL5EWDRkwhUIFy2ZoESQGYZCQUgb0nLRJBUWSbkISYWLpGA0SYWLpGBIi0VXL4OkWDTJhIukWLT1FkhLhYZQNMkEICsUTSLhIikVTSJhkRYKSZGIWuJZcPebJMIiKRNNEmGRlglKBDkmUCgIiUVCLrqEwjJOsQDk5CJGLCwSgiEhFimN0RJiESMUFgmxiG1WlpALKaFokwgXCaGIEQmLhFB0iYSLhFRIiETSiSeFDl1dEgGMVyQsEkJBiSDHEAoFIbnkCkasVLiUCkaMVLiUCEaKVLjkCkaJVOSuspQrFikyYSmVitTVj0rEolQoYkXCUioUKTJhyZWKFJFwKZGKXJlIPXP9iILDVIxAuJTKRKxAuOTKBAWCnAAoFISUkiMWOVLhkiMYqVLhkioYuVLhkioYqWIhsWRrqljkCIUlRyxKl1JNlYscoUiVCJ8cqcgRCUuqUOSKhEuqVKSKRLZAuCQ+zFSBcMmRiRyBcMmRCYoEOUFQKAiRJEUuSqXCEisXJULhEysYEmIBpMlFjFhIn/8hRixKZMInVi6kzs0QKxYpQlEqEpZYoSiRCJ8YqZAQCZcYqUgRCRGJAKK/6UsEwiVFJkolwpIiE5QIckKhUBCiSZdgSEmFS5tgSEqFpUsupKTCp00y2qRC62RyXVIhKRSWLrHQONlbm1x0CYWURLh0CYWkSFi6hEJaJixtUtEmE2Ly4NPxMKUkwqVNKKQEwqVLJigQhACgUBAyPkJyoSEUPr5gaEiFT0gytMTCEhKMkFhoCYUlJBYaMuESEgutM0cful9vsh4SCg2J8AlJhYZIuISkQkskLCGhCImEmkCMduToVRry4OPLhIZA+ISEghJByBEoFIRMCisY45AKi5WLcUiFixUMbanwsZJhxUJbJlysWGjLhI+Vi3EIxaH7XTUjoRiHRLhYodCWCB8rFdoi4WKlwoqEujwc2YH6f+MQCBcrE+OQCIuVCQoEIZ1QKAiZFh7/gfeN9f52TgNzd8d6lyMWbk3m8FD1xjvh3LoIrF6ezGM1e+O/z4U7k3msd+8d3yTTZfcUsHXveB/z2U+O9e5GrF4dr0BY5u7s48qXL471Pj/xo28f6/0RcgygUBAyjYxTLnZOH1wep2D45Ujj+kV9nFKxdfHg8jjF4sJv3jj075e+9NxY7necQrG/cPjf26fH+Mv1qYPL4xSKccnEjdcefkwP/er4Eqe5OwcHhnGKBCWCkCIoFITMAtqC4UqFj7ZkNDVQawuGtli4MuGjLRe+ULhoyoW2UPgS4aItFK5E+GhLhbZI+AJh0RYJVx58tGWCAkGIKBQKQmYRDcFokwoXDcGIPYeEhmRoiEWbTLhoiUWbUFg0xEJLKNpEwqIlFG0i4aIhFRoi0SQPPhoy0SYQLhoyQYEgRBUKBSHHASnBiJUKF0nByDnrtZRkSIlFrEz4SMlFjEz4SMmFpFDESISPlFTESoSPlFRIiUSsPLhIikSsQLhIyQQFgpCxQqEg5DhSIhg5UuFTKhk5YuFSIhklYpErEy6lYpEjFC4lclEqFDkS4VIqFLki4VIiFSUikSMPLqUikSMPPiUyQYEgZKJQKAg5KaRIhoRU+KRKRqlU+KRKRqpYSMiET6pclMqET6pc5AhFqUT4pEqFhET4pEpFqkiUyoNPqkxIyINPikxQHgiZOigUhJxEYuVCQyxcuiRDWip8YiUjRi40hMISKxbSQuHTJRgxQiEtED6xQqEhEpYYoYiVCGl58OmSCQ15cIkVCUoEIVMNhYIQUtMkGdpS4ROSDG2x8GkSjSax0JQJnya50JYJn5BcNAmFtkT4NEmFpkT4NElFk0hoi4NPSCS05cGnSSYoD4TMHBQKQkgzVjLGLRU+VjLGLRY+VjRcsRinTPhYuRi3TIR46UvPjYRi3AIRwkrFOCXCx5UKKxLjFgcfKxLjlgcfKxOUB0KOBRQKQkgar/qR8Z7RO8Tizfr/g/5k9wMA9tYmvQfA6nMVLnxk8lJx44vPTnoXAAA7awY7Z8Z7VvQQm5fGd0K4JuY36ufhwQ/vTHhPgF/9lXdNehcIITpQKAgh5UxKMqxY+ExCNCYlFqvPNZRATUAwJiUUO2vh77JJScUkRMKKg8+kRILyQMiJgkJBCBkvmvLRJBhdaAqIlmg0iUQsGsKhJRRNwhB9eyWx0BSHJkHoQlMgKAmEkAYoFISQ6UBSNHLFIoSkbEjJRalM+EjJhaRQlErEkfGEpEJSInKlIYSkSFAcCCGJUCgIIdNNiWhIikUTucKRKxfSMhEiVzBKhEJaIIL3kSkVuRIhKQxNlIgExYEQIgSFghAyu8TKxjjEoolY4egSjHGIRBsxkhErFOOQh9b77xCLWIEYhzA0ESsSlAZCyBigUBBCji++cExSLNrwpcOXi0nLRBuuaPhCMWlxaMOXCl8iJikLbfgiQWEghEwBFApCyMnk9d8/+eVvY5lfn43D6WBu0nsQz90HJr0H8Xzqh94x6V0ghJA2KBSEENLEtErHtArGNAvFtAoEZYEQcgygUBBCiASTlo9pkIxpEYpJywMlgRBywqBQEELIJBingIxLNsYpFOOUBgoCIYS0QqEghJBZQ1JGJGVDWigkpYFSQAghalAoCCGEEEIIIdlEC0XO707TueYeIYQQQgghZOz0Jr0DhBBCCCGEkNmFQkEIIYQQQgjJhkJBCCGEEEIIyYZCQQghhBBCCMmGQkEIIYQQQgjJhkJBCCGEEEIIyYZCQQghhBBCCMmGQkEIIYQQQgjJhkJBCCGEEEIIyYZCQQghhBBCCMmGQkEIIYQQQgjJhkJBCCGEEEIIyYZCQQghhBBCCMmGQkEIIYQQQgjJhkJBCCGEEEIIyYZCQQghhBBCCMmGQkEIIYQQQgjJhkJBCCGEEEIIyYZCQQghhBBCCMmGQkEIIYQQQgjJhkJBCCGEEEIIyYZCQQghhBBCCMmGQkEIIYQQQgjJhkJBCCGEEEIIyYZCQQghhBBCCMmGQkEIIYQQQgjJhkJBCCGEEEIIyYZCQQghhBBCCMmGQkEIIYQQQgjJhkJBCCGEEEIIyYZCQQghhBBCCMmGQkEIIYQQQgjJhkJBCCGEEEIIyYZCQQghhBBCCMmGQkEIIYQQQgjJhkJBCCGEEEIIyWZu0jtAyCxgjFkCsDDp/SCEEDJ2dqqq2pr0ThAyzZiqqia9D4RMNcaYpQUsbe6A3yeEEHICuQLglZQKQpphQkFINws72MJXmm/BHOZhegYwdbVgfdnUWzmXTa/nXO9cNgZmeFt3exhTb2cvD6+ur3e2Cd0W4X2ojDkoajSH76sabQ/nehxcb3B4HGd/KmfMyt3P4WX3fqtD1ztj2vsY7nPlPBR3zKjre+FtRhy6vu2yCV5/eP8bLjfdl3N91zip93vovv3rAuMcHb+K3geYCod+ejq0P1XwvtzrK2ccu41pui3cbQ7u1TTc1pjK+Sgcvq1xbnvoo3botlXw+t7wERtnP4ypDm8zvNzDwTg993p3eyB4fc+5r/r6weiywcH49vr+oe0Ho8NDHxWMc9v+aN8Go/vqu5fNYDR+3wwOxh+Oa8cc7Y83Tn90feVcHowOOfV9DZztD/bn8PYH+9B3Hm/f2Qfj3q/zXNnL9X7i4Lmy+2CA/vBd0APQN/ayQQ8Hlw+u742u75v68u31AV7xJU/fhzqhplAQ0gCFgpBI5jCPOTMP40zs3cvupN0YVyJcuYgVikOzH+f6htuKCEX4ehWhcCeQSkIRJxHuZRO8PkoomsZE/DjJQuFvj4j9CUz4o4XCuY+xCkXw8sFtD8tCm1CExaFTKPzrM4WiloI0oQhdf1Qo3El1mlD0gkJRNVyOE4r+aBuD3vCF6cM4+3Mwge/DOPtgHKEYoD988frO89Yf/nv0GANC0Y8UioPr24SCbaaExMJPCyGEEEIIISQbCgUhhBBCCCEkGwoFIYQQQgghJBsKBSGEEEIIISQbCgUhhBBCCCEkGwoFIYQQQgghJBsKBSGEEEIIISQbCgUhhBBCCCEkGwoFIYQQQgghJBsKBSGEEEIIISQbCgUhhBBCCCEkm7lJ7wAhs8IedoEKMJWBdfH6sqk3cC6bqudc71weGBhjPd4AZni9ORgTxow2r693tgnd1r1cHVyujAEqZxznvqrR9nCux8H1Axwex9mfqudcdvdztAtm9FCqQ9c7Y+LgYaHnjoNDY0Zd3wtvM+LQ9W2XTfD6wMt79HLTfTnXd42Ter+H7tu/LjDO0fGr6H2AqQ4ei3N/lTOOf1/u9ZUzjvt2Dt4W7jYH92oabmtM5XwUDt/WOLd1P2rVodtWwevtIzYABs71vcDlHg7G6bnXu9sP/x3cBu71g9Flg4Px7fX9Q9sP0Bs+rj4qGOe2/dG+DUb31Xcvm8Fo/L4ZHIw/HNeOOdofb5z+6PrKuTwY/UpZ39fA2f5gfw5vf7APfefx9p19MO79Os+VvVzvJw6eK7sPBugP3wU9AH1jLxv0cHD54HqMru+beqzb6wMQQroxVVV1b0XICcYYcxrAZQBrk94XQgghY2cDwINVVd2e9I4QMq0woSAkjjUADwFYn/SOEEIIGRunADw36Z0gZNqhUBASzzp/oSKEkJODccsnCSGNsCmbEEIIIYQQkg2FghBCCCGEEJINhYKQbrYB/PDw/4QQQk4OPP4TEgFXeSKEEEIIIYRkw4SCEEIIIYQQkg2FghBCCCGEEJINhYIQQgghhBCSDYWCEEIIIYQQkg2FghBCCCGEEJINhYLMFMaYv2yMedoYs2WM+S1jzJd1bP9txpg/HG7/MWPMN3l/N8aY9xhjXjDGbBpjfsUY81jDWIvGmN8zxlTGmC/2/vYnh3+7a4x5xhjzA97f7zfG/FNjzKeMMQNjzP/UcB9njTF/f7g/28Ptvym0LSGEnCRSjv/GmD9vjPl3xpgbw/9+xd/eGPM3h98Pd5xt/ojz90eMMf/AGPPZ4ffDp40xP2yMWfDGqAL/3XG2+XDDNh90tgn9vfK/SwiZVigUZGYwxvwpAD+Jek3wNwH4fQC/ZIy52LD9VwD4ZwD+AYA3AvgAgA8YYx53NnsngL8C4LsB/BEAd4ZjLgWG/HEAzwfu560A/gmAnwbwOIC/BODtxpjvcTZbBHANwI8O9zu0vwsAfhnAIwD+SwCvBvDnAVwObU8IISeF1OM/gK9Gffz/jwG8BcCzAD5kjHnQ2eZTAL4HwOsBfCWAp4fbXBj+/TWo50n/DYDXAXg76u+Kv+WM8RMA7vf++w8A/qWzzbd6f38cwL63jT/GdwGoAPxfLU8LIVMDz0NBZgZjzG8B+O2qqr5n+O8e6i+Jv1tV1d8ObP9zAFarqvoW57qPAPi9qqq+2xhjUAvC/1hV1U8M/34GwFUAf6aqqn/u3O6tqL/M/gsATwB4Y1VVvzf82z8FMF9V1bc5238vall5uPI+ZMaYDw/34fu8678bwA8AeE1VVbs5zxEhhBxHUo//gdv3AdwA8D1VVf2jhm1OA7gF4I9XVfX/NGzzAwD+YlVVjzb8/Q0Afg/Af1RV1b9r2Ob7ALwHwP1VVd1p2OYDAE5VVfW17Y+MkOmACQWZCYa/3n8JgF+x11VVNRj++y0NN3uLu/2QX3K2fyWA+7wxbwH4LXdMY8wlAD8D4DsA3A3czyKALe+6TQAPAXhFy8Py+U8B/CaAv2+MuWqM+bgx5q8NvwgJIeREknn891kBMA/g5Zb7+AuohSKYIg850zTGkD8H4FNNMjHkbQD+eYtMXALwzajTdUJmAgoFmRXuBdBHnR64XEUtBSHu69j+Pue64DbDFOMfAvjpqqo+2nA/vwTgW40xX2uM6RljXgXg+4d/u7/hNiEeRV3q1AfwTQB+ZDjODyWMQQghx42c47/Pe1En0od+ZDLGfIsxZgP1j0JvB/B1VVW9FBrAGPMFAL4XwP/S8PclAP81WkRg2MfxOID/rWVfvxPAOoD3t2xDyFRBoSCkne8FcArAj7Vs8zMA/h6AXwCwA+AjAGy51CDhvnoAXgTwF6qq+p2qqn4OwP+AumaXEEJIBsaYdwH4dgB/oqoqP03+VQBfDOArAPwigH8R6ssY9l78IoB/WVXVzzTc1Z9A/X3xsy278zYAH6uq6t+3bPNdAP5JYF8JmVooFGRWeAl1E9sl7/pLAK403OZKx/ZXnOuatvka1JH6tjFmD8BTw+s/aoz5WQCoan4QwBrqEqf7ANgvi8+0P6xDvIA6Kt93rvsEgPvcVUUIIeSEkXP8BwAYY/4qgHcB+Pqqqv7A/3tVVXeqqnqqqqqPVFX1NgB7qCf97hgPoBaP30BdFtXEnwPwC1VV+UmKHWcVtdi0JRh/DPWCHG0JBiFTB4WCzARVVe0A+B0Aowa1YVPe16LuOwjxm+72Q77O2f6zqL+M3DFPo17tyW7zVwC8AfUvWF+MuhQJAP4UgL/u7eN+VVWXh/v6XwH4zaqqrsU/Svw6gC8YPi7LqwC8MByTEEJOHJnHfxhj3gngvwPwjS0lqz491H1xdowHAXx4eP9/dti7EbqvV6JeUaqt7+HbhmP/Hy3bvA3A71RV1dbHQcjUMTfpHSAkgZ8E8LPGmI+iTgC+D8AqgP8dAIwx/wjA5aqq3j3c/qcA/FtjzPcD+CDqX4bejOEvTFVVVcPzQfyQMeZJ1ILxI6jrbD8w3OZz7g4Ma20B4NNVVT03vO5e1L0PHwawBODPov7i+CrvtvbcFWsALgz/vVNV1X8YXv8/o17C8KeMMX8XwGMA/hqAv5PzZBFCyDEi6fhvjPlB1Csp/WkATxtjbK/FRlVVG8O04K8D+Neo0+F7AfxlAA9iuJyrIxPPAPirqI/bAICqqvxk5LuG4/zfLY/hbQA+UFXV9dAfhz9ofRsOevAImRkoFGRmqKrq54brg78HdVnR76H+5cnGyw/D6Vmoquo3jDF/GvW5H/4WgCcB/OdVVX3cGfbHUX8p/a8AzgL4teGYqbWr34l6PXKD+hezrw7UyP6uc/lLUH/RPYP6vBOoqupZY8w3AHgfgD9Aff6Jn0LdTEgIISeW1OM/gL8IYAHA/+kN9cMA/ibqEqrXoD523wvgOoDfBvDHqqp6Yrjt1wH4guF/z3njmNGFOi35MwD+oVeyCmebV6M+18XXtzzMbx+O+89atiFkKuF5KAghhBBCCCHZsIeCEEIIIYQQkg2FghBCCCGEEJINhYIQQgghhBCSDYWCEEIIIYQQkg2FghBCCCGEEJINhYIQQgghhBCSDYWCEEIIIYQQkg2FghBCCCGEEJINhYIQQgghhBCSDYWCEEIIIYQQkg2FghBCCCGEEJLN/w8Ieh3TEBtD1wAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "M_sph.evaluate_map()\n", "M_sph.plot_map()\n" @@ -241,22 +185,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "M_sph.evaluate_map(input_y=Data_X[:,0])\n", "M_sph.plot_map()" @@ -271,21 +202,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "AttributeError", - "evalue": "'SOMap' object has no attribute 'n_dim'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;31m# need more iterations to make sure it converges\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mM\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msomsphere\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mSOMap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mData_X\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mData_Y\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtopology\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'grid'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_top\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m15\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_iter\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m300\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mperiodic\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mM\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_dim\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'dimensions'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#dimensions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mM\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_pix\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'cells'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#cells\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mAttributeError\u001b[0m: 'SOMap' object has no attribute 'n_dim'" - ] - } - ], + "outputs": [], "source": [ "# To test with fixed weights, so answer is always the same (to be able to compare)\n", "# need more iterations to make sure it converges\n", @@ -784,9 +703,9 @@ ], "metadata": { "kernelspec": { - "display_name": "env38", + "display_name": "env37", "language": "python", - "name": "env38" + "name": "env37" }, "language_info": { "codemirror_mode": { @@ -798,7 +717,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.2" + "version": "3.7.9" } }, "nbformat": 4, diff --git a/pyptoject.toml b/pyptoject.toml new file mode 100644 index 0000000..eb56957 --- /dev/null +++ b/pyptoject.toml @@ -0,0 +1,2 @@ +[build-system] +requires = ["setuptools", "wheel", "Cython"] \ No newline at end of file diff --git a/setup.py b/setup.py index dcac1ab..cc62785 100644 --- a/setup.py +++ b/setup.py @@ -1,3 +1,4 @@ +from Cython.Build import cythonize from numpy.distutils.core import setup exec(open('version.py').read()) @@ -7,6 +8,7 @@ author='Matias Carrasco Kind', author_email='mcarras2@illinois.edu', packages=[], + ext_modules=cythonize("somsphere/cython/core.pyx"), py_modules=['somsphere'], license='License.txt', description='somsphere : Self Organizing Maps in spherical coordinates and other topologies', diff --git a/somsphere/__init__.py b/somsphere/__init__.py index 0883e7a..064f9c4 100644 --- a/somsphere/__init__.py +++ b/somsphere/__init__.py @@ -16,6 +16,7 @@ from matplotlib import collections from matplotlib.colors import colorConverter +import core from somsphere.models import Topology, DY, SomType from somsphere.utils import get_sigma, is_power_2, compute_distance, count_modified_cells, get_alpha @@ -82,7 +83,7 @@ def create_map(self, inputs_weights=None, random_order=True, eval_map=False): self.n_row) for i in range(self.n_row): inputs = self.X[random_indices[i]] - best, activation = self.__get_best_cell(inputs) + best, activation = core.get_best_cell(inputs=inputs, importance=self.importance, weights=self.weights, n_pix=self.n_pix) self.weights += alpha * count_modified_cells(best, self.dist_lib, sigma) * numpy.transpose( (inputs - numpy.transpose(self.weights))) @@ -92,7 +93,7 @@ def create_map(self, inputs_weights=None, random_order=True, eval_map=False): accum_n = numpy.zeros(self.n_pix) for i in range(self.n_row): inputs = self.X[i] - best, activation = self.__get_best_cell(inputs) + best, activation = core.get_best_cell(inputs=inputs, importance=self.importance, weights=self.weights, n_pix=self.n_pix) for kk in range(self.n_col): accum_w[kk, :] += count_modified_cells(best, self.dist_lib, sigma) * inputs[kk] accum_n += count_modified_cells(best, self.dist_lib, sigma) @@ -121,7 +122,7 @@ def evaluate_map(self, input_x=None, input_y=None): in_y = self.Y if input_y is None else input_y for i in range(len(in_x)): inputs = in_x[i] - best, activation = self.__get_best_cell(inputs) + best, activation = core.get_best_cell(inputs=inputs, importance=self.importance, weights=self.weights, n_pix=self.n_pix) if best not in self.y_vals: self.y_vals[best] = [] self.y_vals[best].append(in_y[i]) @@ -226,7 +227,7 @@ def predict(self, line, best=True): :param bool best: Set to True to get only the best cell; otherwise the 10 closest cells will be returned :return: array with the cell content """ - bests, _ = self.__get_best_cell(line, return_vals=10) + bests, _ = core.get_best_cell(inputs=line, importance=self.importance, weights=self.weights, n_pix=self.n_pix, return_vals=10) if best: return bests[0] for ib in range(10): @@ -258,12 +259,12 @@ def save_map(self, filename='SOM', path=None, itn=-1): def __update_weights(self, inputs_weights): self.weights = inputs_weights if inputs_weights is not None else self.weights - def __get_best_cell(self, inputs, return_vals=1): - """ - Return the closest cell to the input object - It can return more than one value if needed - """ - activations = numpy.sum(numpy.transpose([self.importance]) * ( - numpy.transpose(numpy.tile(inputs, (self.n_pix, 1))) - self.weights) ** 2, axis=0) - - return numpy.argmin(activations) if return_vals == 1 else numpy.argsort(activations)[0:return_vals], activations + # def __core.get_best_cell(self, inputs, return_vals=1): + # """ + # Return the closest cell to the input object + # It can return more than one value if needed + # """ + # activations = numpy.sum(numpy.transpose([self.importance]) * ( + # numpy.transpose(numpy.tile(inputs, (self.n_pix, 1))) - self.weights) ** 2, axis=0) + # + # return numpy.argmin(activations) if return_vals == 1 else numpy.argsort(activations)[0:return_vals], activations diff --git a/somsphere/cython/core.c b/somsphere/cython/core.c new file mode 100644 index 0000000..082ac94 --- /dev/null +++ b/somsphere/cython/core.c @@ -0,0 +1,3772 @@ +/* Generated by Cython 0.29.21 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "name": "core", + "sources": [ + "somsphere/cython/core.pyx" + ] + }, + "module_name": "core" +} +END: Cython Metadata */ + +#define PY_SSIZE_T_CLEAN +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.6+ or Python 3.3+. +#else +#define CYTHON_ABI "0_29_21" +#define CYTHON_HEX_VERSION 0x001D15F0 +#define CYTHON_FUTURE_DIVISION 1 +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#define __PYX_COMMA , +#ifndef HAVE_LONG_LONG + #if PY_VERSION_HEX >= 0x02070000 + #define HAVE_LONG_LONG + #endif +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #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 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #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 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #define CYTHON_USE_PYTYPE_LOOKUP 1 + #endif + #if PY_MAJOR_VERSION < 3 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #define CYTHON_USE_PYLONG_INTERNALS 1 + #endif + #ifndef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if PY_VERSION_HEX < 0x030300F0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #ifndef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT (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) +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #include "longintrepr.h" + #undef SHIFT + #undef BASE + #undef MASK + #ifdef SIZEOF_VOID_P + enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; + #endif +#endif +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif +#ifndef __has_cpp_attribute + #define __has_cpp_attribute(x) 0 +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_MAYBE_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) +#ifdef _MSC_VER + #ifndef _MSC_STDINT_H_ + #if _MSC_VER < 1300 + typedef unsigned char uint8_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int32 uint32_t; + #endif + #endif +#else + #include +#endif +#ifndef CYTHON_FALLTHROUGH + #if defined(__cplusplus) && __cplusplus >= 201103L + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #elif __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_attribute(fallthrough) + #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) + #else + #define CYTHON_FALLTHROUGH + #endif + #endif + #if defined(__clang__ ) && defined(__apple_build_version__) + #if __apple_build_version__ < 7000000 + #undef CYTHON_FALLTHROUGH + #define CYTHON_FALLTHROUGH + #endif + #endif +#endif + +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #elif defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif +#endif + +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) + #define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" +#if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2 + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, 0, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#else + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#endif + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#ifndef METH_STACKLESS + #define METH_STACKLESS 0 +#endif +#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) + #ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + #endif + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); + typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #define __Pyx_PyCFunctionFast _PyCFunctionFast + #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords +#endif +#if CYTHON_FAST_PYCCALL +#define __Pyx_PyFastCFunction_Check(func)\ + ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) +#else +#define __Pyx_PyFastCFunction_Check(func) 0 +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#if CYTHON_COMPILING_IN_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) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif +#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x03060000 + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() +#elif PY_VERSION_HEX >= 0x03000000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#else + #define __Pyx_PyThreadState_Current _PyThreadState_Current +#endif +#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) +#include "pythread.h" +#define Py_tss_NEEDS_INIT 0 +typedef int Py_tss_t; +static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { + *key = PyThread_create_key(); + return 0; +} +static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { + Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); + *key = Py_tss_NEEDS_INIT; + return key; +} +static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { + PyObject_Free(key); +} +static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { + return *key != Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { + PyThread_delete_key(*key); + *key = Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { + return PyThread_set_key_value(*key, value); +} +static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { + return PyThread_get_key_value(*key); +} +#endif +#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) +#else +#define __Pyx_PyDict_NewPresized(n) PyDict_New() +#endif +#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#else +#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) + #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) + #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #endif +#else + #define CYTHON_PEP393_ENABLED 0 + #define PyUnicode_1BYTE_KIND 1 + #define PyUnicode_2BYTE_KIND 2 + #define PyUnicode_4BYTE_KIND 4 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) + #define PyObject_ASCII(o) PyObject_Repr(o) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#ifndef PyObject_Unicode + #define PyObject_Unicode PyObject_Str +#endif +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#if PY_VERSION_HEX >= 0x030900A4 + #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) +#else + #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) +#endif +#if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) +#else + #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if CYTHON_USE_ASYNC_SLOTS + #if PY_VERSION_HEX >= 0x030500B1 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods + #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) + #else + #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) + #endif +#else + #define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef __Pyx_PyAsyncMethodsStruct + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + } __Pyx_PyAsyncMethodsStruct; +#endif + +#if defined(WIN32) || defined(MS_WINDOWS) + #define _USE_MATH_DEFINES +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + +#define __PYX_MARK_ERR_POS(f_index, lineno) \ + { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } +#define __PYX_ERR(f_index, lineno, Ln_error) \ + { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__core +#define __PYX_HAVE_API__core +/* Early includes */ +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { + return (size_t) i < (size_t) limit; +} +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) + #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +#define __Pyx_PySequence_Tuple(obj)\ + (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +#if CYTHON_ASSUME_SAFE_MACROS +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#else +#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) +#endif +#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ +static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } + +static PyObject *__pyx_m = NULL; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_cython_runtime = NULL; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static PyObject *__pyx_empty_unicode; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + + +static const char *__pyx_f[] = { + "somsphere/cython/core.pyx", +}; + +/*--- Type declarations ---*/ + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* RaiseArgTupleInvalid.proto */ +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* PyDictVersioning.proto */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) +#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ + (version_var) = __PYX_GET_DICT_VERSION(dict);\ + (cache_var) = (value); +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ + (VAR) = __pyx_dict_cached_value;\ + } else {\ + (VAR) = __pyx_dict_cached_value = (LOOKUP);\ + __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ + }\ +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); +#else +#define __PYX_GET_DICT_VERSION(dict) (0) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); +#endif + +/* GetModuleGlobalName.proto */ +#if CYTHON_USE_DICT_VERSIONS +#define __Pyx_GetModuleGlobalName(var, name) {\ + 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 + +/* PyCFunctionFastCall.proto */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); +#else +#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +#endif + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); +#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 + +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* 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); +#endif + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* PyIntCompare.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, long intval, long inplace); + +/* SliceObject.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice( + PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, + PyObject** py_start, PyObject** py_stop, PyObject** py_slice, + int has_cstart, int has_cstop, int wraparound); + +/* Import.proto */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* CLineInTraceback.proto */ +#ifdef CYTHON_CLINE_IN_TRACEBACK +#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) +#else +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); +#endif + +/* CodeObjectCache.proto */ +typedef struct { + PyCodeObject* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +/* AddTraceback.proto */ +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +/* FastTypeChecks.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); +#else +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) +#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) +#endif +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) + +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(void); + +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + + +/* Module declarations from 'core' */ +#define __Pyx_MODULE_NAME "core" +extern int __pyx_module_is_main_core; +int __pyx_module_is_main_core = 0; + +/* Implementation of 'core' */ +static const char __pyx_k_sum[] = "sum"; +static const char __pyx_k_axis[] = "axis"; +static const char __pyx_k_core[] = "core"; +static const char __pyx_k_main[] = "__main__"; +static const char __pyx_k_name[] = "__name__"; +static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_tile[] = "tile"; +static const char __pyx_k_n_pix[] = "n_pix"; +static const char __pyx_k_numpy[] = "numpy"; +static const char __pyx_k_argmin[] = "argmin"; +static const char __pyx_k_import[] = "__import__"; +static const char __pyx_k_inputs[] = "inputs"; +static const char __pyx_k_argsort[] = "argsort"; +static const char __pyx_k_weights[] = "weights"; +static const char __pyx_k_transpose[] = "transpose"; +static const char __pyx_k_importance[] = "importance"; +static const char __pyx_k_activations[] = "activations"; +static const char __pyx_k_return_vals[] = "return_vals"; +static const char __pyx_k_get_best_cell[] = "get_best_cell"; +static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; +static const char __pyx_k_somsphere_cython_core_pyx[] = "somsphere/cython/core.pyx"; +static PyObject *__pyx_n_s_activations; +static PyObject *__pyx_n_s_argmin; +static PyObject *__pyx_n_s_argsort; +static PyObject *__pyx_n_s_axis; +static PyObject *__pyx_n_s_cline_in_traceback; +static PyObject *__pyx_n_s_core; +static PyObject *__pyx_n_s_get_best_cell; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_importance; +static PyObject *__pyx_n_s_inputs; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_n_pix; +static PyObject *__pyx_n_s_name; +static PyObject *__pyx_n_s_numpy; +static PyObject *__pyx_n_s_return_vals; +static PyObject *__pyx_kp_s_somsphere_cython_core_pyx; +static PyObject *__pyx_n_s_sum; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_n_s_tile; +static PyObject *__pyx_n_s_transpose; +static PyObject *__pyx_n_s_weights; +static PyObject *__pyx_pf_4core_get_best_cell(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_inputs, PyObject *__pyx_v_importance, PyObject *__pyx_v_n_pix, PyObject *__pyx_v_weights, PyObject *__pyx_v_return_vals); /* proto */ +static PyObject *__pyx_int_0; +static PyObject *__pyx_int_1; +static PyObject *__pyx_int_2; +static PyObject *__pyx_tuple_; +static PyObject *__pyx_codeobj__2; +/* Late includes */ + +/* "core.pyx":4 + * import numpy + * + * def get_best_cell(inputs, importance, n_pix, weights, return_vals=1): # <<<<<<<<<<<<<< + * """ + * Return the closest cell to the input object + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_4core_1get_best_cell(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_4core_get_best_cell[] = "\n Return the closest cell to the input object\n It can return more than one value if needed\n "; +static PyMethodDef __pyx_mdef_4core_1get_best_cell = {"get_best_cell", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_1get_best_cell, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4core_get_best_cell}; +static PyObject *__pyx_pw_4core_1get_best_cell(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_inputs = 0; + PyObject *__pyx_v_importance = 0; + PyObject *__pyx_v_n_pix = 0; + PyObject *__pyx_v_weights = 0; + PyObject *__pyx_v_return_vals = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_best_cell (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_inputs,&__pyx_n_s_importance,&__pyx_n_s_n_pix,&__pyx_n_s_weights,&__pyx_n_s_return_vals,0}; + PyObject* values[5] = {0,0,0,0,0}; + values[4] = ((PyObject *)__pyx_int_1); + 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_inputs)) != 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_importance)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("get_best_cell", 0, 4, 5, 1); __PYX_ERR(0, 4, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_pix)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("get_best_cell", 0, 4, 5, 2); __PYX_ERR(0, 4, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_weights)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("get_best_cell", 0, 4, 5, 3); __PYX_ERR(0, 4, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_return_vals); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_best_cell") < 0)) __PYX_ERR(0, 4, __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); + 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_inputs = values[0]; + __pyx_v_importance = values[1]; + __pyx_v_n_pix = values[2]; + __pyx_v_weights = values[3]; + __pyx_v_return_vals = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_best_cell", 0, 4, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 4, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("core.get_best_cell", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4core_get_best_cell(__pyx_self, __pyx_v_inputs, __pyx_v_importance, __pyx_v_n_pix, __pyx_v_weights, __pyx_v_return_vals); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4core_get_best_cell(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_inputs, PyObject *__pyx_v_importance, PyObject *__pyx_v_n_pix, PyObject *__pyx_v_weights, PyObject *__pyx_v_return_vals) { + PyObject *__pyx_v_activations = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + int __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_best_cell", 0); + + /* "core.pyx":9 + * It can return more than one value if needed + * """ + * activations = numpy.sum(numpy.transpose([importance]) * ( # <<<<<<<<<<<<<< + * numpy.transpose(numpy.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_sum); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_transpose); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_importance); + __Pyx_GIVEREF(__pyx_v_importance); + PyList_SET_ITEM(__pyx_t_3, 0, __pyx_v_importance); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + __pyx_t_1 = (__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_1)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "core.pyx":10 + * """ + * activations = numpy.sum(numpy.transpose([importance]) * ( + * numpy.transpose(numpy.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0) # <<<<<<<<<<<<<< + * + * return numpy.argmin(activations) if return_vals == 1 else numpy.argsort(activations)[0:return_vals], activations + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_transpose); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_numpy); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_tile); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_INCREF(__pyx_v_n_pix); + __Pyx_GIVEREF(__pyx_v_n_pix); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_v_n_pix); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_int_1); + __pyx_t_8 = NULL; + __pyx_t_9 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_9 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_inputs, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_3); + __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[3] = {__pyx_t_8, __pyx_v_inputs, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + if (__pyx_t_8) { + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; + } + __Pyx_INCREF(__pyx_v_inputs); + __Pyx_GIVEREF(__pyx_v_inputs); + PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_v_inputs); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_4 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_3); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyNumber_Subtract(__pyx_t_4, __pyx_v_weights); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_Power(__pyx_t_5, __pyx_int_2, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "core.pyx":9 + * It can return more than one value if needed + * """ + * activations = numpy.sum(numpy.transpose([importance]) * ( # <<<<<<<<<<<<<< + * numpy.transpose(numpy.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0) + * + */ + __pyx_t_5 = PyNumber_Multiply(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); + __pyx_t_5 = 0; + + /* "core.pyx":10 + * """ + * activations = numpy.sum(numpy.transpose([importance]) * ( + * numpy.transpose(numpy.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0) # <<<<<<<<<<<<<< + * + * return numpy.argmin(activations) if return_vals == 1 else numpy.argsort(activations)[0:return_vals], activations + */ + __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_axis, __pyx_int_0) < 0) __PYX_ERR(0, 10, __pyx_L1_error) + + /* "core.pyx":9 + * It can return more than one value if needed + * """ + * activations = numpy.sum(numpy.transpose([importance]) * ( # <<<<<<<<<<<<<< + * numpy.transpose(numpy.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0) + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_activations = __pyx_t_1; + __pyx_t_1 = 0; + + /* "core.pyx":12 + * numpy.transpose(numpy.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0) + * + * return numpy.argmin(activations) if return_vals == 1 else numpy.argsort(activations)[0:return_vals], activations # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_5 = __Pyx_PyInt_EqObjC(__pyx_v_return_vals, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__pyx_t_11) { + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_numpy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_argmin); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + __pyx_t_5 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v_activations) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_activations); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = __pyx_t_5; + __pyx_t_5 = 0; + } else { + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_numpy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_argsort); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + __pyx_t_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_2, __pyx_v_activations) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_activations); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetSlice(__pyx_t_5, 0, 0, NULL, &__pyx_v_return_vals, NULL, 1, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_1 = __pyx_t_4; + __pyx_t_4 = 0; + } + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); + __Pyx_INCREF(__pyx_v_activations); + __Pyx_GIVEREF(__pyx_v_activations); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_activations); + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "core.pyx":4 + * import numpy + * + * def get_best_cell(inputs, importance, n_pix, weights, return_vals=1): # <<<<<<<<<<<<<< + * """ + * Return the closest cell to the input object + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("core.get_best_cell", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_activations); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_core(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_core}, + {0, NULL} +}; +#endif + +static struct PyModuleDef __pyx_moduledef = { + PyModuleDef_HEAD_INIT, + "core", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif +#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_activations, __pyx_k_activations, sizeof(__pyx_k_activations), 0, 0, 1, 1}, + {&__pyx_n_s_argmin, __pyx_k_argmin, sizeof(__pyx_k_argmin), 0, 0, 1, 1}, + {&__pyx_n_s_argsort, __pyx_k_argsort, sizeof(__pyx_k_argsort), 0, 0, 1, 1}, + {&__pyx_n_s_axis, __pyx_k_axis, sizeof(__pyx_k_axis), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_core, __pyx_k_core, sizeof(__pyx_k_core), 0, 0, 1, 1}, + {&__pyx_n_s_get_best_cell, __pyx_k_get_best_cell, sizeof(__pyx_k_get_best_cell), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_importance, __pyx_k_importance, sizeof(__pyx_k_importance), 0, 0, 1, 1}, + {&__pyx_n_s_inputs, __pyx_k_inputs, sizeof(__pyx_k_inputs), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_n_pix, __pyx_k_n_pix, sizeof(__pyx_k_n_pix), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, + {&__pyx_n_s_return_vals, __pyx_k_return_vals, sizeof(__pyx_k_return_vals), 0, 0, 1, 1}, + {&__pyx_kp_s_somsphere_cython_core_pyx, __pyx_k_somsphere_cython_core_pyx, sizeof(__pyx_k_somsphere_cython_core_pyx), 0, 0, 1, 0}, + {&__pyx_n_s_sum, __pyx_k_sum, sizeof(__pyx_k_sum), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_tile, __pyx_k_tile, sizeof(__pyx_k_tile), 0, 0, 1, 1}, + {&__pyx_n_s_transpose, __pyx_k_transpose, sizeof(__pyx_k_transpose), 0, 0, 1, 1}, + {&__pyx_n_s_weights, __pyx_k_weights, sizeof(__pyx_k_weights), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { + return 0; +} + +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "core.pyx":4 + * import numpy + * + * def get_best_cell(inputs, importance, n_pix, weights, return_vals=1): # <<<<<<<<<<<<<< + * """ + * Return the closest cell to the input object + */ + __pyx_tuple_ = PyTuple_Pack(6, __pyx_n_s_inputs, __pyx_n_s_importance, __pyx_n_s_n_pix, __pyx_n_s_weights, __pyx_n_s_return_vals, __pyx_n_s_activations); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + __pyx_codeobj__2 = (PyObject*)__Pyx_PyCode_New(5, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_somsphere_cython_core_pyx, __pyx_n_s_get_best_cell, 4, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__2)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __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) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + + +#ifndef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void +#else +#define __Pyx_PyMODINIT_FUNC void +#endif +#else +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * +#else +#define __Pyx_PyMODINIT_FUNC PyObject * +#endif +#endif + + +#if PY_MAJOR_VERSION < 3 +__Pyx_PyMODINIT_FUNC initcore(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC initcore(void) +#else +__Pyx_PyMODINIT_FUNC PyInit_core(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_core(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + #if PY_VERSION_HEX >= 0x030700A1 + static PY_INT64_T main_interpreter_id = -1; + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); + if (main_interpreter_id == -1) { + main_interpreter_id = current_id; + return (unlikely(current_id == -1)) ? -1 : 0; + } else if (unlikely(main_interpreter_id != current_id)) + #else + static PyInterpreterState *main_interpreter = NULL; + PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; + if (!main_interpreter) { + main_interpreter = current_interpreter; + } else if (unlikely(main_interpreter != current_interpreter)) + #endif + { + PyErr_SetString( + PyExc_ImportError, + "Interpreter change detected - this module can only be loaded into one interpreter per process."); + return -1; + } + return 0; +} +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) { + 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); + } + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, 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"); + if (unlikely(!modname)) goto bad; + module = PyModule_NewObject(modname); + Py_DECREF(modname); + if (unlikely(!module)) goto bad; + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; + return module; +bad: + Py_XDECREF(module); + return NULL; +} + + +static CYTHON_SMALL_CODE int __pyx_pymod_exec_core(PyObject *__pyx_pyinit_module) +#endif +#endif +{ + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module 'core' has already been imported. Re-initialisation is not supported."); + return -1; + } + #elif PY_MAJOR_VERSION >= 3 + if (__pyx_m) return __Pyx_NewRef(__pyx_m); + #endif + #if CYTHON_REFNANNY +__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); +if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); +} +#endif + __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_core(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pxy_PyFrame_Initialize_Offsets + __Pxy_PyFrame_Initialize_Offsets(); + #endif + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("core", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_b); + __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_cython_runtime); + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_core) { + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "core")) { + if (unlikely(PyDict_SetItemString(modules, "core", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_global_init_code(); + (void)__Pyx_modinit_variable_export_code(); + (void)__Pyx_modinit_function_export_code(); + (void)__Pyx_modinit_type_init_code(); + (void)__Pyx_modinit_type_import_code(); + (void)__Pyx_modinit_variable_import_code(); + (void)__Pyx_modinit_function_import_code(); + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + + /* "core.pyx":2 + * #cython: language_level=3 + * import numpy # <<<<<<<<<<<<<< + * + * def get_best_cell(inputs, importance, n_pix, weights, return_vals=1): + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_numpy, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "core.pyx":4 + * import numpy + * + * def get_best_cell(inputs, importance, n_pix, weights, return_vals=1): # <<<<<<<<<<<<<< + * """ + * Return the closest cell to the input object + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_4core_1get_best_cell, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_best_cell, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "core.pyx":1 + * #cython: language_level=3 # <<<<<<<<<<<<<< + * import numpy + * + */ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init core", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_CLEAR(__pyx_m); + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init core"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #elif PY_MAJOR_VERSION >= 3 + return __pyx_m; + #else + return; + #endif +} + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule(modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, "RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* RaiseArgTupleInvalid */ +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* RaiseDoubleKeywords */ +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +/* ParseKeywords */ +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +/* PyObjectGetAttrStr */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* PyDictVersioning */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { + PyObject **dictptr = NULL; + Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; + if (offset) { +#if CYTHON_COMPILING_IN_CPYTHON + dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); +#else + dictptr = _PyObject_GetDictPtr(obj); +#endif + } + return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; +} +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) + return 0; + return obj_dict_version == __Pyx_get_object_dict_version(obj); +} +#endif + +/* GetModuleGlobalName */ +#if CYTHON_USE_DICT_VERSIONS +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) +#else +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) +#endif +{ + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 + result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } else if (unlikely(PyErr_Occurred())) { + return NULL; + } +#else + result = PyDict_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } +#endif +#else + result = PyObject_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); +} + +/* PyCFunctionFastCall */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { + PyCFunctionObject *func = (PyCFunctionObject*)func_obj; + PyCFunction meth = PyCFunction_GET_FUNCTION(func); + PyObject *self = PyCFunction_GET_SELF(func); + int flags = PyCFunction_GET_FLAGS(func); + assert(PyCFunction_Check(func)); + assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); + assert(nargs >= 0); + assert(nargs == 0 || args != NULL); + /* _PyCFunction_FastCallDict() must not be called with an exception set, + because it may clear it (directly or indirectly) and so the + caller loses its exception */ + assert(!PyErr_Occurred()); + if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { + return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); + } else { + return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); + } +} +#endif + +/* PyFunctionFastCall */ +#if CYTHON_FAST_PYCALL +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + fastlocals = __Pyx_PyFrame_GetLocalsplus(f); + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; + } + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; +#endif + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + return NULL; + } + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && +#endif + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif +#endif + +/* PyObjectCall */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* 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) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallOneArg */ +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, &arg, 1); + } +#endif + if (likely(PyCFunction_Check(func))) { + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); +#if CYTHON_FAST_PYCCALL + } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); +#endif + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +/* PyIntCompare */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED long inplace) { + if (op1 == op2) { + Py_RETURN_TRUE; + } + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long a = PyInt_AS_LONG(op1); + if (a == b) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + int unequal; + unsigned long uintval; + Py_ssize_t size = Py_SIZE(op1); + const digit* digits = ((PyLongObject*)op1)->ob_digit; + if (intval == 0) { + if (size == 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } else if (intval < 0) { + if (size >= 0) + Py_RETURN_FALSE; + intval = -intval; + size = -size; + } else { + if (size <= 0) + Py_RETURN_FALSE; + } + uintval = (unsigned long) intval; +#if PyLong_SHIFT * 4 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 4)) { + unequal = (size != 5) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[4] != ((uintval >> (4 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif +#if PyLong_SHIFT * 3 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 3)) { + unequal = (size != 4) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif +#if PyLong_SHIFT * 2 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 2)) { + unequal = (size != 3) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif +#if PyLong_SHIFT * 1 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 1)) { + unequal = (size != 2) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif + unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK)); + if (unequal == 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + if ((double)a == (double)b) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } + return ( + PyObject_RichCompare(op1, op2, Py_EQ)); +} + +/* SliceObject */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj, + Py_ssize_t cstart, Py_ssize_t cstop, + PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice, + int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) { +#if CYTHON_USE_TYPE_SLOTS + PyMappingMethods* mp; +#if PY_MAJOR_VERSION < 3 + PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence; + if (likely(ms && ms->sq_slice)) { + if (!has_cstart) { + if (_py_start && (*_py_start != Py_None)) { + cstart = __Pyx_PyIndex_AsSsize_t(*_py_start); + if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; + } else + cstart = 0; + } + if (!has_cstop) { + if (_py_stop && (*_py_stop != Py_None)) { + cstop = __Pyx_PyIndex_AsSsize_t(*_py_stop); + if ((cstop == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; + } else + cstop = PY_SSIZE_T_MAX; + } + if (wraparound && unlikely((cstart < 0) | (cstop < 0)) && likely(ms->sq_length)) { + Py_ssize_t l = ms->sq_length(obj); + if (likely(l >= 0)) { + if (cstop < 0) { + cstop += l; + if (cstop < 0) cstop = 0; + } + if (cstart < 0) { + cstart += l; + if (cstart < 0) cstart = 0; + } + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + goto bad; + PyErr_Clear(); + } + } + return ms->sq_slice(obj, cstart, cstop); + } +#endif + mp = Py_TYPE(obj)->tp_as_mapping; + if (likely(mp && mp->mp_subscript)) +#endif + { + PyObject* result; + PyObject *py_slice, *py_start, *py_stop; + if (_py_slice) { + py_slice = *_py_slice; + } else { + PyObject* owned_start = NULL; + PyObject* owned_stop = NULL; + if (_py_start) { + py_start = *_py_start; + } else { + if (has_cstart) { + owned_start = py_start = PyInt_FromSsize_t(cstart); + if (unlikely(!py_start)) goto bad; + } else + py_start = Py_None; + } + if (_py_stop) { + py_stop = *_py_stop; + } else { + if (has_cstop) { + owned_stop = py_stop = PyInt_FromSsize_t(cstop); + if (unlikely(!py_stop)) { + Py_XDECREF(owned_start); + goto bad; + } + } else + py_stop = Py_None; + } + py_slice = PySlice_New(py_start, py_stop, Py_None); + Py_XDECREF(owned_start); + Py_XDECREF(owned_stop); + if (unlikely(!py_slice)) goto bad; + } +#if CYTHON_USE_TYPE_SLOTS + result = mp->mp_subscript(obj, py_slice); +#else + result = PyObject_GetItem(obj, py_slice); +#endif + if (!_py_slice) { + Py_DECREF(py_slice); + } + return result; + } + PyErr_Format(PyExc_TypeError, + "'%.200s' object is unsliceable", Py_TYPE(obj)->tp_name); +bad: + return NULL; +} + +/* Import */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_MAJOR_VERSION < 3 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_MAJOR_VERSION < 3 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +} +#endif + +/* CLineInTraceback */ +#ifndef CYTHON_CLINE_IN_TRACEBACK +static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { + PyObject *use_cline; + PyObject *ptype, *pvalue, *ptraceback; +#if CYTHON_COMPILING_IN_CPYTHON + PyObject **cython_runtime_dict; +#endif + if (unlikely(!__pyx_cython_runtime)) { + return c_line; + } + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); +#if CYTHON_COMPILING_IN_CPYTHON + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); + if (likely(cython_runtime_dict)) { + __PYX_PY_DICT_LOOKUP_IF_MODIFIED( + use_cline, *cython_runtime_dict, + __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) + } else +#endif + { + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + if (use_cline_obj) { + use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_DECREF(use_cline_obj); + } else { + PyErr_Clear(); + use_cline = NULL; + } + } + if (!use_cline) { + 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)) { + c_line = 0; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + return c_line; +} +#endif + +/* CodeObjectCache */ +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +/* AddTraceback */ +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + if (c_line) { + c_line = __Pyx_CLineForTraceback(tstate, c_line); + } + py_code = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); + } + py_frame = PyFrame_New( + tstate, /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +/* CIntFromPyVerify */ +#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +/* CIntFromPy */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* CIntFromPy */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* FastTypeChecks */ +#if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = a->tp_base; + if (a == b) + return 1; + } + return b == &PyBaseObject_Type; +} +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (a == b) return 1; + mro = a->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(a, b); +} +#if PY_MAJOR_VERSION == 2 +static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { + PyObject *exception, *value, *tb; + int res; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&exception, &value, &tb); + res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + if (!res) { + res = PyObject_IsSubclass(err, exc_type2); + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + } + __Pyx_ErrRestore(exception, value, tb); + return res; +} +#else +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { + int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; + if (!res) { + res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + } + return res; +} +#endif +static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + assert(PyExceptionClass_Check(exc_type)); + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; ip) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + if (PyObject_Hash(*t->p) == -1) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#if !CYTHON_PEP393_ENABLED +static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +} +#else +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (likely(PyUnicode_IS_ASCII(o))) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +} +#endif +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { + return __Pyx_PyUnicode_AsStringAndSize(o, length); + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static 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)) { + if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, + "__int__ returned non-int (type %.200s). " + "The ability to return an instance of a strict subclass of int " + "is deprecated, and may be removed in a future version of Python.", + Py_TYPE(result)->tp_name)) { + Py_DECREF(result); + return NULL; + } + return result; + } +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + type_name, type_name, Py_TYPE(result)->tp_name); + Py_DECREF(result); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x) || PyLong_Check(x))) +#else + if (likely(PyLong_Check(x))) +#endif + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + #if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = m->nb_int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = m->nb_long(x); + } + #else + if (likely(m && m->nb_int)) { + name = "int"; + res = m->nb_int(x); + } + #endif +#else + if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { + res = PyNumber_Int(x); + } +#endif + if (likely(res)) { +#if PY_MAJOR_VERSION < 3 + if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { +#else + if (unlikely(!PyLong_CheckExact(res))) { +#endif + return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(b); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { + return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/somsphere/cython/core.pyx b/somsphere/cython/core.pyx new file mode 100644 index 0000000..9acd5db --- /dev/null +++ b/somsphere/cython/core.pyx @@ -0,0 +1,12 @@ +#cython: language_level=3 +import numpy + +def get_best_cell(inputs, importance, n_pix, weights, return_vals=1): + """ + Return the closest cell to the input object + It can return more than one value if needed + """ + activations = numpy.sum(numpy.transpose([importance]) * ( + numpy.transpose(numpy.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0) + + return numpy.argmin(activations) if return_vals == 1 else numpy.argsort(activations)[0:return_vals], activations From ace87639ee42f9c153303f371589052e1a55a0ac Mon Sep 17 00:00:00 2001 From: Ruiqi Li Date: Sat, 3 Oct 2020 21:29:01 -0400 Subject: [PATCH 4/7] Add more Cython --- Example.ipynb | 144 +- somsphere/__init__.py | 309 +- somsphere/cython/core.c | 21442 +++++++++++++++++++++++++++++++--- somsphere/cython/core.pyx | 43 +- somsphere/utils/__init__.py | 101 +- 5 files changed, 20246 insertions(+), 1793 deletions(-) diff --git a/Example.ipynb b/Example.ipynb index 0940de9..052cdf6 100644 --- a/Example.ipynb +++ b/Example.ipynb @@ -2,31 +2,23 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 16, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING: WrongDBMModuleWarning: Existing astropy cache is in an unsupported format, either install the appropriate package or use astropy.utils.data.clear_download_cache() to delete the whole cache; db type is dbm.gnu, but the module is not available [astropy.utils.data]\n", - "WARNING: leap-second auto-update failed due to the following exception: WrongDBMModule('Existing astropy cache is in an unsupported format, either install the appropriate package or use astropy.utils.data.clear_download_cache() to delete the whole cache; db type is dbm.gnu, but the module is not available') [astropy.time.core]\n" - ] - } - ], + "outputs": [], "source": [ "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "import somsphere\n", "import healpy as hp\n", "import numpy as np\n", + "import time\n", "\n", "data = \"resources/SDSS_MGS.train\"" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -35,7 +27,7 @@ "(5000, 9)" ] }, - "execution_count": 2, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -48,7 +40,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -57,7 +49,7 @@ "(5000,)" ] }, - "execution_count": 3, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -70,26 +62,36 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "#create an instance\n", - "M=somsphere.SOMap(Data_X, Data_Y,topology='grid', n_top=15, n_iter=100, periodic=False)" + "M=somsphere.SOMap(topology='grid', n_top=15, n_iter=100, periodic=False)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Finished in 27.136485815048218\n" + ] + } + ], "source": [ - "M.create_map() #This actually creates the map using only Data_X" + "start = time.time()\n", + "M.create_map(Data_X, Data_Y) #This actually creates the map using only Data_X\n", + "print(f\"Finished in {time.time() - start}\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -98,16 +100,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "M.plot_map()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -117,28 +132,64 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "ValueError", + "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()", + "output_type": "error", + "traceback": [ + "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", + "\u001B[0;31mValueError\u001B[0m Traceback (most recent call last)", + "\u001B[0;32m\u001B[0m in \u001B[0;36m\u001B[0;34m\u001B[0m\n\u001B[0;32m----> 1\u001B[0;31m \u001B[0mM\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mplot_map\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mData_X\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mData_Y\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m", + "\u001B[0;32m~/dev/somsphere/somsphere/__init__.py\u001B[0m in \u001B[0;36mplot_map\u001B[0;34m(self, min_m, max_m, cbar)\u001B[0m\n\u001B[1;32m 114\u001B[0m \u001B[0maccum_w\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0mkk\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0;34m:\u001B[0m\u001B[0;34m]\u001B[0m \u001B[0;34m+=\u001B[0m \u001B[0mcore\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mcount_modified_cells\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mbest\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mdist_lib\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0msigma\u001B[0m\u001B[0;34m)\u001B[0m \u001B[0;34m*\u001B[0m \u001B[0minputs\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0mkk\u001B[0m\u001B[0;34m]\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 115\u001B[0m \u001B[0maccum_n\u001B[0m \u001B[0;34m+=\u001B[0m \u001B[0mcore\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mcount_modified_cells\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mbest\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mdist_lib\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0msigma\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m--> 116\u001B[0;31m \u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m 117\u001B[0m \u001B[0;32mfor\u001B[0m \u001B[0mkk\u001B[0m \u001B[0;32min\u001B[0m \u001B[0mrange\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mn_col\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 118\u001B[0m \u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mweights\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0mkk\u001B[0m\u001B[0;34m]\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0maccum_w\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0mkk\u001B[0m\u001B[0;34m]\u001B[0m \u001B[0;34m/\u001B[0m \u001B[0maccum_n\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n", + "\u001B[0;32m~/dev/somsphere/somsphere/__init__.py\u001B[0m in \u001B[0;36m__plot_map_grid\u001B[0;34m(self, min_m, max_m, cbar)\u001B[0m\n\u001B[1;32m 229\u001B[0m \u001B[0mM_new\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mnumpy\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mreshape\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mM\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0;34m(\u001B[0m\u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mn_top\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mn_top\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 230\u001B[0m \u001B[0mplt\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mfigure\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mfigsize\u001B[0m\u001B[0;34m=\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;36m8\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0;36m8\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mdpi\u001B[0m\u001B[0;34m=\u001B[0m\u001B[0;36m100\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m--> 231\u001B[0;31m \u001B[0mmin_m\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mM_new\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0mnumpy\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mwhere\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mM_new\u001B[0m \u001B[0;34m>\u001B[0m \u001B[0;34m-\u001B[0m\u001B[0;36m10\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m]\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mmin\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m \u001B[0;32mif\u001B[0m \u001B[0mmin_m\u001B[0m \u001B[0;34m==\u001B[0m \u001B[0;34m-\u001B[0m\u001B[0;36m100\u001B[0m \u001B[0;32melse\u001B[0m \u001B[0mmin_m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m 232\u001B[0m \u001B[0mmax_m\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mM_new\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mmax\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m \u001B[0;32mif\u001B[0m \u001B[0mmax_m\u001B[0m \u001B[0;34m==\u001B[0m \u001B[0;34m-\u001B[0m\u001B[0;36m100\u001B[0m \u001B[0;32melse\u001B[0m \u001B[0mmax_m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 233\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n", + "\u001B[0;31mValueError\u001B[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "M.plot_map()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "#Every time the map is created it will be different given the random weights\n", - "M.create_map()" + "M.create_map(Data_X, Data_Y)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "M.evaluate_map()\n", "M.plot_map()" @@ -146,9 +197,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "M.evaluate_map(input_y=Data_X[:,0])\n", "M.plot_map()" @@ -156,21 +220,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ "#Spherical coordinates\n", - "M_sph=somsphere.SOMap(Data_X, Data_Y,topology='sphere', n_top=8, n_iter=100)" + "M_sph=somsphere.SOMap(topology='sphere', n_top=8, n_iter=100)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ - "M_sph.create_map()" + "M_sph.create_map(Data_X, Data_Y)" ] }, { @@ -703,9 +767,9 @@ ], "metadata": { "kernelspec": { - "display_name": "env37", + "display_name": "env38", "language": "python", - "name": "env37" + "name": "env38" }, "language_info": { "codemirror_mode": { @@ -717,9 +781,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.9" + "version": "3.8.2" } }, "nbformat": 4, "nbformat_minor": 1 -} +} \ No newline at end of file diff --git a/somsphere/__init__.py b/somsphere/__init__.py index 064f9c4..f28fb68 100644 --- a/somsphere/__init__.py +++ b/somsphere/__init__.py @@ -8,6 +8,7 @@ import os import random +import core import healpy as hp import matplotlib as mpl import matplotlib.cm as cm @@ -16,9 +17,8 @@ from matplotlib import collections from matplotlib.colors import colorConverter -import core from somsphere.models import Topology, DY, SomType -from somsphere.utils import get_sigma, is_power_2, compute_distance, count_modified_cells, get_alpha +from somsphere.utils import compute_distance, get_best_cell, get_sigma, get_alpha, is_power_2, timeit class SOMap(object): @@ -40,13 +40,11 @@ class SOMap(object): :param str importance: Path to the file with importance ranking for attributes, default is none """ - def __init__(self, X, Y, topology='grid', som_type='online', n_top=28, n_iter=30, alpha_start=0.8, alpha_end=0.5, - periodic=False, importance=None, dict_dim=None): + def __init__(self, topology='grid', som_type='online', n_top=28, n_iter=30, alpha_start=0.8, + alpha_end=0.5, periodic=False, dict_dim=None): if topology == 'sphere' and not is_power_2(n_top): raise Exception("Error, n_top must be power of 2") - self.X = X - self.Y = Y self.topology: Topology = Topology(topology) self.som_type: SomType = SomType(som_type) self.n_top = n_top @@ -55,52 +53,80 @@ def __init__(self, X, Y, topology='grid', som_type='online', n_top=28, n_iter=30 self.alpha_end = alpha_end self.periodic = periodic self.dict_dim = dict_dim - self.n_row, self.n_col = numpy.shape(X) self.dist_lib, self.n_pix = compute_distance(self.topology, self.n_top, periodic=self.periodic) - importance = numpy.ones(self.n_col) if importance is None else importance - self.importance = importance / numpy.sum(importance) - - self.weights = (numpy.random.rand(self.n_col, self.n_pix)) + self.X[0][0] - - def create_map(self, inputs_weights=None, random_order=True, eval_map=False): + def create_map(self, X, Y, importance=None, inputs_weights=None, random_order=True, eval_map=False): """ This functions actually create the maps, it uses random values to initialize the weights """ - self.__update_weights(inputs_weights) + n_row, n_col = numpy.shape(X) + importance = numpy.ones(n_col) if importance is None else importance + self.X, self.Y = X, Y + self.importance = importance / numpy.sum(importance) + self.weights = inputs_weights if inputs_weights is not None else (numpy.random.rand(n_col, self.n_pix)) + \ + self.X[0][0] + + if self.som_type == SomType.ONLINE: + self.__create_map_online(n_row=n_row, random_order=random_order, eval_map=eval_map) + elif self.som_type == SomType.BATCH: + self.__create_map_batch(n_row=n_row, n_col=n_col, eval_map=eval_map) + else: + raise Exception(f"Unknown type: {self.som_type}") + + @timeit + def __create_map_online(self, n_row, random_order=True, eval_map=False): + t, total_t = 0, self.n_iter * n_row + sigma_0 = self.dist_lib.max() + sigma_f = numpy.min(self.dist_lib[numpy.where(self.dist_lib > 0.)]) + + for it in range(self.n_iter): + alpha = get_alpha(self.alpha_end, self.alpha_start, t, total_t) + sigma = get_sigma(sigma_f, sigma_0, t, total_t) + random_indices = random.sample(range(n_row), n_row) if random_order else numpy.arange( + n_row) + core.create_map_online(X=self.X, n_row=n_row, alpha=alpha, sigma=sigma, + random_indices=random_indices, importance=self.importance, + weights=self.weights, n_pix=self.n_pix, dist_lib=self.dist_lib) + + # for i in range(n_row): + # inputs = self.X[random_indices[i]] + # best, activation = get_best_cell(inputs=inputs, importance=self.importance, + # weights=self.weights, n_pix=self.n_pix) + # self.weights += alpha * count_modified_cells(best, self.dist_lib, sigma) * numpy.transpose( + # (inputs - numpy.transpose(self.weights))) - t, total_t = 0, self.n_iter * self.n_row + t += n_row + + if eval_map: + self.evaluate_map() + self.save_map(itn=it) + + @timeit + def __create_map_batch(self, n_row, n_col, eval_map=False): + t, total_t = 0, self.n_iter * n_row sigma_0 = self.dist_lib.max() sigma_f = numpy.min(self.dist_lib[numpy.where(self.dist_lib > 0.)]) for it in range(self.n_iter): sigma = get_sigma(sigma_f, sigma_0, t, total_t) - if self.som_type == SomType.ONLINE: - # get alpha, sigma - alpha = get_alpha(self.alpha_end, self.alpha_start, t, total_t) - random_indices = random.sample(range(self.n_row), self.n_row) if random_order else numpy.arange( - self.n_row) - for i in range(self.n_row): - inputs = self.X[random_indices[i]] - best, activation = core.get_best_cell(inputs=inputs, importance=self.importance, weights=self.weights, n_pix=self.n_pix) - self.weights += alpha * count_modified_cells(best, self.dist_lib, sigma) * numpy.transpose( - (inputs - numpy.transpose(self.weights))) - - elif self.som_type == SomType.BATCH: - # get alpha, sigma - accum_w = numpy.zeros((self.n_col, self.n_pix)) - accum_n = numpy.zeros(self.n_pix) - for i in range(self.n_row): - inputs = self.X[i] - best, activation = core.get_best_cell(inputs=inputs, importance=self.importance, weights=self.weights, n_pix=self.n_pix) - for kk in range(self.n_col): - accum_w[kk, :] += count_modified_cells(best, self.dist_lib, sigma) * inputs[kk] - accum_n += count_modified_cells(best, self.dist_lib, sigma) - - for kk in range(self.n_col): - self.weights[kk] = accum_w[kk] / accum_n - t += self.n_row + accum_w = numpy.zeros((n_col, self.n_pix)) + accum_n = numpy.zeros(self.n_pix) + core.create_map_batch(X=self.X, n_row=n_row, n_col=n_col, accum_n=accum_n, accum_w=accum_w, sigma=sigma, + importance=self.importance, weights=self.weights, n_pix=self.n_pix, + dist_lib=self.dist_lib) + # for i in range(n_row): + # inputs = self.X[i] + # best, activation = get_best_cell(inputs=inputs, importance=self.importance, + # weights=self.weights, n_pix=self.n_pix) + # for kk in range(n_col): + # accum_w[kk, :] += count_modified_cells(best, self.dist_lib, sigma) * inputs[kk] + # accum_n += count_modified_cells(best, self.dist_lib, sigma) + # + # for kk in range(n_col): + # self.weights[kk] = accum_w[kk] / accum_n + + t += n_row if eval_map: self.evaluate_map() @@ -122,7 +148,8 @@ def evaluate_map(self, input_x=None, input_y=None): in_y = self.Y if input_y is None else input_y for i in range(len(in_x)): inputs = in_x[i] - best, activation = core.get_best_cell(inputs=inputs, importance=self.importance, weights=self.weights, n_pix=self.n_pix) + best, activation = get_best_cell(inputs=inputs, importance=self.importance, weights=self.weights, + n_pix=self.n_pix) if best not in self.y_vals: self.y_vals[best] = [] self.y_vals[best].append(in_y[i]) @@ -130,92 +157,6 @@ def evaluate_map(self, input_x=None, input_y=None): self.i_vals[best] = [] self.i_vals[best].append(i) - def plot_map(self, min_m=-100, max_m=-100, cbar=True): - """ - Plots the map after evaluating, the cells are colored with the mean value inside each - one of them - - :param float min_m: Lower limit for coloring the cells, -100 uses min value - :param float max_m: Upper limit for coloring the cells, -100 uses max value - :param bool cbar: Include a colorbar True/False - """ - - if self.topology == Topology.SPHERE: - M = numpy.zeros(self.n_pix) + hp.UNSEEN - for i in range(self.n_pix): - if i in self.y_vals: - M[i] = numpy.mean(self.y_vals[i]) - plt.figure(10, figsize=(8, 8), dpi=100) - min_m = M[numpy.where(M > -10)].min() if min_m == -100 else min_m - max_m = M.max() if max_m == -100 else max_m - hp.mollview(M, fig=10, title="", min=min_m, max=max_m, cbar=cbar) - - if self.topology == Topology.GRID: - M = numpy.zeros(self.n_pix) - 20. - for i in range(self.n_pix): - if i in self.y_vals: - M[i] = numpy.mean(self.y_vals[i]) - M_new = numpy.reshape(M, (self.n_top, self.n_top)) - plt.figure(figsize=(8, 8), dpi=100) - min_m = M_new[numpy.where(M_new > -10)].min() if min_m == -100 else min_m - max_m = M_new.max() if max_m == -100 else max_m - - M_plot = plt.imshow(M_new, origin='center', interpolation='nearest', cmap=cm.jet, vmin=min_m, vmax=max_m) - M_plot.cmap.set_under("grey") - if cbar: - plt.colorbar() - plt.axis('off') - if self.topology == Topology.HEX: - ptr = 0 - x_l, y_l = numpy.arange(0, self.n_top, 1.), numpy.arange(0, self.n_top, DY) - nx, ny = len(x_l), len(y_l) - n_pix = nx * ny - b_x, b_y = numpy.zeros(n_pix), numpy.zeros(n_pix) - for y_idx in range(ny): - for x_idx in range(nx): - b_x[ptr] = x_l[x_idx] + 0. if y_idx % 2 == 0 else 0.5 - b_y[ptr] = y_l[y_idx] - ptr += 1 - - fcolors = [plt.cm.Spectral_r(x) for x in numpy.random.rand(nx * ny)] - M = numpy.zeros(n_pix) - 20. - for i in range(n_pix): - if i in self.y_vals: - M[i] = numpy.mean(self.y_vals[i]) - - min_m = M[numpy.where(M > -10)].min() if min_m == -100 else min_m - max_m = M.max() if max_m == -100 else max_m - - M = M - min_m - M = M / (max_m - min_m) - for i in range(n_pix): - if M[i] <= 0: - fcolors[i] = plt.cm.Greys(.5) - else: - fcolors[i] = plt.cm.jet(M[i]) - fig_y = ((8. * 0.78 / (self.n_top + 0.5) / 2.) * (3. * ny + 1) / numpy.sqrt(3)) / 0.78 - fig = plt.figure(figsize=(8, fig_y), dpi=100) - ax = fig.add_subplot(1, 1, 1) - col = collections.RegularPolyCollection(6, - sizes=numpy.zeros(nx * ny) + ((8. * 0.78 / ( - self.n_top + 0.5)) / 2. * 72.) ** 2 * 4. * numpy.pi / 3., - offsets=list(zip(b_x, b_y)), - transOffset=ax.transData) - col.set_color(fcolors) - ax.add_collection(col, autolim=True) - ax.set_xlim(-0.5, nx) - ax.set_ylim(-1, nx + 0.5) - plt.axis('off') - if cbar: - figbar = plt.figure(figsize=(8, 1.), dpi=100) - ax1 = figbar.add_axes([0.05, 0.8, 0.9, 0.15]) - cmap = cm.jet - norm = mpl.colors.Normalize(vmin=min_m, vmax=max_m) - cb = mpl.colorbar.ColorbarBase(ax1, cmap=cmap, norm=norm, orientation='horizontal') - cb.set_label('') - - plt.show() - def predict(self, line, best=True): """ Get the predictions given a line search, where the line @@ -227,7 +168,8 @@ def predict(self, line, best=True): :param bool best: Set to True to get only the best cell; otherwise the 10 closest cells will be returned :return: array with the cell content """ - bests, _ = core.get_best_cell(inputs=line, importance=self.importance, weights=self.weights, n_pix=self.n_pix, return_vals=10) + bests, _ = get_best_cell(inputs=line, importance=self.importance, weights=self.weights, n_pix=self.n_pix, + return_vals=10) if best: return bests[0] for ib in range(10): @@ -256,15 +198,102 @@ def save_map(self, filename='SOM', path=None, itn=-1): numpy.save(path + filename, self) numpy.save(path + filename + ".txt", som) - def __update_weights(self, inputs_weights): - self.weights = inputs_weights if inputs_weights is not None else self.weights - - # def __core.get_best_cell(self, inputs, return_vals=1): - # """ - # Return the closest cell to the input object - # It can return more than one value if needed - # """ - # activations = numpy.sum(numpy.transpose([self.importance]) * ( - # numpy.transpose(numpy.tile(inputs, (self.n_pix, 1))) - self.weights) ** 2, axis=0) - # - # return numpy.argmin(activations) if return_vals == 1 else numpy.argsort(activations)[0:return_vals], activations + def plot_map(self, min_m=-100, max_m=-100, cbar=True): + """ + Plots the map after evaluating, the cells are colored with the mean value inside each + one of them + + :param float min_m: Lower limit for coloring the cells, -100 uses min value + :param float max_m: Upper limit for coloring the cells, -100 uses max value + :param bool cbar: Include a colorbar True/False + """ + + if self.topology == Topology.SPHERE: + self.__plot_map_sphere(min_m, max_m, cbar) + + elif self.topology == Topology.GRID: + self.__plot_map_grid(min_m, max_m, cbar) + + elif self.topology == Topology.HEX: + self.__plot_map_hex(min_m, max_m, cbar) + else: + raise Exception(f"Unknown topology: {self.topology}") + + def __plot_map_sphere(self, min_m, max_m, cbar): + M = numpy.zeros(self.n_pix) + hp.UNSEEN + for i in range(self.n_pix): + if i in self.y_vals: + M[i] = numpy.mean(self.y_vals[i]) + plt.figure(10, figsize=(8, 8), dpi=100) + min_m = M[numpy.where(M > -10)].min() if min_m == -100 else min_m + max_m = M.max() if max_m == -100 else max_m + hp.mollview(M, fig=10, title="", min=min_m, max=max_m, cbar=cbar) + plt.show() + + def __plot_map_grid(self, min_m, max_m, cbar): + M = numpy.zeros(self.n_pix) - 20. + for i in range(self.n_pix): + if i in self.y_vals: + M[i] = numpy.mean(self.y_vals[i]) + M_new = numpy.reshape(M, (self.n_top, self.n_top)) + plt.figure(figsize=(8, 8), dpi=100) + min_m = M_new[numpy.where(M_new > -10)].min() if min_m == -100 else min_m + max_m = M_new.max() if max_m == -100 else max_m + + M_plot = plt.imshow(M_new, origin='center', interpolation='nearest', cmap=cm.jet, vmin=min_m, vmax=max_m) + M_plot.cmap.set_under("grey") + if cbar: + plt.colorbar() + plt.axis('off') + + plt.show() + + def __plot_map_hex(self, min_m, max_m, cbar): + ptr = 0 + x_l, y_l = numpy.arange(0, self.n_top, 1.), numpy.arange(0, self.n_top, DY) + nx, ny = len(x_l), len(y_l) + n_pix = nx * ny + b_x, b_y = numpy.zeros(n_pix), numpy.zeros(n_pix) + for y_idx in range(ny): + for x_idx in range(nx): + b_x[ptr] = x_l[x_idx] + 0. if y_idx % 2 == 0 else 0.5 + b_y[ptr] = y_l[y_idx] + ptr += 1 + + fcolors = [plt.cm.Spectral_r(x) for x in numpy.random.rand(nx * ny)] + M = numpy.zeros(n_pix) - 20. + for i in range(n_pix): + if i in self.y_vals: + M[i] = numpy.mean(self.y_vals[i]) + + min_m = M[numpy.where(M > -10)].min() if min_m == -100 else min_m + max_m = M.max() if max_m == -100 else max_m + + M = M - min_m + M = M / (max_m - min_m) + for i in range(n_pix): + if M[i] <= 0: + fcolors[i] = plt.cm.Greys(.5) + else: + fcolors[i] = plt.cm.jet(M[i]) + fig_y = ((8. * 0.78 / (self.n_top + 0.5) / 2.) * (3. * ny + 1) / numpy.sqrt(3)) / 0.78 + fig = plt.figure(figsize=(8, fig_y), dpi=100) + ax = fig.add_subplot(1, 1, 1) + col = collections.RegularPolyCollection(6, + sizes=numpy.zeros(nx * ny) + ((8. * 0.78 / ( + self.n_top + 0.5)) / 2. * 72.) ** 2 * 4. * numpy.pi / 3., + offsets=list(zip(b_x, b_y)), + transOffset=ax.transData) + col.set_color(fcolors) + ax.add_collection(col, autolim=True) + ax.set_xlim(-0.5, nx) + ax.set_ylim(-1, nx + 0.5) + plt.axis('off') + if cbar: + figbar = plt.figure(figsize=(8, 1.), dpi=100) + ax1 = figbar.add_axes([0.05, 0.8, 0.9, 0.15]) + cmap = cm.jet + norm = mpl.colors.Normalize(vmin=min_m, vmax=max_m) + cb = mpl.colorbar.ColorbarBase(ax1, cmap=cmap, norm=norm, orientation='horizontal') + cb.set_label('') + plt.show() diff --git a/somsphere/cython/core.c b/somsphere/cython/core.c index 082ac94..5ac34eb 100644 --- a/somsphere/cython/core.c +++ b/somsphere/cython/core.c @@ -617,6 +617,11 @@ static CYTHON_INLINE float __PYX_NAN() { #define __PYX_HAVE__core #define __PYX_HAVE_API__core /* Early includes */ +#include "pythread.h" +#include +#include +#include +#include "pystate.h" #ifdef _OPENMP #include #endif /* _OPENMP */ @@ -826,9 +831,247 @@ static const char *__pyx_filename; static const char *__pyx_f[] = { "somsphere/cython/core.pyx", + "stringsource", }; +/* MemviewSliceStruct.proto */ +struct __pyx_memoryview_obj; +typedef struct { + struct __pyx_memoryview_obj *memview; + char *data; + Py_ssize_t shape[8]; + Py_ssize_t strides[8]; + Py_ssize_t suboffsets[8]; +} __Pyx_memviewslice; +#define __Pyx_MemoryView_Len(m) (m.shape[0]) + +/* Atomics.proto */ +#include +#ifndef CYTHON_ATOMICS + #define CYTHON_ATOMICS 1 +#endif +#define __pyx_atomic_int_type int +#if CYTHON_ATOMICS && __GNUC__ >= 4 && (__GNUC_MINOR__ > 1 ||\ + (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL >= 2)) &&\ + !defined(__i386__) + #define __pyx_atomic_incr_aligned(value, lock) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_decr_aligned(value, lock) __sync_fetch_and_sub(value, 1) + #ifdef __PYX_DEBUG_ATOMICS + #warning "Using GNU atomics" + #endif +#elif CYTHON_ATOMICS && defined(_MSC_VER) && 0 + #include + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type LONG + #define __pyx_atomic_incr_aligned(value, lock) InterlockedIncrement(value) + #define __pyx_atomic_decr_aligned(value, lock) InterlockedDecrement(value) + #ifdef __PYX_DEBUG_ATOMICS + #pragma message ("Using MSVC atomics") + #endif +#elif CYTHON_ATOMICS && (defined(__ICC) || defined(__INTEL_COMPILER)) && 0 + #define __pyx_atomic_incr_aligned(value, lock) _InterlockedIncrement(value) + #define __pyx_atomic_decr_aligned(value, lock) _InterlockedDecrement(value) + #ifdef __PYX_DEBUG_ATOMICS + #warning "Using Intel atomics" + #endif +#else + #undef CYTHON_ATOMICS + #define CYTHON_ATOMICS 0 + #ifdef __PYX_DEBUG_ATOMICS + #warning "Not using atomics" + #endif +#endif +typedef volatile __pyx_atomic_int_type __pyx_atomic_int; +#if CYTHON_ATOMICS + #define __pyx_add_acquisition_count(memview)\ + __pyx_atomic_incr_aligned(__pyx_get_slice_count_pointer(memview), memview->lock) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_atomic_decr_aligned(__pyx_get_slice_count_pointer(memview), memview->lock) +#else + #define __pyx_add_acquisition_count(memview)\ + __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) +#endif + +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + +/* NoFastGil.proto */ +#define __Pyx_PyGILState_Ensure PyGILState_Ensure +#define __Pyx_PyGILState_Release PyGILState_Release +#define __Pyx_FastGIL_Remember() +#define __Pyx_FastGIL_Forget() +#define __Pyx_FastGilFuncInit() + +/* BufferFormatStructs.proto */ +#define IS_UNSIGNED(type) (((type) -1) > 0) +struct __Pyx_StructField_; +#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) +typedef struct { + const char* name; + struct __Pyx_StructField_* fields; + size_t size; + size_t arraysize[8]; + int ndim; + char typegroup; + char is_unsigned; + int flags; +} __Pyx_TypeInfo; +typedef struct __Pyx_StructField_ { + __Pyx_TypeInfo* type; + const char* name; + size_t offset; +} __Pyx_StructField; +typedef struct { + __Pyx_StructField* field; + size_t parent_offset; +} __Pyx_BufFmt_StackElem; +typedef struct { + __Pyx_StructField root; + __Pyx_BufFmt_StackElem* head; + size_t fmt_offset; + size_t new_count, enc_count; + size_t struct_alignment; + int is_complex; + char enc_type; + char new_packmode; + char enc_packmode; + char is_valid_array; +} __Pyx_BufFmt_Context; + /*--- Type declarations ---*/ +struct __pyx_array_obj; +struct __pyx_MemviewEnum_obj; +struct __pyx_memoryview_obj; +struct __pyx_memoryviewslice_obj; + +/* "View.MemoryView":105 + * + * @cname("__pyx_array") + * cdef class array: # <<<<<<<<<<<<<< + * + * cdef: + */ +struct __pyx_array_obj { + PyObject_HEAD + struct __pyx_vtabstruct_array *__pyx_vtab; + char *data; + Py_ssize_t len; + char *format; + int ndim; + Py_ssize_t *_shape; + Py_ssize_t *_strides; + Py_ssize_t itemsize; + PyObject *mode; + PyObject *_format; + void (*callback_free_data)(void *); + int free_data; + int dtype_is_object; +}; + + +/* "View.MemoryView":279 + * + * @cname('__pyx_MemviewEnum') + * cdef class Enum(object): # <<<<<<<<<<<<<< + * cdef object name + * def __init__(self, name): + */ +struct __pyx_MemviewEnum_obj { + PyObject_HEAD + PyObject *name; +}; + + +/* "View.MemoryView":330 + * + * @cname('__pyx_memoryview') + * cdef class memoryview(object): # <<<<<<<<<<<<<< + * + * cdef object obj + */ +struct __pyx_memoryview_obj { + PyObject_HEAD + struct __pyx_vtabstruct_memoryview *__pyx_vtab; + PyObject *obj; + PyObject *_size; + PyObject *_array_interface; + PyThread_type_lock lock; + __pyx_atomic_int acquisition_count[2]; + __pyx_atomic_int *acquisition_count_aligned_p; + Py_buffer view; + int flags; + int dtype_is_object; + __Pyx_TypeInfo *typeinfo; +}; + + +/* "View.MemoryView":965 + * + * @cname('__pyx_memoryviewslice') + * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< + * "Internal class for passing memoryview slices to Python" + * + */ +struct __pyx_memoryviewslice_obj { + struct __pyx_memoryview_obj __pyx_base; + __Pyx_memviewslice from_slice; + PyObject *from_object; + PyObject *(*to_object_func)(char *); + int (*to_dtype_func)(char *, PyObject *); +}; + + + +/* "View.MemoryView":105 + * + * @cname("__pyx_array") + * cdef class array: # <<<<<<<<<<<<<< + * + * cdef: + */ + +struct __pyx_vtabstruct_array { + PyObject *(*get_memview)(struct __pyx_array_obj *); +}; +static struct __pyx_vtabstruct_array *__pyx_vtabptr_array; + + +/* "View.MemoryView":330 + * + * @cname('__pyx_memoryview') + * cdef class memoryview(object): # <<<<<<<<<<<<<< + * + * cdef object obj + */ + +struct __pyx_vtabstruct_memoryview { + char *(*get_item_pointer)(struct __pyx_memoryview_obj *, PyObject *); + PyObject *(*is_slice)(struct __pyx_memoryview_obj *, PyObject *); + PyObject *(*setitem_slice_assignment)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); + PyObject *(*setitem_slice_assign_scalar)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *); + PyObject *(*setitem_indexed)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); + PyObject *(*convert_item_to_object)(struct __pyx_memoryview_obj *, char *); + PyObject *(*assign_item_from_object)(struct __pyx_memoryview_obj *, char *, PyObject *); +}; +static struct __pyx_vtabstruct_memoryview *__pyx_vtabptr_memoryview; + + +/* "View.MemoryView":965 + * + * @cname('__pyx_memoryviewslice') + * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< + * "Internal class for passing memoryview slices to Python" + * + */ + +struct __pyx_vtabstruct__memoryviewslice { + struct __pyx_vtabstruct_memoryview __pyx_base; +}; +static struct __pyx_vtabstruct__memoryviewslice *__pyx_vtabptr__memoryviewslice; /* --- Runtime support code (head) --- */ /* Refnanny.proto */ @@ -894,6 +1137,16 @@ static const char *__pyx_f[] = { #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + /* RaiseArgTupleInvalid.proto */ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); @@ -906,15 +1159,27 @@ static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ const char* function_name); -/* PyObjectGetAttrStr.proto */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) -#endif - -/* GetBuiltinName.proto */ -static PyObject *__Pyx_GetBuiltinName(PyObject *name); +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound, int boundscheck); /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS @@ -963,11 +1228,30 @@ static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_ve static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif -/* PyCFunctionFastCall.proto */ -#if CYTHON_FAST_PYCCALL -static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); #else -#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* RaiseTooManyValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +/* RaiseNeedMoreValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +/* IterFinish.proto */ +static CYTHON_INLINE int __Pyx_IterFinish(void); + +/* UnpackItemEndCheck.proto */ +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); + +/* ObjectGetItem.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key); +#else +#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) #endif /* PyFunctionFastCall.proto */ @@ -993,13 +1277,49 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) #endif -/* PyObjectCall.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +/* PyCFunctionFastCall.proto */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); #else -#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) #endif +/* MemviewSliceInit.proto */ +#define __Pyx_BUF_MAX_NDIMS %(BUF_MAX_NDIMS)d +#define __Pyx_MEMVIEW_DIRECT 1 +#define __Pyx_MEMVIEW_PTR 2 +#define __Pyx_MEMVIEW_FULL 4 +#define __Pyx_MEMVIEW_CONTIG 8 +#define __Pyx_MEMVIEW_STRIDED 16 +#define __Pyx_MEMVIEW_FOLLOW 32 +#define __Pyx_IS_C_CONTIG 1 +#define __Pyx_IS_F_CONTIG 2 +static int __Pyx_init_memviewslice( + struct __pyx_memoryview_obj *memview, + int ndim, + __Pyx_memviewslice *memviewslice, + int memview_is_new_reference); +static CYTHON_INLINE int __pyx_add_acquisition_count_locked( + __pyx_atomic_int *acquisition_count, PyThread_type_lock lock); +static CYTHON_INLINE int __pyx_sub_acquisition_count_locked( + __pyx_atomic_int *acquisition_count, PyThread_type_lock lock); +#define __pyx_get_slice_count_pointer(memview) (memview->acquisition_count_aligned_p) +#define __pyx_get_slice_count(memview) (*__pyx_get_slice_count_pointer(memview)) +#define __PYX_INC_MEMVIEW(slice, have_gil) __Pyx_INC_MEMVIEW(slice, have_gil, __LINE__) +#define __PYX_XDEC_MEMVIEW(slice, have_gil) __Pyx_XDEC_MEMVIEW(slice, have_gil, __LINE__) +static CYTHON_INLINE void __Pyx_INC_MEMVIEW(__Pyx_memviewslice *, int, int); +static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW(__Pyx_memviewslice *, int, int); + +/* SetItemInt.proto */ +#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\ + __Pyx_SetItemInt_Generic(o, to_py_func(i), v))) +static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); +static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, + int is_list, int wraparound, int boundscheck); + /* PyObjectCall2Args.proto */ static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); @@ -1011,17 +1331,11 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); -/* PyIntCompare.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, long intval, long inplace); - -/* SliceObject.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice( - PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, - PyObject** py_start, PyObject** py_stop, PyObject** py_slice, - int has_cstart, int has_cstop, int wraparound); - -/* Import.proto */ -static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); +/* ArgTypeTest.proto */ +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ + ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + __Pyx__ArgTypeTest(obj, type, name, exact)) +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE @@ -1059,6 +1373,213 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* IncludeStringH.proto */ +#include + +/* BytesEquals.proto */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* StrEquals.proto */ +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals +#else +#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals +#endif + +/* None.proto */ +static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t, Py_ssize_t); + +/* UnaryNegOverflows.proto */ +#define UNARY_NEG_WOULD_OVERFLOW(x)\ + (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x))) + +static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *); /*proto*/ +/* GetAttr.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); + +/* decode_c_string_utf16.proto */ +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = 0; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16LE(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = -1; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16BE(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = 1; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} + +/* decode_c_string.proto */ +static CYTHON_INLINE PyObject* __Pyx_decode_c_string( + const char* cstring, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); + +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* GetAttr3.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); + +/* RaiseNoneIterError.proto */ +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); + +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +/* GetTopmostException.proto */ +#if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); +#endif + +/* SaveResetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +#else +#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) +#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) +#endif + +/* GetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* SwapException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* Import.proto */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +/* FastTypeChecks.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); +#else +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) +#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) +#endif +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) + +static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +/* ListCompAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len)) { + Py_INCREF(x); + PyList_SET_ITEM(list, len, x); + __Pyx_SET_SIZE(list, len + 1); + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) +#endif + +/* PyIntBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) +#endif + +/* ListExtend.proto */ +static CYTHON_INLINE int __Pyx_PyList_Extend(PyObject* L, PyObject* v) { +#if CYTHON_COMPILING_IN_CPYTHON + PyObject* none = _PyList_Extend((PyListObject*)L, v); + if (unlikely(!none)) + return -1; + Py_DECREF(none); + return 0; +#else + return PyList_SetSlice(L, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, v); +#endif +} + +/* ListAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { + Py_INCREF(x); + PyList_SET_ITEM(list, len, x); + __Pyx_SET_SIZE(list, len + 1); + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_PyList_Append(L,x) PyList_Append(L,x) +#endif + +/* None.proto */ +static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); + +/* None.proto */ +static CYTHON_INLINE long __Pyx_div_long(long, long); + +/* ImportFrom.proto */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); + +/* HasAttr.proto */ +static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); + +/* PyObject_GenericGetAttrNoDict.proto */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr +#endif + +/* PyObject_GenericGetAttr.proto */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr +#endif + +/* SetVTable.proto */ +static int __Pyx_SetVtable(PyObject *dict, void *vtable); + +/* PyObjectGetAttrStrNoError.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + +/* SetupReduce.proto */ +static int __Pyx_setup_reduce(PyObject* type_obj); + /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) @@ -1085,27 +1606,91 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); +#if PY_MAJOR_VERSION < 3 + static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); + static void __Pyx_ReleaseBuffer(Py_buffer *view); +#else + #define __Pyx_GetBuffer PyObject_GetBuffer + #define __Pyx_ReleaseBuffer PyBuffer_Release +#endif + + +/* BufferStructDeclare.proto */ +typedef struct { + Py_ssize_t shape, strides, suboffsets; +} __Pyx_Buf_DimInfo; +typedef struct { + size_t refcount; + Py_buffer pybuffer; +} __Pyx_Buffer; +typedef struct { + __Pyx_Buffer *rcbuffer; + char *data; + __Pyx_Buf_DimInfo diminfo[8]; +} __Pyx_LocalBuf_ND; + +/* MemviewSliceIsContig.proto */ +static int __pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim); + +/* OverlappingSlices.proto */ +static int __pyx_slices_overlap(__Pyx_memviewslice *slice1, + __Pyx_memviewslice *slice2, + int ndim, size_t itemsize); + +/* Capsule.proto */ +static CYTHON_INLINE PyObject *__pyx_capsule_create(void *p, const char *sig); + /* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +/* MemviewDtypeToObject.proto */ +static CYTHON_INLINE PyObject *__pyx_memview_get_double(const char *itemp); +static CYTHON_INLINE int __pyx_memview_set_double(const char *itemp, PyObject *obj); + +/* MemviewSliceCopyTemplate.proto */ +static __Pyx_memviewslice +__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, + const char *mode, int ndim, + size_t sizeof_dtype, int contig_flag, + int dtype_is_object); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + /* CIntFromPy.proto */ -static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); +static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *); -/* FastTypeChecks.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) -static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); -static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); -static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); -#else -#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) -#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) -#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) -#endif -#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) +/* IsLittleEndian.proto */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); + +/* BufferFormatCheck.proto */ +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type); + +/* TypeInfoCompare.proto */ +static int __pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b); + +/* MemviewSliceValidateAndInit.proto */ +static int __Pyx_ValidateAndInit_memviewslice( + int *axes_specs, + int c_or_f_flag, + int buf_flags, + int ndim, + __Pyx_TypeInfo *dtype, + __Pyx_BufFmt_StackElem stack[], + __Pyx_memviewslice *memviewslice, + PyObject *original_obj); + +/* ObjectToMemviewSlice.proto */ +static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_ds_double(PyObject *, int writable_flag); /* CheckBinaryVersion.proto */ static int __Pyx_check_binary_version(void); @@ -1113,95 +1698,444 @@ static int __Pyx_check_binary_version(void); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); +static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self); /* proto*/ +static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto*/ +static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj); /* proto*/ +static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src); /* proto*/ +static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value); /* proto*/ +static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto*/ +static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/ +static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/ +static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/ +static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/ /* Module declarations from 'core' */ +static PyTypeObject *__pyx_array_type = 0; +static PyTypeObject *__pyx_MemviewEnum_type = 0; +static PyTypeObject *__pyx_memoryview_type = 0; +static PyTypeObject *__pyx_memoryviewslice_type = 0; +static PyObject *generic = 0; +static PyObject *strided = 0; +static PyObject *indirect = 0; +static PyObject *contiguous = 0; +static PyObject *indirect_contiguous = 0; +static int __pyx_memoryview_thread_locks_used; +static PyThread_type_lock __pyx_memoryview_thread_locks[8]; +static struct __pyx_array_obj *__pyx_array_new(PyObject *, Py_ssize_t, char *, char *, char *); /*proto*/ +static void *__pyx_align_pointer(void *, size_t); /*proto*/ +static PyObject *__pyx_memoryview_new(PyObject *, int, int, __Pyx_TypeInfo *); /*proto*/ +static CYTHON_INLINE int __pyx_memoryview_check(PyObject *); /*proto*/ +static PyObject *_unellipsify(PyObject *, int); /*proto*/ +static PyObject *assert_direct_dimensions(Py_ssize_t *, int); /*proto*/ +static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *, PyObject *); /*proto*/ +static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int, int); /*proto*/ +static char *__pyx_pybuffer_index(Py_buffer *, char *, Py_ssize_t, Py_ssize_t); /*proto*/ +static int __pyx_memslice_transpose(__Pyx_memviewslice *); /*proto*/ +static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice, int, PyObject *(*)(char *), int (*)(char *, PyObject *), int); /*proto*/ +static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ +static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ +static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *); /*proto*/ +static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ +static Py_ssize_t abs_py_ssize_t(Py_ssize_t); /*proto*/ +static char __pyx_get_best_slice_order(__Pyx_memviewslice *, int); /*proto*/ +static void _copy_strided_to_strided(char *, Py_ssize_t *, char *, Py_ssize_t *, Py_ssize_t *, Py_ssize_t *, int, size_t); /*proto*/ +static void copy_strided_to_strided(__Pyx_memviewslice *, __Pyx_memviewslice *, int, size_t); /*proto*/ +static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *, int); /*proto*/ +static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *, Py_ssize_t *, Py_ssize_t, int, char); /*proto*/ +static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *, __Pyx_memviewslice *, char, int); /*proto*/ +static int __pyx_memoryview_err_extents(int, Py_ssize_t, Py_ssize_t); /*proto*/ +static int __pyx_memoryview_err_dim(PyObject *, char *, int); /*proto*/ +static int __pyx_memoryview_err(PyObject *, char *); /*proto*/ +static int __pyx_memoryview_copy_contents(__Pyx_memviewslice, __Pyx_memviewslice, int, int, int); /*proto*/ +static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *, int, int); /*proto*/ +static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *, int, int, int); /*proto*/ +static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/ +static void __pyx_memoryview_refcount_objects_in_slice(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/ +static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *, int, size_t, void *, int); /*proto*/ +static void __pyx_memoryview__slice_assign_scalar(char *, Py_ssize_t *, Py_ssize_t *, int, size_t, void *); /*proto*/ +static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *, PyObject *); /*proto*/ +static __Pyx_TypeInfo __Pyx_TypeInfo_double = { "double", NULL, sizeof(double), { 0 }, 0, 'R', 0, 0 }; #define __Pyx_MODULE_NAME "core" extern int __pyx_module_is_main_core; int __pyx_module_is_main_core = 0; /* Implementation of 'core' */ -static const char __pyx_k_sum[] = "sum"; -static const char __pyx_k_axis[] = "axis"; +static PyObject *__pyx_builtin_range; +static PyObject *__pyx_builtin_ValueError; +static PyObject *__pyx_builtin_MemoryError; +static PyObject *__pyx_builtin_enumerate; +static PyObject *__pyx_builtin_TypeError; +static PyObject *__pyx_builtin_Ellipsis; +static PyObject *__pyx_builtin_id; +static PyObject *__pyx_builtin_IndexError; +static const char __pyx_k_O[] = "O"; +static const char __pyx_k_X[] = "X"; +static const char __pyx_k_c[] = "c"; +static const char __pyx_k_i[] = "i"; +static const char __pyx_k_j[] = "j"; +static const char __pyx_k_k[] = "k"; +static const char __pyx_k_an[] = "an"; +static const char __pyx_k_id[] = "id"; +static const char __pyx_k_nc[] = "nc"; +static const char __pyx_k_nr[] = "nr"; +static const char __pyx_k_alp[] = "alp"; +static const char __pyx_k_imp[] = "imp"; +static const char __pyx_k_new[] = "__new__"; +static const char __pyx_k_obj[] = "obj"; +static const char __pyx_k_sig[] = "sig"; +static const char __pyx_k_base[] = "base"; +static const char __pyx_k_best[] = "best"; static const char __pyx_k_core[] = "core"; +static const char __pyx_k_dict[] = "__dict__"; static const char __pyx_k_main[] = "__main__"; -static const char __pyx_k_name[] = "__name__"; +static const char __pyx_k_mode[] = "mode"; +static const char __pyx_k_name[] = "name"; +static const char __pyx_k_ndim[] = "ndim"; +static const char __pyx_k_npix[] = "npix"; +static const char __pyx_k_pack[] = "pack"; +static const char __pyx_k_size[] = "size"; +static const char __pyx_k_step[] = "step"; +static const char __pyx_k_stop[] = "stop"; static const char __pyx_k_test[] = "__test__"; -static const char __pyx_k_tile[] = "tile"; +static const char __pyx_k_ASCII[] = "ASCII"; +static const char __pyx_k_alpha[] = "alpha"; +static const char __pyx_k_class[] = "__class__"; +static const char __pyx_k_error[] = "error"; +static const char __pyx_k_flags[] = "flags"; +static const char __pyx_k_n_col[] = "n_col"; static const char __pyx_k_n_pix[] = "n_pix"; +static const char __pyx_k_n_row[] = "n_row"; static const char __pyx_k_numpy[] = "numpy"; -static const char __pyx_k_argmin[] = "argmin"; +static const char __pyx_k_range[] = "range"; +static const char __pyx_k_shape[] = "shape"; +static const char __pyx_k_sigma[] = "sigma"; +static const char __pyx_k_start[] = "start"; +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_inputs[] = "inputs"; -static const char __pyx_k_argsort[] = "argsort"; +static const char __pyx_k_name_2[] = "__name__"; +static const char __pyx_k_pickle[] = "pickle"; +static const char __pyx_k_reduce[] = "__reduce__"; +static const char __pyx_k_struct[] = "struct"; +static const char __pyx_k_timeit[] = "timeit"; +static const char __pyx_k_unpack[] = "unpack"; +static const char __pyx_k_update[] = "update"; +static const char __pyx_k_accum_n[] = "accum_n"; +static const char __pyx_k_accum_w[] = "accum_w"; +static const char __pyx_k_fortran[] = "fortran"; +static const char __pyx_k_memview[] = "memview"; static const char __pyx_k_weights[] = "weights"; +static const char __pyx_k_Ellipsis[] = "Ellipsis"; +static const char __pyx_k_dist_lib[] = "dist_lib"; +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_setstate[] = "__setstate__"; +static const char __pyx_k_TypeError[] = "TypeError"; +static const char __pyx_k_enumerate[] = "enumerate"; +static const char __pyx_k_pyx_state[] = "__pyx_state"; +static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; static const char __pyx_k_transpose[] = "transpose"; +static const char __pyx_k_IndexError[] = "IndexError"; +static const char __pyx_k_ValueError[] = "ValueError"; +static const char __pyx_k_activation[] = "activation"; static const char __pyx_k_importance[] = "importance"; -static const char __pyx_k_activations[] = "activations"; -static const char __pyx_k_return_vals[] = "return_vals"; +static const char __pyx_k_pyx_result[] = "__pyx_result"; +static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; +static const char __pyx_k_MemoryError[] = "MemoryError"; +static const char __pyx_k_PickleError[] = "PickleError"; +static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; +static const char __pyx_k_stringsource[] = "stringsource"; static const char __pyx_k_get_best_cell[] = "get_best_cell"; +static const char __pyx_k_pyx_getbuffer[] = "__pyx_getbuffer"; +static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; +static const char __pyx_k_random_indices[] = "random_indices"; +static const char __pyx_k_View_MemoryView[] = "View.MemoryView"; +static const char __pyx_k_allocate_buffer[] = "allocate_buffer"; +static const char __pyx_k_dtype_is_object[] = "dtype_is_object"; +static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError"; +static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; +static const char __pyx_k_somsphere_utils[] = "somsphere.utils"; +static const char __pyx_k_create_map_batch[] = "create_map_batch"; +static const char __pyx_k_create_map_online[] = "create_map_online"; +static const char __pyx_k_pyx_unpickle_Enum[] = "__pyx_unpickle_Enum"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; +static const char __pyx_k_strided_and_direct[] = ""; +static const char __pyx_k_count_modified_cells[] = "count_modified_cells"; +static const char __pyx_k_strided_and_indirect[] = ""; +static const char __pyx_k_contiguous_and_direct[] = ""; +static const char __pyx_k_MemoryView_of_r_object[] = ""; +static const char __pyx_k_MemoryView_of_r_at_0x_x[] = ""; +static const char __pyx_k_contiguous_and_indirect[] = ""; +static const char __pyx_k_Cannot_index_with_type_s[] = "Cannot index with type '%s'"; +static const char __pyx_k_Invalid_shape_in_axis_d_d[] = "Invalid shape in axis %d: %d."; static const char __pyx_k_somsphere_cython_core_pyx[] = "somsphere/cython/core.pyx"; -static PyObject *__pyx_n_s_activations; -static PyObject *__pyx_n_s_argmin; -static PyObject *__pyx_n_s_argsort; -static PyObject *__pyx_n_s_axis; +static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cython.array"; +static const char __pyx_k_unable_to_allocate_array_data[] = "unable to allocate array data."; +static const char __pyx_k_strided_and_direct_or_indirect[] = ""; +static const char __pyx_k_Buffer_view_does_not_expose_stri[] = "Buffer view does not expose strides"; +static const char __pyx_k_Can_only_create_a_buffer_that_is[] = "Can only create a buffer that is contiguous in memory."; +static const char __pyx_k_Cannot_assign_to_read_only_memor[] = "Cannot assign to read-only memoryview"; +static const char __pyx_k_Cannot_create_writable_memory_vi[] = "Cannot create writable memory view from read-only memoryview"; +static const char __pyx_k_Empty_shape_tuple_for_cython_arr[] = "Empty shape tuple for cython.array"; +static const char __pyx_k_Incompatible_checksums_s_vs_0xb0[] = "Incompatible checksums (%s vs 0xb068931 = (name))"; +static const char __pyx_k_Indirect_dimensions_not_supporte[] = "Indirect dimensions not supported"; +static const char __pyx_k_Invalid_mode_expected_c_or_fortr[] = "Invalid mode, expected 'c' or 'fortran', got %s"; +static const char __pyx_k_Out_of_bounds_on_buffer_access_a[] = "Out of bounds on buffer access (axis %d)"; +static const char __pyx_k_Unable_to_convert_item_to_object[] = "Unable to convert item to object"; +static const char __pyx_k_got_differing_extents_in_dimensi[] = "got differing extents in dimension %d (got %d and %d)"; +static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; +static const char __pyx_k_unable_to_allocate_shape_and_str[] = "unable to allocate shape and strides."; +static PyObject *__pyx_n_s_ASCII; +static PyObject *__pyx_kp_s_Buffer_view_does_not_expose_stri; +static PyObject *__pyx_kp_s_Can_only_create_a_buffer_that_is; +static PyObject *__pyx_kp_s_Cannot_assign_to_read_only_memor; +static PyObject *__pyx_kp_s_Cannot_create_writable_memory_vi; +static PyObject *__pyx_kp_s_Cannot_index_with_type_s; +static PyObject *__pyx_n_s_Ellipsis; +static PyObject *__pyx_kp_s_Empty_shape_tuple_for_cython_arr; +static PyObject *__pyx_kp_s_Incompatible_checksums_s_vs_0xb0; +static PyObject *__pyx_n_s_IndexError; +static PyObject *__pyx_kp_s_Indirect_dimensions_not_supporte; +static PyObject *__pyx_kp_s_Invalid_mode_expected_c_or_fortr; +static PyObject *__pyx_kp_s_Invalid_shape_in_axis_d_d; +static PyObject *__pyx_n_s_MemoryError; +static PyObject *__pyx_kp_s_MemoryView_of_r_at_0x_x; +static PyObject *__pyx_kp_s_MemoryView_of_r_object; +static PyObject *__pyx_n_b_O; +static PyObject *__pyx_kp_s_Out_of_bounds_on_buffer_access_a; +static PyObject *__pyx_n_s_PickleError; +static PyObject *__pyx_n_s_TypeError; +static PyObject *__pyx_kp_s_Unable_to_convert_item_to_object; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_n_s_View_MemoryView; +static PyObject *__pyx_n_s_X; +static PyObject *__pyx_n_s_accum_n; +static PyObject *__pyx_n_s_accum_w; +static PyObject *__pyx_n_s_activation; +static PyObject *__pyx_n_s_allocate_buffer; +static PyObject *__pyx_n_s_alp; +static PyObject *__pyx_n_s_alpha; +static PyObject *__pyx_n_s_an; +static PyObject *__pyx_n_s_base; +static PyObject *__pyx_n_s_best; +static PyObject *__pyx_n_s_c; +static PyObject *__pyx_n_u_c; +static PyObject *__pyx_n_s_class; static PyObject *__pyx_n_s_cline_in_traceback; +static PyObject *__pyx_kp_s_contiguous_and_direct; +static PyObject *__pyx_kp_s_contiguous_and_indirect; static PyObject *__pyx_n_s_core; +static PyObject *__pyx_n_s_count_modified_cells; +static PyObject *__pyx_n_s_create_map_batch; +static PyObject *__pyx_n_s_create_map_online; +static PyObject *__pyx_n_s_dict; +static PyObject *__pyx_n_s_dist_lib; +static PyObject *__pyx_n_s_dtype_is_object; +static PyObject *__pyx_n_s_encode; +static PyObject *__pyx_n_s_enumerate; +static PyObject *__pyx_n_s_error; +static PyObject *__pyx_n_s_flags; +static PyObject *__pyx_n_s_format; +static PyObject *__pyx_n_s_fortran; +static PyObject *__pyx_n_u_fortran; static PyObject *__pyx_n_s_get_best_cell; +static PyObject *__pyx_n_s_getstate; +static PyObject *__pyx_kp_s_got_differing_extents_in_dimensi; +static PyObject *__pyx_n_s_i; +static PyObject *__pyx_n_s_id; +static PyObject *__pyx_n_s_imp; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_importance; static PyObject *__pyx_n_s_inputs; +static PyObject *__pyx_n_s_itemsize; +static PyObject *__pyx_kp_s_itemsize_0_for_cython_array; +static PyObject *__pyx_n_s_j; +static PyObject *__pyx_n_s_k; static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_memview; +static PyObject *__pyx_n_s_mode; +static PyObject *__pyx_n_s_n_col; static PyObject *__pyx_n_s_n_pix; +static PyObject *__pyx_n_s_n_row; static PyObject *__pyx_n_s_name; +static PyObject *__pyx_n_s_name_2; +static PyObject *__pyx_n_s_nc; +static PyObject *__pyx_n_s_ndim; +static PyObject *__pyx_n_s_new; +static PyObject *__pyx_kp_s_no_default___reduce___due_to_non; +static PyObject *__pyx_n_s_npix; +static PyObject *__pyx_n_s_nr; static PyObject *__pyx_n_s_numpy; -static PyObject *__pyx_n_s_return_vals; +static PyObject *__pyx_n_s_obj; +static PyObject *__pyx_n_s_pack; +static PyObject *__pyx_n_s_pickle; +static PyObject *__pyx_n_s_pyx_PickleError; +static PyObject *__pyx_n_s_pyx_checksum; +static PyObject *__pyx_n_s_pyx_getbuffer; +static PyObject *__pyx_n_s_pyx_result; +static PyObject *__pyx_n_s_pyx_state; +static PyObject *__pyx_n_s_pyx_type; +static PyObject *__pyx_n_s_pyx_unpickle_Enum; +static PyObject *__pyx_n_s_pyx_vtable; +static PyObject *__pyx_n_s_random_indices; +static PyObject *__pyx_n_s_range; +static PyObject *__pyx_n_s_reduce; +static PyObject *__pyx_n_s_reduce_cython; +static PyObject *__pyx_n_s_reduce_ex; +static PyObject *__pyx_n_s_setstate; +static PyObject *__pyx_n_s_setstate_cython; +static PyObject *__pyx_n_s_shape; +static PyObject *__pyx_n_s_sig; +static PyObject *__pyx_n_s_sigma; +static PyObject *__pyx_n_s_size; static PyObject *__pyx_kp_s_somsphere_cython_core_pyx; -static PyObject *__pyx_n_s_sum; +static PyObject *__pyx_n_s_somsphere_utils; +static PyObject *__pyx_n_s_start; +static PyObject *__pyx_n_s_step; +static PyObject *__pyx_n_s_stop; +static PyObject *__pyx_kp_s_strided_and_direct; +static PyObject *__pyx_kp_s_strided_and_direct_or_indirect; +static PyObject *__pyx_kp_s_strided_and_indirect; +static PyObject *__pyx_kp_s_stringsource; +static PyObject *__pyx_n_s_struct; static PyObject *__pyx_n_s_test; -static PyObject *__pyx_n_s_tile; +static PyObject *__pyx_n_s_timeit; static PyObject *__pyx_n_s_transpose; +static PyObject *__pyx_kp_s_unable_to_allocate_array_data; +static PyObject *__pyx_kp_s_unable_to_allocate_shape_and_str; +static PyObject *__pyx_n_s_unpack; +static PyObject *__pyx_n_s_update; static PyObject *__pyx_n_s_weights; -static PyObject *__pyx_pf_4core_get_best_cell(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_inputs, PyObject *__pyx_v_importance, PyObject *__pyx_v_n_pix, PyObject *__pyx_v_weights, PyObject *__pyx_v_return_vals); /* proto */ +static PyObject *__pyx_pf_4core_create_map_batch(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_n_row, PyObject *__pyx_v_n_col, PyObject *__pyx_v_accum_w, PyObject *__pyx_v_accum_n, PyObject *__pyx_v_sigma, PyObject *__pyx_v_importance, PyObject *__pyx_v_n_pix, PyObject *__pyx_v_dist_lib, PyObject *__pyx_v_weights); /* proto */ +static PyObject *__pyx_pf_4core_2create_map_online(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_n_row, CYTHON_UNUSED PyObject *__pyx_v_alpha, PyObject *__pyx_v_sigma, PyObject *__pyx_v_random_indices, PyObject *__pyx_v_importance, PyObject *__pyx_v_n_pix, PyObject *__pyx_v_dist_lib, PyObject *__pyx_v_weights); /* proto */ +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer); /* proto */ +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self); /* proto */ +static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr); /* proto */ +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item); /* proto */ +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ +static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object); /* proto */ +static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto */ +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto */ +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_int_0; static PyObject *__pyx_int_1; -static PyObject *__pyx_int_2; -static PyObject *__pyx_tuple_; -static PyObject *__pyx_codeobj__2; +static PyObject *__pyx_int_184977713; +static PyObject *__pyx_int_neg_1; +static PyObject *__pyx_slice_; +static PyObject *__pyx_tuple__2; +static PyObject *__pyx_tuple__3; +static PyObject *__pyx_tuple__4; +static PyObject *__pyx_tuple__5; +static PyObject *__pyx_tuple__6; +static PyObject *__pyx_tuple__7; +static PyObject *__pyx_tuple__8; +static PyObject *__pyx_tuple__9; +static PyObject *__pyx_tuple__10; +static PyObject *__pyx_tuple__11; +static PyObject *__pyx_tuple__12; +static PyObject *__pyx_tuple__13; +static PyObject *__pyx_tuple__14; +static PyObject *__pyx_tuple__15; +static PyObject *__pyx_tuple__16; +static PyObject *__pyx_tuple__17; +static PyObject *__pyx_tuple__18; +static PyObject *__pyx_tuple__19; +static PyObject *__pyx_tuple__21; +static PyObject *__pyx_tuple__23; +static PyObject *__pyx_tuple__24; +static PyObject *__pyx_tuple__25; +static PyObject *__pyx_tuple__26; +static PyObject *__pyx_tuple__27; +static PyObject *__pyx_tuple__28; +static PyObject *__pyx_codeobj__20; +static PyObject *__pyx_codeobj__22; +static PyObject *__pyx_codeobj__29; /* Late includes */ -/* "core.pyx":4 - * import numpy +/* "core.pyx":6 + * from somsphere.utils import get_best_cell, count_modified_cells, timeit * - * def get_best_cell(inputs, importance, n_pix, weights, return_vals=1): # <<<<<<<<<<<<<< - * """ - * Return the closest cell to the input object + * def create_map_batch(X, n_row, n_col, accum_w, accum_n, sigma, importance, n_pix, dist_lib, weights): # <<<<<<<<<<<<<< + * cdef int i, j, k + * cdef int nr = n_row */ /* Python wrapper */ -static PyObject *__pyx_pw_4core_1get_best_cell(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_4core_get_best_cell[] = "\n Return the closest cell to the input object\n It can return more than one value if needed\n "; -static PyMethodDef __pyx_mdef_4core_1get_best_cell = {"get_best_cell", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_1get_best_cell, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4core_get_best_cell}; -static PyObject *__pyx_pw_4core_1get_best_cell(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_inputs = 0; +static PyObject *__pyx_pw_4core_1create_map_batch(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_4core_1create_map_batch = {"create_map_batch", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_1create_map_batch, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4core_1create_map_batch(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_X = 0; + PyObject *__pyx_v_n_row = 0; + PyObject *__pyx_v_n_col = 0; + PyObject *__pyx_v_accum_w = 0; + PyObject *__pyx_v_accum_n = 0; + PyObject *__pyx_v_sigma = 0; PyObject *__pyx_v_importance = 0; PyObject *__pyx_v_n_pix = 0; + PyObject *__pyx_v_dist_lib = 0; PyObject *__pyx_v_weights = 0; - PyObject *__pyx_v_return_vals = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("get_best_cell (wrapper)", 0); + __Pyx_RefNannySetupContext("create_map_batch (wrapper)", 0); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_inputs,&__pyx_n_s_importance,&__pyx_n_s_n_pix,&__pyx_n_s_weights,&__pyx_n_s_return_vals,0}; - PyObject* values[5] = {0,0,0,0,0}; - values[4] = ((PyObject *)__pyx_int_1); + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_X,&__pyx_n_s_n_row,&__pyx_n_s_n_col,&__pyx_n_s_accum_w,&__pyx_n_s_accum_n,&__pyx_n_s_sigma,&__pyx_n_s_importance,&__pyx_n_s_n_pix,&__pyx_n_s_dist_lib,&__pyx_n_s_weights,0}; + PyObject* values[10] = {0,0,0,0,0,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 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); CYTHON_FALLTHROUGH; case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); @@ -1218,799 +2152,15881 @@ static PyObject *__pyx_pw_4core_1get_best_cell(PyObject *__pyx_self, PyObject *_ kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_inputs)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_X)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_importance)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_row)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("get_best_cell", 0, 4, 5, 1); __PYX_ERR(0, 4, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("create_map_batch", 1, 10, 10, 1); __PYX_ERR(0, 6, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_pix)) != 0)) kw_args--; + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_col)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("get_best_cell", 0, 4, 5, 2); __PYX_ERR(0, 4, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("create_map_batch", 1, 10, 10, 2); __PYX_ERR(0, 6, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: - if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_weights)) != 0)) kw_args--; + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_accum_w)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("get_best_cell", 0, 4, 5, 3); __PYX_ERR(0, 4, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("create_map_batch", 1, 10, 10, 3); __PYX_ERR(0, 6, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_return_vals); - if (value) { values[4] = value; kw_args--; } + if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_accum_n)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("create_map_batch", 1, 10, 10, 4); __PYX_ERR(0, 6, __pyx_L3_error) } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_best_cell") < 0)) __PYX_ERR(0, 4, __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); - 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; + case 5: + if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sigma)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("create_map_batch", 1, 10, 10, 5); __PYX_ERR(0, 6, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_importance)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("create_map_batch", 1, 10, 10, 6); __PYX_ERR(0, 6, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 7: + if (likely((values[7] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_pix)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("create_map_batch", 1, 10, 10, 7); __PYX_ERR(0, 6, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 8: + if (likely((values[8] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dist_lib)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("create_map_batch", 1, 10, 10, 8); __PYX_ERR(0, 6, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 9: + if (likely((values[9] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_weights)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("create_map_batch", 1, 10, 10, 9); __PYX_ERR(0, 6, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create_map_batch") < 0)) __PYX_ERR(0, 6, __pyx_L3_error) } + } else if (PyTuple_GET_SIZE(__pyx_args) != 10) { + 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); + values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + values[7] = PyTuple_GET_ITEM(__pyx_args, 7); + values[8] = PyTuple_GET_ITEM(__pyx_args, 8); + values[9] = PyTuple_GET_ITEM(__pyx_args, 9); } - __pyx_v_inputs = values[0]; - __pyx_v_importance = values[1]; - __pyx_v_n_pix = values[2]; - __pyx_v_weights = values[3]; - __pyx_v_return_vals = values[4]; + __pyx_v_X = values[0]; + __pyx_v_n_row = values[1]; + __pyx_v_n_col = values[2]; + __pyx_v_accum_w = values[3]; + __pyx_v_accum_n = values[4]; + __pyx_v_sigma = values[5]; + __pyx_v_importance = values[6]; + __pyx_v_n_pix = values[7]; + __pyx_v_dist_lib = values[8]; + __pyx_v_weights = values[9]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("get_best_cell", 0, 4, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 4, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("create_map_batch", 1, 10, 10, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 6, __pyx_L3_error) __pyx_L3_error:; - __Pyx_AddTraceback("core.get_best_cell", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("core.create_map_batch", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_4core_get_best_cell(__pyx_self, __pyx_v_inputs, __pyx_v_importance, __pyx_v_n_pix, __pyx_v_weights, __pyx_v_return_vals); + __pyx_r = __pyx_pf_4core_create_map_batch(__pyx_self, __pyx_v_X, __pyx_v_n_row, __pyx_v_n_col, __pyx_v_accum_w, __pyx_v_accum_n, __pyx_v_sigma, __pyx_v_importance, __pyx_v_n_pix, __pyx_v_dist_lib, __pyx_v_weights); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_4core_get_best_cell(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_inputs, PyObject *__pyx_v_importance, PyObject *__pyx_v_n_pix, PyObject *__pyx_v_weights, PyObject *__pyx_v_return_vals) { - PyObject *__pyx_v_activations = NULL; +static PyObject *__pyx_pf_4core_create_map_batch(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_n_row, PyObject *__pyx_v_n_col, PyObject *__pyx_v_accum_w, PyObject *__pyx_v_accum_n, PyObject *__pyx_v_sigma, PyObject *__pyx_v_importance, PyObject *__pyx_v_n_pix, PyObject *__pyx_v_dist_lib, PyObject *__pyx_v_weights) { + int __pyx_v_i; + int __pyx_v_j; + int __pyx_v_k; + int __pyx_v_nr; + int __pyx_v_nc; + int __pyx_v_npix; + double __pyx_v_sig; + __Pyx_memviewslice __pyx_v_imp = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_an = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_inputs = NULL; + PyObject *__pyx_v_best = NULL; + CYTHON_UNUSED PyObject *__pyx_v_activation = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; + int __pyx_t_1; + double __pyx_t_2; + __Pyx_memviewslice __pyx_t_3 = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_t_4; + int __pyx_t_5; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; - int __pyx_t_9; - PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *(*__pyx_t_10)(PyObject *); int __pyx_t_11; + int __pyx_t_12; + int __pyx_t_13; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + int __pyx_t_16; + PyObject *__pyx_t_17 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_best_cell", 0); + __Pyx_RefNannySetupContext("create_map_batch", 0); + + /* "core.pyx":8 + * def create_map_batch(X, n_row, n_col, accum_w, accum_n, sigma, importance, n_pix, dist_lib, weights): + * cdef int i, j, k + * cdef int nr = n_row # <<<<<<<<<<<<<< + * cdef int nc = n_col + * cdef int npix = n_pix + */ + __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_n_row); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 8, __pyx_L1_error) + __pyx_v_nr = __pyx_t_1; /* "core.pyx":9 - * It can return more than one value if needed - * """ - * activations = numpy.sum(numpy.transpose([importance]) * ( # <<<<<<<<<<<<<< - * numpy.transpose(numpy.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0) - * + * cdef int i, j, k + * cdef int nr = n_row + * cdef int nc = n_col # <<<<<<<<<<<<<< + * cdef int npix = n_pix + * cdef double sig = sigma */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_sum); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_transpose); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_v_importance); - __Pyx_GIVEREF(__pyx_v_importance); - PyList_SET_ITEM(__pyx_t_3, 0, __pyx_v_importance); - __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - } - } - __pyx_t_1 = (__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_1)) __PYX_ERR(0, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_n_col); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 9, __pyx_L1_error) + __pyx_v_nc = __pyx_t_1; /* "core.pyx":10 - * """ - * activations = numpy.sum(numpy.transpose([importance]) * ( - * numpy.transpose(numpy.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0) # <<<<<<<<<<<<<< - * - * return numpy.argmin(activations) if return_vals == 1 else numpy.argsort(activations)[0:return_vals], activations + * cdef int nr = n_row + * cdef int nc = n_col + * cdef int npix = n_pix # <<<<<<<<<<<<<< + * cdef double sig = sigma + * cdef double[:] imp = importance */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 10, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_transpose); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 10, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_numpy); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 10, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_tile); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 10, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 10, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_INCREF(__pyx_v_n_pix); - __Pyx_GIVEREF(__pyx_v_n_pix); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_v_n_pix); - __Pyx_INCREF(__pyx_int_1); - __Pyx_GIVEREF(__pyx_int_1); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_int_1); - __pyx_t_8 = NULL; - __pyx_t_9 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); - __pyx_t_9 = 1; - } - } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_7)) { - PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_v_inputs, __pyx_t_6}; - __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 10, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_GOTREF(__pyx_t_3); - __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[3] = {__pyx_t_8, __pyx_v_inputs, __pyx_t_6}; - __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 10, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - } else - #endif - { - __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 10, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - if (__pyx_t_8) { - __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; - } - __Pyx_INCREF(__pyx_v_inputs); - __Pyx_GIVEREF(__pyx_v_inputs); - PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_v_inputs); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_6); + __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_n_pix); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 10, __pyx_L1_error) + __pyx_v_npix = __pyx_t_1; + + /* "core.pyx":11 + * cdef int nc = n_col + * cdef int npix = n_pix + * cdef double sig = sigma # <<<<<<<<<<<<<< + * cdef double[:] imp = importance + * cdef double[:] an = accum_n + */ + __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_v_sigma); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 11, __pyx_L1_error) + __pyx_v_sig = __pyx_t_2; + + /* "core.pyx":12 + * cdef int npix = n_pix + * cdef double sig = sigma + * cdef double[:] imp = importance # <<<<<<<<<<<<<< + * cdef double[:] an = accum_n + * for i in range(nr): + */ + __pyx_t_3 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_importance, PyBUF_WRITABLE); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 12, __pyx_L1_error) + __pyx_v_imp = __pyx_t_3; + __pyx_t_3.memview = NULL; + __pyx_t_3.data = NULL; + + /* "core.pyx":13 + * cdef double sig = sigma + * cdef double[:] imp = importance + * cdef double[:] an = accum_n # <<<<<<<<<<<<<< + * for i in range(nr): + * inputs = X[i] + */ + __pyx_t_3 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_accum_n, PyBUF_WRITABLE); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 13, __pyx_L1_error) + __pyx_v_an = __pyx_t_3; + __pyx_t_3.memview = NULL; + __pyx_t_3.data = NULL; + + /* "core.pyx":14 + * cdef double[:] imp = importance + * cdef double[:] an = accum_n + * for i in range(nr): # <<<<<<<<<<<<<< + * inputs = X[i] + * best, activation = get_best_cell(inputs=inputs, importance=imp, + */ + __pyx_t_1 = __pyx_v_nr; + __pyx_t_4 = __pyx_t_1; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "core.pyx":15 + * cdef double[:] an = accum_n + * for i in range(nr): + * inputs = X[i] # <<<<<<<<<<<<<< + * best, activation = get_best_cell(inputs=inputs, importance=imp, + * weights=weights, n_pix=npix) + */ + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_X, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_XDECREF_SET(__pyx_v_inputs, __pyx_t_6); __pyx_t_6 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 10, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - } - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - } - } - __pyx_t_4 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_3); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 10, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = PyNumber_Subtract(__pyx_t_4, __pyx_v_weights); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 10, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyNumber_Power(__pyx_t_5, __pyx_int_2, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 10, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "core.pyx":9 - * It can return more than one value if needed - * """ - * activations = numpy.sum(numpy.transpose([importance]) * ( # <<<<<<<<<<<<<< - * numpy.transpose(numpy.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0) - * + /* "core.pyx":16 + * for i in range(nr): + * inputs = X[i] + * best, activation = get_best_cell(inputs=inputs, importance=imp, # <<<<<<<<<<<<<< + * weights=weights, n_pix=npix) + * for j in range(nc): */ - __pyx_t_5 = PyNumber_Multiply(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); - __pyx_t_5 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_get_best_cell); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_inputs, __pyx_v_inputs) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + __pyx_t_8 = __pyx_memoryview_fromslice(__pyx_v_imp, 1, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_importance, __pyx_t_8) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "core.pyx":10 - * """ - * activations = numpy.sum(numpy.transpose([importance]) * ( - * numpy.transpose(numpy.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0) # <<<<<<<<<<<<<< - * - * return numpy.argmin(activations) if return_vals == 1 else numpy.argsort(activations)[0:return_vals], activations + /* "core.pyx":17 + * inputs = X[i] + * best, activation = get_best_cell(inputs=inputs, importance=imp, + * weights=weights, n_pix=npix) # <<<<<<<<<<<<<< + * for j in range(nc): + * accum_w[j, :] += count_modified_cells(best, dist_lib, sig) * inputs[j] */ - __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 10, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_axis, __pyx_int_0) < 0) __PYX_ERR(0, 10, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_weights, __pyx_v_weights) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_npix); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_n_pix, __pyx_t_8) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "core.pyx":9 - * It can return more than one value if needed - * """ - * activations = numpy.sum(numpy.transpose([importance]) * ( # <<<<<<<<<<<<<< - * numpy.transpose(numpy.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0) + /* "core.pyx":16 + * for i in range(nr): + * inputs = X[i] + * best, activation = get_best_cell(inputs=inputs, importance=imp, # <<<<<<<<<<<<<< + * weights=weights, n_pix=npix) + * for j in range(nc): + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_empty_tuple, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if ((likely(PyTuple_CheckExact(__pyx_t_8))) || (PyList_CheckExact(__pyx_t_8))) { + PyObject* sequence = __pyx_t_8; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 16, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_7 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_7 = PyList_GET_ITEM(sequence, 0); + __pyx_t_6 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx_t_6); + #else + __pyx_t_7 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_9 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_10 = Py_TYPE(__pyx_t_9)->tp_iternext; + index = 0; __pyx_t_7 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_7)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_7); + index = 1; __pyx_t_6 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 2) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + __pyx_t_10 = NULL; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L6_unpacking_done; + __pyx_L5_unpacking_failed:; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_10 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 16, __pyx_L1_error) + __pyx_L6_unpacking_done:; + } + __Pyx_XDECREF_SET(__pyx_v_best, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_XDECREF_SET(__pyx_v_activation, __pyx_t_6); + __pyx_t_6 = 0; + + /* "core.pyx":18 + * best, activation = get_best_cell(inputs=inputs, importance=imp, + * weights=weights, n_pix=npix) + * for j in range(nc): # <<<<<<<<<<<<<< + * accum_w[j, :] += count_modified_cells(best, dist_lib, sig) * inputs[j] + * an += count_modified_cells(best, dist_lib, sig) + */ + __pyx_t_11 = __pyx_v_nc; + __pyx_t_12 = __pyx_t_11; + for (__pyx_t_13 = 0; __pyx_t_13 < __pyx_t_12; __pyx_t_13+=1) { + __pyx_v_j = __pyx_t_13; + + /* "core.pyx":19 + * weights=weights, n_pix=npix) + * for j in range(nc): + * accum_w[j, :] += count_modified_cells(best, dist_lib, sig) * inputs[j] # <<<<<<<<<<<<<< + * an += count_modified_cells(best, dist_lib, sig) * */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_activations = __pyx_t_1; - __pyx_t_1 = 0; + __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_j); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_8); + __Pyx_INCREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_slice_); + __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_v_accum_w, __pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_count_modified_cells); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_14 = PyFloat_FromDouble(__pyx_v_sig); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __pyx_t_15 = NULL; + __pyx_t_16 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_15)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_15); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + __pyx_t_16 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[4] = {__pyx_t_15, __pyx_v_best, __pyx_v_dist_lib, __pyx_t_14}; + __pyx_t_7 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_16, 3+__pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { + PyObject *__pyx_temp[4] = {__pyx_t_15, __pyx_v_best, __pyx_v_dist_lib, __pyx_t_14}; + __pyx_t_7 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_16, 3+__pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + } else + #endif + { + __pyx_t_17 = PyTuple_New(3+__pyx_t_16); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + if (__pyx_t_15) { + __Pyx_GIVEREF(__pyx_t_15); PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_15); __pyx_t_15 = NULL; + } + __Pyx_INCREF(__pyx_v_best); + __Pyx_GIVEREF(__pyx_v_best); + PyTuple_SET_ITEM(__pyx_t_17, 0+__pyx_t_16, __pyx_v_best); + __Pyx_INCREF(__pyx_v_dist_lib); + __Pyx_GIVEREF(__pyx_v_dist_lib); + PyTuple_SET_ITEM(__pyx_t_17, 1+__pyx_t_16, __pyx_v_dist_lib); + __Pyx_GIVEREF(__pyx_t_14); + PyTuple_SET_ITEM(__pyx_t_17, 2+__pyx_t_16, __pyx_t_14); + __pyx_t_14 = 0; + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_17, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + } + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_inputs, __pyx_v_j, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_17 = PyNumber_Multiply(__pyx_t_7, __pyx_t_9); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = PyNumber_InPlaceAdd(__pyx_t_8, __pyx_t_17); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + if (unlikely(PyObject_SetItem(__pyx_v_accum_w, __pyx_t_6, __pyx_t_9) < 0)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } - /* "core.pyx":12 - * numpy.transpose(numpy.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0) + /* "core.pyx":20 + * for j in range(nc): + * accum_w[j, :] += count_modified_cells(best, dist_lib, sig) * inputs[j] + * an += count_modified_cells(best, dist_lib, sig) # <<<<<<<<<<<<<< * - * return numpy.argmin(activations) if return_vals == 1 else numpy.argsort(activations)[0:return_vals], activations # <<<<<<<<<<<<<< + * for k in range(nc): */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = __Pyx_PyInt_EqObjC(__pyx_v_return_vals, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 12, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (__pyx_t_11) { - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_numpy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_argmin); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_4); + __pyx_t_6 = __pyx_memoryview_fromslice(__pyx_v_an, 1, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_count_modified_cells); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_8 = PyFloat_FromDouble(__pyx_v_sig); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = NULL; + __pyx_t_11 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_17))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_17); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_17); + __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); + __Pyx_DECREF_SET(__pyx_t_17, function); + __pyx_t_11 = 1; } } - __pyx_t_5 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v_activations) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_activations); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_1 = __pyx_t_5; - __pyx_t_5 = 0; - } else { - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_numpy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_argsort); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_17)) { + PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_best, __pyx_v_dist_lib, __pyx_t_8}; + __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_17, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_17)) { + PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_best, __pyx_v_dist_lib, __pyx_t_8}; + __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_17, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + { + __pyx_t_14 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_7); __pyx_t_7 = NULL; } + __Pyx_INCREF(__pyx_v_best); + __Pyx_GIVEREF(__pyx_v_best); + PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_11, __pyx_v_best); + __Pyx_INCREF(__pyx_v_dist_lib); + __Pyx_GIVEREF(__pyx_v_dist_lib); + PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_11, __pyx_v_dist_lib); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_14, 2+__pyx_t_11, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_17, __pyx_t_14, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; } - __pyx_t_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_2, __pyx_v_activations) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_activations); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_GetSlice(__pyx_t_5, 0, 0, NULL, &__pyx_v_return_vals, NULL, 1, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_1 = __pyx_t_4; - __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __pyx_t_17 = PyNumber_InPlaceAdd(__pyx_t_6, __pyx_t_9); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_3 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_t_17, PyBUF_WRITABLE); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __PYX_XDEC_MEMVIEW(&__pyx_v_an, 1); + __pyx_v_an = __pyx_t_3; + __pyx_t_3.memview = NULL; + __pyx_t_3.data = NULL; } - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); - __Pyx_INCREF(__pyx_v_activations); - __Pyx_GIVEREF(__pyx_v_activations); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_activations); - __pyx_t_1 = 0; - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; - goto __pyx_L0; - /* "core.pyx":4 - * import numpy + /* "core.pyx":22 + * an += count_modified_cells(best, dist_lib, sig) * - * def get_best_cell(inputs, importance, n_pix, weights, return_vals=1): # <<<<<<<<<<<<<< - * """ - * Return the closest cell to the input object + * for k in range(nc): # <<<<<<<<<<<<<< + * weights[k] = accum_w[k] / an + * + */ + __pyx_t_1 = __pyx_v_nc; + __pyx_t_4 = __pyx_t_1; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_k = __pyx_t_5; + + /* "core.pyx":23 + * + * for k in range(nc): + * weights[k] = accum_w[k] / an # <<<<<<<<<<<<<< + * + * def create_map_online(X, n_row, alpha, sigma, random_indices, importance, n_pix, dist_lib, weights): + */ + __pyx_t_17 = __Pyx_GetItemInt(__pyx_v_accum_w, __pyx_v_k, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_9 = __pyx_memoryview_fromslice(__pyx_v_an, 1, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_6 = __Pyx_PyNumber_Divide(__pyx_t_17, __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(__Pyx_SetItemInt(__pyx_v_weights, __pyx_v_k, __pyx_t_6, int, 1, __Pyx_PyInt_From_int, 0, 1, 1) < 0)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + + /* "core.pyx":6 + * from somsphere.utils import get_best_cell, count_modified_cells, timeit + * + * def create_map_batch(X, n_row, n_col, accum_w, accum_n, sigma, importance, n_pix, dist_lib, weights): # <<<<<<<<<<<<<< + * cdef int i, j, k + * cdef int nr = n_row */ /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); + __PYX_XDEC_MEMVIEW(&__pyx_t_3, 1); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_10); - __Pyx_AddTraceback("core.get_best_cell", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_XDECREF(__pyx_t_15); + __Pyx_XDECREF(__pyx_t_17); + __Pyx_AddTraceback("core.create_map_batch", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_activations); + __PYX_XDEC_MEMVIEW(&__pyx_v_imp, 1); + __PYX_XDEC_MEMVIEW(&__pyx_v_an, 1); + __Pyx_XDECREF(__pyx_v_inputs); + __Pyx_XDECREF(__pyx_v_best); + __Pyx_XDECREF(__pyx_v_activation); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyMethodDef __pyx_methods[] = { - {0, 0, 0, 0} -}; - -#if PY_MAJOR_VERSION >= 3 -#if CYTHON_PEP489_MULTI_PHASE_INIT -static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ -static int __pyx_pymod_exec_core(PyObject* module); /*proto*/ -static PyModuleDef_Slot __pyx_moduledef_slots[] = { - {Py_mod_create, (void*)__pyx_pymod_create}, - {Py_mod_exec, (void*)__pyx_pymod_exec_core}, - {0, NULL} -}; -#endif - -static struct PyModuleDef __pyx_moduledef = { - PyModuleDef_HEAD_INIT, - "core", - 0, /* m_doc */ - #if CYTHON_PEP489_MULTI_PHASE_INIT - 0, /* m_size */ - #else - -1, /* m_size */ - #endif - __pyx_methods /* m_methods */, - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_moduledef_slots, /* m_slots */ - #else - NULL, /* m_reload */ - #endif - NULL, /* m_traverse */ - NULL, /* m_clear */ - NULL /* m_free */ -}; -#endif -#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_activations, __pyx_k_activations, sizeof(__pyx_k_activations), 0, 0, 1, 1}, - {&__pyx_n_s_argmin, __pyx_k_argmin, sizeof(__pyx_k_argmin), 0, 0, 1, 1}, - {&__pyx_n_s_argsort, __pyx_k_argsort, sizeof(__pyx_k_argsort), 0, 0, 1, 1}, - {&__pyx_n_s_axis, __pyx_k_axis, sizeof(__pyx_k_axis), 0, 0, 1, 1}, - {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, - {&__pyx_n_s_core, __pyx_k_core, sizeof(__pyx_k_core), 0, 0, 1, 1}, - {&__pyx_n_s_get_best_cell, __pyx_k_get_best_cell, sizeof(__pyx_k_get_best_cell), 0, 0, 1, 1}, - {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, - {&__pyx_n_s_importance, __pyx_k_importance, sizeof(__pyx_k_importance), 0, 0, 1, 1}, - {&__pyx_n_s_inputs, __pyx_k_inputs, sizeof(__pyx_k_inputs), 0, 0, 1, 1}, - {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, - {&__pyx_n_s_n_pix, __pyx_k_n_pix, sizeof(__pyx_k_n_pix), 0, 0, 1, 1}, - {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, - {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, - {&__pyx_n_s_return_vals, __pyx_k_return_vals, sizeof(__pyx_k_return_vals), 0, 0, 1, 1}, - {&__pyx_kp_s_somsphere_cython_core_pyx, __pyx_k_somsphere_cython_core_pyx, sizeof(__pyx_k_somsphere_cython_core_pyx), 0, 0, 1, 0}, - {&__pyx_n_s_sum, __pyx_k_sum, sizeof(__pyx_k_sum), 0, 0, 1, 1}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {&__pyx_n_s_tile, __pyx_k_tile, sizeof(__pyx_k_tile), 0, 0, 1, 1}, - {&__pyx_n_s_transpose, __pyx_k_transpose, sizeof(__pyx_k_transpose), 0, 0, 1, 1}, - {&__pyx_n_s_weights, __pyx_k_weights, sizeof(__pyx_k_weights), 0, 0, 1, 1}, - {0, 0, 0, 0, 0, 0, 0} -}; -static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { - return 0; -} +/* "core.pyx":25 + * weights[k] = accum_w[k] / an + * + * def create_map_online(X, n_row, alpha, sigma, random_indices, importance, n_pix, dist_lib, weights): # <<<<<<<<<<<<<< + * cdef int i + * cdef int nr = n_row + */ -static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - - /* "core.pyx":4 - * import numpy - * - * def get_best_cell(inputs, importance, n_pix, weights, return_vals=1): # <<<<<<<<<<<<<< - * """ - * Return the closest cell to the input object - */ - __pyx_tuple_ = PyTuple_Pack(6, __pyx_n_s_inputs, __pyx_n_s_importance, __pyx_n_s_n_pix, __pyx_n_s_weights, __pyx_n_s_return_vals, __pyx_n_s_activations); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple_); - __Pyx_GIVEREF(__pyx_tuple_); - __pyx_codeobj__2 = (PyObject*)__Pyx_PyCode_New(5, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_somsphere_cython_core_pyx, __pyx_n_s_get_best_cell, 4, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__2)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} - -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); - __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) - return 0; - __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) { +/* Python wrapper */ +static PyObject *__pyx_pw_4core_3create_map_online(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_4core_3create_map_online = {"create_map_online", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_3create_map_online, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4core_3create_map_online(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_X = 0; + PyObject *__pyx_v_n_row = 0; + CYTHON_UNUSED PyObject *__pyx_v_alpha = 0; + PyObject *__pyx_v_sigma = 0; + PyObject *__pyx_v_random_indices = 0; + PyObject *__pyx_v_importance = 0; + PyObject *__pyx_v_n_pix = 0; + PyObject *__pyx_v_dist_lib = 0; + PyObject *__pyx_v_weights = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); - /*--- Global init code ---*/ + __Pyx_RefNannySetupContext("create_map_online (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_X,&__pyx_n_s_n_row,&__pyx_n_s_alpha,&__pyx_n_s_sigma,&__pyx_n_s_random_indices,&__pyx_n_s_importance,&__pyx_n_s_n_pix,&__pyx_n_s_dist_lib,&__pyx_n_s_weights,0}; + PyObject* values[9] = {0,0,0,0,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 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + 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_X)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_row)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 9, 9, 1); __PYX_ERR(0, 25, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 9, 9, 2); __PYX_ERR(0, 25, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sigma)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 9, 9, 3); __PYX_ERR(0, 25, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_random_indices)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 9, 9, 4); __PYX_ERR(0, 25, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_importance)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 9, 9, 5); __PYX_ERR(0, 25, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_pix)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 9, 9, 6); __PYX_ERR(0, 25, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 7: + if (likely((values[7] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dist_lib)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 9, 9, 7); __PYX_ERR(0, 25, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 8: + if (likely((values[8] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_weights)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 9, 9, 8); __PYX_ERR(0, 25, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create_map_online") < 0)) __PYX_ERR(0, 25, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 9) { + 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); + values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + values[7] = PyTuple_GET_ITEM(__pyx_args, 7); + values[8] = PyTuple_GET_ITEM(__pyx_args, 8); + } + __pyx_v_X = values[0]; + __pyx_v_n_row = values[1]; + __pyx_v_alpha = values[2]; + __pyx_v_sigma = values[3]; + __pyx_v_random_indices = values[4]; + __pyx_v_importance = values[5]; + __pyx_v_n_pix = values[6]; + __pyx_v_dist_lib = values[7]; + __pyx_v_weights = values[8]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 9, 9, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 25, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("core.create_map_online", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); - return 0; -} + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4core_2create_map_online(__pyx_self, __pyx_v_X, __pyx_v_n_row, __pyx_v_alpha, __pyx_v_sigma, __pyx_v_random_indices, __pyx_v_importance, __pyx_v_n_pix, __pyx_v_dist_lib, __pyx_v_weights); -static int __Pyx_modinit_variable_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); - /*--- Variable export code ---*/ + /* function exit code */ __Pyx_RefNannyFinishContext(); - return 0; + return __pyx_r; } -static int __Pyx_modinit_function_export_code(void) { +static PyObject *__pyx_pf_4core_2create_map_online(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_n_row, CYTHON_UNUSED PyObject *__pyx_v_alpha, PyObject *__pyx_v_sigma, PyObject *__pyx_v_random_indices, PyObject *__pyx_v_importance, PyObject *__pyx_v_n_pix, PyObject *__pyx_v_dist_lib, PyObject *__pyx_v_weights) { + int __pyx_v_i; + int __pyx_v_nr; + int __pyx_v_npix; + double __pyx_v_alp; + double __pyx_v_sig; + __Pyx_memviewslice __pyx_v_imp = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_inputs = NULL; + PyObject *__pyx_v_best = NULL; + CYTHON_UNUSED PyObject *__pyx_v_activation = NULL; + PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); - /*--- Function export code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} + int __pyx_t_1; + double __pyx_t_2; + __Pyx_memviewslice __pyx_t_3 = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *(*__pyx_t_10)(PyObject *); + PyObject *__pyx_t_11 = NULL; + int __pyx_t_12; + PyObject *__pyx_t_13 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("create_map_online", 0); + __Pyx_INCREF(__pyx_v_weights); -static int __Pyx_modinit_type_init_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); - /*--- Type init code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} + /* "core.pyx":27 + * def create_map_online(X, n_row, alpha, sigma, random_indices, importance, n_pix, dist_lib, weights): + * cdef int i + * cdef int nr = n_row # <<<<<<<<<<<<<< + * cdef int npix = n_pix + * cdef double alp = alp + */ + __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_n_row); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 27, __pyx_L1_error) + __pyx_v_nr = __pyx_t_1; -static int __Pyx_modinit_type_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); - /*--- Type import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} + /* "core.pyx":28 + * cdef int i + * cdef int nr = n_row + * cdef int npix = n_pix # <<<<<<<<<<<<<< + * cdef double alp = alp + * cdef double sig = sigma + */ + __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_n_pix); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 28, __pyx_L1_error) + __pyx_v_npix = __pyx_t_1; -static int __Pyx_modinit_variable_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); - /*--- Variable import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} + /* "core.pyx":30 + * cdef int npix = n_pix + * cdef double alp = alp + * cdef double sig = sigma # <<<<<<<<<<<<<< + * cdef double[:] imp = importance + * for i in range(nr): + */ + __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_v_sigma); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 30, __pyx_L1_error) + __pyx_v_sig = __pyx_t_2; -static int __Pyx_modinit_function_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); - /*--- Function import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} + /* "core.pyx":31 + * cdef double alp = alp + * cdef double sig = sigma + * cdef double[:] imp = importance # <<<<<<<<<<<<<< + * for i in range(nr): + * inputs = X[random_indices[i]] + */ + __pyx_t_3 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_importance, PyBUF_WRITABLE); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 31, __pyx_L1_error) + __pyx_v_imp = __pyx_t_3; + __pyx_t_3.memview = NULL; + __pyx_t_3.data = NULL; + /* "core.pyx":32 + * cdef double sig = sigma + * cdef double[:] imp = importance + * for i in range(nr): # <<<<<<<<<<<<<< + * inputs = X[random_indices[i]] + * best, activation = get_best_cell(inputs=inputs, importance=imp, + */ + __pyx_t_1 = __pyx_v_nr; + __pyx_t_4 = __pyx_t_1; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; -#ifndef CYTHON_NO_PYINIT_EXPORT -#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC -#elif PY_MAJOR_VERSION < 3 -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" void -#else -#define __Pyx_PyMODINIT_FUNC void -#endif -#else -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * -#else -#define __Pyx_PyMODINIT_FUNC PyObject * -#endif -#endif + /* "core.pyx":33 + * cdef double[:] imp = importance + * for i in range(nr): + * inputs = X[random_indices[i]] # <<<<<<<<<<<<<< + * best, activation = get_best_cell(inputs=inputs, importance=imp, + * weights=weights, n_pix=npix) + */ + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_random_indices, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_v_X, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF_SET(__pyx_v_inputs, __pyx_t_7); + __pyx_t_7 = 0; + /* "core.pyx":34 + * for i in range(nr): + * inputs = X[random_indices[i]] + * best, activation = get_best_cell(inputs=inputs, importance=imp, # <<<<<<<<<<<<<< + * weights=weights, n_pix=npix) + * weights += alp * count_modified_cells(best, dist_lib, sig) * numpy.transpose( + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_get_best_cell); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_inputs, __pyx_v_inputs) < 0) __PYX_ERR(0, 34, __pyx_L1_error) + __pyx_t_8 = __pyx_memoryview_fromslice(__pyx_v_imp, 1, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_importance, __pyx_t_8) < 0) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; -#if PY_MAJOR_VERSION < 3 -__Pyx_PyMODINIT_FUNC initcore(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC initcore(void) -#else -__Pyx_PyMODINIT_FUNC PyInit_core(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC PyInit_core(void) -#if CYTHON_PEP489_MULTI_PHASE_INIT -{ - return PyModuleDef_Init(&__pyx_moduledef); -} -static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { - #if PY_VERSION_HEX >= 0x030700A1 - static PY_INT64_T main_interpreter_id = -1; - PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); - if (main_interpreter_id == -1) { - main_interpreter_id = current_id; - return (unlikely(current_id == -1)) ? -1 : 0; - } else if (unlikely(main_interpreter_id != current_id)) - #else - static PyInterpreterState *main_interpreter = NULL; - PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; - if (!main_interpreter) { - main_interpreter = current_interpreter; - } else if (unlikely(main_interpreter != current_interpreter)) + /* "core.pyx":35 + * inputs = X[random_indices[i]] + * best, activation = get_best_cell(inputs=inputs, importance=imp, + * weights=weights, n_pix=npix) # <<<<<<<<<<<<<< + * weights += alp * count_modified_cells(best, dist_lib, sig) * numpy.transpose( + * (inputs - numpy.transpose(weights))) + */ + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_weights, __pyx_v_weights) < 0) __PYX_ERR(0, 34, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_npix); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_n_pix, __pyx_t_8) < 0) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "core.pyx":34 + * for i in range(nr): + * inputs = X[random_indices[i]] + * best, activation = get_best_cell(inputs=inputs, importance=imp, # <<<<<<<<<<<<<< + * weights=weights, n_pix=npix) + * weights += alp * count_modified_cells(best, dist_lib, sig) * numpy.transpose( + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if ((likely(PyTuple_CheckExact(__pyx_t_8))) || (PyList_CheckExact(__pyx_t_8))) { + PyObject* sequence = __pyx_t_8; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 34, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_6 = PyList_GET_ITEM(sequence, 0); + __pyx_t_7 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + #else + __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_9 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_10 = Py_TYPE(__pyx_t_9)->tp_iternext; + index = 0; __pyx_t_6 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_6); + index = 1; __pyx_t_7 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_7)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 2) < 0) __PYX_ERR(0, 34, __pyx_L1_error) + __pyx_t_10 = NULL; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L6_unpacking_done; + __pyx_L5_unpacking_failed:; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_10 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 34, __pyx_L1_error) + __pyx_L6_unpacking_done:; + } + __Pyx_XDECREF_SET(__pyx_v_best, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_XDECREF_SET(__pyx_v_activation, __pyx_t_7); + __pyx_t_7 = 0; + + /* "core.pyx":36 + * best, activation = get_best_cell(inputs=inputs, importance=imp, + * weights=weights, n_pix=npix) + * weights += alp * count_modified_cells(best, dist_lib, sig) * numpy.transpose( # <<<<<<<<<<<<<< + * (inputs - numpy.transpose(weights))) + */ + __pyx_t_8 = PyFloat_FromDouble(__pyx_v_alp); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_count_modified_cells); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = PyFloat_FromDouble(__pyx_v_sig); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_11 = NULL; + __pyx_t_12 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_12 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[4] = {__pyx_t_11, __pyx_v_best, __pyx_v_dist_lib, __pyx_t_9}; + __pyx_t_7 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[4] = {__pyx_t_11, __pyx_v_best, __pyx_v_dist_lib, __pyx_t_9}; + __pyx_t_7 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else #endif { - PyErr_SetString( - PyExc_ImportError, - "Interpreter change detected - this module can only be loaded into one interpreter per process."); - return -1; + __pyx_t_13 = PyTuple_New(3+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + if (__pyx_t_11) { + __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_11); __pyx_t_11 = NULL; + } + __Pyx_INCREF(__pyx_v_best); + __Pyx_GIVEREF(__pyx_v_best); + PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_12, __pyx_v_best); + __Pyx_INCREF(__pyx_v_dist_lib); + __Pyx_GIVEREF(__pyx_v_dist_lib); + PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_12, __pyx_v_dist_lib); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_13, 2+__pyx_t_12, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_13, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } - 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) { - 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); - } - Py_DECREF(value); - } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { - PyErr_Clear(); - } else { - result = -1; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = PyNumber_Multiply(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_numpy); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_transpose); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "core.pyx":37 + * weights=weights, n_pix=npix) + * weights += alp * count_modified_cells(best, dist_lib, sig) * numpy.transpose( + * (inputs - numpy.transpose(weights))) # <<<<<<<<<<<<<< + */ + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_numpy); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_transpose); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_11))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_11); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_11, function); + } } - return result; -} -static CYTHON_SMALL_CODE 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"); - if (unlikely(!modname)) goto bad; - module = PyModule_NewObject(modname); - Py_DECREF(modname); - if (unlikely(!module)) goto bad; - moddict = PyModule_GetDict(module); - if (unlikely(!moddict)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; - return module; -bad: - Py_XDECREF(module); - return NULL; + __pyx_t_8 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_9, __pyx_v_weights) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_v_weights); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_11 = PyNumber_Subtract(__pyx_v_inputs, __pyx_t_8); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_13); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_13, function); + } + } + __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_8, __pyx_t_11) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_11); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + + /* "core.pyx":36 + * best, activation = get_best_cell(inputs=inputs, importance=imp, + * weights=weights, n_pix=npix) + * weights += alp * count_modified_cells(best, dist_lib, sig) * numpy.transpose( # <<<<<<<<<<<<<< + * (inputs - numpy.transpose(weights))) + */ + __pyx_t_13 = PyNumber_Multiply(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyNumber_InPlaceAdd(__pyx_v_weights, __pyx_t_13); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF_SET(__pyx_v_weights, __pyx_t_7); + __pyx_t_7 = 0; + } + + /* "core.pyx":25 + * weights[k] = accum_w[k] / an + * + * def create_map_online(X, n_row, alpha, sigma, random_indices, importance, n_pix, dist_lib, weights): # <<<<<<<<<<<<<< + * cdef int i + * cdef int nr = n_row + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __PYX_XDEC_MEMVIEW(&__pyx_t_3, 1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_AddTraceback("core.create_map_online", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __PYX_XDEC_MEMVIEW(&__pyx_v_imp, 1); + __Pyx_XDECREF(__pyx_v_inputs); + __Pyx_XDECREF(__pyx_v_best); + __Pyx_XDECREF(__pyx_v_activation); + __Pyx_XDECREF(__pyx_v_weights); + __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): + * + */ -static CYTHON_SMALL_CODE int __pyx_pymod_exec_core(PyObject *__pyx_pyinit_module) -#endif -#endif -{ - PyObject *__pyx_t_1 = NULL; +/* 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_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; + int __pyx_r; __Pyx_RefNannyDeclarations - #if CYTHON_PEP489_MULTI_PHASE_INIT - if (__pyx_m) { - if (__pyx_m == __pyx_pyinit_module) return 0; - PyErr_SetString(PyExc_RuntimeError, "Module 'core' has already been imported. Re-initialisation is not supported."); - return -1; - } - #elif PY_MAJOR_VERSION >= 3 - if (__pyx_m) return __Pyx_NewRef(__pyx_m); - #endif - #if CYTHON_REFNANNY -__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); -if (!__Pyx_RefNanny) { - PyErr_Clear(); - __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); - if (!__Pyx_RefNanny) - Py_FatalError("failed to import 'refnanny' module"); -} -#endif - __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_core(void)", 0); - if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pxy_PyFrame_Initialize_Offsets - __Pxy_PyFrame_Initialize_Offsets(); - #endif - __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pyx_CyFunction_USED - if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_FusedFunction_USED - if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Coroutine_USED - if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Generator_USED - if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_AsyncGen_USED - if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_StopAsyncIteration_USED - if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - /*--- Library function declarations ---*/ - /*--- Threads initialization code ---*/ - #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS - #ifdef WITH_THREAD /* Python build with threading support? */ - PyEval_InitThreads(); - #endif - #endif - /*--- Module creation code ---*/ - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_m = __pyx_pyinit_module; - Py_INCREF(__pyx_m); - #else - #if PY_MAJOR_VERSION < 3 - __pyx_m = Py_InitModule4("core", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); - #else - __pyx_m = PyModule_Create(&__pyx_moduledef); - #endif - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_d); - __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_b); - __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_cython_runtime); - if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); - /*--- Initialize various global constants etc. ---*/ - if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) - if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - if (__pyx_module_is_main_core) { - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - } - #if PY_MAJOR_VERSION >= 3 + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); { - PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) - if (!PyDict_GetItemString(modules, "core")) { - if (unlikely(PyDict_SetItemString(modules, "core", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + 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; + } } - } - #endif - /*--- Builtin init code ---*/ - if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Constants init code ---*/ - if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Global type/function init code ---*/ - (void)__Pyx_modinit_global_init_code(); - (void)__Pyx_modinit_variable_export_code(); - (void)__Pyx_modinit_function_export_code(); - (void)__Pyx_modinit_type_init_code(); - (void)__Pyx_modinit_type_import_code(); - (void)__Pyx_modinit_variable_import_code(); - (void)__Pyx_modinit_function_import_code(); - /*--- Execution code ---*/ - #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) - if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif + __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 { - /* "core.pyx":2 - * #cython: language_level=3 - * import numpy # <<<<<<<<<<<<<< + /* "View.MemoryView":123 * - * def get_best_cell(inputs, importance, n_pix, weights, return_vals=1): - */ - __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_numpy, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "core.pyx":4 - * import numpy + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, + * mode="c", bint allocate_buffer=True): # <<<<<<<<<<<<<< * - * def get_best_cell(inputs, importance, n_pix, weights, return_vals=1): # <<<<<<<<<<<<<< - * """ - * Return the closest cell to the input object + * cdef int idx */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_4core_1get_best_cell, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_best_cell, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __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); - /* "core.pyx":1 - * #cython: language_level=3 # <<<<<<<<<<<<<< - * import numpy + /* "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): * */ - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /*--- Wrapped vars code ---*/ + /* function exit code */ goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - if (__pyx_m) { - if (__pyx_d) { - __Pyx_AddTraceback("init core", __pyx_clineno, __pyx_lineno, __pyx_filename); - } - Py_CLEAR(__pyx_m); - } else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_ImportError, "init core"); - } + __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); - #if CYTHON_PEP489_MULTI_PHASE_INIT - return (__pyx_m != NULL) ? 0 : -1; - #elif PY_MAJOR_VERSION >= 3 - return __pyx_m; - #else - return; - #endif + return __pyx_r; } -/* --- Runtime support code --- */ -/* Refnanny */ -#if CYTHON_REFNANNY -static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { - PyObject *m = NULL, *p = 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 + 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; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __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__2, 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 + * + * 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__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 136, __pyx_L1_error) + + /* "View.MemoryView":135 + * raise ValueError("Empty shape tuple for cython.array") + * + * if itemsize <= 0: # <<<<<<<<<<<<<< + * raise ValueError("itemsize <= 0 for cython.array") + * + */ + } + + /* "View.MemoryView":138 + * raise ValueError("itemsize <= 0 for cython.array") + * + * if not isinstance(format, bytes): # <<<<<<<<<<<<<< + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string + */ + __pyx_t_2 = PyBytes_Check(__pyx_v_format); + __pyx_t_4 = ((!(__pyx_t_2 != 0)) != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":139 + * + * if not isinstance(format, bytes): + * format = format.encode('ASCII') # <<<<<<<<<<<<<< + * self._format = format # keep a reference to the byte string + * self.format = self._format + */ + __pyx_t_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_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; + + /* "View.MemoryView":138 + * raise ValueError("itemsize <= 0 for cython.array") + * + * if not isinstance(format, bytes): # <<<<<<<<<<<<<< + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string + */ + } + + /* "View.MemoryView":140 + * if not isinstance(format, bytes): + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string # <<<<<<<<<<<<<< + * self.format = self._format + * + */ + 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); + __Pyx_GOTREF(__pyx_v_self->_format); + __Pyx_DECREF(__pyx_v_self->_format); + __pyx_v_self->_format = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":141 + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string + * self.format = self._format # <<<<<<<<<<<<<< + * + * + */ + if (unlikely(__pyx_v_self->_format == Py_None)) { + PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); + __PYX_ERR(1, 141, __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; + + /* "View.MemoryView":144 + * + * + * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) # <<<<<<<<<<<<<< + * self._strides = self._shape + self.ndim + * + */ + __pyx_v_self->_shape = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * __pyx_v_self->ndim) * 2))); + + /* "View.MemoryView":145 + * + * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) + * self._strides = self._shape + self.ndim # <<<<<<<<<<<<<< + * + * if not self._shape: + */ + __pyx_v_self->_strides = (__pyx_v_self->_shape + __pyx_v_self->ndim); + + /* "View.MemoryView":147 + * self._strides = self._shape + self.ndim + * + * if not self._shape: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate shape and strides.") + * + */ + __pyx_t_4 = ((!(__pyx_v_self->_shape != 0)) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":148 + * + * if not self._shape: + * raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__4, 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) + + /* "View.MemoryView":147 + * self._strides = self._shape + self.ndim + * + * if not self._shape: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate shape and strides.") + * + */ + } + + /* "View.MemoryView":151 + * + * + * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + */ + __pyx_t_8 = 0; + __pyx_t_3 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0; + for (;;) { + if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(1, 151, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_5); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(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); + + /* "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_4 = ((__pyx_v_dim <= 0) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":153 + * for idx, dim in enumerate(shape): + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) # <<<<<<<<<<<<<< + * self._shape[idx] = dim + * + */ + __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_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_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_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(1, 153, __pyx_L1_error) + + /* "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 + */ + } + + /* "View.MemoryView":154 + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * self._shape[idx] = dim # <<<<<<<<<<<<<< + * + * cdef char order + */ + (__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim; + + /* "View.MemoryView":151 + * + * + * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":157 + * + * 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) + if (__pyx_t_4) { + + /* "View.MemoryView":158 + * cdef char order + * if mode == 'fortran': + * order = b'F' # <<<<<<<<<<<<<< + * self.mode = u'fortran' + * elif mode == 'c': + */ + __pyx_v_order = 'F'; + + /* "View.MemoryView":159 + * if mode == 'fortran': + * order = b'F' + * self.mode = u'fortran' # <<<<<<<<<<<<<< + * elif mode == 'c': + * order = b'C' + */ + __Pyx_INCREF(__pyx_n_u_fortran); + __Pyx_GIVEREF(__pyx_n_u_fortran); + __Pyx_GOTREF(__pyx_v_self->mode); + __Pyx_DECREF(__pyx_v_self->mode); + __pyx_v_self->mode = __pyx_n_u_fortran; + + /* "View.MemoryView":157 + * + * cdef char order + * if mode == 'fortran': # <<<<<<<<<<<<<< + * order = b'F' + * self.mode = u'fortran' + */ + goto __pyx_L10; + } + + /* "View.MemoryView":160 + * order = b'F' + * self.mode = u'fortran' + * elif mode == 'c': # <<<<<<<<<<<<<< + * order = b'C' + * self.mode = u'c' + */ + __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) + if (likely(__pyx_t_4)) { + + /* "View.MemoryView":161 + * self.mode = u'fortran' + * elif mode == 'c': + * order = b'C' # <<<<<<<<<<<<<< + * self.mode = u'c' + * else: + */ + __pyx_v_order = 'C'; + + /* "View.MemoryView":162 + * elif mode == 'c': + * order = b'C' + * self.mode = u'c' # <<<<<<<<<<<<<< + * else: + * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) + */ + __Pyx_INCREF(__pyx_n_u_c); + __Pyx_GIVEREF(__pyx_n_u_c); + __Pyx_GOTREF(__pyx_v_self->mode); + __Pyx_DECREF(__pyx_v_self->mode); + __pyx_v_self->mode = __pyx_n_u_c; + + /* "View.MemoryView":160 + * order = b'F' + * self.mode = u'fortran' + * elif mode == 'c': # <<<<<<<<<<<<<< + * order = b'C' + * self.mode = u'c' + */ + goto __pyx_L10; + } + + /* "View.MemoryView":164 + * self.mode = u'c' + * else: + * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) # <<<<<<<<<<<<<< + * + * self.len = fill_contig_strides_array(self._shape, self._strides, + */ + /*else*/ { + __pyx_t_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_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(1, 164, __pyx_L1_error) + } + __pyx_L10:; + + /* "View.MemoryView":166 + * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) + * + * self.len = fill_contig_strides_array(self._shape, self._strides, # <<<<<<<<<<<<<< + * itemsize, self.ndim, order) + * + */ + __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 + * itemsize, self.ndim, order) + * + * self.free_data = allocate_buffer # <<<<<<<<<<<<<< + * self.dtype_is_object = format == b'O' + * if allocate_buffer: + */ + __pyx_v_self->free_data = __pyx_v_allocate_buffer; + + /* "View.MemoryView":170 + * + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' # <<<<<<<<<<<<<< + * if allocate_buffer: + * + */ + __pyx_t_10 = PyObject_RichCompare(__pyx_v_format, __pyx_n_b_O, Py_EQ); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(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_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_v_self->dtype_is_object = __pyx_t_4; + + /* "View.MemoryView":171 + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' + * if allocate_buffer: # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_4 = (__pyx_v_allocate_buffer != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":174 + * + * + * self.data = malloc(self.len) # <<<<<<<<<<<<<< + * if not self.data: + * raise MemoryError("unable to allocate array data.") + */ + __pyx_v_self->data = ((char *)malloc(__pyx_v_self->len)); + + /* "View.MemoryView":175 + * + * self.data = malloc(self.len) + * if not self.data: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate array data.") + * + */ + __pyx_t_4 = ((!(__pyx_v_self->data != 0)) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":176 + * self.data = malloc(self.len) + * if not self.data: + * raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<< + * + * if self.dtype_is_object: + */ + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(1, 176, __pyx_L1_error) + + /* "View.MemoryView":175 + * + * self.data = malloc(self.len) + * if not self.data: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate array data.") + * + */ + } + + /* "View.MemoryView":178 + * raise MemoryError("unable to allocate array data.") + * + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * p = self.data + * for i in range(self.len / itemsize): + */ + __pyx_t_4 = (__pyx_v_self->dtype_is_object != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":179 + * + * if self.dtype_is_object: + * p = self.data # <<<<<<<<<<<<<< + * for i in range(self.len / itemsize): + * p[i] = Py_None + */ + __pyx_v_p = ((PyObject **)__pyx_v_self->data); + + /* "View.MemoryView":180 + * if self.dtype_is_object: + * p = self.data + * for i in range(self.len / itemsize): # <<<<<<<<<<<<<< + * p[i] = Py_None + * Py_INCREF(Py_None) + */ + if (unlikely(__pyx_v_itemsize == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); + __PYX_ERR(1, 180, __pyx_L1_error) + } + else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_self->len))) { + PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); + __PYX_ERR(1, 180, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_div_Py_ssize_t(__pyx_v_self->len, __pyx_v_itemsize); + __pyx_t_9 = __pyx_t_1; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_9; __pyx_t_11+=1) { + __pyx_v_i = __pyx_t_11; + + /* "View.MemoryView":181 + * p = self.data + * for i in range(self.len / itemsize): + * p[i] = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) + * + */ + (__pyx_v_p[__pyx_v_i]) = Py_None; + + /* "View.MemoryView":182 + * for i in range(self.len / itemsize): + * p[i] = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * + * @cname('getbuffer') + */ + Py_INCREF(Py_None); + } + + /* "View.MemoryView":178 + * raise MemoryError("unable to allocate array data.") + * + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * p = self.data + * for i in range(self.len / itemsize): + */ + } + + /* "View.MemoryView":171 + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' + * if 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 */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_format); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":185 + * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * cdef int bufmode = -1 + * if self.mode == u"c": + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(((struct __pyx_array_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_v_bufmode; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + char *__pyx_t_4; + Py_ssize_t __pyx_t_5; + int __pyx_t_6; + Py_ssize_t *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + if (__pyx_v_info == NULL) { + PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); + return -1; + } + __Pyx_RefNannySetupContext("__getbuffer__", 0); + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + + /* "View.MemoryView":186 + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 # <<<<<<<<<<<<<< + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + */ + __pyx_v_bufmode = -1; + + /* "View.MemoryView":187 + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 + * if self.mode == u"c": # <<<<<<<<<<<<<< + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": + */ + __pyx_t_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_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":188 + * cdef int bufmode = -1 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + */ + __pyx_v_bufmode = (PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); + + /* "View.MemoryView":187 + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 + * if self.mode == u"c": # <<<<<<<<<<<<<< + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": + */ + goto __pyx_L3; + } + + /* "View.MemoryView":189 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": # <<<<<<<<<<<<<< + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): + */ + __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_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":190 + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< + * if not (flags & bufmode): + * raise ValueError("Can only create a buffer that is contiguous in memory.") + */ + __pyx_v_bufmode = (PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); + + /* "View.MemoryView":189 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": # <<<<<<<<<<<<<< + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): + */ + } + __pyx_L3:; + + /* "View.MemoryView":191 + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): # <<<<<<<<<<<<<< + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data + */ + __pyx_t_1 = ((!((__pyx_v_flags & __pyx_v_bufmode) != 0)) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":192 + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): + * raise ValueError("Can only create a buffer that is contiguous in memory.") # <<<<<<<<<<<<<< + * info.buf = self.data + * info.len = self.len + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 192, __pyx_L1_error) + + /* "View.MemoryView":191 + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): # <<<<<<<<<<<<<< + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data + */ + } + + /* "View.MemoryView":193 + * if not (flags & bufmode): + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data # <<<<<<<<<<<<<< + * info.len = self.len + * info.ndim = self.ndim + */ + __pyx_t_4 = __pyx_v_self->data; + __pyx_v_info->buf = __pyx_t_4; + + /* "View.MemoryView":194 + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data + * info.len = self.len # <<<<<<<<<<<<<< + * info.ndim = self.ndim + * info.shape = self._shape + */ + __pyx_t_5 = __pyx_v_self->len; + __pyx_v_info->len = __pyx_t_5; + + /* "View.MemoryView":195 + * info.buf = self.data + * info.len = self.len + * info.ndim = self.ndim # <<<<<<<<<<<<<< + * info.shape = self._shape + * info.strides = self._strides + */ + __pyx_t_6 = __pyx_v_self->ndim; + __pyx_v_info->ndim = __pyx_t_6; + + /* "View.MemoryView":196 + * info.len = self.len + * info.ndim = self.ndim + * info.shape = self._shape # <<<<<<<<<<<<<< + * info.strides = self._strides + * info.suboffsets = NULL + */ + __pyx_t_7 = __pyx_v_self->_shape; + __pyx_v_info->shape = __pyx_t_7; + + /* "View.MemoryView":197 + * info.ndim = self.ndim + * info.shape = self._shape + * info.strides = self._strides # <<<<<<<<<<<<<< + * info.suboffsets = NULL + * info.itemsize = self.itemsize + */ + __pyx_t_7 = __pyx_v_self->_strides; + __pyx_v_info->strides = __pyx_t_7; + + /* "View.MemoryView":198 + * info.shape = self._shape + * info.strides = self._strides + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * info.itemsize = self.itemsize + * info.readonly = 0 + */ + __pyx_v_info->suboffsets = NULL; + + /* "View.MemoryView":199 + * info.strides = self._strides + * info.suboffsets = NULL + * info.itemsize = self.itemsize # <<<<<<<<<<<<<< + * info.readonly = 0 + * + */ + __pyx_t_5 = __pyx_v_self->itemsize; + __pyx_v_info->itemsize = __pyx_t_5; + + /* "View.MemoryView":200 + * info.suboffsets = NULL + * info.itemsize = self.itemsize + * info.readonly = 0 # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: + */ + __pyx_v_info->readonly = 0; + + /* "View.MemoryView":202 + * info.readonly = 0 + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.format + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":203 + * + * if flags & PyBUF_FORMAT: + * info.format = self.format # <<<<<<<<<<<<<< + * else: + * info.format = NULL + */ + __pyx_t_4 = __pyx_v_self->format; + __pyx_v_info->format = __pyx_t_4; + + /* "View.MemoryView":202 + * info.readonly = 0 + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.format + * else: + */ + goto __pyx_L5; + } + + /* "View.MemoryView":205 + * info.format = self.format + * else: + * info.format = NULL # <<<<<<<<<<<<<< + * + * info.obj = self + */ + /*else*/ { + __pyx_v_info->format = NULL; + } + __pyx_L5:; + + /* "View.MemoryView":207 + * info.format = NULL + * + * info.obj = self # <<<<<<<<<<<<<< + * + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") + */ + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + + /* "View.MemoryView":185 + * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * cdef int bufmode = -1 + * if self.mode == u"c": + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.array.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + __pyx_L2:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":211 + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") + * + * def __dealloc__(array self): # <<<<<<<<<<<<<< + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + */ + +/* Python wrapper */ +static void __pyx_array___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_array___dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "View.MemoryView":212 + * + * def __dealloc__(array self): + * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< + * self.callback_free_data(self.data) + * elif self.free_data: + */ + __pyx_t_1 = ((__pyx_v_self->callback_free_data != NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":213 + * def __dealloc__(array self): + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) # <<<<<<<<<<<<<< + * elif self.free_data: + * if self.dtype_is_object: + */ + __pyx_v_self->callback_free_data(__pyx_v_self->data); + + /* "View.MemoryView":212 + * + * def __dealloc__(array self): + * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< + * self.callback_free_data(self.data) + * elif self.free_data: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":214 + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + * elif self.free_data: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, + */ + __pyx_t_1 = (__pyx_v_self->free_data != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":215 + * self.callback_free_data(self.data) + * elif self.free_data: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice(self.data, self._shape, + * self._strides, self.ndim, False) + */ + __pyx_t_1 = (__pyx_v_self->dtype_is_object != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":216 + * elif self.free_data: + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, # <<<<<<<<<<<<<< + * self._strides, self.ndim, False) + * free(self.data) + */ + __pyx_memoryview_refcount_objects_in_slice(__pyx_v_self->data, __pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_self->ndim, 0); + + /* "View.MemoryView":215 + * self.callback_free_data(self.data) + * elif self.free_data: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice(self.data, self._shape, + * self._strides, self.ndim, False) + */ + } + + /* "View.MemoryView":218 + * refcount_objects_in_slice(self.data, self._shape, + * self._strides, self.ndim, False) + * free(self.data) # <<<<<<<<<<<<<< + * PyObject_Free(self._shape) + * + */ + free(__pyx_v_self->data); + + /* "View.MemoryView":214 + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + * elif self.free_data: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, + */ + } + __pyx_L3:; + + /* "View.MemoryView":219 + * self._strides, self.ndim, False) + * free(self.data) + * PyObject_Free(self._shape) # <<<<<<<<<<<<<< + * + * @property + */ + PyObject_Free(__pyx_v_self->_shape); + + /* "View.MemoryView":211 + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") + * + * def __dealloc__(array self): # <<<<<<<<<<<<<< + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":222 + * + * @property + * def memview(self): # <<<<<<<<<<<<<< + * return self.get_memview() + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_5array_7memview___get__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":223 + * @property + * def memview(self): + * return self.get_memview() # <<<<<<<<<<<<<< + * + * @cname('get_memview') + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((struct __pyx_vtabstruct_array *)__pyx_v_self->__pyx_vtab)->get_memview(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":222 + * + * @property + * def memview(self): # <<<<<<<<<<<<<< + * return self.get_memview() + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.memview.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":226 + * + * @cname('get_memview') + * cdef get_memview(self): # <<<<<<<<<<<<<< + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE + * return memoryview(self, flags, self.dtype_is_object) + */ + +static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) { + int __pyx_v_flags; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_memview", 0); + + /* "View.MemoryView":227 + * @cname('get_memview') + * cdef get_memview(self): + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE # <<<<<<<<<<<<<< + * return memoryview(self, flags, self.dtype_is_object) + * + */ + __pyx_v_flags = ((PyBUF_ANY_CONTIGUOUS | PyBUF_FORMAT) | PyBUF_WRITABLE); + + /* "View.MemoryView":228 + * cdef get_memview(self): + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE + * return memoryview(self, flags, self.dtype_is_object) # <<<<<<<<<<<<<< + * + * def __len__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 228, __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_GOTREF(__pyx_t_3); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":226 + * + * @cname('get_memview') + * cdef get_memview(self): # <<<<<<<<<<<<<< + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE + * return memoryview(self, flags, self.dtype_is_object) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.array.get_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":230 + * return memoryview(self, flags, self.dtype_is_object) + * + * def __len__(self): # <<<<<<<<<<<<<< + * return self._shape[0] + * + */ + +/* Python wrapper */ +static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self); /*proto*/ +static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__", 0); + + /* "View.MemoryView":231 + * + * def __len__(self): + * return self._shape[0] # <<<<<<<<<<<<<< + * + * def __getattr__(self, attr): + */ + __pyx_r = (__pyx_v_self->_shape[0]); + goto __pyx_L0; + + /* "View.MemoryView":230 + * return memoryview(self, flags, self.dtype_is_object) + * + * def __len__(self): # <<<<<<<<<<<<<< + * return self._shape[0] + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":233 + * return self._shape[0] + * + * def __getattr__(self, attr): # <<<<<<<<<<<<<< + * return getattr(self.memview, attr) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr); /*proto*/ +static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_attr)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getattr__", 0); + + /* "View.MemoryView":234 + * + * def __getattr__(self, attr): + * return getattr(self.memview, attr) # <<<<<<<<<<<<<< + * + * def __getitem__(self, item): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_GetAttr(__pyx_t_1, __pyx_v_attr); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":233 + * return self._shape[0] + * + * def __getattr__(self, attr): # <<<<<<<<<<<<<< + * return getattr(self.memview, attr) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.array.__getattr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":236 + * return getattr(self.memview, attr) + * + * def __getitem__(self, item): # <<<<<<<<<<<<<< + * return self.memview[item] + * + */ + +/* Python wrapper */ +static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item); /*proto*/ +static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "View.MemoryView":237 + * + * def __getitem__(self, item): + * return self.memview[item] # <<<<<<<<<<<<<< + * + * def __setitem__(self, item, value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":236 + * return getattr(self.memview, attr) + * + * def __getitem__(self, item): # <<<<<<<<<<<<<< + * return self.memview[item] + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":239 + * return self.memview[item] + * + * def __setitem__(self, item, value): # <<<<<<<<<<<<<< + * self.memview[item] = value + * + */ + +/* Python wrapper */ +static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setitem__", 0); + + /* "View.MemoryView":240 + * + * 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_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) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "View.MemoryView":239 + * return self.memview[item] + * + * def __setitem__(self, item, value): # <<<<<<<<<<<<<< + * self.memview[item] = value + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_array___reduce_cython__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_array_2__setstate_cython__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":244 + * + * @cname("__pyx_array_new") + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< + * char *mode, char *buf): + * cdef array result + */ + +static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, char *__pyx_v_format, char *__pyx_v_mode, char *__pyx_v_buf) { + struct __pyx_array_obj *__pyx_v_result = 0; + struct __pyx_array_obj *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("array_cwrapper", 0); + + /* "View.MemoryView":248 + * cdef array result + * + * if buf == NULL: # <<<<<<<<<<<<<< + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + */ + __pyx_t_1 = ((__pyx_v_buf == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":249 + * + * 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_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_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_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v_shape); + __Pyx_GIVEREF(__pyx_v_shape); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_shape); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4); + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":248 + * cdef array result + * + * if buf == NULL: # <<<<<<<<<<<<<< + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":251 + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< + * allocate_buffer=False) + * result.data = buf + */ + /*else*/ { + __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 251, __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_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_shape); + __Pyx_GIVEREF(__pyx_v_shape); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_shape); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_3); + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_3 = 0; + + /* "View.MemoryView":252 + * 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_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) + + /* "View.MemoryView":251 + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< + * allocate_buffer=False) + * result.data = buf + */ + __pyx_t_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_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 + * result = array(shape, itemsize, format, mode.decode('ASCII'), + * allocate_buffer=False) + * result.data = buf # <<<<<<<<<<<<<< + * + * return result + */ + __pyx_v_result->data = __pyx_v_buf; + } + __pyx_L3:; + + /* "View.MemoryView":255 + * result.data = buf + * + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "View.MemoryView":244 + * + * @cname("__pyx_array_new") + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< + * char *mode, char *buf): + * cdef array result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.array_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":281 + * cdef class Enum(object): + * cdef object name + * def __init__(self, name): # <<<<<<<<<<<<<< + * self.name = name + * def __repr__(self): + */ + +/* Python wrapper */ +static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_name = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 281, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_name = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 281, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("View.MemoryView.Enum.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v_name); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__", 0); + + /* "View.MemoryView":282 + * cdef object name + * def __init__(self, name): + * self.name = name # <<<<<<<<<<<<<< + * def __repr__(self): + * return self.name + */ + __Pyx_INCREF(__pyx_v_name); + __Pyx_GIVEREF(__pyx_v_name); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = __pyx_v_name; + + /* "View.MemoryView":281 + * cdef class Enum(object): + * cdef object name + * def __init__(self, name): # <<<<<<<<<<<<<< + * self.name = name + * def __repr__(self): + */ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":283 + * def __init__(self, name): + * self.name = name + * def __repr__(self): # <<<<<<<<<<<<<< + * return self.name + * + */ + +/* Python wrapper */ +static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "View.MemoryView":284 + * self.name = name + * def __repr__(self): + * return self.name # <<<<<<<<<<<<<< + * + * cdef generic = Enum("") + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->name); + __pyx_r = __pyx_v_self->name; + goto __pyx_L0; + + /* "View.MemoryView":283 + * def __init__(self, name): + * self.name = name + * def __repr__(self): # <<<<<<<<<<<<<< + * return self.name + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_MemviewEnum___reduce_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.name,) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self->name); + __Pyx_GIVEREF(__pyx_v_self->name); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->name); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.name,) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self.name,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + 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_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 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.name is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.name,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.name is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + */ + /*else*/ { + __pyx_t_3 = (__pyx_v_self->name != Py_None); + __pyx_v_use_setstate = __pyx_t_3; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * else: + */ + __pyx_t_3 = (__pyx_v_use_setstate != 0); + if (__pyx_t_3) { + + /* "(tree fragment)":13 + * use_setstate = self.name is not None + * if use_setstate: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __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_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_INCREF(__pyx_int_184977713); + __Pyx_GIVEREF(__pyx_int_184977713); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Enum__set_state(self, __pyx_state) + */ + /*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_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_INCREF(__pyx_int_184977713); + __Pyx_GIVEREF(__pyx_int_184977713); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.Enum.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Enum__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + 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) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":298 + * + * @cname('__pyx_align_pointer') + * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< + * "Align pointer memory on a given boundary" + * cdef Py_intptr_t aligned_p = memory + */ + +static void *__pyx_align_pointer(void *__pyx_v_memory, size_t __pyx_v_alignment) { + Py_intptr_t __pyx_v_aligned_p; + size_t __pyx_v_offset; + void *__pyx_r; + int __pyx_t_1; + + /* "View.MemoryView":300 + * cdef void *align_pointer(void *memory, size_t alignment) nogil: + * "Align pointer memory on a given boundary" + * cdef Py_intptr_t aligned_p = memory # <<<<<<<<<<<<<< + * cdef size_t offset + * + */ + __pyx_v_aligned_p = ((Py_intptr_t)__pyx_v_memory); + + /* "View.MemoryView":304 + * + * with cython.cdivision(True): + * offset = aligned_p % alignment # <<<<<<<<<<<<<< + * + * if offset > 0: + */ + __pyx_v_offset = (__pyx_v_aligned_p % __pyx_v_alignment); + + /* "View.MemoryView":306 + * offset = aligned_p % alignment + * + * if offset > 0: # <<<<<<<<<<<<<< + * aligned_p += alignment - offset + * + */ + __pyx_t_1 = ((__pyx_v_offset > 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":307 + * + * if offset > 0: + * aligned_p += alignment - offset # <<<<<<<<<<<<<< + * + * return aligned_p + */ + __pyx_v_aligned_p = (__pyx_v_aligned_p + (__pyx_v_alignment - __pyx_v_offset)); + + /* "View.MemoryView":306 + * offset = aligned_p % alignment + * + * if offset > 0: # <<<<<<<<<<<<<< + * aligned_p += alignment - offset + * + */ + } + + /* "View.MemoryView":309 + * aligned_p += alignment - offset + * + * return aligned_p # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((void *)__pyx_v_aligned_p); + goto __pyx_L0; + + /* "View.MemoryView":298 + * + * @cname('__pyx_align_pointer') + * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< + * "Align pointer memory on a given boundary" + * cdef Py_intptr_t aligned_p = memory + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":345 + * cdef __Pyx_TypeInfo *typeinfo + * + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< + * self.obj = obj + * self.flags = flags + */ + +/* Python wrapper */ +static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_obj = 0; + int __pyx_v_flags; + int __pyx_v_dtype_is_object; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_obj,&__pyx_n_s_flags,&__pyx_n_s_dtype_is_object,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_obj)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, 1); __PYX_ERR(1, 345, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dtype_is_object); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 345, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __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) + 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) + } 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_L3_error:; + __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_obj, __pyx_v_flags, __pyx_v_dtype_is_object); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* "View.MemoryView":346 + * + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): + * self.obj = obj # <<<<<<<<<<<<<< + * self.flags = flags + * if type(self) is memoryview or obj is not None: + */ + __Pyx_INCREF(__pyx_v_obj); + __Pyx_GIVEREF(__pyx_v_obj); + __Pyx_GOTREF(__pyx_v_self->obj); + __Pyx_DECREF(__pyx_v_self->obj); + __pyx_v_self->obj = __pyx_v_obj; + + /* "View.MemoryView":347 + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): + * self.obj = obj + * self.flags = flags # <<<<<<<<<<<<<< + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) + */ + __pyx_v_self->flags = __pyx_v_flags; + + /* "View.MemoryView":348 + * self.obj = obj + * self.flags = flags + * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: + */ + __pyx_t_2 = (((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))) == ((PyObject *)__pyx_memoryview_type)); + __pyx_t_3 = (__pyx_t_2 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = (__pyx_v_obj != Py_None); + __pyx_t_2 = (__pyx_t_3 != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "View.MemoryView":349 + * self.flags = flags + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) # <<<<<<<<<<<<<< + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None + */ + __pyx_t_4 = __Pyx_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 349, __pyx_L1_error) + + /* "View.MemoryView":350 + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: # <<<<<<<<<<<<<< + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) + */ + __pyx_t_1 = ((((PyObject *)__pyx_v_self->view.obj) == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":351 + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) + * + */ + ((Py_buffer *)(&__pyx_v_self->view))->obj = Py_None; + + /* "View.MemoryView":352 + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * + * global __pyx_memoryview_thread_locks_used + */ + Py_INCREF(Py_None); + + /* "View.MemoryView":350 + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: # <<<<<<<<<<<<<< + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) + */ + } + + /* "View.MemoryView":348 + * self.obj = obj + * self.flags = flags + * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: + */ + } + + /* "View.MemoryView":355 + * + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + */ + __pyx_t_1 = ((__pyx_memoryview_thread_locks_used < 8) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":356 + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: + */ + __pyx_v_self->lock = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); + + /* "View.MemoryView":357 + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 # <<<<<<<<<<<<<< + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + */ + __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used + 1); + + /* "View.MemoryView":355 + * + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + */ + } + + /* "View.MemoryView":358 + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: # <<<<<<<<<<<<<< + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: + */ + __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":359 + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() # <<<<<<<<<<<<<< + * if self.lock is NULL: + * raise MemoryError + */ + __pyx_v_self->lock = PyThread_allocate_lock(); + + /* "View.MemoryView":360 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * + */ + __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":361 + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: + * raise MemoryError # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: + */ + PyErr_NoMemory(); __PYX_ERR(1, 361, __pyx_L1_error) + + /* "View.MemoryView":360 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * + */ + } + + /* "View.MemoryView":358 + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: # <<<<<<<<<<<<<< + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: + */ + } + + /* "View.MemoryView":363 + * raise MemoryError + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":364 + * + * if flags & PyBUF_FORMAT: + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') # <<<<<<<<<<<<<< + * else: + * self.dtype_is_object = dtype_is_object + */ + __pyx_t_2 = (((__pyx_v_self->view.format[0]) == 'O') != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_2 = (((__pyx_v_self->view.format[1]) == '\x00') != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L11_bool_binop_done:; + __pyx_v_self->dtype_is_object = __pyx_t_1; + + /* "View.MemoryView":363 + * raise MemoryError + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') + * else: + */ + goto __pyx_L10; + } + + /* "View.MemoryView":366 + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') + * else: + * self.dtype_is_object = dtype_is_object # <<<<<<<<<<<<<< + * + * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( + */ + /*else*/ { + __pyx_v_self->dtype_is_object = __pyx_v_dtype_is_object; + } + __pyx_L10:; + + /* "View.MemoryView":368 + * self.dtype_is_object = dtype_is_object + * + * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( # <<<<<<<<<<<<<< + * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) + * self.typeinfo = NULL + */ + __pyx_v_self->acquisition_count_aligned_p = ((__pyx_atomic_int *)__pyx_align_pointer(((void *)(&(__pyx_v_self->acquisition_count[0]))), (sizeof(__pyx_atomic_int)))); + + /* "View.MemoryView":370 + * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( + * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) + * self.typeinfo = NULL # <<<<<<<<<<<<<< + * + * def __dealloc__(memoryview self): + */ + __pyx_v_self->typeinfo = NULL; + + /* "View.MemoryView":345 + * cdef __Pyx_TypeInfo *typeinfo + * + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< + * self.obj = obj + * self.flags = flags + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":372 + * self.typeinfo = NULL + * + * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) + */ + +/* Python wrapper */ +static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self) { + int __pyx_v_i; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyThread_type_lock __pyx_t_6; + PyThread_type_lock __pyx_t_7; + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "View.MemoryView":373 + * + * def __dealloc__(memoryview self): + * if self.obj is not None: # <<<<<<<<<<<<<< + * __Pyx_ReleaseBuffer(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: + */ + __pyx_t_1 = (__pyx_v_self->obj != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":374 + * def __dealloc__(memoryview self): + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) # <<<<<<<<<<<<<< + * elif (<__pyx_buffer *> &self.view).obj == Py_None: + * + */ + __Pyx_ReleaseBuffer((&__pyx_v_self->view)); + + /* "View.MemoryView":373 + * + * def __dealloc__(memoryview self): + * if self.obj is not None: # <<<<<<<<<<<<<< + * __Pyx_ReleaseBuffer(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":375 + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<< + * + * (<__pyx_buffer *> &self.view).obj = NULL + */ + __pyx_t_2 = ((((Py_buffer *)(&__pyx_v_self->view))->obj == Py_None) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":377 + * elif (<__pyx_buffer *> &self.view).obj == Py_None: + * + * (<__pyx_buffer *> &self.view).obj = NULL # <<<<<<<<<<<<<< + * Py_DECREF(Py_None) + * + */ + ((Py_buffer *)(&__pyx_v_self->view))->obj = NULL; + + /* "View.MemoryView":378 + * + * (<__pyx_buffer *> &self.view).obj = NULL + * Py_DECREF(Py_None) # <<<<<<<<<<<<<< + * + * cdef int i + */ + Py_DECREF(Py_None); + + /* "View.MemoryView":375 + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<< + * + * (<__pyx_buffer *> &self.view).obj = NULL + */ + } + __pyx_L3:; + + /* "View.MemoryView":382 + * cdef int i + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: # <<<<<<<<<<<<<< + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: + */ + __pyx_t_2 = ((__pyx_v_self->lock != NULL) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":383 + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: + * for i in range(__pyx_memoryview_thread_locks_used): # <<<<<<<<<<<<<< + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 + */ + __pyx_t_3 = __pyx_memoryview_thread_locks_used; + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "View.MemoryView":384 + * if self.lock != NULL: + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: + */ + __pyx_t_2 = (((__pyx_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":385 + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 # <<<<<<<<<<<<<< + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + */ + __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used - 1); + + /* "View.MemoryView":386 + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + */ + __pyx_t_2 = ((__pyx_v_i != __pyx_memoryview_thread_locks_used) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":388 + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) # <<<<<<<<<<<<<< + * break + * else: + */ + __pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); + __pyx_t_7 = (__pyx_memoryview_thread_locks[__pyx_v_i]); + + /* "View.MemoryView":387 + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + * break + */ + (__pyx_memoryview_thread_locks[__pyx_v_i]) = __pyx_t_6; + (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_7; + + /* "View.MemoryView":386 + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + */ + } + + /* "View.MemoryView":389 + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + * break # <<<<<<<<<<<<<< + * else: + * PyThread_free_lock(self.lock) + */ + goto __pyx_L6_break; + + /* "View.MemoryView":384 + * if self.lock != NULL: + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: + */ + } + } + /*else*/ { + + /* "View.MemoryView":391 + * break + * else: + * PyThread_free_lock(self.lock) # <<<<<<<<<<<<<< + * + * cdef char *get_item_pointer(memoryview self, object index) except NULL: + */ + PyThread_free_lock(__pyx_v_self->lock); + } + __pyx_L6_break:; + + /* "View.MemoryView":382 + * cdef int i + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: # <<<<<<<<<<<<<< + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: + */ + } + + /* "View.MemoryView":372 + * self.typeinfo = NULL + * + * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":393 + * PyThread_free_lock(self.lock) + * + * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< + * cdef Py_ssize_t dim + * cdef char *itemp = self.view.buf + */ + +static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { + Py_ssize_t __pyx_v_dim; + char *__pyx_v_itemp; + PyObject *__pyx_v_idx = NULL; + char *__pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *(*__pyx_t_4)(PyObject *); + PyObject *__pyx_t_5 = NULL; + Py_ssize_t __pyx_t_6; + char *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_item_pointer", 0); + + /* "View.MemoryView":395 + * cdef char *get_item_pointer(memoryview self, object index) except NULL: + * cdef Py_ssize_t dim + * cdef char *itemp = self.view.buf # <<<<<<<<<<<<<< + * + * for dim, idx in enumerate(index): + */ + __pyx_v_itemp = ((char *)__pyx_v_self->view.buf); + + /* "View.MemoryView":397 + * cdef char *itemp = self.view.buf + * + * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< + * itemp = pybuffer_index(&self.view, itemp, idx, dim) + * + */ + __pyx_t_1 = 0; + if (likely(PyList_CheckExact(__pyx_v_index)) || PyTuple_CheckExact(__pyx_v_index)) { + __pyx_t_2 = __pyx_v_index; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 397, __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, 397, __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, 397, __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, 397, __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, 397, __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, 397, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } + } else { + __pyx_t_5 = __pyx_t_4(__pyx_t_2); + if (unlikely(!__pyx_t_5)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 397, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_v_dim = __pyx_t_1; + __pyx_t_1 = (__pyx_t_1 + 1); + + /* "View.MemoryView":398 + * + * 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, 398, __pyx_L1_error) + __pyx_t_7 = __pyx_pybuffer_index((&__pyx_v_self->view), __pyx_v_itemp, __pyx_t_6, __pyx_v_dim); if (unlikely(__pyx_t_7 == ((char *)NULL))) __PYX_ERR(1, 398, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_7; + + /* "View.MemoryView":397 + * cdef char *itemp = self.view.buf + * + * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< + * itemp = pybuffer_index(&self.view, itemp, idx, dim) + * + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":400 + * itemp = pybuffer_index(&self.view, itemp, idx, dim) + * + * return itemp # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_itemp; + goto __pyx_L0; + + /* "View.MemoryView":393 + * PyThread_free_lock(self.lock) + * + * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< + * cdef Py_ssize_t dim + * cdef char *itemp = self.view.buf + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview.get_item_pointer", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_idx); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":403 + * + * + * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< + * if index is Ellipsis: + * return self + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index); /*proto*/ +static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { + PyObject *__pyx_v_have_slices = NULL; + PyObject *__pyx_v_indices = NULL; + char *__pyx_v_itemp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + char *__pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "View.MemoryView":404 + * + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: # <<<<<<<<<<<<<< + * return self + * + */ + __pyx_t_1 = (__pyx_v_index == __pyx_builtin_Ellipsis); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":405 + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: + * return self # <<<<<<<<<<<<<< + * + * have_slices, indices = _unellipsify(index, self.view.ndim) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "View.MemoryView":404 + * + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: # <<<<<<<<<<<<<< + * return self + * + */ + } + + /* "View.MemoryView":407 + * 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, 407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (likely(__pyx_t_3 != Py_None)) { + PyObject* sequence = __pyx_t_3; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(1, 407, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + #else + __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 407, __pyx_L1_error) + } + __pyx_v_have_slices = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_v_indices = __pyx_t_5; + __pyx_t_5 = 0; + + /* "View.MemoryView":410 + * + * 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, 410, __pyx_L1_error) + if (__pyx_t_2) { + + /* "View.MemoryView":411 + * cdef char *itemp + * if have_slices: + * return memview_slice(self, indices) # <<<<<<<<<<<<<< + * else: + * itemp = self.get_item_pointer(indices) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":410 + * + * cdef char *itemp + * if have_slices: # <<<<<<<<<<<<<< + * return memview_slice(self, indices) + * else: + */ + } + + /* "View.MemoryView":413 + * return memview_slice(self, indices) + * else: + * itemp = self.get_item_pointer(indices) # <<<<<<<<<<<<<< + * return self.convert_item_to_object(itemp) + * + */ + /*else*/ { + __pyx_t_6 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_6 == ((char *)NULL))) __PYX_ERR(1, 413, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_6; + + /* "View.MemoryView":414 + * else: + * itemp = self.get_item_pointer(indices) + * return self.convert_item_to_object(itemp) # <<<<<<<<<<<<<< + * + * def __setitem__(memoryview self, object index, object value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":403 + * + * + * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< + * if index is Ellipsis: + * return self + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_have_slices); + __Pyx_XDECREF(__pyx_v_indices); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":416 + * return self.convert_item_to_object(itemp) + * + * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") + */ + +/* Python wrapper */ +static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { + PyObject *__pyx_v_have_slices = NULL; + PyObject *__pyx_v_obj = NULL; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setitem__", 0); + __Pyx_INCREF(__pyx_v_index); + + /* "View.MemoryView":417 + * + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: # <<<<<<<<<<<<<< + * raise TypeError("Cannot assign to read-only memoryview") + * + */ + __pyx_t_1 = (__pyx_v_self->view.readonly != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":418 + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<< + * + * have_slices, index = _unellipsify(index, self.view.ndim) + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 418, __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, 418, __pyx_L1_error) + + /* "View.MemoryView":417 + * + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: # <<<<<<<<<<<<<< + * raise TypeError("Cannot assign to read-only memoryview") + * + */ + } + + /* "View.MemoryView":420 + * 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, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (likely(__pyx_t_2 != Py_None)) { + PyObject* sequence = __pyx_t_2; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(1, 420, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 420, __pyx_L1_error) + } + __pyx_v_have_slices = __pyx_t_3; + __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":422 + * 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, 422, __pyx_L1_error) + if (__pyx_t_1) { + + /* "View.MemoryView":423 + * + * 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, 423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_obj = __pyx_t_2; + __pyx_t_2 = 0; + + /* "View.MemoryView":424 + * 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, 424, __pyx_L1_error) + if (__pyx_t_1) { + + /* "View.MemoryView":425 + * 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, 425, __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, 425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "View.MemoryView":424 + * if have_slices: + * obj = self.is_slice(value) + * if obj: # <<<<<<<<<<<<<< + * self.setitem_slice_assignment(self[index], obj) + * else: + */ + goto __pyx_L5; + } + + /* "View.MemoryView":427 + * self.setitem_slice_assignment(self[index], obj) + * else: + * self.setitem_slice_assign_scalar(self[index], value) # <<<<<<<<<<<<<< + * else: + * self.setitem_indexed(index, value) + */ + /*else*/ { + __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 427, __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, 427, __pyx_L1_error) + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_4), __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L5:; + + /* "View.MemoryView":422 + * have_slices, index = _unellipsify(index, self.view.ndim) + * + * if have_slices: # <<<<<<<<<<<<<< + * obj = self.is_slice(value) + * if obj: + */ + goto __pyx_L4; + } + + /* "View.MemoryView":429 + * self.setitem_slice_assign_scalar(self[index], value) + * else: + * self.setitem_indexed(index, value) # <<<<<<<<<<<<<< + * + * cdef is_slice(self, obj): + */ + /*else*/ { + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L4:; + + /* "View.MemoryView":416 + * return self.convert_item_to_object(itemp) + * + * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView.memoryview.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_have_slices); + __Pyx_XDECREF(__pyx_v_obj); + __Pyx_XDECREF(__pyx_v_index); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":431 + * self.setitem_indexed(index, value) + * + * cdef is_slice(self, obj): # <<<<<<<<<<<<<< + * if not isinstance(obj, memoryview): + * try: + */ + +static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("is_slice", 0); + __Pyx_INCREF(__pyx_v_obj); + + /* "View.MemoryView":432 + * + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + */ + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_obj, __pyx_memoryview_type); + __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":433 + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): + * try: # <<<<<<<<<<<<<< + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_5); + /*try:*/ { + + /* "View.MemoryView":434 + * if not isinstance(obj, memoryview): + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< + * self.dtype_is_object) + * except TypeError: + */ + __pyx_t_6 = __Pyx_PyInt_From_int(((__pyx_v_self->flags & (~PyBUF_WRITABLE)) | PyBUF_ANY_CONTIGUOUS)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 434, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_6); + + /* "View.MemoryView":435 + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) # <<<<<<<<<<<<<< + * except TypeError: + * return None + */ + __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 435, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_7); + + /* "View.MemoryView":434 + * if not isinstance(obj, memoryview): + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< + * self.dtype_is_object) + * except TypeError: + */ + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 434, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_INCREF(__pyx_v_obj); + __Pyx_GIVEREF(__pyx_v_obj); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_obj); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7); + __pyx_t_6 = 0; + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 434, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF_SET(__pyx_v_obj, __pyx_t_7); + __pyx_t_7 = 0; + + /* "View.MemoryView":433 + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): + * try: # <<<<<<<<<<<<<< + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) + */ + } + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L9_try_end; + __pyx_L4_error:; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "View.MemoryView":436 + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) + * except TypeError: # <<<<<<<<<<<<<< + * return None + * + */ + __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); + if (__pyx_t_9) { + __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_6) < 0) __PYX_ERR(1, 436, __pyx_L6_except_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GOTREF(__pyx_t_6); + + /* "View.MemoryView":437 + * self.dtype_is_object) + * except TypeError: + * return None # <<<<<<<<<<<<<< + * + * return obj + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L7_except_return; + } + goto __pyx_L6_except_error; + __pyx_L6_except_error:; + + /* "View.MemoryView":433 + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): + * try: # <<<<<<<<<<<<<< + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) + */ + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); + goto __pyx_L1_error; + __pyx_L7_except_return:; + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); + goto __pyx_L0; + __pyx_L9_try_end:; + } + + /* "View.MemoryView":432 + * + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + */ + } + + /* "View.MemoryView":439 + * return None + * + * return obj # <<<<<<<<<<<<<< + * + * cdef setitem_slice_assignment(self, dst, src): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_obj); + __pyx_r = __pyx_v_obj; + goto __pyx_L0; + + /* "View.MemoryView":431 + * self.setitem_indexed(index, value) + * + * cdef is_slice(self, obj): # <<<<<<<<<<<<<< + * if not isinstance(obj, memoryview): + * try: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_obj); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":441 + * return obj + * + * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice dst_slice + * cdef __Pyx_memviewslice src_slice + */ + +static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src) { + __Pyx_memviewslice __pyx_v_dst_slice; + __Pyx_memviewslice __pyx_v_src_slice; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + __Pyx_memviewslice *__pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setitem_slice_assignment", 0); + + /* "View.MemoryView":445 + * 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, 445, __pyx_L1_error) + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_src), (&__pyx_v_src_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 445, __pyx_L1_error) + + /* "View.MemoryView":446 + * + * 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, 446, __pyx_L1_error) + __pyx_t_2 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice)); if (unlikely(__pyx_t_2 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 446, __pyx_L1_error) + + /* "View.MemoryView":447 + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], + * get_slice_from_memview(dst, &dst_slice)[0], + * src.ndim, dst.ndim, self.dtype_is_object) # <<<<<<<<<<<<<< + * + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 447, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 447, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_dst, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 447, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 447, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":445 + * cdef __Pyx_memviewslice src_slice + * + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], # <<<<<<<<<<<<<< + * get_slice_from_memview(dst, &dst_slice)[0], + * src.ndim, dst.ndim, self.dtype_is_object) + */ + __pyx_t_6 = __pyx_memoryview_copy_contents((__pyx_t_1[0]), (__pyx_t_2[0]), __pyx_t_4, __pyx_t_5, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 445, __pyx_L1_error) + + /* "View.MemoryView":441 + * return obj + * + * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice dst_slice + * cdef __Pyx_memviewslice src_slice + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assignment", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":449 + * src.ndim, dst.ndim, self.dtype_is_object) + * + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< + * cdef int array[128] + * cdef void *tmp = NULL + */ + +static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value) { + int __pyx_v_array[0x80]; + void *__pyx_v_tmp; + void *__pyx_v_item; + __Pyx_memviewslice *__pyx_v_dst_slice; + __Pyx_memviewslice __pyx_v_tmp_slice; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + char const *__pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setitem_slice_assign_scalar", 0); + + /* "View.MemoryView":451 + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): + * cdef int array[128] + * cdef void *tmp = NULL # <<<<<<<<<<<<<< + * cdef void *item + * + */ + __pyx_v_tmp = NULL; + + /* "View.MemoryView":456 + * cdef __Pyx_memviewslice *dst_slice + * cdef __Pyx_memviewslice tmp_slice + * dst_slice = get_slice_from_memview(dst, &tmp_slice) # <<<<<<<<<<<<<< + * + * if self.view.itemsize > sizeof(array): + */ + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_dst, (&__pyx_v_tmp_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 456, __pyx_L1_error) + __pyx_v_dst_slice = __pyx_t_1; + + /* "View.MemoryView":458 + * dst_slice = get_slice_from_memview(dst, &tmp_slice) + * + * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: + */ + __pyx_t_2 = ((((size_t)__pyx_v_self->view.itemsize) > (sizeof(__pyx_v_array))) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":459 + * + * if self.view.itemsize > sizeof(array): + * tmp = PyMem_Malloc(self.view.itemsize) # <<<<<<<<<<<<<< + * if tmp == NULL: + * raise MemoryError + */ + __pyx_v_tmp = PyMem_Malloc(__pyx_v_self->view.itemsize); + + /* "View.MemoryView":460 + * if self.view.itemsize > sizeof(array): + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * item = tmp + */ + __pyx_t_2 = ((__pyx_v_tmp == NULL) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":461 + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: + * raise MemoryError # <<<<<<<<<<<<<< + * item = tmp + * else: + */ + PyErr_NoMemory(); __PYX_ERR(1, 461, __pyx_L1_error) + + /* "View.MemoryView":460 + * if self.view.itemsize > sizeof(array): + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * item = tmp + */ + } + + /* "View.MemoryView":462 + * if tmp == NULL: + * raise MemoryError + * item = tmp # <<<<<<<<<<<<<< + * else: + * item = array + */ + __pyx_v_item = __pyx_v_tmp; + + /* "View.MemoryView":458 + * dst_slice = get_slice_from_memview(dst, &tmp_slice) + * + * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":464 + * item = tmp + * else: + * item = array # <<<<<<<<<<<<<< + * + * try: + */ + /*else*/ { + __pyx_v_item = ((void *)__pyx_v_array); + } + __pyx_L3:; + + /* "View.MemoryView":466 + * item = array + * + * try: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * ( item)[0] = value + */ + /*try:*/ { + + /* "View.MemoryView":467 + * + * try: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * ( item)[0] = value + * else: + */ + __pyx_t_2 = (__pyx_v_self->dtype_is_object != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":468 + * try: + * if self.dtype_is_object: + * ( item)[0] = value # <<<<<<<<<<<<<< + * else: + * self.assign_item_from_object( item, value) + */ + (((PyObject **)__pyx_v_item)[0]) = ((PyObject *)__pyx_v_value); + + /* "View.MemoryView":467 + * + * try: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * ( item)[0] = value + * else: + */ + goto __pyx_L8; + } + + /* "View.MemoryView":470 + * ( item)[0] = value + * else: + * self.assign_item_from_object( item, value) # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, ((char *)__pyx_v_item), __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 470, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_L8:; + + /* "View.MemoryView":474 + * + * + * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, + */ + __pyx_t_2 = ((__pyx_v_self->view.suboffsets != NULL) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":475 + * + * if self.view.suboffsets != NULL: + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) # <<<<<<<<<<<<<< + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, + * item, self.dtype_is_object) + */ + __pyx_t_3 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 475, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":474 + * + * + * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, + */ + } + + /* "View.MemoryView":476 + * if self.view.suboffsets != NULL: + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, # <<<<<<<<<<<<<< + * item, self.dtype_is_object) + * finally: + */ + __pyx_memoryview_slice_assign_scalar(__pyx_v_dst_slice, __pyx_v_dst->view.ndim, __pyx_v_self->view.itemsize, __pyx_v_item, __pyx_v_self->dtype_is_object); + } + + /* "View.MemoryView":479 + * item, self.dtype_is_object) + * finally: + * PyMem_Free(tmp) # <<<<<<<<<<<<<< + * + * cdef setitem_indexed(self, index, value): + */ + /*finally:*/ { + /*normal exit:*/{ + PyMem_Free(__pyx_v_tmp); + goto __pyx_L7; + } + __pyx_L6_error:; + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_12); + __pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename; + { + PyMem_Free(__pyx_v_tmp); + } + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); + } + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ErrRestore(__pyx_t_7, __pyx_t_8, __pyx_t_9); + __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; + __pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_5; __pyx_filename = __pyx_t_6; + goto __pyx_L1_error; + } + __pyx_L7:; + } + + /* "View.MemoryView":449 + * src.ndim, dst.ndim, self.dtype_is_object) + * + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< + * cdef int array[128] + * cdef void *tmp = NULL + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assign_scalar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":481 + * PyMem_Free(tmp) + * + * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< + * cdef char *itemp = self.get_item_pointer(index) + * self.assign_item_from_object(itemp, value) + */ + +static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { + char *__pyx_v_itemp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setitem_indexed", 0); + + /* "View.MemoryView":482 + * + * 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, 482, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_1; + + /* "View.MemoryView":483 + * 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, 483, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":481 + * PyMem_Free(tmp) + * + * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< + * cdef char *itemp = self.get_item_pointer(index) + * self.assign_item_from_object(itemp, value) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_indexed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":485 + * self.assign_item_from_object(itemp, value) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + */ + +static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp) { + PyObject *__pyx_v_struct = NULL; + PyObject *__pyx_v_bytesitem = 0; + PyObject *__pyx_v_result = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + size_t __pyx_t_10; + int __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("convert_item_to_object", 0); + + /* "View.MemoryView":488 + * """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, 488, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_struct = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":491 + * 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, 491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_bytesitem = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":492 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_4); + /*try:*/ { + + /* "View.MemoryView":493 + * 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, 493, __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, 493, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 493, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 493, __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, 493, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_6); + __Pyx_INCREF(__pyx_v_bytesitem); + __Pyx_GIVEREF(__pyx_v_bytesitem); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_bytesitem); + __pyx_t_6 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 493, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":492 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + */ + } + + /* "View.MemoryView":497 + * raise ValueError("Unable to convert item to object") + * else: + * if len(self.view.format) == 1: # <<<<<<<<<<<<<< + * return result[0] + * return result + */ + /*else:*/ { + __pyx_t_10 = strlen(__pyx_v_self->view.format); + __pyx_t_11 = ((__pyx_t_10 == 1) != 0); + if (__pyx_t_11) { + + /* "View.MemoryView":498 + * else: + * if len(self.view.format) == 1: + * return result[0] # <<<<<<<<<<<<<< + * return result + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_result, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 498, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L6_except_return; + + /* "View.MemoryView":497 + * raise ValueError("Unable to convert item to object") + * else: + * if len(self.view.format) == 1: # <<<<<<<<<<<<<< + * return result[0] + * return result + */ + } + + /* "View.MemoryView":499 + * if len(self.view.format) == 1: + * return result[0] + * return result # <<<<<<<<<<<<<< + * + * cdef assign_item_from_object(self, char *itemp, object value): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L6_except_return; + } + __pyx_L3_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "View.MemoryView":494 + * try: + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: # <<<<<<<<<<<<<< + * raise ValueError("Unable to convert item to object") + * else: + */ + __Pyx_ErrFetch(&__pyx_t_1, &__pyx_t_5, &__pyx_t_9); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 494, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_ErrRestore(__pyx_t_1, __pyx_t_5, __pyx_t_9); + __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_9 = 0; + if (__pyx_t_8) { + __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(1, 494, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_1); + + /* "View.MemoryView":495 + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + * raise ValueError("Unable to convert item to object") # <<<<<<<<<<<<<< + * else: + * if len(self.view.format) == 1: + */ + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 495, __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, 495, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "View.MemoryView":492 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + */ + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); + goto __pyx_L1_error; + __pyx_L6_except_return:; + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); + goto __pyx_L0; + } + + /* "View.MemoryView":485 + * self.assign_item_from_object(itemp, value) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_struct); + __Pyx_XDECREF(__pyx_v_bytesitem); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":501 + * return result + * + * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + */ + +static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) { + PyObject *__pyx_v_struct = NULL; + char __pyx_v_c; + PyObject *__pyx_v_bytesvalue = 0; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + Py_ssize_t __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + char *__pyx_t_11; + char *__pyx_t_12; + char *__pyx_t_13; + char *__pyx_t_14; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("assign_item_from_object", 0); + + /* "View.MemoryView":504 + * """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, 504, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_struct = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":509 + * cdef Py_ssize_t i + * + * if isinstance(value, tuple): # <<<<<<<<<<<<<< + * bytesvalue = struct.pack(self.view.format, *value) + * else: + */ + __pyx_t_2 = PyTuple_Check(__pyx_v_value); + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "View.MemoryView":510 + * + * 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, 510, __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, 510, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 510, __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, 510, __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, 510, __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, 510, __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, 510, __pyx_L1_error) + __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":509 + * cdef Py_ssize_t i + * + * if isinstance(value, tuple): # <<<<<<<<<<<<<< + * bytesvalue = struct.pack(self.view.format, *value) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":512 + * bytesvalue = struct.pack(self.view.format, *value) + * else: + * bytesvalue = struct.pack(self.view.format, value) # <<<<<<<<<<<<<< + * + * for i, c in enumerate(bytesvalue): + */ + /*else*/ { + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 512, __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, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __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, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_value); + __pyx_t_1 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __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, 512, __pyx_L1_error) + __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + } + __pyx_L3:; + + /* "View.MemoryView":514 + * bytesvalue = struct.pack(self.view.format, value) + * + * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< + * itemp[i] = c + * + */ + __pyx_t_9 = 0; + if (unlikely(__pyx_v_bytesvalue == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable"); + __PYX_ERR(1, 514, __pyx_L1_error) + } + __Pyx_INCREF(__pyx_v_bytesvalue); + __pyx_t_10 = __pyx_v_bytesvalue; + __pyx_t_12 = PyBytes_AS_STRING(__pyx_t_10); + __pyx_t_13 = (__pyx_t_12 + PyBytes_GET_SIZE(__pyx_t_10)); + for (__pyx_t_14 = __pyx_t_12; __pyx_t_14 < __pyx_t_13; __pyx_t_14++) { + __pyx_t_11 = __pyx_t_14; + __pyx_v_c = (__pyx_t_11[0]); + + /* "View.MemoryView":515 + * + * for i, c in enumerate(bytesvalue): + * itemp[i] = c # <<<<<<<<<<<<<< + * + * @cname('getbuffer') + */ + __pyx_v_i = __pyx_t_9; + + /* "View.MemoryView":514 + * bytesvalue = struct.pack(self.view.format, value) + * + * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< + * itemp[i] = c + * + */ + __pyx_t_9 = (__pyx_t_9 + 1); + + /* "View.MemoryView":515 + * + * for i, c in enumerate(bytesvalue): + * itemp[i] = c # <<<<<<<<<<<<<< + * + * @cname('getbuffer') + */ + (__pyx_v_itemp[__pyx_v_i]) = __pyx_v_c; + } + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "View.MemoryView":501 + * return result + * + * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("View.MemoryView.memoryview.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_struct); + __Pyx_XDECREF(__pyx_v_bytesvalue); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":518 + * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * if flags & PyBUF_WRITABLE and self.view.readonly: + * raise ValueError("Cannot create writable memory view from read-only memoryview") + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t *__pyx_t_4; + char *__pyx_t_5; + void *__pyx_t_6; + int __pyx_t_7; + Py_ssize_t __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + if (__pyx_v_info == NULL) { + PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); + return -1; + } + __Pyx_RefNannySetupContext("__getbuffer__", 0); + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + + /* "View.MemoryView":519 + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< + * raise ValueError("Cannot create writable memory view from read-only memoryview") + * + */ + __pyx_t_2 = ((__pyx_v_flags & PyBUF_WRITABLE) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_self->view.readonly != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":520 + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: + * raise ValueError("Cannot create writable memory view from read-only memoryview") # <<<<<<<<<<<<<< + * + * if flags & PyBUF_ND: + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 520, __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, 520, __pyx_L1_error) + + /* "View.MemoryView":519 + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< + * raise ValueError("Cannot create writable memory view from read-only memoryview") + * + */ + } + + /* "View.MemoryView":522 + * raise ValueError("Cannot create writable memory view from read-only memoryview") + * + * if flags & PyBUF_ND: # <<<<<<<<<<<<<< + * info.shape = self.view.shape + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":523 + * + * if flags & PyBUF_ND: + * info.shape = self.view.shape # <<<<<<<<<<<<<< + * else: + * info.shape = NULL + */ + __pyx_t_4 = __pyx_v_self->view.shape; + __pyx_v_info->shape = __pyx_t_4; + + /* "View.MemoryView":522 + * raise ValueError("Cannot create writable memory view from read-only memoryview") + * + * if flags & PyBUF_ND: # <<<<<<<<<<<<<< + * info.shape = self.view.shape + * else: + */ + goto __pyx_L6; + } + + /* "View.MemoryView":525 + * info.shape = self.view.shape + * else: + * info.shape = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_STRIDES: + */ + /*else*/ { + __pyx_v_info->shape = NULL; + } + __pyx_L6:; + + /* "View.MemoryView":527 + * info.shape = NULL + * + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< + * info.strides = self.view.strides + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":528 + * + * if flags & PyBUF_STRIDES: + * info.strides = self.view.strides # <<<<<<<<<<<<<< + * else: + * info.strides = NULL + */ + __pyx_t_4 = __pyx_v_self->view.strides; + __pyx_v_info->strides = __pyx_t_4; + + /* "View.MemoryView":527 + * info.shape = NULL + * + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< + * info.strides = self.view.strides + * else: + */ + goto __pyx_L7; + } + + /* "View.MemoryView":530 + * info.strides = self.view.strides + * else: + * info.strides = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_INDIRECT: + */ + /*else*/ { + __pyx_v_info->strides = NULL; + } + __pyx_L7:; + + /* "View.MemoryView":532 + * info.strides = NULL + * + * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< + * info.suboffsets = self.view.suboffsets + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_INDIRECT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":533 + * + * if flags & PyBUF_INDIRECT: + * info.suboffsets = self.view.suboffsets # <<<<<<<<<<<<<< + * else: + * info.suboffsets = NULL + */ + __pyx_t_4 = __pyx_v_self->view.suboffsets; + __pyx_v_info->suboffsets = __pyx_t_4; + + /* "View.MemoryView":532 + * info.strides = NULL + * + * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< + * info.suboffsets = self.view.suboffsets + * else: + */ + goto __pyx_L8; + } + + /* "View.MemoryView":535 + * info.suboffsets = self.view.suboffsets + * else: + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: + */ + /*else*/ { + __pyx_v_info->suboffsets = NULL; + } + __pyx_L8:; + + /* "View.MemoryView":537 + * info.suboffsets = NULL + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.view.format + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":538 + * + * if flags & PyBUF_FORMAT: + * info.format = self.view.format # <<<<<<<<<<<<<< + * else: + * info.format = NULL + */ + __pyx_t_5 = __pyx_v_self->view.format; + __pyx_v_info->format = __pyx_t_5; + + /* "View.MemoryView":537 + * info.suboffsets = NULL + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.view.format + * else: + */ + goto __pyx_L9; + } + + /* "View.MemoryView":540 + * info.format = self.view.format + * else: + * info.format = NULL # <<<<<<<<<<<<<< + * + * info.buf = self.view.buf + */ + /*else*/ { + __pyx_v_info->format = NULL; + } + __pyx_L9:; + + /* "View.MemoryView":542 + * info.format = NULL + * + * info.buf = self.view.buf # <<<<<<<<<<<<<< + * info.ndim = self.view.ndim + * info.itemsize = self.view.itemsize + */ + __pyx_t_6 = __pyx_v_self->view.buf; + __pyx_v_info->buf = __pyx_t_6; + + /* "View.MemoryView":543 + * + * info.buf = self.view.buf + * info.ndim = self.view.ndim # <<<<<<<<<<<<<< + * info.itemsize = self.view.itemsize + * info.len = self.view.len + */ + __pyx_t_7 = __pyx_v_self->view.ndim; + __pyx_v_info->ndim = __pyx_t_7; + + /* "View.MemoryView":544 + * info.buf = self.view.buf + * info.ndim = self.view.ndim + * info.itemsize = self.view.itemsize # <<<<<<<<<<<<<< + * info.len = self.view.len + * info.readonly = self.view.readonly + */ + __pyx_t_8 = __pyx_v_self->view.itemsize; + __pyx_v_info->itemsize = __pyx_t_8; + + /* "View.MemoryView":545 + * info.ndim = self.view.ndim + * info.itemsize = self.view.itemsize + * info.len = self.view.len # <<<<<<<<<<<<<< + * info.readonly = self.view.readonly + * info.obj = self + */ + __pyx_t_8 = __pyx_v_self->view.len; + __pyx_v_info->len = __pyx_t_8; + + /* "View.MemoryView":546 + * info.itemsize = self.view.itemsize + * info.len = self.view.len + * info.readonly = self.view.readonly # <<<<<<<<<<<<<< + * info.obj = self + * + */ + __pyx_t_1 = __pyx_v_self->view.readonly; + __pyx_v_info->readonly = __pyx_t_1; + + /* "View.MemoryView":547 + * info.len = self.view.len + * info.readonly = self.view.readonly + * info.obj = self # <<<<<<<<<<<<<< + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") + */ + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + + /* "View.MemoryView":518 + * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * if flags & PyBUF_WRITABLE and self.view.readonly: + * raise ValueError("Cannot create writable memory view from read-only memoryview") + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + __pyx_L2:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":553 + * + * @property + * def T(self): # <<<<<<<<<<<<<< + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + struct __pyx_memoryviewslice_obj *__pyx_v_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":554 + * @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, 554, __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, 554, __pyx_L1_error) + __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":555 + * 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, 555, __pyx_L1_error) + + /* "View.MemoryView":556 + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) + * return result # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "View.MemoryView":553 + * + * @property + * def T(self): # <<<<<<<<<<<<<< + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.T.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":559 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.obj + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":560 + * @property + * def base(self): + * return self.obj # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->obj); + __pyx_r = __pyx_v_self->obj; + goto __pyx_L0; + + /* "View.MemoryView":559 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.obj + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":563 + * + * @property + * def shape(self): # <<<<<<<<<<<<<< + * return tuple([length for length in self.view.shape[:self.view.ndim]]) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_v_length; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t *__pyx_t_2; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":564 + * @property + * def shape(self): + * return tuple([length for length in self.view.shape[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 564, __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, 564, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(1, 564, __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, 564, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "View.MemoryView":563 + * + * @property + * def shape(self): # <<<<<<<<<<<<<< + * return tuple([length for length in self.view.shape[:self.view.ndim]]) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview.shape.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":567 + * + * @property + * def strides(self): # <<<<<<<<<<<<<< + * if self.view.strides == NULL: + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_v_stride; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + Py_ssize_t *__pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":568 + * @property + * def strides(self): + * if self.view.strides == NULL: # <<<<<<<<<<<<<< + * + * raise ValueError("Buffer view does not expose strides") + */ + __pyx_t_1 = ((__pyx_v_self->view.strides == NULL) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":570 + * if self.view.strides == NULL: + * + * raise ValueError("Buffer view does not expose strides") # <<<<<<<<<<<<<< + * + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 570, __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, 570, __pyx_L1_error) + + /* "View.MemoryView":568 + * @property + * def strides(self): + * if self.view.strides == NULL: # <<<<<<<<<<<<<< + * + * raise ValueError("Buffer view does not expose strides") + */ + } + + /* "View.MemoryView":572 + * raise ValueError("Buffer view does not expose strides") + * + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 572, __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, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 572, __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, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_6; + __pyx_t_6 = 0; + goto __pyx_L0; + + /* "View.MemoryView":567 + * + * @property + * def strides(self): # <<<<<<<<<<<<<< + * if self.view.strides == NULL: + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("View.MemoryView.memoryview.strides.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":575 + * + * @property + * def suboffsets(self): # <<<<<<<<<<<<<< + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_v_suboffset; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t *__pyx_t_4; + Py_ssize_t *__pyx_t_5; + Py_ssize_t *__pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":576 + * @property + * def suboffsets(self): + * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< + * return (-1,) * self.view.ndim + * + */ + __pyx_t_1 = ((__pyx_v_self->view.suboffsets == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":577 + * def suboffsets(self): + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< + * + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 577, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Multiply(__pyx_tuple__13, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 577, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":576 + * @property + * def suboffsets(self): + * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< + * return (-1,) * self.view.ndim + * + */ + } + + /* "View.MemoryView":579 + * return (-1,) * self.view.ndim + * + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 579, __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, 579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_2))) __PYX_ERR(1, 579, __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, 579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":575 + * + * @property + * def suboffsets(self): # <<<<<<<<<<<<<< + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.suboffsets.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":582 + * + * @property + * def ndim(self): # <<<<<<<<<<<<<< + * return self.view.ndim + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":583 + * @property + * def ndim(self): + * return self.view.ndim # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":582 + * + * @property + * def ndim(self): # <<<<<<<<<<<<<< + * return self.view.ndim + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.ndim.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":586 + * + * @property + * def itemsize(self): # <<<<<<<<<<<<<< + * return self.view.itemsize + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":587 + * @property + * def itemsize(self): + * return self.view.itemsize # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 587, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":586 + * + * @property + * def itemsize(self): # <<<<<<<<<<<<<< + * return self.view.itemsize + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.itemsize.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":590 + * + * @property + * def nbytes(self): # <<<<<<<<<<<<<< + * return self.size * self.view.itemsize + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":591 + * @property + * def nbytes(self): + * return self.size * self.view.itemsize # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 591, __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, 591, __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, 591, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":590 + * + * @property + * def nbytes(self): # <<<<<<<<<<<<<< + * return self.size * self.view.itemsize + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.nbytes.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":594 + * + * @property + * def size(self): # <<<<<<<<<<<<<< + * if self._size is None: + * result = 1 + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_v_result = NULL; + PyObject *__pyx_v_length = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + Py_ssize_t *__pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":595 + * @property + * def size(self): + * if self._size is None: # <<<<<<<<<<<<<< + * result = 1 + * + */ + __pyx_t_1 = (__pyx_v_self->_size == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":596 + * def size(self): + * if self._size is None: + * result = 1 # <<<<<<<<<<<<<< + * + * for length in self.view.shape[:self.view.ndim]: + */ + __Pyx_INCREF(__pyx_int_1); + __pyx_v_result = __pyx_int_1; + + /* "View.MemoryView":598 + * result = 1 + * + * for length in self.view.shape[:self.view.ndim]: # <<<<<<<<<<<<<< + * result *= length + * + */ + __pyx_t_4 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); + for (__pyx_t_5 = __pyx_v_self->view.shape; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { + __pyx_t_3 = __pyx_t_5; + __pyx_t_6 = PyInt_FromSsize_t((__pyx_t_3[0])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 598, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_6); + __pyx_t_6 = 0; + + /* "View.MemoryView":599 + * + * 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, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_6); + __pyx_t_6 = 0; + } + + /* "View.MemoryView":601 + * result *= length + * + * self._size = result # <<<<<<<<<<<<<< + * + * return self._size + */ + __Pyx_INCREF(__pyx_v_result); + __Pyx_GIVEREF(__pyx_v_result); + __Pyx_GOTREF(__pyx_v_self->_size); + __Pyx_DECREF(__pyx_v_self->_size); + __pyx_v_self->_size = __pyx_v_result; + + /* "View.MemoryView":595 + * @property + * def size(self): + * if self._size is None: # <<<<<<<<<<<<<< + * result = 1 + * + */ + } + + /* "View.MemoryView":603 + * self._size = result + * + * return self._size # <<<<<<<<<<<<<< + * + * def __len__(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_size); + __pyx_r = __pyx_v_self->_size; + goto __pyx_L0; + + /* "View.MemoryView":594 + * + * @property + * def size(self): # <<<<<<<<<<<<<< + * if self._size is None: + * result = 1 + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("View.MemoryView.memoryview.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_length); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":605 + * return self._size + * + * def __len__(self): # <<<<<<<<<<<<<< + * if self.view.ndim >= 1: + * return self.view.shape[0] + */ + +/* Python wrapper */ +static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self); /*proto*/ +static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__len__", 0); + + /* "View.MemoryView":606 + * + * def __len__(self): + * if self.view.ndim >= 1: # <<<<<<<<<<<<<< + * return self.view.shape[0] + * + */ + __pyx_t_1 = ((__pyx_v_self->view.ndim >= 1) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":607 + * def __len__(self): + * if self.view.ndim >= 1: + * return self.view.shape[0] # <<<<<<<<<<<<<< + * + * return 0 + */ + __pyx_r = (__pyx_v_self->view.shape[0]); + goto __pyx_L0; + + /* "View.MemoryView":606 + * + * def __len__(self): + * if self.view.ndim >= 1: # <<<<<<<<<<<<<< + * return self.view.shape[0] + * + */ + } + + /* "View.MemoryView":609 + * return self.view.shape[0] + * + * return 0 # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":605 + * return self._size + * + * def __len__(self): # <<<<<<<<<<<<<< + * if self.view.ndim >= 1: + * return self.view.shape[0] + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":611 + * return 0 + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__, + * id(self)) + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "View.MemoryView":612 + * + * def __repr__(self): + * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< + * id(self)) + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":613 + * 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, 613, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "View.MemoryView":612 + * + * def __repr__(self): + * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< + * id(self)) + * + */ + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":611 + * return 0 + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__, + * id(self)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":615 + * id(self)) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__,) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__str__", 0); + + /* "View.MemoryView":616 + * + * def __str__(self): + * return "" % (self.base.__class__.__name__,) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 616, __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, 616, __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, 616, __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, 616, __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, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":615 + * id(self)) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__,) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":619 + * + * + * def is_c_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_c_contig (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice *__pyx_v_mslice; + __Pyx_memviewslice __pyx_v_tmp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("is_c_contig", 0); + + /* "View.MemoryView":622 + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<< + * return slice_is_contig(mslice[0], 'C', self.view.ndim) + * + */ + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 622, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":623 + * cdef __Pyx_memviewslice tmp + * mslice = get_slice_from_memview(self, &tmp) + * return slice_is_contig(mslice[0], 'C', self.view.ndim) # <<<<<<<<<<<<<< + * + * def is_f_contig(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'C', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 623, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":619 + * + * + * def is_c_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.is_c_contig", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":625 + * return slice_is_contig(mslice[0], 'C', self.view.ndim) + * + * def is_f_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_f_contig (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice *__pyx_v_mslice; + __Pyx_memviewslice __pyx_v_tmp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("is_f_contig", 0); + + /* "View.MemoryView":628 + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<< + * return slice_is_contig(mslice[0], 'F', self.view.ndim) + * + */ + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 628, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":629 + * cdef __Pyx_memviewslice tmp + * mslice = get_slice_from_memview(self, &tmp) + * return slice_is_contig(mslice[0], 'F', self.view.ndim) # <<<<<<<<<<<<<< + * + * def copy(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'F', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 629, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":625 + * return slice_is_contig(mslice[0], 'C', self.view.ndim) + * + * def is_f_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.is_f_contig", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":631 + * return slice_is_contig(mslice[0], 'F', self.view.ndim) + * + * def copy(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice mslice + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("copy (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice __pyx_v_mslice; + int __pyx_v_flags; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("copy", 0); + + /* "View.MemoryView":633 + * def copy(self): + * cdef __Pyx_memviewslice mslice + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS # <<<<<<<<<<<<<< + * + * slice_copy(self, &mslice) + */ + __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_F_CONTIGUOUS)); + + /* "View.MemoryView":635 + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS + * + * slice_copy(self, &mslice) # <<<<<<<<<<<<<< + * mslice = slice_copy_contig(&mslice, "c", self.view.ndim, + * self.view.itemsize, + */ + __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_mslice)); + + /* "View.MemoryView":636 + * + * 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, 636, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":641 + * self.dtype_is_object) + * + * return memoryview_copy_from_slice(self, &mslice) # <<<<<<<<<<<<<< + * + * def copy_fortran(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_mslice)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 641, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":631 + * return slice_is_contig(mslice[0], 'F', self.view.ndim) + * + * def copy(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice mslice + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.copy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":643 + * return memoryview_copy_from_slice(self, &mslice) + * + * def copy_fortran(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice src, dst + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("copy_fortran (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice __pyx_v_src; + __Pyx_memviewslice __pyx_v_dst; + int __pyx_v_flags; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("copy_fortran", 0); + + /* "View.MemoryView":645 + * def copy_fortran(self): + * cdef __Pyx_memviewslice src, dst + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS # <<<<<<<<<<<<<< + * + * slice_copy(self, &src) + */ + __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_C_CONTIGUOUS)); + + /* "View.MemoryView":647 + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS + * + * slice_copy(self, &src) # <<<<<<<<<<<<<< + * dst = slice_copy_contig(&src, "fortran", self.view.ndim, + * self.view.itemsize, + */ + __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_src)); + + /* "View.MemoryView":648 + * + * 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, 648, __pyx_L1_error) + __pyx_v_dst = __pyx_t_1; + + /* "View.MemoryView":653 + * self.dtype_is_object) + * + * return memoryview_copy_from_slice(self, &dst) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_dst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 653, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":643 + * return memoryview_copy_from_slice(self, &mslice) + * + * def copy_fortran(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice src, dst + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.copy_fortran", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_memoryview___reduce_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_memoryview_2__setstate_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":657 + * + * @cname('__pyx_memoryview_new') + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<< + * cdef memoryview result = memoryview(o, flags, dtype_is_object) + * result.typeinfo = typeinfo + */ + +static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, int __pyx_v_dtype_is_object, __Pyx_TypeInfo *__pyx_v_typeinfo) { + struct __pyx_memoryview_obj *__pyx_v_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_cwrapper", 0); + + /* "View.MemoryView":658 + * @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, 658, __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, 658, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 658, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_o); + __Pyx_GIVEREF(__pyx_v_o); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_o); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 658, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result = ((struct __pyx_memoryview_obj *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":659 + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): + * cdef memoryview result = memoryview(o, flags, dtype_is_object) + * result.typeinfo = typeinfo # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_v_result->typeinfo = __pyx_v_typeinfo; + + /* "View.MemoryView":660 + * cdef memoryview result = memoryview(o, flags, dtype_is_object) + * result.typeinfo = typeinfo + * return result # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_check') + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "View.MemoryView":657 + * + * @cname('__pyx_memoryview_new') + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<< + * cdef memoryview result = memoryview(o, flags, dtype_is_object) + * result.typeinfo = typeinfo + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":663 + * + * @cname('__pyx_memoryview_check') + * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< + * return isinstance(o, memoryview) + * + */ + +static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("memoryview_check", 0); + + /* "View.MemoryView":664 + * @cname('__pyx_memoryview_check') + * cdef inline bint memoryview_check(object o): + * return isinstance(o, memoryview) # <<<<<<<<<<<<<< + * + * cdef tuple _unellipsify(object index, int ndim): + */ + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_o, __pyx_memoryview_type); + __pyx_r = __pyx_t_1; + goto __pyx_L0; + + /* "View.MemoryView":663 + * + * @cname('__pyx_memoryview_check') + * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< + * return isinstance(o, memoryview) + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":666 + * return isinstance(o, memoryview) + * + * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< + * """ + * Replace all ellipses with full slices and fill incomplete indices with + */ + +static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { + PyObject *__pyx_v_tup = NULL; + PyObject *__pyx_v_result = NULL; + int __pyx_v_have_slices; + int __pyx_v_seen_ellipsis; + CYTHON_UNUSED PyObject *__pyx_v_idx = NULL; + PyObject *__pyx_v_item = NULL; + Py_ssize_t __pyx_v_nslices; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + Py_ssize_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + PyObject *__pyx_t_7 = NULL; + Py_ssize_t __pyx_t_8; + int __pyx_t_9; + int __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_unellipsify", 0); + + /* "View.MemoryView":671 + * full slices. + * """ + * if not isinstance(index, tuple): # <<<<<<<<<<<<<< + * tup = (index,) + * else: + */ + __pyx_t_1 = PyTuple_Check(__pyx_v_index); + __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":672 + * """ + * if not isinstance(index, tuple): + * tup = (index,) # <<<<<<<<<<<<<< + * else: + * tup = index + */ + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 672, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_index); + __Pyx_GIVEREF(__pyx_v_index); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_index); + __pyx_v_tup = __pyx_t_3; + __pyx_t_3 = 0; + + /* "View.MemoryView":671 + * full slices. + * """ + * if not isinstance(index, tuple): # <<<<<<<<<<<<<< + * tup = (index,) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":674 + * tup = (index,) + * else: + * tup = index # <<<<<<<<<<<<<< + * + * result = [] + */ + /*else*/ { + __Pyx_INCREF(__pyx_v_index); + __pyx_v_tup = __pyx_v_index; + } + __pyx_L3:; + + /* "View.MemoryView":676 + * tup = index + * + * result = [] # <<<<<<<<<<<<<< + * have_slices = False + * seen_ellipsis = False + */ + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 676, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_result = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":677 + * + * result = [] + * have_slices = False # <<<<<<<<<<<<<< + * seen_ellipsis = False + * for idx, item in enumerate(tup): + */ + __pyx_v_have_slices = 0; + + /* "View.MemoryView":678 + * result = [] + * have_slices = False + * seen_ellipsis = False # <<<<<<<<<<<<<< + * for idx, item in enumerate(tup): + * if item is Ellipsis: + */ + __pyx_v_seen_ellipsis = 0; + + /* "View.MemoryView":679 + * have_slices = False + * seen_ellipsis = False + * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< + * if item is Ellipsis: + * if not seen_ellipsis: + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_3 = __pyx_int_0; + if (likely(PyList_CheckExact(__pyx_v_tup)) || PyTuple_CheckExact(__pyx_v_tup)) { + __pyx_t_4 = __pyx_v_tup; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_v_tup); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 679, __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, 679, __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, 679, __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, 679, __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, 679, __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, 679, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + } + } else { + __pyx_t_7 = __pyx_t_6(__pyx_t_4); + if (unlikely(!__pyx_t_7)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 679, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_7); + } + __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_INCREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_3); + __pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 679, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); + __pyx_t_3 = __pyx_t_7; + __pyx_t_7 = 0; + + /* "View.MemoryView":680 + * seen_ellipsis = False + * for idx, item in enumerate(tup): + * if item is Ellipsis: # <<<<<<<<<<<<<< + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + */ + __pyx_t_2 = (__pyx_v_item == __pyx_builtin_Ellipsis); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":681 + * for idx, item in enumerate(tup): + * if item is Ellipsis: + * if not seen_ellipsis: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * seen_ellipsis = True + */ + __pyx_t_1 = ((!(__pyx_v_seen_ellipsis != 0)) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":682 + * 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, 682, __pyx_L1_error) + __pyx_t_7 = PyList_New(1 * ((((__pyx_v_ndim - __pyx_t_8) + 1)<0) ? 0:((__pyx_v_ndim - __pyx_t_8) + 1))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 682, __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_); + __Pyx_GIVEREF(__pyx_slice_); + PyList_SET_ITEM(__pyx_t_7, __pyx_temp, __pyx_slice_); + } + } + __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_7); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 682, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "View.MemoryView":683 + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * seen_ellipsis = True # <<<<<<<<<<<<<< + * else: + * result.append(slice(None)) + */ + __pyx_v_seen_ellipsis = 1; + + /* "View.MemoryView":681 + * for idx, item in enumerate(tup): + * if item is Ellipsis: + * if not seen_ellipsis: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * seen_ellipsis = True + */ + goto __pyx_L7; + } + + /* "View.MemoryView":685 + * seen_ellipsis = True + * else: + * result.append(slice(None)) # <<<<<<<<<<<<<< + * have_slices = True + * else: + */ + /*else*/ { + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_slice_); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 685, __pyx_L1_error) + } + __pyx_L7:; + + /* "View.MemoryView":686 + * else: + * result.append(slice(None)) + * have_slices = True # <<<<<<<<<<<<<< + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): + */ + __pyx_v_have_slices = 1; + + /* "View.MemoryView":680 + * seen_ellipsis = False + * for idx, item in enumerate(tup): + * if item is Ellipsis: # <<<<<<<<<<<<<< + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + */ + goto __pyx_L6; + } + + /* "View.MemoryView":688 + * have_slices = True + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<< + * raise TypeError("Cannot index with type '%s'" % type(item)) + * + */ + /*else*/ { + __pyx_t_2 = PySlice_Check(__pyx_v_item); + __pyx_t_10 = ((!(__pyx_t_2 != 0)) != 0); + if (__pyx_t_10) { + } else { + __pyx_t_1 = __pyx_t_10; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_10 = ((!(PyIndex_Check(__pyx_v_item) != 0)) != 0); + __pyx_t_1 = __pyx_t_10; + __pyx_L9_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":689 + * 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, 689, __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, 689, __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, 689, __pyx_L1_error) + + /* "View.MemoryView":688 + * have_slices = True + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<< + * raise TypeError("Cannot index with type '%s'" % type(item)) + * + */ + } + + /* "View.MemoryView":691 + * raise TypeError("Cannot index with type '%s'" % type(item)) + * + * have_slices = have_slices or isinstance(item, slice) # <<<<<<<<<<<<<< + * result.append(item) + * + */ + __pyx_t_10 = (__pyx_v_have_slices != 0); + if (!__pyx_t_10) { + } else { + __pyx_t_1 = __pyx_t_10; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_10 = PySlice_Check(__pyx_v_item); + __pyx_t_2 = (__pyx_t_10 != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L11_bool_binop_done:; + __pyx_v_have_slices = __pyx_t_1; + + /* "View.MemoryView":692 + * + * 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, 692, __pyx_L1_error) + } + __pyx_L6:; + + /* "View.MemoryView":679 + * have_slices = False + * seen_ellipsis = False + * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< + * if item is Ellipsis: + * if not seen_ellipsis: + */ + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":694 + * 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, 694, __pyx_L1_error) + __pyx_v_nslices = (__pyx_v_ndim - __pyx_t_5); + + /* "View.MemoryView":695 + * + * nslices = ndim - len(result) + * if nslices: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * nslices) + * + */ + __pyx_t_1 = (__pyx_v_nslices != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":696 + * 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, 696, __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_); + __Pyx_GIVEREF(__pyx_slice_); + PyList_SET_ITEM(__pyx_t_3, __pyx_temp, __pyx_slice_); + } + } + __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 696, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":695 + * + * nslices = ndim - len(result) + * if nslices: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * nslices) + * + */ + } + + /* "View.MemoryView":698 + * result.extend([slice(None)] * nslices) + * + * return have_slices or nslices, tuple(result) # <<<<<<<<<<<<<< + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + */ + __Pyx_XDECREF(__pyx_r); + if (!__pyx_v_have_slices) { + } else { + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_have_slices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 698, __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, 698, __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, 698, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 698, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_4); + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_r = ((PyObject*)__pyx_t_11); + __pyx_t_11 = 0; + goto __pyx_L0; + + /* "View.MemoryView":666 + * return isinstance(o, memoryview) + * + * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< + * """ + * Replace all ellipses with full slices and fill incomplete indices with + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("View.MemoryView._unellipsify", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_tup); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_idx); + __Pyx_XDECREF(__pyx_v_item); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":700 + * return have_slices or nslices, tuple(result) + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + */ + +static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __pyx_v_ndim) { + Py_ssize_t __pyx_v_suboffset; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + Py_ssize_t *__pyx_t_1; + Py_ssize_t *__pyx_t_2; + Py_ssize_t *__pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("assert_direct_dimensions", 0); + + /* "View.MemoryView":701 + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * for suboffset in suboffsets[:ndim]: # <<<<<<<<<<<<<< + * if suboffset >= 0: + * raise ValueError("Indirect dimensions not supported") + */ + __pyx_t_2 = (__pyx_v_suboffsets + __pyx_v_ndim); + for (__pyx_t_3 = __pyx_v_suboffsets; __pyx_t_3 < __pyx_t_2; __pyx_t_3++) { + __pyx_t_1 = __pyx_t_3; + __pyx_v_suboffset = (__pyx_t_1[0]); + + /* "View.MemoryView":702 + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * raise ValueError("Indirect dimensions not supported") + * + */ + __pyx_t_4 = ((__pyx_v_suboffset >= 0) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":703 + * 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, 703, __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, 703, __pyx_L1_error) + + /* "View.MemoryView":702 + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * raise ValueError("Indirect dimensions not supported") + * + */ + } + } + + /* "View.MemoryView":700 + * return have_slices or nslices, tuple(result) + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.assert_direct_dimensions", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":710 + * + * @cname('__pyx_memview_slice') + * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< + * cdef int new_ndim = 0, suboffset_dim = -1, dim + * cdef bint negative_step + */ + +static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *__pyx_v_memview, PyObject *__pyx_v_indices) { + int __pyx_v_new_ndim; + int __pyx_v_suboffset_dim; + int __pyx_v_dim; + __Pyx_memviewslice __pyx_v_src; + __Pyx_memviewslice __pyx_v_dst; + __Pyx_memviewslice *__pyx_v_p_src; + struct __pyx_memoryviewslice_obj *__pyx_v_memviewsliceobj = 0; + __Pyx_memviewslice *__pyx_v_p_dst; + int *__pyx_v_p_suboffset_dim; + Py_ssize_t __pyx_v_start; + Py_ssize_t __pyx_v_stop; + Py_ssize_t __pyx_v_step; + int __pyx_v_have_start; + int __pyx_v_have_stop; + int __pyx_v_have_step; + PyObject *__pyx_v_index = NULL; + struct __pyx_memoryview_obj *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + struct __pyx_memoryview_obj *__pyx_t_4; + char *__pyx_t_5; + int __pyx_t_6; + Py_ssize_t __pyx_t_7; + PyObject *(*__pyx_t_8)(PyObject *); + PyObject *__pyx_t_9 = NULL; + Py_ssize_t __pyx_t_10; + int __pyx_t_11; + Py_ssize_t __pyx_t_12; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memview_slice", 0); + + /* "View.MemoryView":711 + * @cname('__pyx_memview_slice') + * cdef memoryview memview_slice(memoryview memview, object indices): + * cdef int new_ndim = 0, suboffset_dim = -1, dim # <<<<<<<<<<<<<< + * cdef bint negative_step + * cdef __Pyx_memviewslice src, dst + */ + __pyx_v_new_ndim = 0; + __pyx_v_suboffset_dim = -1; + + /* "View.MemoryView":718 + * + * + * memset(&dst, 0, sizeof(dst)) # <<<<<<<<<<<<<< + * + * cdef _memoryviewslice memviewsliceobj + */ + (void)(memset((&__pyx_v_dst), 0, (sizeof(__pyx_v_dst)))); + + /* "View.MemoryView":722 + * cdef _memoryviewslice memviewsliceobj + * + * assert memview.view.ndim > 0 # <<<<<<<<<<<<<< + * + * if isinstance(memview, _memoryviewslice): + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!((__pyx_v_memview->view.ndim > 0) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + __PYX_ERR(1, 722, __pyx_L1_error) + } + } + #endif + + /* "View.MemoryView":724 + * assert memview.view.ndim > 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * memviewsliceobj = memview + * p_src = &memviewsliceobj.from_slice + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":725 + * + * 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, 725, __pyx_L1_error) + __pyx_t_3 = ((PyObject *)__pyx_v_memview); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_memviewsliceobj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":726 + * if isinstance(memview, _memoryviewslice): + * memviewsliceobj = memview + * p_src = &memviewsliceobj.from_slice # <<<<<<<<<<<<<< + * else: + * slice_copy(memview, &src) + */ + __pyx_v_p_src = (&__pyx_v_memviewsliceobj->from_slice); + + /* "View.MemoryView":724 + * assert memview.view.ndim > 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * memviewsliceobj = memview + * p_src = &memviewsliceobj.from_slice + */ + goto __pyx_L3; + } + + /* "View.MemoryView":728 + * p_src = &memviewsliceobj.from_slice + * else: + * slice_copy(memview, &src) # <<<<<<<<<<<<<< + * p_src = &src + * + */ + /*else*/ { + __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_src)); + + /* "View.MemoryView":729 + * else: + * slice_copy(memview, &src) + * p_src = &src # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_p_src = (&__pyx_v_src); + } + __pyx_L3:; + + /* "View.MemoryView":735 + * + * + * dst.memview = p_src.memview # <<<<<<<<<<<<<< + * dst.data = p_src.data + * + */ + __pyx_t_4 = __pyx_v_p_src->memview; + __pyx_v_dst.memview = __pyx_t_4; + + /* "View.MemoryView":736 + * + * dst.memview = p_src.memview + * dst.data = p_src.data # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = __pyx_v_p_src->data; + __pyx_v_dst.data = __pyx_t_5; + + /* "View.MemoryView":741 + * + * + * cdef __Pyx_memviewslice *p_dst = &dst # <<<<<<<<<<<<<< + * cdef int *p_suboffset_dim = &suboffset_dim + * cdef Py_ssize_t start, stop, step + */ + __pyx_v_p_dst = (&__pyx_v_dst); + + /* "View.MemoryView":742 + * + * cdef __Pyx_memviewslice *p_dst = &dst + * cdef int *p_suboffset_dim = &suboffset_dim # <<<<<<<<<<<<<< + * cdef Py_ssize_t start, stop, step + * cdef bint have_start, have_stop, have_step + */ + __pyx_v_p_suboffset_dim = (&__pyx_v_suboffset_dim); + + /* "View.MemoryView":746 + * cdef bint have_start, have_stop, have_step + * + * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< + * if PyIndex_Check(index): + * slice_memviewslice( + */ + __pyx_t_6 = 0; + if (likely(PyList_CheckExact(__pyx_v_indices)) || PyTuple_CheckExact(__pyx_v_indices)) { + __pyx_t_3 = __pyx_v_indices; __Pyx_INCREF(__pyx_t_3); __pyx_t_7 = 0; + __pyx_t_8 = NULL; + } else { + __pyx_t_7 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_indices); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 746, __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, 746, __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, 746, __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, 746, __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, 746, __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, 746, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + } + } else { + __pyx_t_9 = __pyx_t_8(__pyx_t_3); + if (unlikely(!__pyx_t_9)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 746, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_9); + } + __Pyx_XDECREF_SET(__pyx_v_index, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_v_dim = __pyx_t_6; + __pyx_t_6 = (__pyx_t_6 + 1); + + /* "View.MemoryView":747 + * + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): # <<<<<<<<<<<<<< + * slice_memviewslice( + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + */ + __pyx_t_2 = (PyIndex_Check(__pyx_v_index) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":751 + * 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, 751, __pyx_L1_error) + + /* "View.MemoryView":748 + * 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, 748, __pyx_L1_error) + + /* "View.MemoryView":747 + * + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): # <<<<<<<<<<<<<< + * slice_memviewslice( + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + */ + goto __pyx_L6; + } + + /* "View.MemoryView":754 + * 0, 0, 0, # have_{start,stop,step} + * False) + * elif index is None: # <<<<<<<<<<<<<< + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 + */ + __pyx_t_2 = (__pyx_v_index == Py_None); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":755 + * False) + * elif index is None: + * p_dst.shape[new_ndim] = 1 # <<<<<<<<<<<<<< + * p_dst.strides[new_ndim] = 0 + * p_dst.suboffsets[new_ndim] = -1 + */ + (__pyx_v_p_dst->shape[__pyx_v_new_ndim]) = 1; + + /* "View.MemoryView":756 + * elif index is None: + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 # <<<<<<<<<<<<<< + * p_dst.suboffsets[new_ndim] = -1 + * new_ndim += 1 + */ + (__pyx_v_p_dst->strides[__pyx_v_new_ndim]) = 0; + + /* "View.MemoryView":757 + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 + * p_dst.suboffsets[new_ndim] = -1 # <<<<<<<<<<<<<< + * new_ndim += 1 + * else: + */ + (__pyx_v_p_dst->suboffsets[__pyx_v_new_ndim]) = -1L; + + /* "View.MemoryView":758 + * p_dst.strides[new_ndim] = 0 + * p_dst.suboffsets[new_ndim] = -1 + * new_ndim += 1 # <<<<<<<<<<<<<< + * else: + * start = index.start or 0 + */ + __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); + + /* "View.MemoryView":754 + * 0, 0, 0, # have_{start,stop,step} + * False) + * elif index is None: # <<<<<<<<<<<<<< + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 + */ + goto __pyx_L6; + } + + /* "View.MemoryView":760 + * new_ndim += 1 + * else: + * start = index.start or 0 # <<<<<<<<<<<<<< + * stop = index.stop or 0 + * step = index.step or 0 + */ + /*else*/ { + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 760, __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, 760, __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, 760, __pyx_L1_error) + __pyx_t_10 = __pyx_t_12; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_10 = 0; + __pyx_L7_bool_binop_done:; + __pyx_v_start = __pyx_t_10; + + /* "View.MemoryView":761 + * 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, 761, __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, 761, __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, 761, __pyx_L1_error) + __pyx_t_10 = __pyx_t_12; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_10 = 0; + __pyx_L9_bool_binop_done:; + __pyx_v_stop = __pyx_t_10; + + /* "View.MemoryView":762 + * 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, 762, __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, 762, __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, 762, __pyx_L1_error) + __pyx_t_10 = __pyx_t_12; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_10 = 0; + __pyx_L11_bool_binop_done:; + __pyx_v_step = __pyx_t_10; + + /* "View.MemoryView":764 + * 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, 764, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = (__pyx_t_9 != Py_None); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_have_start = __pyx_t_1; + + /* "View.MemoryView":765 + * + * 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, 765, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = (__pyx_t_9 != Py_None); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_have_stop = __pyx_t_1; + + /* "View.MemoryView":766 + * 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, 766, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = (__pyx_t_9 != Py_None); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_have_step = __pyx_t_1; + + /* "View.MemoryView":768 + * 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, 768, __pyx_L1_error) + + /* "View.MemoryView":774 + * have_start, have_stop, have_step, + * True) + * new_ndim += 1 # <<<<<<<<<<<<<< + * + * if isinstance(memview, _memoryviewslice): + */ + __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); + } + __pyx_L6:; + + /* "View.MemoryView":746 + * cdef bint have_start, have_stop, have_step + * + * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< + * if PyIndex_Check(index): + * slice_memviewslice( + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":776 + * new_ndim += 1 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":777 + * + * if isinstance(memview, _memoryviewslice): + * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< + * memviewsliceobj.to_object_func, + * memviewsliceobj.to_dtype_func, + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + + /* "View.MemoryView":778 + * 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, 778, __pyx_L1_error) } + + /* "View.MemoryView":779 + * 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, 779, __pyx_L1_error) } + + /* "View.MemoryView":777 + * + * 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, 777, __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, 777, __pyx_L1_error) + __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":776 + * new_ndim += 1 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, + */ + } + + /* "View.MemoryView":782 + * memview.dtype_is_object) + * else: + * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< + * memview.dtype_is_object) + * + */ + /*else*/ { + __Pyx_XDECREF(((PyObject *)__pyx_r)); + + /* "View.MemoryView":783 + * 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, 782, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "View.MemoryView":782 + * 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, 782, __pyx_L1_error) + __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":710 + * + * @cname('__pyx_memview_slice') + * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< + * cdef int new_ndim = 0, suboffset_dim = -1, dim + * cdef bint negative_step + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("View.MemoryView.memview_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_memviewsliceobj); + __Pyx_XDECREF(__pyx_v_index); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":807 + * + * @cname('__pyx_memoryview_slice_memviewslice') + * cdef int slice_memviewslice( # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, + */ + +static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, Py_ssize_t __pyx_v_shape, Py_ssize_t __pyx_v_stride, Py_ssize_t __pyx_v_suboffset, int __pyx_v_dim, int __pyx_v_new_ndim, int *__pyx_v_suboffset_dim, Py_ssize_t __pyx_v_start, Py_ssize_t __pyx_v_stop, Py_ssize_t __pyx_v_step, int __pyx_v_have_start, int __pyx_v_have_stop, int __pyx_v_have_step, int __pyx_v_is_slice) { + Py_ssize_t __pyx_v_new_shape; + int __pyx_v_negative_step; + int __pyx_r; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":827 + * cdef bint negative_step + * + * if not is_slice: # <<<<<<<<<<<<<< + * + * if start < 0: + */ + __pyx_t_1 = ((!(__pyx_v_is_slice != 0)) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":829 + * if not is_slice: + * + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if not 0 <= start < shape: + */ + __pyx_t_1 = ((__pyx_v_start < 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":830 + * + * if start < 0: + * start += shape # <<<<<<<<<<<<<< + * if not 0 <= start < shape: + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) + */ + __pyx_v_start = (__pyx_v_start + __pyx_v_shape); + + /* "View.MemoryView":829 + * if not is_slice: + * + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if not 0 <= start < shape: + */ + } + + /* "View.MemoryView":831 + * if start < 0: + * start += shape + * if not 0 <= start < shape: # <<<<<<<<<<<<<< + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) + * else: + */ + __pyx_t_1 = (0 <= __pyx_v_start); + if (__pyx_t_1) { + __pyx_t_1 = (__pyx_v_start < __pyx_v_shape); + } + __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":832 + * 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, 832, __pyx_L1_error) + + /* "View.MemoryView":831 + * if start < 0: + * start += shape + * if not 0 <= start < shape: # <<<<<<<<<<<<<< + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) + * else: + */ + } + + /* "View.MemoryView":827 + * cdef bint negative_step + * + * if not is_slice: # <<<<<<<<<<<<<< + * + * if start < 0: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":835 + * else: + * + * negative_step = have_step != 0 and step < 0 # <<<<<<<<<<<<<< + * + * if have_step and step == 0: + */ + /*else*/ { + __pyx_t_1 = ((__pyx_v_have_step != 0) != 0); + if (__pyx_t_1) { + } else { + __pyx_t_2 = __pyx_t_1; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_1 = ((__pyx_v_step < 0) != 0); + __pyx_t_2 = __pyx_t_1; + __pyx_L6_bool_binop_done:; + __pyx_v_negative_step = __pyx_t_2; + + /* "View.MemoryView":837 + * negative_step = have_step != 0 and step < 0 + * + * if have_step and step == 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) + * + */ + __pyx_t_1 = (__pyx_v_have_step != 0); + if (__pyx_t_1) { + } else { + __pyx_t_2 = __pyx_t_1; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_1 = ((__pyx_v_step == 0) != 0); + __pyx_t_2 = __pyx_t_1; + __pyx_L9_bool_binop_done:; + if (__pyx_t_2) { + + /* "View.MemoryView":838 + * + * 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, 838, __pyx_L1_error) + + /* "View.MemoryView":837 + * negative_step = have_step != 0 and step < 0 + * + * if have_step and step == 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) + * + */ + } + + /* "View.MemoryView":841 + * + * + * if have_start: # <<<<<<<<<<<<<< + * if start < 0: + * start += shape + */ + __pyx_t_2 = (__pyx_v_have_start != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":842 + * + * if have_start: + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if start < 0: + */ + __pyx_t_2 = ((__pyx_v_start < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":843 + * if have_start: + * if start < 0: + * start += shape # <<<<<<<<<<<<<< + * if start < 0: + * start = 0 + */ + __pyx_v_start = (__pyx_v_start + __pyx_v_shape); + + /* "View.MemoryView":844 + * if start < 0: + * start += shape + * if start < 0: # <<<<<<<<<<<<<< + * start = 0 + * elif start >= shape: + */ + __pyx_t_2 = ((__pyx_v_start < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":845 + * start += shape + * if start < 0: + * start = 0 # <<<<<<<<<<<<<< + * elif start >= shape: + * if negative_step: + */ + __pyx_v_start = 0; + + /* "View.MemoryView":844 + * if start < 0: + * start += shape + * if start < 0: # <<<<<<<<<<<<<< + * start = 0 + * elif start >= shape: + */ + } + + /* "View.MemoryView":842 + * + * if have_start: + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if start < 0: + */ + goto __pyx_L12; + } + + /* "View.MemoryView":846 + * if start < 0: + * start = 0 + * elif start >= shape: # <<<<<<<<<<<<<< + * if negative_step: + * start = shape - 1 + */ + __pyx_t_2 = ((__pyx_v_start >= __pyx_v_shape) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":847 + * start = 0 + * elif start >= shape: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + __pyx_t_2 = (__pyx_v_negative_step != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":848 + * elif start >= shape: + * if negative_step: + * start = shape - 1 # <<<<<<<<<<<<<< + * else: + * start = shape + */ + __pyx_v_start = (__pyx_v_shape - 1); + + /* "View.MemoryView":847 + * start = 0 + * elif start >= shape: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + goto __pyx_L14; + } + + /* "View.MemoryView":850 + * start = shape - 1 + * else: + * start = shape # <<<<<<<<<<<<<< + * else: + * if negative_step: + */ + /*else*/ { + __pyx_v_start = __pyx_v_shape; + } + __pyx_L14:; + + /* "View.MemoryView":846 + * if start < 0: + * start = 0 + * elif start >= shape: # <<<<<<<<<<<<<< + * if negative_step: + * start = shape - 1 + */ + } + __pyx_L12:; + + /* "View.MemoryView":841 + * + * + * if have_start: # <<<<<<<<<<<<<< + * if start < 0: + * start += shape + */ + goto __pyx_L11; + } + + /* "View.MemoryView":852 + * start = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + /*else*/ { + __pyx_t_2 = (__pyx_v_negative_step != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":853 + * else: + * if negative_step: + * start = shape - 1 # <<<<<<<<<<<<<< + * else: + * start = 0 + */ + __pyx_v_start = (__pyx_v_shape - 1); + + /* "View.MemoryView":852 + * start = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + goto __pyx_L15; + } + + /* "View.MemoryView":855 + * start = shape - 1 + * else: + * start = 0 # <<<<<<<<<<<<<< + * + * if have_stop: + */ + /*else*/ { + __pyx_v_start = 0; + } + __pyx_L15:; + } + __pyx_L11:; + + /* "View.MemoryView":857 + * start = 0 + * + * if have_stop: # <<<<<<<<<<<<<< + * if stop < 0: + * stop += shape + */ + __pyx_t_2 = (__pyx_v_have_stop != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":858 + * + * if have_stop: + * if stop < 0: # <<<<<<<<<<<<<< + * stop += shape + * if stop < 0: + */ + __pyx_t_2 = ((__pyx_v_stop < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":859 + * if have_stop: + * if stop < 0: + * stop += shape # <<<<<<<<<<<<<< + * if stop < 0: + * stop = 0 + */ + __pyx_v_stop = (__pyx_v_stop + __pyx_v_shape); + + /* "View.MemoryView":860 + * if stop < 0: + * stop += shape + * if stop < 0: # <<<<<<<<<<<<<< + * stop = 0 + * elif stop > shape: + */ + __pyx_t_2 = ((__pyx_v_stop < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":861 + * stop += shape + * if stop < 0: + * stop = 0 # <<<<<<<<<<<<<< + * elif stop > shape: + * stop = shape + */ + __pyx_v_stop = 0; + + /* "View.MemoryView":860 + * if stop < 0: + * stop += shape + * if stop < 0: # <<<<<<<<<<<<<< + * stop = 0 + * elif stop > shape: + */ + } + + /* "View.MemoryView":858 + * + * if have_stop: + * if stop < 0: # <<<<<<<<<<<<<< + * stop += shape + * if stop < 0: + */ + goto __pyx_L17; + } + + /* "View.MemoryView":862 + * if stop < 0: + * stop = 0 + * elif stop > shape: # <<<<<<<<<<<<<< + * stop = shape + * else: + */ + __pyx_t_2 = ((__pyx_v_stop > __pyx_v_shape) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":863 + * stop = 0 + * elif stop > shape: + * stop = shape # <<<<<<<<<<<<<< + * else: + * if negative_step: + */ + __pyx_v_stop = __pyx_v_shape; + + /* "View.MemoryView":862 + * if stop < 0: + * stop = 0 + * elif stop > shape: # <<<<<<<<<<<<<< + * stop = shape + * else: + */ + } + __pyx_L17:; + + /* "View.MemoryView":857 + * start = 0 + * + * if have_stop: # <<<<<<<<<<<<<< + * if stop < 0: + * stop += shape + */ + goto __pyx_L16; + } + + /* "View.MemoryView":865 + * stop = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * stop = -1 + * else: + */ + /*else*/ { + __pyx_t_2 = (__pyx_v_negative_step != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":866 + * else: + * if negative_step: + * stop = -1 # <<<<<<<<<<<<<< + * else: + * stop = shape + */ + __pyx_v_stop = -1L; + + /* "View.MemoryView":865 + * stop = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * stop = -1 + * else: + */ + goto __pyx_L19; + } + + /* "View.MemoryView":868 + * stop = -1 + * else: + * stop = shape # <<<<<<<<<<<<<< + * + * if not have_step: + */ + /*else*/ { + __pyx_v_stop = __pyx_v_shape; + } + __pyx_L19:; + } + __pyx_L16:; + + /* "View.MemoryView":870 + * stop = shape + * + * if not have_step: # <<<<<<<<<<<<<< + * step = 1 + * + */ + __pyx_t_2 = ((!(__pyx_v_have_step != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":871 + * + * if not have_step: + * step = 1 # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_step = 1; + + /* "View.MemoryView":870 + * stop = shape + * + * if not have_step: # <<<<<<<<<<<<<< + * step = 1 + * + */ + } + + /* "View.MemoryView":875 + * + * with cython.cdivision(True): + * new_shape = (stop - start) // step # <<<<<<<<<<<<<< + * + * if (stop - start) - step * new_shape: + */ + __pyx_v_new_shape = ((__pyx_v_stop - __pyx_v_start) / __pyx_v_step); + + /* "View.MemoryView":877 + * new_shape = (stop - start) // step + * + * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< + * new_shape += 1 + * + */ + __pyx_t_2 = (((__pyx_v_stop - __pyx_v_start) - (__pyx_v_step * __pyx_v_new_shape)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":878 + * + * if (stop - start) - step * new_shape: + * new_shape += 1 # <<<<<<<<<<<<<< + * + * if new_shape < 0: + */ + __pyx_v_new_shape = (__pyx_v_new_shape + 1); + + /* "View.MemoryView":877 + * new_shape = (stop - start) // step + * + * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< + * new_shape += 1 + * + */ + } + + /* "View.MemoryView":880 + * new_shape += 1 + * + * if new_shape < 0: # <<<<<<<<<<<<<< + * new_shape = 0 + * + */ + __pyx_t_2 = ((__pyx_v_new_shape < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":881 + * + * if new_shape < 0: + * new_shape = 0 # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_new_shape = 0; + + /* "View.MemoryView":880 + * new_shape += 1 + * + * if new_shape < 0: # <<<<<<<<<<<<<< + * new_shape = 0 + * + */ + } + + /* "View.MemoryView":884 + * + * + * dst.strides[new_ndim] = stride * step # <<<<<<<<<<<<<< + * dst.shape[new_ndim] = new_shape + * dst.suboffsets[new_ndim] = suboffset + */ + (__pyx_v_dst->strides[__pyx_v_new_ndim]) = (__pyx_v_stride * __pyx_v_step); + + /* "View.MemoryView":885 + * + * dst.strides[new_ndim] = stride * step + * dst.shape[new_ndim] = new_shape # <<<<<<<<<<<<<< + * dst.suboffsets[new_ndim] = suboffset + * + */ + (__pyx_v_dst->shape[__pyx_v_new_ndim]) = __pyx_v_new_shape; + + /* "View.MemoryView":886 + * dst.strides[new_ndim] = stride * step + * dst.shape[new_ndim] = new_shape + * dst.suboffsets[new_ndim] = suboffset # <<<<<<<<<<<<<< + * + * + */ + (__pyx_v_dst->suboffsets[__pyx_v_new_ndim]) = __pyx_v_suboffset; + } + __pyx_L3:; + + /* "View.MemoryView":889 + * + * + * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< + * dst.data += start * stride + * else: + */ + __pyx_t_2 = (((__pyx_v_suboffset_dim[0]) < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":890 + * + * if suboffset_dim[0] < 0: + * dst.data += start * stride # <<<<<<<<<<<<<< + * else: + * dst.suboffsets[suboffset_dim[0]] += start * stride + */ + __pyx_v_dst->data = (__pyx_v_dst->data + (__pyx_v_start * __pyx_v_stride)); + + /* "View.MemoryView":889 + * + * + * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< + * dst.data += start * stride + * else: + */ + goto __pyx_L23; + } + + /* "View.MemoryView":892 + * dst.data += start * stride + * else: + * dst.suboffsets[suboffset_dim[0]] += start * stride # <<<<<<<<<<<<<< + * + * if suboffset >= 0: + */ + /*else*/ { + __pyx_t_3 = (__pyx_v_suboffset_dim[0]); + (__pyx_v_dst->suboffsets[__pyx_t_3]) = ((__pyx_v_dst->suboffsets[__pyx_t_3]) + (__pyx_v_start * __pyx_v_stride)); + } + __pyx_L23:; + + /* "View.MemoryView":894 + * dst.suboffsets[suboffset_dim[0]] += start * stride + * + * if suboffset >= 0: # <<<<<<<<<<<<<< + * if not is_slice: + * if new_ndim == 0: + */ + __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":895 + * + * if suboffset >= 0: + * if not is_slice: # <<<<<<<<<<<<<< + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset + */ + __pyx_t_2 = ((!(__pyx_v_is_slice != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":896 + * if suboffset >= 0: + * if not is_slice: + * if new_ndim == 0: # <<<<<<<<<<<<<< + * dst.data = ( dst.data)[0] + suboffset + * else: + */ + __pyx_t_2 = ((__pyx_v_new_ndim == 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":897 + * if not is_slice: + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset # <<<<<<<<<<<<<< + * else: + * _err_dim(IndexError, "All dimensions preceding dimension %d " + */ + __pyx_v_dst->data = ((((char **)__pyx_v_dst->data)[0]) + __pyx_v_suboffset); + + /* "View.MemoryView":896 + * if suboffset >= 0: + * if not is_slice: + * if new_ndim == 0: # <<<<<<<<<<<<<< + * dst.data = ( dst.data)[0] + suboffset + * else: + */ + goto __pyx_L26; + } + + /* "View.MemoryView":899 + * dst.data = ( dst.data)[0] + suboffset + * else: + * _err_dim(IndexError, "All dimensions preceding dimension %d " # <<<<<<<<<<<<<< + * "must be indexed and not sliced", dim) + * else: + */ + /*else*/ { + + /* "View.MemoryView":900 + * 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, 899, __pyx_L1_error) + } + __pyx_L26:; + + /* "View.MemoryView":895 + * + * if suboffset >= 0: + * if not is_slice: # <<<<<<<<<<<<<< + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset + */ + goto __pyx_L25; + } + + /* "View.MemoryView":902 + * "must be indexed and not sliced", dim) + * else: + * suboffset_dim[0] = new_ndim # <<<<<<<<<<<<<< + * + * return 0 + */ + /*else*/ { + (__pyx_v_suboffset_dim[0]) = __pyx_v_new_ndim; + } + __pyx_L25:; + + /* "View.MemoryView":894 + * dst.suboffsets[suboffset_dim[0]] += start * stride + * + * if suboffset >= 0: # <<<<<<<<<<<<<< + * if not is_slice: + * if new_ndim == 0: + */ + } + + /* "View.MemoryView":904 + * suboffset_dim[0] = new_ndim + * + * return 0 # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":807 + * + * @cname('__pyx_memoryview_slice_memviewslice') + * cdef int slice_memviewslice( # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, + */ + + /* function exit code */ + __pyx_L1_error:; + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.slice_memviewslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":910 + * + * @cname('__pyx_pybuffer_index') + * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<< + * Py_ssize_t dim) except NULL: + * cdef Py_ssize_t shape, stride, suboffset = -1 + */ + +static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, Py_ssize_t __pyx_v_index, Py_ssize_t __pyx_v_dim) { + Py_ssize_t __pyx_v_shape; + Py_ssize_t __pyx_v_stride; + Py_ssize_t __pyx_v_suboffset; + Py_ssize_t __pyx_v_itemsize; + char *__pyx_v_resultp; + char *__pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("pybuffer_index", 0); + + /* "View.MemoryView":912 + * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, + * Py_ssize_t dim) except NULL: + * cdef Py_ssize_t shape, stride, suboffset = -1 # <<<<<<<<<<<<<< + * cdef Py_ssize_t itemsize = view.itemsize + * cdef char *resultp + */ + __pyx_v_suboffset = -1L; + + /* "View.MemoryView":913 + * Py_ssize_t dim) except NULL: + * cdef Py_ssize_t shape, stride, suboffset = -1 + * cdef Py_ssize_t itemsize = view.itemsize # <<<<<<<<<<<<<< + * cdef char *resultp + * + */ + __pyx_t_1 = __pyx_v_view->itemsize; + __pyx_v_itemsize = __pyx_t_1; + + /* "View.MemoryView":916 + * cdef char *resultp + * + * if view.ndim == 0: # <<<<<<<<<<<<<< + * shape = view.len / itemsize + * stride = itemsize + */ + __pyx_t_2 = ((__pyx_v_view->ndim == 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":917 + * + * if view.ndim == 0: + * shape = view.len / itemsize # <<<<<<<<<<<<<< + * stride = itemsize + * else: + */ + if (unlikely(__pyx_v_itemsize == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); + __PYX_ERR(1, 917, __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, 917, __pyx_L1_error) + } + __pyx_v_shape = __Pyx_div_Py_ssize_t(__pyx_v_view->len, __pyx_v_itemsize); + + /* "View.MemoryView":918 + * if view.ndim == 0: + * shape = view.len / itemsize + * stride = itemsize # <<<<<<<<<<<<<< + * else: + * shape = view.shape[dim] + */ + __pyx_v_stride = __pyx_v_itemsize; + + /* "View.MemoryView":916 + * cdef char *resultp + * + * if view.ndim == 0: # <<<<<<<<<<<<<< + * shape = view.len / itemsize + * stride = itemsize + */ + goto __pyx_L3; + } + + /* "View.MemoryView":920 + * stride = itemsize + * else: + * shape = view.shape[dim] # <<<<<<<<<<<<<< + * stride = view.strides[dim] + * if view.suboffsets != NULL: + */ + /*else*/ { + __pyx_v_shape = (__pyx_v_view->shape[__pyx_v_dim]); + + /* "View.MemoryView":921 + * else: + * shape = view.shape[dim] + * stride = view.strides[dim] # <<<<<<<<<<<<<< + * if view.suboffsets != NULL: + * suboffset = view.suboffsets[dim] + */ + __pyx_v_stride = (__pyx_v_view->strides[__pyx_v_dim]); + + /* "View.MemoryView":922 + * shape = view.shape[dim] + * stride = view.strides[dim] + * if view.suboffsets != NULL: # <<<<<<<<<<<<<< + * suboffset = view.suboffsets[dim] + * + */ + __pyx_t_2 = ((__pyx_v_view->suboffsets != NULL) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":923 + * stride = view.strides[dim] + * if view.suboffsets != NULL: + * suboffset = view.suboffsets[dim] # <<<<<<<<<<<<<< + * + * if index < 0: + */ + __pyx_v_suboffset = (__pyx_v_view->suboffsets[__pyx_v_dim]); + + /* "View.MemoryView":922 + * shape = view.shape[dim] + * stride = view.strides[dim] + * if view.suboffsets != NULL: # <<<<<<<<<<<<<< + * suboffset = view.suboffsets[dim] + * + */ + } + } + __pyx_L3:; + + /* "View.MemoryView":925 + * suboffset = view.suboffsets[dim] + * + * if index < 0: # <<<<<<<<<<<<<< + * index += view.shape[dim] + * if index < 0: + */ + __pyx_t_2 = ((__pyx_v_index < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":926 + * + * if index < 0: + * index += view.shape[dim] # <<<<<<<<<<<<<< + * if index < 0: + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + */ + __pyx_v_index = (__pyx_v_index + (__pyx_v_view->shape[__pyx_v_dim])); + + /* "View.MemoryView":927 + * if index < 0: + * index += view.shape[dim] + * if index < 0: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + __pyx_t_2 = ((__pyx_v_index < 0) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":928 + * 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, 928, __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, 928, __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, 928, __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, 928, __pyx_L1_error) + + /* "View.MemoryView":927 + * if index < 0: + * index += view.shape[dim] + * if index < 0: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + } + + /* "View.MemoryView":925 + * suboffset = view.suboffsets[dim] + * + * if index < 0: # <<<<<<<<<<<<<< + * index += view.shape[dim] + * if index < 0: + */ + } + + /* "View.MemoryView":930 + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + * if index >= shape: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + __pyx_t_2 = ((__pyx_v_index >= __pyx_v_shape) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":931 + * + * 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, 931, __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, 931, __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, 931, __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, 931, __pyx_L1_error) + + /* "View.MemoryView":930 + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + * if index >= shape: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + } + + /* "View.MemoryView":933 + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + * resultp = bufp + index * stride # <<<<<<<<<<<<<< + * if suboffset >= 0: + * resultp = ( resultp)[0] + suboffset + */ + __pyx_v_resultp = (__pyx_v_bufp + (__pyx_v_index * __pyx_v_stride)); + + /* "View.MemoryView":934 + * + * resultp = bufp + index * stride + * if suboffset >= 0: # <<<<<<<<<<<<<< + * resultp = ( resultp)[0] + suboffset + * + */ + __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":935 + * resultp = bufp + index * stride + * if suboffset >= 0: + * resultp = ( resultp)[0] + suboffset # <<<<<<<<<<<<<< + * + * return resultp + */ + __pyx_v_resultp = ((((char **)__pyx_v_resultp)[0]) + __pyx_v_suboffset); + + /* "View.MemoryView":934 + * + * resultp = bufp + index * stride + * if suboffset >= 0: # <<<<<<<<<<<<<< + * resultp = ( resultp)[0] + suboffset + * + */ + } + + /* "View.MemoryView":937 + * resultp = ( resultp)[0] + suboffset + * + * return resultp # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_resultp; + goto __pyx_L0; + + /* "View.MemoryView":910 + * + * @cname('__pyx_pybuffer_index') + * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<< + * Py_ssize_t dim) except NULL: + * cdef Py_ssize_t shape, stride, suboffset = -1 + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView.pybuffer_index", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":943 + * + * @cname('__pyx_memslice_transpose') + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< + * cdef int ndim = memslice.memview.view.ndim + * + */ + +static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { + int __pyx_v_ndim; + Py_ssize_t *__pyx_v_shape; + Py_ssize_t *__pyx_v_strides; + int __pyx_v_i; + int __pyx_v_j; + int __pyx_r; + int __pyx_t_1; + Py_ssize_t *__pyx_t_2; + long __pyx_t_3; + long __pyx_t_4; + Py_ssize_t __pyx_t_5; + Py_ssize_t __pyx_t_6; + int __pyx_t_7; + int __pyx_t_8; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":944 + * @cname('__pyx_memslice_transpose') + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: + * cdef int ndim = memslice.memview.view.ndim # <<<<<<<<<<<<<< + * + * cdef Py_ssize_t *shape = memslice.shape + */ + __pyx_t_1 = __pyx_v_memslice->memview->view.ndim; + __pyx_v_ndim = __pyx_t_1; + + /* "View.MemoryView":946 + * cdef int ndim = memslice.memview.view.ndim + * + * cdef Py_ssize_t *shape = memslice.shape # <<<<<<<<<<<<<< + * cdef Py_ssize_t *strides = memslice.strides + * + */ + __pyx_t_2 = __pyx_v_memslice->shape; + __pyx_v_shape = __pyx_t_2; + + /* "View.MemoryView":947 + * + * cdef Py_ssize_t *shape = memslice.shape + * cdef Py_ssize_t *strides = memslice.strides # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __pyx_v_memslice->strides; + __pyx_v_strides = __pyx_t_2; + + /* "View.MemoryView":951 + * + * cdef int i, j + * for i in range(ndim / 2): # <<<<<<<<<<<<<< + * j = ndim - 1 - i + * strides[i], strides[j] = strides[j], strides[i] + */ + __pyx_t_3 = __Pyx_div_long(__pyx_v_ndim, 2); + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_1 = 0; __pyx_t_1 < __pyx_t_4; __pyx_t_1+=1) { + __pyx_v_i = __pyx_t_1; + + /* "View.MemoryView":952 + * cdef int i, j + * for i in range(ndim / 2): + * j = ndim - 1 - i # <<<<<<<<<<<<<< + * strides[i], strides[j] = strides[j], strides[i] + * shape[i], shape[j] = shape[j], shape[i] + */ + __pyx_v_j = ((__pyx_v_ndim - 1) - __pyx_v_i); + + /* "View.MemoryView":953 + * for i in range(ndim / 2): + * j = ndim - 1 - i + * strides[i], strides[j] = strides[j], strides[i] # <<<<<<<<<<<<<< + * shape[i], shape[j] = shape[j], shape[i] + * + */ + __pyx_t_5 = (__pyx_v_strides[__pyx_v_j]); + __pyx_t_6 = (__pyx_v_strides[__pyx_v_i]); + (__pyx_v_strides[__pyx_v_i]) = __pyx_t_5; + (__pyx_v_strides[__pyx_v_j]) = __pyx_t_6; + + /* "View.MemoryView":954 + * j = ndim - 1 - i + * strides[i], strides[j] = strides[j], strides[i] + * shape[i], shape[j] = shape[j], shape[i] # <<<<<<<<<<<<<< + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: + */ + __pyx_t_6 = (__pyx_v_shape[__pyx_v_j]); + __pyx_t_5 = (__pyx_v_shape[__pyx_v_i]); + (__pyx_v_shape[__pyx_v_i]) = __pyx_t_6; + (__pyx_v_shape[__pyx_v_j]) = __pyx_t_5; + + /* "View.MemoryView":956 + * shape[i], shape[j] = shape[j], shape[i] + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") + * + */ + __pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_i]) >= 0) != 0); + if (!__pyx_t_8) { + } else { + __pyx_t_7 = __pyx_t_8; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_j]) >= 0) != 0); + __pyx_t_7 = __pyx_t_8; + __pyx_L6_bool_binop_done:; + if (__pyx_t_7) { + + /* "View.MemoryView":957 + * + * 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, 957, __pyx_L1_error) + + /* "View.MemoryView":956 + * shape[i], shape[j] = shape[j], shape[i] + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") + * + */ + } + } + + /* "View.MemoryView":959 + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") + * + * return 1 # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = 1; + goto __pyx_L0; + + /* "View.MemoryView":943 + * + * @cname('__pyx_memslice_transpose') + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< + * cdef int ndim = memslice.memview.view.ndim + * + */ + + /* function exit code */ + __pyx_L1_error:; + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.transpose_memslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = 0; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":976 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + * + */ + +/* Python wrapper */ +static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "View.MemoryView":977 + * + * def __dealloc__(self): + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) # <<<<<<<<<<<<<< + * + * cdef convert_item_to_object(self, char *itemp): + */ + __PYX_XDEC_MEMVIEW((&__pyx_v_self->from_slice), 1); + + /* "View.MemoryView":976 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + * + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":979 + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * if self.to_object_func != NULL: + * return self.to_object_func(itemp) + */ + +static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("convert_item_to_object", 0); + + /* "View.MemoryView":980 + * + * cdef convert_item_to_object(self, char *itemp): + * if self.to_object_func != NULL: # <<<<<<<<<<<<<< + * return self.to_object_func(itemp) + * else: + */ + __pyx_t_1 = ((__pyx_v_self->to_object_func != NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":981 + * cdef convert_item_to_object(self, char *itemp): + * if self.to_object_func != NULL: + * return self.to_object_func(itemp) # <<<<<<<<<<<<<< + * else: + * return memoryview.convert_item_to_object(self, itemp) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_v_self->to_object_func(__pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 981, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":980 + * + * cdef convert_item_to_object(self, char *itemp): + * if self.to_object_func != NULL: # <<<<<<<<<<<<<< + * return self.to_object_func(itemp) + * else: + */ + } + + /* "View.MemoryView":983 + * return self.to_object_func(itemp) + * else: + * return memoryview.convert_item_to_object(self, itemp) # <<<<<<<<<<<<<< + * + * cdef assign_item_from_object(self, char *itemp, object value): + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_memoryview_convert_item_to_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 983, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":979 + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * if self.to_object_func != NULL: + * return self.to_object_func(itemp) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":985 + * return memoryview.convert_item_to_object(self, itemp) + * + * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< + * if self.to_dtype_func != NULL: + * self.to_dtype_func(itemp, value) + */ + +static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("assign_item_from_object", 0); + + /* "View.MemoryView":986 + * + * cdef assign_item_from_object(self, char *itemp, object value): + * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< + * self.to_dtype_func(itemp, value) + * else: + */ + __pyx_t_1 = ((__pyx_v_self->to_dtype_func != NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":987 + * 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, 987, __pyx_L1_error) + + /* "View.MemoryView":986 + * + * cdef assign_item_from_object(self, char *itemp, object value): + * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< + * self.to_dtype_func(itemp, value) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":989 + * self.to_dtype_func(itemp, value) + * else: + * memoryview.assign_item_from_object(self, itemp, value) # <<<<<<<<<<<<<< + * + * @property + */ + /*else*/ { + __pyx_t_3 = __pyx_memoryview_assign_item_from_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 989, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_L3:; + + /* "View.MemoryView":985 + * return memoryview.convert_item_to_object(self, itemp) + * + * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< + * if self.to_dtype_func != NULL: + * self.to_dtype_func(itemp, value) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":992 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.from_object + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(struct __pyx_memoryviewslice_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":993 + * @property + * def base(self): + * return self.from_object # <<<<<<<<<<<<<< + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->from_object); + __pyx_r = __pyx_v_self->from_object; + goto __pyx_L0; + + /* "View.MemoryView":992 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.from_object + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_memoryviewslice___reduce_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_memoryviewslice_2__setstate_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":999 + * + * @cname('__pyx_memoryview_fromslice') + * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< + * int ndim, + * object (*to_object_func)(char *), + */ + +static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewslice, int __pyx_v_ndim, PyObject *(*__pyx_v_to_object_func)(char *), int (*__pyx_v_to_dtype_func)(char *, PyObject *), int __pyx_v_dtype_is_object) { + struct __pyx_memoryviewslice_obj *__pyx_v_result = 0; + Py_ssize_t __pyx_v_suboffset; + PyObject *__pyx_v_length = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_TypeInfo *__pyx_t_4; + Py_buffer __pyx_t_5; + Py_ssize_t *__pyx_t_6; + Py_ssize_t *__pyx_t_7; + Py_ssize_t *__pyx_t_8; + Py_ssize_t __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_fromslice", 0); + + /* "View.MemoryView":1007 + * cdef _memoryviewslice result + * + * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< + * return None + * + */ + __pyx_t_1 = ((((PyObject *)__pyx_v_memviewslice.memview) == Py_None) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1008 + * + * if memviewslice.memview == Py_None: + * return None # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "View.MemoryView":1007 + * cdef _memoryviewslice result + * + * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< + * return None + * + */ + } + + /* "View.MemoryView":1013 + * + * + * result = _memoryviewslice(None, 0, dtype_is_object) # <<<<<<<<<<<<<< + * + * result.from_slice = memviewslice + */ + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1013, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1013, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + PyTuple_SET_ITEM(__pyx_t_3, 0, Py_None); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_0); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryviewslice_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1013, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":1015 + * result = _memoryviewslice(None, 0, dtype_is_object) + * + * result.from_slice = memviewslice # <<<<<<<<<<<<<< + * __PYX_INC_MEMVIEW(&memviewslice, 1) + * + */ + __pyx_v_result->from_slice = __pyx_v_memviewslice; + + /* "View.MemoryView":1016 + * + * result.from_slice = memviewslice + * __PYX_INC_MEMVIEW(&memviewslice, 1) # <<<<<<<<<<<<<< + * + * result.from_object = ( memviewslice.memview).base + */ + __PYX_INC_MEMVIEW((&__pyx_v_memviewslice), 1); + + /* "View.MemoryView":1018 + * __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, 1018, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_result->from_object); + __Pyx_DECREF(__pyx_v_result->from_object); + __pyx_v_result->from_object = __pyx_t_2; + __pyx_t_2 = 0; + + /* "View.MemoryView":1019 + * + * result.from_object = ( memviewslice.memview).base + * result.typeinfo = memviewslice.memview.typeinfo # <<<<<<<<<<<<<< + * + * result.view = memviewslice.memview.view + */ + __pyx_t_4 = __pyx_v_memviewslice.memview->typeinfo; + __pyx_v_result->__pyx_base.typeinfo = __pyx_t_4; + + /* "View.MemoryView":1021 + * result.typeinfo = memviewslice.memview.typeinfo + * + * result.view = memviewslice.memview.view # <<<<<<<<<<<<<< + * result.view.buf = memviewslice.data + * result.view.ndim = ndim + */ + __pyx_t_5 = __pyx_v_memviewslice.memview->view; + __pyx_v_result->__pyx_base.view = __pyx_t_5; + + /* "View.MemoryView":1022 + * + * result.view = memviewslice.memview.view + * result.view.buf = memviewslice.data # <<<<<<<<<<<<<< + * result.view.ndim = ndim + * (<__pyx_buffer *> &result.view).obj = Py_None + */ + __pyx_v_result->__pyx_base.view.buf = ((void *)__pyx_v_memviewslice.data); + + /* "View.MemoryView":1023 + * result.view = memviewslice.memview.view + * result.view.buf = memviewslice.data + * result.view.ndim = ndim # <<<<<<<<<<<<<< + * (<__pyx_buffer *> &result.view).obj = Py_None + * Py_INCREF(Py_None) + */ + __pyx_v_result->__pyx_base.view.ndim = __pyx_v_ndim; + + /* "View.MemoryView":1024 + * result.view.buf = memviewslice.data + * result.view.ndim = ndim + * (<__pyx_buffer *> &result.view).obj = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) + * + */ + ((Py_buffer *)(&__pyx_v_result->__pyx_base.view))->obj = Py_None; + + /* "View.MemoryView":1025 + * result.view.ndim = ndim + * (<__pyx_buffer *> &result.view).obj = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: + */ + Py_INCREF(Py_None); + + /* "View.MemoryView":1027 + * Py_INCREF(Py_None) + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< + * result.flags = PyBUF_RECORDS + * else: + */ + __pyx_t_1 = ((((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->flags & PyBUF_WRITABLE) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1028 + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: + * result.flags = PyBUF_RECORDS # <<<<<<<<<<<<<< + * else: + * result.flags = PyBUF_RECORDS_RO + */ + __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS; + + /* "View.MemoryView":1027 + * Py_INCREF(Py_None) + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< + * result.flags = PyBUF_RECORDS + * else: + */ + goto __pyx_L4; + } + + /* "View.MemoryView":1030 + * result.flags = PyBUF_RECORDS + * else: + * result.flags = PyBUF_RECORDS_RO # <<<<<<<<<<<<<< + * + * result.view.shape = result.from_slice.shape + */ + /*else*/ { + __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS_RO; + } + __pyx_L4:; + + /* "View.MemoryView":1032 + * result.flags = PyBUF_RECORDS_RO + * + * result.view.shape = result.from_slice.shape # <<<<<<<<<<<<<< + * result.view.strides = result.from_slice.strides + * + */ + __pyx_v_result->__pyx_base.view.shape = ((Py_ssize_t *)__pyx_v_result->from_slice.shape); + + /* "View.MemoryView":1033 + * + * result.view.shape = result.from_slice.shape + * result.view.strides = result.from_slice.strides # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_result->__pyx_base.view.strides = ((Py_ssize_t *)__pyx_v_result->from_slice.strides); + + /* "View.MemoryView":1036 + * + * + * result.view.suboffsets = NULL # <<<<<<<<<<<<<< + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: + */ + __pyx_v_result->__pyx_base.view.suboffsets = NULL; + + /* "View.MemoryView":1037 + * + * result.view.suboffsets = NULL + * for suboffset in result.from_slice.suboffsets[:ndim]: # <<<<<<<<<<<<<< + * if suboffset >= 0: + * result.view.suboffsets = result.from_slice.suboffsets + */ + __pyx_t_7 = (__pyx_v_result->from_slice.suboffsets + __pyx_v_ndim); + for (__pyx_t_8 = __pyx_v_result->from_slice.suboffsets; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) { + __pyx_t_6 = __pyx_t_8; + __pyx_v_suboffset = (__pyx_t_6[0]); + + /* "View.MemoryView":1038 + * result.view.suboffsets = NULL + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * result.view.suboffsets = result.from_slice.suboffsets + * break + */ + __pyx_t_1 = ((__pyx_v_suboffset >= 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1039 + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: + * result.view.suboffsets = result.from_slice.suboffsets # <<<<<<<<<<<<<< + * break + * + */ + __pyx_v_result->__pyx_base.view.suboffsets = ((Py_ssize_t *)__pyx_v_result->from_slice.suboffsets); + + /* "View.MemoryView":1040 + * if suboffset >= 0: + * result.view.suboffsets = result.from_slice.suboffsets + * break # <<<<<<<<<<<<<< + * + * result.view.len = result.view.itemsize + */ + goto __pyx_L6_break; + + /* "View.MemoryView":1038 + * result.view.suboffsets = NULL + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * result.view.suboffsets = result.from_slice.suboffsets + * break + */ + } + } + __pyx_L6_break:; + + /* "View.MemoryView":1042 + * break + * + * result.view.len = result.view.itemsize # <<<<<<<<<<<<<< + * for length in result.view.shape[:ndim]: + * result.view.len *= length + */ + __pyx_t_9 = __pyx_v_result->__pyx_base.view.itemsize; + __pyx_v_result->__pyx_base.view.len = __pyx_t_9; + + /* "View.MemoryView":1043 + * + * result.view.len = result.view.itemsize + * for length in result.view.shape[:ndim]: # <<<<<<<<<<<<<< + * result.view.len *= length + * + */ + __pyx_t_7 = (__pyx_v_result->__pyx_base.view.shape + __pyx_v_ndim); + for (__pyx_t_8 = __pyx_v_result->__pyx_base.view.shape; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) { + __pyx_t_6 = __pyx_t_8; + __pyx_t_2 = PyInt_FromSsize_t((__pyx_t_6[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1043, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":1044 + * result.view.len = result.view.itemsize + * for length in result.view.shape[:ndim]: + * result.view.len *= length # <<<<<<<<<<<<<< + * + * result.to_object_func = to_object_func + */ + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_result->__pyx_base.view.len); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1044, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_InPlaceMultiply(__pyx_t_2, __pyx_v_length); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1044, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 1044, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result->__pyx_base.view.len = __pyx_t_9; + } + + /* "View.MemoryView":1046 + * result.view.len *= length + * + * result.to_object_func = to_object_func # <<<<<<<<<<<<<< + * result.to_dtype_func = to_dtype_func + * + */ + __pyx_v_result->to_object_func = __pyx_v_to_object_func; + + /* "View.MemoryView":1047 + * + * result.to_object_func = to_object_func + * result.to_dtype_func = to_dtype_func # <<<<<<<<<<<<<< + * + * return result + */ + __pyx_v_result->to_dtype_func = __pyx_v_to_dtype_func; + + /* "View.MemoryView":1049 + * result.to_dtype_func = to_dtype_func + * + * return result # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "View.MemoryView":999 + * + * @cname('__pyx_memoryview_fromslice') + * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< + * int ndim, + * object (*to_object_func)(char *), + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview_fromslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XDECREF(__pyx_v_length); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1052 + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') + * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + */ + +static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_mslice) { + struct __pyx_memoryviewslice_obj *__pyx_v_obj = 0; + __Pyx_memviewslice *__pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_slice_from_memview", 0); + + /* "View.MemoryView":1055 + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * obj = memview + * return &obj.from_slice + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1056 + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): + * obj = memview # <<<<<<<<<<<<<< + * return &obj.from_slice + * else: + */ + if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(1, 1056, __pyx_L1_error) + __pyx_t_3 = ((PyObject *)__pyx_v_memview); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_obj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":1057 + * if isinstance(memview, _memoryviewslice): + * obj = memview + * return &obj.from_slice # <<<<<<<<<<<<<< + * else: + * slice_copy(memview, mslice) + */ + __pyx_r = (&__pyx_v_obj->from_slice); + goto __pyx_L0; + + /* "View.MemoryView":1055 + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * obj = memview + * return &obj.from_slice + */ + } + + /* "View.MemoryView":1059 + * return &obj.from_slice + * else: + * slice_copy(memview, mslice) # <<<<<<<<<<<<<< + * return mslice + * + */ + /*else*/ { + __pyx_memoryview_slice_copy(__pyx_v_memview, __pyx_v_mslice); + + /* "View.MemoryView":1060 + * else: + * slice_copy(memview, mslice) + * return mslice # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_slice_copy') + */ + __pyx_r = __pyx_v_mslice; + goto __pyx_L0; + } + + /* "View.MemoryView":1052 + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') + * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.get_slice_from_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_obj); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1063 + * + * @cname('__pyx_memoryview_slice_copy') + * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< + * cdef int dim + * cdef (Py_ssize_t*) shape, strides, suboffsets + */ + +static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_dst) { + int __pyx_v_dim; + Py_ssize_t *__pyx_v_shape; + Py_ssize_t *__pyx_v_strides; + Py_ssize_t *__pyx_v_suboffsets; + __Pyx_RefNannyDeclarations + Py_ssize_t *__pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + Py_ssize_t __pyx_t_5; + __Pyx_RefNannySetupContext("slice_copy", 0); + + /* "View.MemoryView":1067 + * cdef (Py_ssize_t*) shape, strides, suboffsets + * + * shape = memview.view.shape # <<<<<<<<<<<<<< + * strides = memview.view.strides + * suboffsets = memview.view.suboffsets + */ + __pyx_t_1 = __pyx_v_memview->view.shape; + __pyx_v_shape = __pyx_t_1; + + /* "View.MemoryView":1068 + * + * shape = memview.view.shape + * strides = memview.view.strides # <<<<<<<<<<<<<< + * suboffsets = memview.view.suboffsets + * + */ + __pyx_t_1 = __pyx_v_memview->view.strides; + __pyx_v_strides = __pyx_t_1; + + /* "View.MemoryView":1069 + * shape = memview.view.shape + * strides = memview.view.strides + * suboffsets = memview.view.suboffsets # <<<<<<<<<<<<<< + * + * dst.memview = <__pyx_memoryview *> memview + */ + __pyx_t_1 = __pyx_v_memview->view.suboffsets; + __pyx_v_suboffsets = __pyx_t_1; + + /* "View.MemoryView":1071 + * suboffsets = memview.view.suboffsets + * + * dst.memview = <__pyx_memoryview *> memview # <<<<<<<<<<<<<< + * dst.data = memview.view.buf + * + */ + __pyx_v_dst->memview = ((struct __pyx_memoryview_obj *)__pyx_v_memview); + + /* "View.MemoryView":1072 + * + * dst.memview = <__pyx_memoryview *> memview + * dst.data = memview.view.buf # <<<<<<<<<<<<<< + * + * for dim in range(memview.view.ndim): + */ + __pyx_v_dst->data = ((char *)__pyx_v_memview->view.buf); + + /* "View.MemoryView":1074 + * dst.data = memview.view.buf + * + * for dim in range(memview.view.ndim): # <<<<<<<<<<<<<< + * dst.shape[dim] = shape[dim] + * dst.strides[dim] = strides[dim] + */ + __pyx_t_2 = __pyx_v_memview->view.ndim; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_dim = __pyx_t_4; + + /* "View.MemoryView":1075 + * + * for dim in range(memview.view.ndim): + * dst.shape[dim] = shape[dim] # <<<<<<<<<<<<<< + * dst.strides[dim] = strides[dim] + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 + */ + (__pyx_v_dst->shape[__pyx_v_dim]) = (__pyx_v_shape[__pyx_v_dim]); + + /* "View.MemoryView":1076 + * for dim in range(memview.view.ndim): + * dst.shape[dim] = shape[dim] + * dst.strides[dim] = strides[dim] # <<<<<<<<<<<<<< + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 + * + */ + (__pyx_v_dst->strides[__pyx_v_dim]) = (__pyx_v_strides[__pyx_v_dim]); + + /* "View.MemoryView":1077 + * dst.shape[dim] = shape[dim] + * dst.strides[dim] = strides[dim] + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_object') + */ + if ((__pyx_v_suboffsets != 0)) { + __pyx_t_5 = (__pyx_v_suboffsets[__pyx_v_dim]); + } else { + __pyx_t_5 = -1L; + } + (__pyx_v_dst->suboffsets[__pyx_v_dim]) = __pyx_t_5; + } + + /* "View.MemoryView":1063 + * + * @cname('__pyx_memoryview_slice_copy') + * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< + * cdef int dim + * cdef (Py_ssize_t*) shape, strides, suboffsets + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":1080 + * + * @cname('__pyx_memoryview_copy_object') + * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< + * "Create a new memoryview object" + * cdef __Pyx_memviewslice memviewslice + */ + +static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx_v_memview) { + __Pyx_memviewslice __pyx_v_memviewslice; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_copy", 0); + + /* "View.MemoryView":1083 + * "Create a new memoryview object" + * cdef __Pyx_memviewslice memviewslice + * slice_copy(memview, &memviewslice) # <<<<<<<<<<<<<< + * return memoryview_copy_from_slice(memview, &memviewslice) + * + */ + __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_memviewslice)); + + /* "View.MemoryView":1084 + * cdef __Pyx_memviewslice memviewslice + * slice_copy(memview, &memviewslice) + * return memoryview_copy_from_slice(memview, &memviewslice) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_object_from_slice') + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_memoryview_copy_object_from_slice(__pyx_v_memview, (&__pyx_v_memviewslice)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1084, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":1080 + * + * @cname('__pyx_memoryview_copy_object') + * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< + * "Create a new memoryview object" + * cdef __Pyx_memviewslice memviewslice + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview_copy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1087 + * + * @cname('__pyx_memoryview_copy_object_from_slice') + * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< + * """ + * Create a new memoryview object from a given memoryview object and slice. + */ + +static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_memviewslice) { + PyObject *(*__pyx_v_to_object_func)(char *); + int (*__pyx_v_to_dtype_func)(char *, PyObject *); + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *(*__pyx_t_3)(char *); + int (*__pyx_t_4)(char *, PyObject *); + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_copy_from_slice", 0); + + /* "View.MemoryView":1094 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * to_object_func = (<_memoryviewslice> memview).to_object_func + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1095 + * + * if isinstance(memview, _memoryviewslice): + * to_object_func = (<_memoryviewslice> memview).to_object_func # <<<<<<<<<<<<<< + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + * else: + */ + __pyx_t_3 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_object_func; + __pyx_v_to_object_func = __pyx_t_3; + + /* "View.MemoryView":1096 + * if isinstance(memview, _memoryviewslice): + * to_object_func = (<_memoryviewslice> memview).to_object_func + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func # <<<<<<<<<<<<<< + * else: + * to_object_func = NULL + */ + __pyx_t_4 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_dtype_func; + __pyx_v_to_dtype_func = __pyx_t_4; + + /* "View.MemoryView":1094 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * to_object_func = (<_memoryviewslice> memview).to_object_func + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1098 + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + * else: + * to_object_func = NULL # <<<<<<<<<<<<<< + * to_dtype_func = NULL + * + */ + /*else*/ { + __pyx_v_to_object_func = NULL; + + /* "View.MemoryView":1099 + * else: + * to_object_func = NULL + * to_dtype_func = NULL # <<<<<<<<<<<<<< + * + * return memoryview_fromslice(memviewslice[0], memview.view.ndim, + */ + __pyx_v_to_dtype_func = NULL; + } + __pyx_L3:; + + /* "View.MemoryView":1101 + * to_dtype_func = NULL + * + * return memoryview_fromslice(memviewslice[0], memview.view.ndim, # <<<<<<<<<<<<<< + * to_object_func, to_dtype_func, + * memview.dtype_is_object) + */ + __Pyx_XDECREF(__pyx_r); + + /* "View.MemoryView":1103 + * return memoryview_fromslice(memviewslice[0], memview.view.ndim, + * to_object_func, to_dtype_func, + * memview.dtype_is_object) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_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, 1101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "View.MemoryView":1087 + * + * @cname('__pyx_memoryview_copy_object_from_slice') + * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< + * """ + * Create a new memoryview object from a given memoryview object and slice. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview_copy_from_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1109 + * + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< + * if arg < 0: + * return -arg + */ + +static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { + Py_ssize_t __pyx_r; + int __pyx_t_1; + + /* "View.MemoryView":1110 + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: + * if arg < 0: # <<<<<<<<<<<<<< + * return -arg + * else: + */ + __pyx_t_1 = ((__pyx_v_arg < 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1111 + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: + * if arg < 0: + * return -arg # <<<<<<<<<<<<<< + * else: + * return arg + */ + __pyx_r = (-__pyx_v_arg); + goto __pyx_L0; + + /* "View.MemoryView":1110 + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: + * if arg < 0: # <<<<<<<<<<<<<< + * return -arg + * else: + */ + } + + /* "View.MemoryView":1113 + * return -arg + * else: + * return arg # <<<<<<<<<<<<<< + * + * @cname('__pyx_get_best_slice_order') + */ + /*else*/ { + __pyx_r = __pyx_v_arg; + goto __pyx_L0; + } + + /* "View.MemoryView":1109 + * + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< + * if arg < 0: + * return -arg + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1116 + * + * @cname('__pyx_get_best_slice_order') + * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<< + * """ + * Figure out the best memory access order for a given slice. + */ + +static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim) { + int __pyx_v_i; + Py_ssize_t __pyx_v_c_stride; + Py_ssize_t __pyx_v_f_stride; + char __pyx_r; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + + /* "View.MemoryView":1121 + * """ + * cdef int i + * cdef Py_ssize_t c_stride = 0 # <<<<<<<<<<<<<< + * cdef Py_ssize_t f_stride = 0 + * + */ + __pyx_v_c_stride = 0; + + /* "View.MemoryView":1122 + * cdef int i + * cdef Py_ssize_t c_stride = 0 + * cdef Py_ssize_t f_stride = 0 # <<<<<<<<<<<<<< + * + * for i in range(ndim - 1, -1, -1): + */ + __pyx_v_f_stride = 0; + + /* "View.MemoryView":1124 + * cdef Py_ssize_t f_stride = 0 + * + * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< + * if mslice.shape[i] > 1: + * c_stride = mslice.strides[i] + */ + for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { + __pyx_v_i = __pyx_t_1; + + /* "View.MemoryView":1125 + * + * for i in range(ndim - 1, -1, -1): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * c_stride = mslice.strides[i] + * break + */ + __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1126 + * for i in range(ndim - 1, -1, -1): + * if mslice.shape[i] > 1: + * c_stride = mslice.strides[i] # <<<<<<<<<<<<<< + * break + * + */ + __pyx_v_c_stride = (__pyx_v_mslice->strides[__pyx_v_i]); + + /* "View.MemoryView":1127 + * if mslice.shape[i] > 1: + * c_stride = mslice.strides[i] + * break # <<<<<<<<<<<<<< + * + * for i in range(ndim): + */ + goto __pyx_L4_break; + + /* "View.MemoryView":1125 + * + * for i in range(ndim - 1, -1, -1): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * c_stride = mslice.strides[i] + * break + */ + } + } + __pyx_L4_break:; + + /* "View.MemoryView":1129 + * break + * + * for i in range(ndim): # <<<<<<<<<<<<<< + * if mslice.shape[i] > 1: + * f_stride = mslice.strides[i] + */ + __pyx_t_1 = __pyx_v_ndim; + __pyx_t_3 = __pyx_t_1; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1130 + * + * for i in range(ndim): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * f_stride = mslice.strides[i] + * break + */ + __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1131 + * for i in range(ndim): + * if mslice.shape[i] > 1: + * f_stride = mslice.strides[i] # <<<<<<<<<<<<<< + * break + * + */ + __pyx_v_f_stride = (__pyx_v_mslice->strides[__pyx_v_i]); + + /* "View.MemoryView":1132 + * if mslice.shape[i] > 1: + * f_stride = mslice.strides[i] + * break # <<<<<<<<<<<<<< + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): + */ + goto __pyx_L7_break; + + /* "View.MemoryView":1130 + * + * for i in range(ndim): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * f_stride = mslice.strides[i] + * break + */ + } + } + __pyx_L7_break:; + + /* "View.MemoryView":1134 + * break + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< + * return 'C' + * else: + */ + __pyx_t_2 = ((abs_py_ssize_t(__pyx_v_c_stride) <= abs_py_ssize_t(__pyx_v_f_stride)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1135 + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): + * return 'C' # <<<<<<<<<<<<<< + * else: + * return 'F' + */ + __pyx_r = 'C'; + goto __pyx_L0; + + /* "View.MemoryView":1134 + * break + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< + * return 'C' + * else: + */ + } + + /* "View.MemoryView":1137 + * return 'C' + * else: + * return 'F' # <<<<<<<<<<<<<< + * + * @cython.cdivision(True) + */ + /*else*/ { + __pyx_r = 'F'; + goto __pyx_L0; + } + + /* "View.MemoryView":1116 + * + * @cname('__pyx_get_best_slice_order') + * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<< + * """ + * Figure out the best memory access order for a given slice. + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1140 + * + * @cython.cdivision(True) + * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< + * char *dst_data, Py_ssize_t *dst_strides, + * Py_ssize_t *src_shape, Py_ssize_t *dst_shape, + */ + +static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v_src_strides, char *__pyx_v_dst_data, Py_ssize_t *__pyx_v_dst_strides, Py_ssize_t *__pyx_v_src_shape, Py_ssize_t *__pyx_v_dst_shape, int __pyx_v_ndim, size_t __pyx_v_itemsize) { + CYTHON_UNUSED Py_ssize_t __pyx_v_i; + CYTHON_UNUSED Py_ssize_t __pyx_v_src_extent; + Py_ssize_t __pyx_v_dst_extent; + Py_ssize_t __pyx_v_src_stride; + Py_ssize_t __pyx_v_dst_stride; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + Py_ssize_t __pyx_t_4; + Py_ssize_t __pyx_t_5; + Py_ssize_t __pyx_t_6; + + /* "View.MemoryView":1147 + * + * cdef Py_ssize_t i + * cdef Py_ssize_t src_extent = src_shape[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t dst_extent = dst_shape[0] + * cdef Py_ssize_t src_stride = src_strides[0] + */ + __pyx_v_src_extent = (__pyx_v_src_shape[0]); + + /* "View.MemoryView":1148 + * cdef Py_ssize_t i + * cdef Py_ssize_t src_extent = src_shape[0] + * cdef Py_ssize_t dst_extent = dst_shape[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t src_stride = src_strides[0] + * cdef Py_ssize_t dst_stride = dst_strides[0] + */ + __pyx_v_dst_extent = (__pyx_v_dst_shape[0]); + + /* "View.MemoryView":1149 + * cdef Py_ssize_t src_extent = src_shape[0] + * cdef Py_ssize_t dst_extent = dst_shape[0] + * cdef Py_ssize_t src_stride = src_strides[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t dst_stride = dst_strides[0] + * + */ + __pyx_v_src_stride = (__pyx_v_src_strides[0]); + + /* "View.MemoryView":1150 + * cdef Py_ssize_t dst_extent = dst_shape[0] + * cdef Py_ssize_t src_stride = src_strides[0] + * cdef Py_ssize_t dst_stride = dst_strides[0] # <<<<<<<<<<<<<< + * + * if ndim == 1: + */ + __pyx_v_dst_stride = (__pyx_v_dst_strides[0]); + + /* "View.MemoryView":1152 + * cdef Py_ssize_t dst_stride = dst_strides[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): + */ + __pyx_t_1 = ((__pyx_v_ndim == 1) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1153 + * + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) + */ + __pyx_t_2 = ((__pyx_v_src_stride > 0) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L5_bool_binop_done; + } + __pyx_t_2 = ((__pyx_v_dst_stride > 0) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L5_bool_binop_done; + } + + /* "View.MemoryView":1154 + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): # <<<<<<<<<<<<<< + * memcpy(dst_data, src_data, itemsize * dst_extent) + * else: + */ + __pyx_t_2 = (((size_t)__pyx_v_src_stride) == __pyx_v_itemsize); + if (__pyx_t_2) { + __pyx_t_2 = (__pyx_v_itemsize == ((size_t)__pyx_v_dst_stride)); + } + __pyx_t_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L5_bool_binop_done:; + + /* "View.MemoryView":1153 + * + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) + */ + if (__pyx_t_1) { + + /* "View.MemoryView":1155 + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) # <<<<<<<<<<<<<< + * else: + * for i in range(dst_extent): + */ + (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, (__pyx_v_itemsize * __pyx_v_dst_extent))); + + /* "View.MemoryView":1153 + * + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) + */ + goto __pyx_L4; + } + + /* "View.MemoryView":1157 + * memcpy(dst_data, src_data, itemsize * dst_extent) + * else: + * for i in range(dst_extent): # <<<<<<<<<<<<<< + * memcpy(dst_data, src_data, itemsize) + * src_data += src_stride + */ + /*else*/ { + __pyx_t_4 = __pyx_v_dst_extent; + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1158 + * else: + * for i in range(dst_extent): + * memcpy(dst_data, src_data, itemsize) # <<<<<<<<<<<<<< + * src_data += src_stride + * dst_data += dst_stride + */ + (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, __pyx_v_itemsize)); + + /* "View.MemoryView":1159 + * for i in range(dst_extent): + * memcpy(dst_data, src_data, itemsize) + * src_data += src_stride # <<<<<<<<<<<<<< + * dst_data += dst_stride + * else: + */ + __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); + + /* "View.MemoryView":1160 + * memcpy(dst_data, src_data, itemsize) + * src_data += src_stride + * dst_data += dst_stride # <<<<<<<<<<<<<< + * else: + * for i in range(dst_extent): + */ + __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride); + } + } + __pyx_L4:; + + /* "View.MemoryView":1152 + * cdef Py_ssize_t dst_stride = dst_strides[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1162 + * dst_data += dst_stride + * else: + * for i in range(dst_extent): # <<<<<<<<<<<<<< + * _copy_strided_to_strided(src_data, src_strides + 1, + * dst_data, dst_strides + 1, + */ + /*else*/ { + __pyx_t_4 = __pyx_v_dst_extent; + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1163 + * else: + * for i in range(dst_extent): + * _copy_strided_to_strided(src_data, src_strides + 1, # <<<<<<<<<<<<<< + * dst_data, dst_strides + 1, + * src_shape + 1, dst_shape + 1, + */ + _copy_strided_to_strided(__pyx_v_src_data, (__pyx_v_src_strides + 1), __pyx_v_dst_data, (__pyx_v_dst_strides + 1), (__pyx_v_src_shape + 1), (__pyx_v_dst_shape + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize); + + /* "View.MemoryView":1167 + * src_shape + 1, dst_shape + 1, + * ndim - 1, itemsize) + * src_data += src_stride # <<<<<<<<<<<<<< + * dst_data += dst_stride + * + */ + __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); + + /* "View.MemoryView":1168 + * ndim - 1, itemsize) + * src_data += src_stride + * dst_data += dst_stride # <<<<<<<<<<<<<< + * + * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, + */ + __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride); + } + } + __pyx_L3:; + + /* "View.MemoryView":1140 + * + * @cython.cdivision(True) + * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< + * char *dst_data, Py_ssize_t *dst_strides, + * Py_ssize_t *src_shape, Py_ssize_t *dst_shape, + */ + + /* function exit code */ +} + +/* "View.MemoryView":1170 + * dst_data += dst_stride + * + * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) nogil: + */ + +static void copy_strided_to_strided(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize) { + + /* "View.MemoryView":1173 + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) nogil: + * _copy_strided_to_strided(src.data, src.strides, dst.data, dst.strides, # <<<<<<<<<<<<<< + * src.shape, dst.shape, ndim, itemsize) + * + */ + _copy_strided_to_strided(__pyx_v_src->data, __pyx_v_src->strides, __pyx_v_dst->data, __pyx_v_dst->strides, __pyx_v_src->shape, __pyx_v_dst->shape, __pyx_v_ndim, __pyx_v_itemsize); + + /* "View.MemoryView":1170 + * dst_data += dst_stride + * + * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) nogil: + */ + + /* function exit code */ +} + +/* "View.MemoryView":1177 + * + * @cname('__pyx_memoryview_slice_get_size') + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<< + * "Return the size of the memory occupied by the slice in number of bytes" + * cdef Py_ssize_t shape, size = src.memview.view.itemsize + */ + +static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_src, int __pyx_v_ndim) { + Py_ssize_t __pyx_v_shape; + Py_ssize_t __pyx_v_size; + Py_ssize_t __pyx_r; + Py_ssize_t __pyx_t_1; + Py_ssize_t *__pyx_t_2; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + + /* "View.MemoryView":1179 + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: + * "Return the size of the memory occupied by the slice in number of bytes" + * cdef Py_ssize_t shape, size = src.memview.view.itemsize # <<<<<<<<<<<<<< + * + * for shape in src.shape[:ndim]: + */ + __pyx_t_1 = __pyx_v_src->memview->view.itemsize; + __pyx_v_size = __pyx_t_1; + + /* "View.MemoryView":1181 + * cdef Py_ssize_t shape, size = src.memview.view.itemsize + * + * for shape in src.shape[:ndim]: # <<<<<<<<<<<<<< + * size *= shape + * + */ + __pyx_t_3 = (__pyx_v_src->shape + __pyx_v_ndim); + for (__pyx_t_4 = __pyx_v_src->shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { + __pyx_t_2 = __pyx_t_4; + __pyx_v_shape = (__pyx_t_2[0]); + + /* "View.MemoryView":1182 + * + * for shape in src.shape[:ndim]: + * size *= shape # <<<<<<<<<<<<<< + * + * return size + */ + __pyx_v_size = (__pyx_v_size * __pyx_v_shape); + } + + /* "View.MemoryView":1184 + * size *= shape + * + * return size # <<<<<<<<<<<<<< + * + * @cname('__pyx_fill_contig_strides_array') + */ + __pyx_r = __pyx_v_size; + goto __pyx_L0; + + /* "View.MemoryView":1177 + * + * @cname('__pyx_memoryview_slice_get_size') + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<< + * "Return the size of the memory occupied by the slice in number of bytes" + * cdef Py_ssize_t shape, size = src.memview.view.itemsize + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1187 + * + * @cname('__pyx_fill_contig_strides_array') + * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< + * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, + * int ndim, char order) nogil: + */ + +static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, Py_ssize_t __pyx_v_stride, int __pyx_v_ndim, char __pyx_v_order) { + int __pyx_v_idx; + Py_ssize_t __pyx_r; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + + /* "View.MemoryView":1196 + * cdef int idx + * + * if order == 'F': # <<<<<<<<<<<<<< + * for idx in range(ndim): + * strides[idx] = stride + */ + __pyx_t_1 = ((__pyx_v_order == 'F') != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1197 + * + * if order == 'F': + * for idx in range(ndim): # <<<<<<<<<<<<<< + * strides[idx] = stride + * stride *= shape[idx] + */ + __pyx_t_2 = __pyx_v_ndim; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_idx = __pyx_t_4; + + /* "View.MemoryView":1198 + * if order == 'F': + * for idx in range(ndim): + * strides[idx] = stride # <<<<<<<<<<<<<< + * stride *= shape[idx] + * else: + */ + (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; + + /* "View.MemoryView":1199 + * for idx in range(ndim): + * strides[idx] = stride + * stride *= shape[idx] # <<<<<<<<<<<<<< + * else: + * for idx in range(ndim - 1, -1, -1): + */ + __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx])); + } + + /* "View.MemoryView":1196 + * cdef int idx + * + * if order == 'F': # <<<<<<<<<<<<<< + * for idx in range(ndim): + * strides[idx] = stride + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1201 + * stride *= shape[idx] + * else: + * for idx in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< + * strides[idx] = stride + * stride *= shape[idx] + */ + /*else*/ { + for (__pyx_t_2 = (__pyx_v_ndim - 1); __pyx_t_2 > -1; __pyx_t_2-=1) { + __pyx_v_idx = __pyx_t_2; + + /* "View.MemoryView":1202 + * else: + * for idx in range(ndim - 1, -1, -1): + * strides[idx] = stride # <<<<<<<<<<<<<< + * stride *= shape[idx] + * + */ + (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; + + /* "View.MemoryView":1203 + * for idx in range(ndim - 1, -1, -1): + * strides[idx] = stride + * stride *= shape[idx] # <<<<<<<<<<<<<< + * + * return stride + */ + __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx])); + } + } + __pyx_L3:; + + /* "View.MemoryView":1205 + * stride *= shape[idx] + * + * return stride # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_data_to_temp') + */ + __pyx_r = __pyx_v_stride; + goto __pyx_L0; + + /* "View.MemoryView":1187 + * + * @cname('__pyx_fill_contig_strides_array') + * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< + * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, + * int ndim, char order) nogil: + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1208 + * + * @cname('__pyx_memoryview_copy_data_to_temp') + * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *tmpslice, + * char order, + */ + +static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_tmpslice, char __pyx_v_order, int __pyx_v_ndim) { + int __pyx_v_i; + void *__pyx_v_result; + size_t __pyx_v_itemsize; + size_t __pyx_v_size; + void *__pyx_r; + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + struct __pyx_memoryview_obj *__pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":1219 + * cdef void *result + * + * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< + * cdef size_t size = slice_get_size(src, ndim) + * + */ + __pyx_t_1 = __pyx_v_src->memview->view.itemsize; + __pyx_v_itemsize = __pyx_t_1; + + /* "View.MemoryView":1220 + * + * cdef size_t itemsize = src.memview.view.itemsize + * cdef size_t size = slice_get_size(src, ndim) # <<<<<<<<<<<<<< + * + * result = malloc(size) + */ + __pyx_v_size = __pyx_memoryview_slice_get_size(__pyx_v_src, __pyx_v_ndim); + + /* "View.MemoryView":1222 + * cdef size_t size = slice_get_size(src, ndim) + * + * result = malloc(size) # <<<<<<<<<<<<<< + * if not result: + * _err(MemoryError, NULL) + */ + __pyx_v_result = malloc(__pyx_v_size); + + /* "View.MemoryView":1223 + * + * result = malloc(size) + * if not result: # <<<<<<<<<<<<<< + * _err(MemoryError, NULL) + * + */ + __pyx_t_2 = ((!(__pyx_v_result != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1224 + * 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, 1224, __pyx_L1_error) + + /* "View.MemoryView":1223 + * + * result = malloc(size) + * if not result: # <<<<<<<<<<<<<< + * _err(MemoryError, NULL) + * + */ + } + + /* "View.MemoryView":1227 + * + * + * tmpslice.data = result # <<<<<<<<<<<<<< + * tmpslice.memview = src.memview + * for i in range(ndim): + */ + __pyx_v_tmpslice->data = ((char *)__pyx_v_result); + + /* "View.MemoryView":1228 + * + * tmpslice.data = result + * tmpslice.memview = src.memview # <<<<<<<<<<<<<< + * for i in range(ndim): + * tmpslice.shape[i] = src.shape[i] + */ + __pyx_t_4 = __pyx_v_src->memview; + __pyx_v_tmpslice->memview = __pyx_t_4; + + /* "View.MemoryView":1229 + * tmpslice.data = result + * tmpslice.memview = src.memview + * for i in range(ndim): # <<<<<<<<<<<<<< + * tmpslice.shape[i] = src.shape[i] + * tmpslice.suboffsets[i] = -1 + */ + __pyx_t_3 = __pyx_v_ndim; + __pyx_t_5 = __pyx_t_3; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1230 + * tmpslice.memview = src.memview + * for i in range(ndim): + * tmpslice.shape[i] = src.shape[i] # <<<<<<<<<<<<<< + * tmpslice.suboffsets[i] = -1 + * + */ + (__pyx_v_tmpslice->shape[__pyx_v_i]) = (__pyx_v_src->shape[__pyx_v_i]); + + /* "View.MemoryView":1231 + * for i in range(ndim): + * tmpslice.shape[i] = src.shape[i] + * tmpslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< + * + * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, + */ + (__pyx_v_tmpslice->suboffsets[__pyx_v_i]) = -1L; + } + + /* "View.MemoryView":1233 + * tmpslice.suboffsets[i] = -1 + * + * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, # <<<<<<<<<<<<<< + * ndim, order) + * + */ + (void)(__pyx_fill_contig_strides_array((&(__pyx_v_tmpslice->shape[0])), (&(__pyx_v_tmpslice->strides[0])), __pyx_v_itemsize, __pyx_v_ndim, __pyx_v_order)); + + /* "View.MemoryView":1237 + * + * + * for i in range(ndim): # <<<<<<<<<<<<<< + * if tmpslice.shape[i] == 1: + * tmpslice.strides[i] = 0 + */ + __pyx_t_3 = __pyx_v_ndim; + __pyx_t_5 = __pyx_t_3; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1238 + * + * for i in range(ndim): + * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< + * tmpslice.strides[i] = 0 + * + */ + __pyx_t_2 = (((__pyx_v_tmpslice->shape[__pyx_v_i]) == 1) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1239 + * for i in range(ndim): + * if tmpslice.shape[i] == 1: + * tmpslice.strides[i] = 0 # <<<<<<<<<<<<<< + * + * if slice_is_contig(src[0], order, ndim): + */ + (__pyx_v_tmpslice->strides[__pyx_v_i]) = 0; + + /* "View.MemoryView":1238 + * + * for i in range(ndim): + * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< + * tmpslice.strides[i] = 0 + * + */ + } + } + + /* "View.MemoryView":1241 + * tmpslice.strides[i] = 0 + * + * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< + * memcpy(result, src.data, size) + * else: + */ + __pyx_t_2 = (__pyx_memviewslice_is_contig((__pyx_v_src[0]), __pyx_v_order, __pyx_v_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1242 + * + * if slice_is_contig(src[0], order, ndim): + * memcpy(result, src.data, size) # <<<<<<<<<<<<<< + * else: + * copy_strided_to_strided(src, tmpslice, ndim, itemsize) + */ + (void)(memcpy(__pyx_v_result, __pyx_v_src->data, __pyx_v_size)); + + /* "View.MemoryView":1241 + * tmpslice.strides[i] = 0 + * + * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< + * memcpy(result, src.data, size) + * else: + */ + goto __pyx_L9; + } + + /* "View.MemoryView":1244 + * memcpy(result, src.data, size) + * else: + * copy_strided_to_strided(src, tmpslice, ndim, itemsize) # <<<<<<<<<<<<<< + * + * return result + */ + /*else*/ { + copy_strided_to_strided(__pyx_v_src, __pyx_v_tmpslice, __pyx_v_ndim, __pyx_v_itemsize); + } + __pyx_L9:; + + /* "View.MemoryView":1246 + * copy_strided_to_strided(src, tmpslice, ndim, itemsize) + * + * return result # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "View.MemoryView":1208 + * + * @cname('__pyx_memoryview_copy_data_to_temp') + * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *tmpslice, + * char order, + */ + + /* function exit code */ + __pyx_L1_error:; + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.copy_data_to_temp", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = NULL; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1251 + * + * @cname('__pyx_memoryview_err_extents') + * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< + * Py_ssize_t extent2) except -1 with gil: + * raise ValueError("got differing extents in dimension %d (got %d and %d)" % + */ + +static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent1, Py_ssize_t __pyx_v_extent2) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("_err_extents", 0); + + /* "View.MemoryView":1254 + * 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, 1254, __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, 1254, __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, 1254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + + /* "View.MemoryView":1253 + * 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, 1253, __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, 1253, __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, 1253, __pyx_L1_error) + + /* "View.MemoryView":1251 + * + * @cname('__pyx_memoryview_err_extents') + * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< + * Py_ssize_t extent2) except -1 with gil: + * raise ValueError("got differing extents in dimension %d (got %d and %d)" % + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView._err_extents", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "View.MemoryView":1257 + * + * @cname('__pyx_memoryview_err_dim') + * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii') % dim) + * + */ + +static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg, int __pyx_v_dim) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("_err_dim", 0); + __Pyx_INCREF(__pyx_v_error); + + /* "View.MemoryView":1258 + * @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, 1258, __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, 1258, __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, 1258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_INCREF(__pyx_v_error); + __pyx_t_3 = __pyx_v_error; __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __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, 1258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 1258, __pyx_L1_error) + + /* "View.MemoryView":1257 + * + * @cname('__pyx_memoryview_err_dim') + * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii') % dim) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView._err_dim", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_XDECREF(__pyx_v_error); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "View.MemoryView":1261 + * + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< + * if msg != NULL: + * raise error(msg.decode('ascii')) + */ + +static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("_err", 0); + __Pyx_INCREF(__pyx_v_error); + + /* "View.MemoryView":1262 + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: + * if msg != NULL: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii')) + * else: + */ + __pyx_t_1 = ((__pyx_v_msg != NULL) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":1263 + * 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, 1263, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_error); + __pyx_t_4 = __pyx_v_error; __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + __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, 1263, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 1263, __pyx_L1_error) + + /* "View.MemoryView":1262 + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: + * if msg != NULL: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii')) + * else: + */ + } + + /* "View.MemoryView":1265 + * raise error(msg.decode('ascii')) + * else: + * raise error # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_contents') + */ + /*else*/ { + __Pyx_Raise(__pyx_v_error, 0, 0, 0); + __PYX_ERR(1, 1265, __pyx_L1_error) + } + + /* "View.MemoryView":1261 + * + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< + * if msg != NULL: + * raise error(msg.decode('ascii')) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView._err", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_XDECREF(__pyx_v_error); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "View.MemoryView":1268 + * + * @cname('__pyx_memoryview_copy_contents') + * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice dst, + * int src_ndim, int dst_ndim, + */ + +static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_memviewslice __pyx_v_dst, int __pyx_v_src_ndim, int __pyx_v_dst_ndim, int __pyx_v_dtype_is_object) { + void *__pyx_v_tmpdata; + size_t __pyx_v_itemsize; + int __pyx_v_i; + char __pyx_v_order; + int __pyx_v_broadcasting; + int __pyx_v_direct_copy; + __Pyx_memviewslice __pyx_v_tmp; + int __pyx_v_ndim; + int __pyx_r; + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + void *__pyx_t_7; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":1276 + * Check for overlapping memory and verify the shapes. + * """ + * cdef void *tmpdata = NULL # <<<<<<<<<<<<<< + * cdef size_t itemsize = src.memview.view.itemsize + * cdef int i + */ + __pyx_v_tmpdata = NULL; + + /* "View.MemoryView":1277 + * """ + * cdef void *tmpdata = NULL + * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< + * cdef int i + * cdef char order = get_best_order(&src, src_ndim) + */ + __pyx_t_1 = __pyx_v_src.memview->view.itemsize; + __pyx_v_itemsize = __pyx_t_1; + + /* "View.MemoryView":1279 + * cdef size_t itemsize = src.memview.view.itemsize + * cdef int i + * cdef char order = get_best_order(&src, src_ndim) # <<<<<<<<<<<<<< + * cdef bint broadcasting = False + * cdef bint direct_copy = False + */ + __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_src), __pyx_v_src_ndim); + + /* "View.MemoryView":1280 + * cdef int i + * cdef char order = get_best_order(&src, src_ndim) + * cdef bint broadcasting = False # <<<<<<<<<<<<<< + * cdef bint direct_copy = False + * cdef __Pyx_memviewslice tmp + */ + __pyx_v_broadcasting = 0; + + /* "View.MemoryView":1281 + * cdef char order = get_best_order(&src, src_ndim) + * cdef bint broadcasting = False + * cdef bint direct_copy = False # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice tmp + * + */ + __pyx_v_direct_copy = 0; + + /* "View.MemoryView":1284 + * cdef __Pyx_memviewslice tmp + * + * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: + */ + __pyx_t_2 = ((__pyx_v_src_ndim < __pyx_v_dst_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1285 + * + * if src_ndim < dst_ndim: + * broadcast_leading(&src, src_ndim, dst_ndim) # <<<<<<<<<<<<<< + * elif dst_ndim < src_ndim: + * broadcast_leading(&dst, dst_ndim, src_ndim) + */ + __pyx_memoryview_broadcast_leading((&__pyx_v_src), __pyx_v_src_ndim, __pyx_v_dst_ndim); + + /* "View.MemoryView":1284 + * cdef __Pyx_memviewslice tmp + * + * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1286 + * if src_ndim < dst_ndim: + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&dst, dst_ndim, src_ndim) + * + */ + __pyx_t_2 = ((__pyx_v_dst_ndim < __pyx_v_src_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1287 + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: + * broadcast_leading(&dst, dst_ndim, src_ndim) # <<<<<<<<<<<<<< + * + * cdef int ndim = max(src_ndim, dst_ndim) + */ + __pyx_memoryview_broadcast_leading((&__pyx_v_dst), __pyx_v_dst_ndim, __pyx_v_src_ndim); + + /* "View.MemoryView":1286 + * if src_ndim < dst_ndim: + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&dst, dst_ndim, src_ndim) + * + */ + } + __pyx_L3:; + + /* "View.MemoryView":1289 + * broadcast_leading(&dst, dst_ndim, src_ndim) + * + * cdef int ndim = max(src_ndim, dst_ndim) # <<<<<<<<<<<<<< + * + * for i in range(ndim): + */ + __pyx_t_3 = __pyx_v_dst_ndim; + __pyx_t_4 = __pyx_v_src_ndim; + if (((__pyx_t_3 > __pyx_t_4) != 0)) { + __pyx_t_5 = __pyx_t_3; + } else { + __pyx_t_5 = __pyx_t_4; + } + __pyx_v_ndim = __pyx_t_5; + + /* "View.MemoryView":1291 + * cdef int ndim = max(src_ndim, dst_ndim) + * + * for i in range(ndim): # <<<<<<<<<<<<<< + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: + */ + __pyx_t_5 = __pyx_v_ndim; + __pyx_t_3 = __pyx_t_5; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1292 + * + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< + * if src.shape[i] == 1: + * broadcasting = True + */ + __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) != (__pyx_v_dst.shape[__pyx_v_i])) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1293 + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: # <<<<<<<<<<<<<< + * broadcasting = True + * src.strides[i] = 0 + */ + __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) == 1) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1294 + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: + * broadcasting = True # <<<<<<<<<<<<<< + * src.strides[i] = 0 + * else: + */ + __pyx_v_broadcasting = 1; + + /* "View.MemoryView":1295 + * if src.shape[i] == 1: + * broadcasting = True + * src.strides[i] = 0 # <<<<<<<<<<<<<< + * else: + * _err_extents(i, dst.shape[i], src.shape[i]) + */ + (__pyx_v_src.strides[__pyx_v_i]) = 0; + + /* "View.MemoryView":1293 + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: # <<<<<<<<<<<<<< + * broadcasting = True + * src.strides[i] = 0 + */ + goto __pyx_L7; + } + + /* "View.MemoryView":1297 + * src.strides[i] = 0 + * else: + * _err_extents(i, dst.shape[i], src.shape[i]) # <<<<<<<<<<<<<< + * + * if src.suboffsets[i] >= 0: + */ + /*else*/ { + __pyx_t_6 = __pyx_memoryview_err_extents(__pyx_v_i, (__pyx_v_dst.shape[__pyx_v_i]), (__pyx_v_src.shape[__pyx_v_i])); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1297, __pyx_L1_error) + } + __pyx_L7:; + + /* "View.MemoryView":1292 + * + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< + * if src.shape[i] == 1: + * broadcasting = True + */ + } + + /* "View.MemoryView":1299 + * _err_extents(i, dst.shape[i], src.shape[i]) + * + * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + */ + __pyx_t_2 = (((__pyx_v_src.suboffsets[__pyx_v_i]) >= 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1300 + * + * 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, 1300, __pyx_L1_error) + + /* "View.MemoryView":1299 + * _err_extents(i, dst.shape[i], src.shape[i]) + * + * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + */ + } + } + + /* "View.MemoryView":1302 + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< + * + * if not slice_is_contig(src, order, ndim): + */ + __pyx_t_2 = (__pyx_slices_overlap((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1304 + * if slices_overlap(&src, &dst, ndim, itemsize): + * + * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< + * order = get_best_order(&dst, ndim) + * + */ + __pyx_t_2 = ((!(__pyx_memviewslice_is_contig(__pyx_v_src, __pyx_v_order, __pyx_v_ndim) != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1305 + * + * if not slice_is_contig(src, order, ndim): + * order = get_best_order(&dst, ndim) # <<<<<<<<<<<<<< + * + * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) + */ + __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim); + + /* "View.MemoryView":1304 + * if slices_overlap(&src, &dst, ndim, itemsize): + * + * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< + * order = get_best_order(&dst, ndim) + * + */ + } + + /* "View.MemoryView":1307 + * 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, 1307, __pyx_L1_error) + __pyx_v_tmpdata = __pyx_t_7; + + /* "View.MemoryView":1308 + * + * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) + * src = tmp # <<<<<<<<<<<<<< + * + * if not broadcasting: + */ + __pyx_v_src = __pyx_v_tmp; + + /* "View.MemoryView":1302 + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< + * + * if not slice_is_contig(src, order, ndim): + */ + } + + /* "View.MemoryView":1310 + * src = tmp + * + * if not broadcasting: # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = ((!(__pyx_v_broadcasting != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1313 + * + * + * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): + */ + __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'C', __pyx_v_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1314 + * + * if slice_is_contig(src, 'C', ndim): + * direct_copy = slice_is_contig(dst, 'C', ndim) # <<<<<<<<<<<<<< + * elif slice_is_contig(src, 'F', ndim): + * direct_copy = slice_is_contig(dst, 'F', ndim) + */ + __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'C', __pyx_v_ndim); + + /* "View.MemoryView":1313 + * + * + * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): + */ + goto __pyx_L12; + } + + /* "View.MemoryView":1315 + * if slice_is_contig(src, 'C', ndim): + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + */ + __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'F', __pyx_v_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1316 + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): + * direct_copy = slice_is_contig(dst, 'F', ndim) # <<<<<<<<<<<<<< + * + * if direct_copy: + */ + __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'F', __pyx_v_ndim); + + /* "View.MemoryView":1315 + * if slice_is_contig(src, 'C', ndim): + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + */ + } + __pyx_L12:; + + /* "View.MemoryView":1318 + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + * if direct_copy: # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + */ + __pyx_t_2 = (__pyx_v_direct_copy != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1320 + * if direct_copy: + * + * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, True) + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1321 + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) # <<<<<<<<<<<<<< + * refcount_copying(&dst, dtype_is_object, ndim, True) + * free(tmpdata) + */ + (void)(memcpy(__pyx_v_dst.data, __pyx_v_src.data, __pyx_memoryview_slice_get_size((&__pyx_v_src), __pyx_v_ndim))); + + /* "View.MemoryView":1322 + * refcount_copying(&dst, dtype_is_object, ndim, False) + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< + * free(tmpdata) + * return 0 + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1323 + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, True) + * free(tmpdata) # <<<<<<<<<<<<<< + * return 0 + * + */ + free(__pyx_v_tmpdata); + + /* "View.MemoryView":1324 + * refcount_copying(&dst, dtype_is_object, ndim, True) + * free(tmpdata) + * return 0 # <<<<<<<<<<<<<< + * + * if order == 'F' == get_best_order(&dst, ndim): + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":1318 + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + * if direct_copy: # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + */ + } + + /* "View.MemoryView":1310 + * src = tmp + * + * if not broadcasting: # <<<<<<<<<<<<<< + * + * + */ + } + + /* "View.MemoryView":1326 + * return 0 + * + * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = (__pyx_v_order == 'F'); + if (__pyx_t_2) { + __pyx_t_2 = ('F' == __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim)); + } + __pyx_t_8 = (__pyx_t_2 != 0); + if (__pyx_t_8) { + + /* "View.MemoryView":1329 + * + * + * 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, 1329, __pyx_L1_error) + + /* "View.MemoryView":1330 + * + * 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, 1330, __pyx_L1_error) + + /* "View.MemoryView":1326 + * return 0 + * + * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< + * + * + */ + } + + /* "View.MemoryView":1332 + * transpose_memslice(&dst) + * + * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< + * copy_strided_to_strided(&src, &dst, ndim, itemsize) + * refcount_copying(&dst, dtype_is_object, ndim, True) + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1333 + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + * copy_strided_to_strided(&src, &dst, ndim, itemsize) # <<<<<<<<<<<<<< + * refcount_copying(&dst, dtype_is_object, ndim, True) + * + */ + copy_strided_to_strided((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize); + + /* "View.MemoryView":1334 + * refcount_copying(&dst, dtype_is_object, ndim, False) + * copy_strided_to_strided(&src, &dst, ndim, itemsize) + * refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< + * + * free(tmpdata) + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1336 + * refcount_copying(&dst, dtype_is_object, ndim, True) + * + * free(tmpdata) # <<<<<<<<<<<<<< + * return 0 + * + */ + free(__pyx_v_tmpdata); + + /* "View.MemoryView":1337 + * + * free(tmpdata) + * return 0 # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_broadcast_leading') + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":1268 + * + * @cname('__pyx_memoryview_copy_contents') + * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice dst, + * int src_ndim, int dst_ndim, + */ + + /* function exit code */ + __pyx_L1_error:; + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.memoryview_copy_contents", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1340 + * + * @cname('__pyx_memoryview_broadcast_leading') + * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< + * int ndim, + * int ndim_other) nogil: + */ + +static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim, int __pyx_v_ndim_other) { + int __pyx_v_i; + int __pyx_v_offset; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + + /* "View.MemoryView":1344 + * int ndim_other) nogil: + * cdef int i + * cdef int offset = ndim_other - ndim # <<<<<<<<<<<<<< + * + * for i in range(ndim - 1, -1, -1): + */ + __pyx_v_offset = (__pyx_v_ndim_other - __pyx_v_ndim); + + /* "View.MemoryView":1346 + * cdef int offset = ndim_other - ndim + * + * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< + * mslice.shape[i + offset] = mslice.shape[i] + * mslice.strides[i + offset] = mslice.strides[i] + */ + for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { + __pyx_v_i = __pyx_t_1; + + /* "View.MemoryView":1347 + * + * for i in range(ndim - 1, -1, -1): + * mslice.shape[i + offset] = mslice.shape[i] # <<<<<<<<<<<<<< + * mslice.strides[i + offset] = mslice.strides[i] + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] + */ + (__pyx_v_mslice->shape[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->shape[__pyx_v_i]); + + /* "View.MemoryView":1348 + * for i in range(ndim - 1, -1, -1): + * mslice.shape[i + offset] = mslice.shape[i] + * mslice.strides[i + offset] = mslice.strides[i] # <<<<<<<<<<<<<< + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] + * + */ + (__pyx_v_mslice->strides[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->strides[__pyx_v_i]); + + /* "View.MemoryView":1349 + * mslice.shape[i + offset] = mslice.shape[i] + * mslice.strides[i + offset] = mslice.strides[i] + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] # <<<<<<<<<<<<<< + * + * for i in range(offset): + */ + (__pyx_v_mslice->suboffsets[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->suboffsets[__pyx_v_i]); + } + + /* "View.MemoryView":1351 + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] + * + * for i in range(offset): # <<<<<<<<<<<<<< + * mslice.shape[i] = 1 + * mslice.strides[i] = mslice.strides[0] + */ + __pyx_t_1 = __pyx_v_offset; + __pyx_t_2 = __pyx_t_1; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_i = __pyx_t_3; + + /* "View.MemoryView":1352 + * + * for i in range(offset): + * mslice.shape[i] = 1 # <<<<<<<<<<<<<< + * mslice.strides[i] = mslice.strides[0] + * mslice.suboffsets[i] = -1 + */ + (__pyx_v_mslice->shape[__pyx_v_i]) = 1; + + /* "View.MemoryView":1353 + * for i in range(offset): + * mslice.shape[i] = 1 + * mslice.strides[i] = mslice.strides[0] # <<<<<<<<<<<<<< + * mslice.suboffsets[i] = -1 + * + */ + (__pyx_v_mslice->strides[__pyx_v_i]) = (__pyx_v_mslice->strides[0]); + + /* "View.MemoryView":1354 + * mslice.shape[i] = 1 + * mslice.strides[i] = mslice.strides[0] + * mslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< + * + * + */ + (__pyx_v_mslice->suboffsets[__pyx_v_i]) = -1L; + } + + /* "View.MemoryView":1340 + * + * @cname('__pyx_memoryview_broadcast_leading') + * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< + * int ndim, + * int ndim_other) nogil: + */ + + /* function exit code */ +} + +/* "View.MemoryView":1362 + * + * @cname('__pyx_memoryview_refcount_copying') + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< + * int ndim, bint inc) nogil: + * + */ + +static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_dtype_is_object, int __pyx_v_ndim, int __pyx_v_inc) { + int __pyx_t_1; + + /* "View.MemoryView":1366 + * + * + * if dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, + * dst.strides, ndim, inc) + */ + __pyx_t_1 = (__pyx_v_dtype_is_object != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1367 + * + * if dtype_is_object: + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, # <<<<<<<<<<<<<< + * dst.strides, ndim, inc) + * + */ + __pyx_memoryview_refcount_objects_in_slice_with_gil(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_inc); + + /* "View.MemoryView":1366 + * + * + * if dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, + * dst.strides, ndim, inc) + */ + } + + /* "View.MemoryView":1362 + * + * @cname('__pyx_memoryview_refcount_copying') + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< + * int ndim, bint inc) nogil: + * + */ + + /* function exit code */ +} + +/* "View.MemoryView":1371 + * + * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') + * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, + * bint inc) with gil: + */ + +static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) { + __Pyx_RefNannyDeclarations + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("refcount_objects_in_slice_with_gil", 0); + + /* "View.MemoryView":1374 + * Py_ssize_t *strides, int ndim, + * bint inc) with gil: + * refcount_objects_in_slice(data, shape, strides, ndim, inc) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_refcount_objects_in_slice') + */ + __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, __pyx_v_shape, __pyx_v_strides, __pyx_v_ndim, __pyx_v_inc); + + /* "View.MemoryView":1371 + * + * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') + * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, + * bint inc) with gil: + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif +} + +/* "View.MemoryView":1377 + * + * @cname('__pyx_memoryview_refcount_objects_in_slice') + * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, bint inc): + * cdef Py_ssize_t i + */ + +static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) { + CYTHON_UNUSED Py_ssize_t __pyx_v_i; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + __Pyx_RefNannySetupContext("refcount_objects_in_slice", 0); + + /* "View.MemoryView":1381 + * cdef Py_ssize_t i + * + * for i in range(shape[0]): # <<<<<<<<<<<<<< + * if ndim == 1: + * if inc: + */ + __pyx_t_1 = (__pyx_v_shape[0]); + __pyx_t_2 = __pyx_t_1; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_i = __pyx_t_3; + + /* "View.MemoryView":1382 + * + * for i in range(shape[0]): + * if ndim == 1: # <<<<<<<<<<<<<< + * if inc: + * Py_INCREF(( data)[0]) + */ + __pyx_t_4 = ((__pyx_v_ndim == 1) != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":1383 + * for i in range(shape[0]): + * if ndim == 1: + * if inc: # <<<<<<<<<<<<<< + * Py_INCREF(( data)[0]) + * else: + */ + __pyx_t_4 = (__pyx_v_inc != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":1384 + * if ndim == 1: + * if inc: + * Py_INCREF(( data)[0]) # <<<<<<<<<<<<<< + * else: + * Py_DECREF(( data)[0]) + */ + Py_INCREF((((PyObject **)__pyx_v_data)[0])); + + /* "View.MemoryView":1383 + * for i in range(shape[0]): + * if ndim == 1: + * if inc: # <<<<<<<<<<<<<< + * Py_INCREF(( data)[0]) + * else: + */ + goto __pyx_L6; + } + + /* "View.MemoryView":1386 + * Py_INCREF(( data)[0]) + * else: + * Py_DECREF(( data)[0]) # <<<<<<<<<<<<<< + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, + */ + /*else*/ { + Py_DECREF((((PyObject **)__pyx_v_data)[0])); + } + __pyx_L6:; + + /* "View.MemoryView":1382 + * + * for i in range(shape[0]): + * if ndim == 1: # <<<<<<<<<<<<<< + * if inc: + * Py_INCREF(( data)[0]) + */ + goto __pyx_L5; + } + + /* "View.MemoryView":1388 + * Py_DECREF(( data)[0]) + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< + * ndim - 1, inc) + * + */ + /*else*/ { + + /* "View.MemoryView":1389 + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, + * ndim - 1, inc) # <<<<<<<<<<<<<< + * + * data += strides[0] + */ + __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_inc); + } + __pyx_L5:; + + /* "View.MemoryView":1391 + * ndim - 1, inc) + * + * data += strides[0] # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_data = (__pyx_v_data + (__pyx_v_strides[0])); + } + + /* "View.MemoryView":1377 + * + * @cname('__pyx_memoryview_refcount_objects_in_slice') + * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, bint inc): + * cdef Py_ssize_t i + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":1397 + * + * @cname('__pyx_memoryview_slice_assign_scalar') + * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< + * size_t itemsize, void *item, + * bint dtype_is_object) nogil: + */ + +static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item, int __pyx_v_dtype_is_object) { + + /* "View.MemoryView":1400 + * size_t itemsize, void *item, + * bint dtype_is_object) nogil: + * refcount_copying(dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, + * itemsize, item) + */ + __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1401 + * bint dtype_is_object) nogil: + * refcount_copying(dst, dtype_is_object, ndim, False) + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, # <<<<<<<<<<<<<< + * itemsize, item) + * refcount_copying(dst, dtype_is_object, ndim, True) + */ + __pyx_memoryview__slice_assign_scalar(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_itemsize, __pyx_v_item); + + /* "View.MemoryView":1403 + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, + * itemsize, item) + * refcount_copying(dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< + * + * + */ + __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1397 + * + * @cname('__pyx_memoryview_slice_assign_scalar') + * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< + * size_t itemsize, void *item, + * bint dtype_is_object) nogil: + */ + + /* function exit code */ +} + +/* "View.MemoryView":1407 + * + * @cname('__pyx_memoryview__slice_assign_scalar') + * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, + * size_t itemsize, void *item) nogil: + */ + +static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item) { + CYTHON_UNUSED Py_ssize_t __pyx_v_i; + Py_ssize_t __pyx_v_stride; + Py_ssize_t __pyx_v_extent; + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + + /* "View.MemoryView":1411 + * size_t itemsize, void *item) nogil: + * cdef Py_ssize_t i + * cdef Py_ssize_t stride = strides[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t extent = shape[0] + * + */ + __pyx_v_stride = (__pyx_v_strides[0]); + + /* "View.MemoryView":1412 + * cdef Py_ssize_t i + * cdef Py_ssize_t stride = strides[0] + * cdef Py_ssize_t extent = shape[0] # <<<<<<<<<<<<<< + * + * if ndim == 1: + */ + __pyx_v_extent = (__pyx_v_shape[0]); + + /* "View.MemoryView":1414 + * cdef Py_ssize_t extent = shape[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * for i in range(extent): + * memcpy(data, item, itemsize) + */ + __pyx_t_1 = ((__pyx_v_ndim == 1) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1415 + * + * if ndim == 1: + * for i in range(extent): # <<<<<<<<<<<<<< + * memcpy(data, item, itemsize) + * data += stride + */ + __pyx_t_2 = __pyx_v_extent; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1416 + * if ndim == 1: + * for i in range(extent): + * memcpy(data, item, itemsize) # <<<<<<<<<<<<<< + * data += stride + * else: + */ + (void)(memcpy(__pyx_v_data, __pyx_v_item, __pyx_v_itemsize)); + + /* "View.MemoryView":1417 + * for i in range(extent): + * memcpy(data, item, itemsize) + * data += stride # <<<<<<<<<<<<<< + * else: + * for i in range(extent): + */ + __pyx_v_data = (__pyx_v_data + __pyx_v_stride); + } + + /* "View.MemoryView":1414 + * cdef Py_ssize_t extent = shape[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * for i in range(extent): + * memcpy(data, item, itemsize) + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1419 + * data += stride + * else: + * for i in range(extent): # <<<<<<<<<<<<<< + * _slice_assign_scalar(data, shape + 1, strides + 1, + * ndim - 1, itemsize, item) + */ + /*else*/ { + __pyx_t_2 = __pyx_v_extent; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1420 + * else: + * for i in range(extent): + * _slice_assign_scalar(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< + * ndim - 1, itemsize, item) + * data += stride + */ + __pyx_memoryview__slice_assign_scalar(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize, __pyx_v_item); + + /* "View.MemoryView":1422 + * _slice_assign_scalar(data, shape + 1, strides + 1, + * ndim - 1, itemsize, item) + * data += stride # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_data = (__pyx_v_data + __pyx_v_stride); + } + } + __pyx_L3:; + + /* "View.MemoryView":1407 + * + * @cname('__pyx_memoryview__slice_assign_scalar') + * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, + * size_t itemsize, void *item) nogil: + */ + + /* function exit code */ +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* 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 PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_Enum") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum", 0); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum != 0xb068931: # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum) + */ + __pyx_t_1 = ((__pyx_v___pyx_checksum != 0xb068931) != 0); + if (__pyx_t_1) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * 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_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_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_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 + * 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_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_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_v___pyx_PickleError); + __pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + __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); + __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) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * 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 + * 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_GOTREF(__pyx_t_2); + __pyx_t_4 = 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)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __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); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v___pyx_result = __pyx_t_3; + __pyx_t_3 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum) + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_1 = (__pyx_v___pyx_state != Py_None); + __pyx_t_6 = (__pyx_t_1 != 0); + if (__pyx_t_6) { + + /* "(tree fragment)":9 + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(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) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum) + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + * __pyx_result.name = __pyx_state[0] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum__set_state", 0); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + * __pyx_result.name = __pyx_state[0] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->name); + __Pyx_DECREF(__pyx_v___pyx_result->name); + __pyx_v___pyx_result->name = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 13, __pyx_L1_error) + } + __pyx_t_3 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_4 = ((__pyx_t_3 > 1) != 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_5 = (__pyx_t_4 != 0); + __pyx_t_2 = __pyx_t_5; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< + */ + __pyx_t_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_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_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_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __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); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static struct __pyx_vtabstruct_array __pyx_vtable_array; + +static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_array_obj *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_array_obj *)o); + p->__pyx_vtab = __pyx_vtabptr_array; + p->mode = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->_format = ((PyObject*)Py_None); Py_INCREF(Py_None); + if (unlikely(__pyx_array___cinit__(o, a, k) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_array(PyObject *o) { + struct __pyx_array_obj *p = (struct __pyx_array_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_array___dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->mode); + Py_CLEAR(p->_format); + (*Py_TYPE(o)->tp_free)(o); +} +static PyObject *__pyx_sq_item_array(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} + +static int __pyx_mp_ass_subscript_array(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_array___setitem__(o, i, v); + } + else { + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); + return -1; + } +} + +static PyObject *__pyx_tp_getattro_array(PyObject *o, PyObject *n) { + PyObject *v = __Pyx_PyObject_GenericGetAttr(o, n); + if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + v = __pyx_array___getattr__(o, n); + } + return v; +} + +static PyObject *__pyx_getprop___pyx_array_memview(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(o); +} + +static PyMethodDef __pyx_methods_array[] = { + {"__getattr__", (PyCFunction)__pyx_array___getattr__, METH_O|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_array_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_array_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_array[] = { + {(char *)"memview", __pyx_getprop___pyx_array_memview, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PySequenceMethods __pyx_tp_as_sequence_array = { + __pyx_array___len__, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_array, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_array = { + __pyx_array___len__, /*mp_length*/ + __pyx_array___getitem__, /*mp_subscript*/ + __pyx_mp_ass_subscript_array, /*mp_ass_subscript*/ +}; + +static PyBufferProcs __pyx_tp_as_buffer_array = { + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getreadbuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getwritebuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getsegcount*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getcharbuffer*/ + #endif + __pyx_array_getbuffer, /*bf_getbuffer*/ + 0, /*bf_releasebuffer*/ +}; + +static PyTypeObject __pyx_type___pyx_array = { + PyVarObject_HEAD_INIT(0, 0) + "core.array", /*tp_name*/ + sizeof(struct __pyx_array_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_array, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_array, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_array, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + __pyx_tp_getattro_array, /*tp_getattro*/ + 0, /*tp_setattro*/ + &__pyx_tp_as_buffer_array, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_array, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_array, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_array, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif +}; + +static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_MemviewEnum_obj *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_MemviewEnum_obj *)o); + p->name = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_Enum(PyObject *o) { + struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->name); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_Enum(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; + if (p->name) { + e = (*v)(p->name, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_Enum(PyObject *o) { + PyObject* tmp; + struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; + tmp = ((PyObject*)p->name); + p->name = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyMethodDef __pyx_methods_Enum[] = { + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type___pyx_MemviewEnum = { + PyVarObject_HEAD_INIT(0, 0) + "core.Enum", /*tp_name*/ + sizeof(struct __pyx_MemviewEnum_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_Enum, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_MemviewEnum___repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_Enum, /*tp_traverse*/ + __pyx_tp_clear_Enum, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_Enum, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_MemviewEnum___init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_Enum, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif +}; +static struct __pyx_vtabstruct_memoryview __pyx_vtable_memoryview; + +static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_memoryview_obj *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_memoryview_obj *)o); + p->__pyx_vtab = __pyx_vtabptr_memoryview; + p->obj = Py_None; Py_INCREF(Py_None); + p->_size = Py_None; Py_INCREF(Py_None); + p->_array_interface = Py_None; Py_INCREF(Py_None); + p->view.obj = NULL; + if (unlikely(__pyx_memoryview___cinit__(o, a, k) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_memoryview(PyObject *o) { + struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_memoryview___dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->obj); + Py_CLEAR(p->_size); + Py_CLEAR(p->_array_interface); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_memoryview(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; + if (p->obj) { + e = (*v)(p->obj, a); if (e) return e; + } + if (p->_size) { + e = (*v)(p->_size, a); if (e) return e; + } + if (p->_array_interface) { + e = (*v)(p->_array_interface, a); if (e) return e; + } + if (p->view.obj) { + e = (*v)(p->view.obj, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_memoryview(PyObject *o) { + PyObject* tmp; + struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; + tmp = ((PyObject*)p->obj); + p->obj = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_size); + p->_size = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_array_interface); + p->_array_interface = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + Py_CLEAR(p->view.obj); + return 0; +} +static PyObject *__pyx_sq_item_memoryview(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} + +static int __pyx_mp_ass_subscript_memoryview(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_memoryview___setitem__(o, i, v); + } + else { + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); + return -1; + } +} + +static PyObject *__pyx_getprop___pyx_memoryview_T(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_base(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_shape(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_strides(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_suboffsets(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_ndim(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_itemsize(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_nbytes(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_size(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(o); +} + +static PyMethodDef __pyx_methods_memoryview[] = { + {"is_c_contig", (PyCFunction)__pyx_memoryview_is_c_contig, METH_NOARGS, 0}, + {"is_f_contig", (PyCFunction)__pyx_memoryview_is_f_contig, METH_NOARGS, 0}, + {"copy", (PyCFunction)__pyx_memoryview_copy, METH_NOARGS, 0}, + {"copy_fortran", (PyCFunction)__pyx_memoryview_copy_fortran, METH_NOARGS, 0}, + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_memoryview[] = { + {(char *)"T", __pyx_getprop___pyx_memoryview_T, 0, (char *)0, 0}, + {(char *)"base", __pyx_getprop___pyx_memoryview_base, 0, (char *)0, 0}, + {(char *)"shape", __pyx_getprop___pyx_memoryview_shape, 0, (char *)0, 0}, + {(char *)"strides", __pyx_getprop___pyx_memoryview_strides, 0, (char *)0, 0}, + {(char *)"suboffsets", __pyx_getprop___pyx_memoryview_suboffsets, 0, (char *)0, 0}, + {(char *)"ndim", __pyx_getprop___pyx_memoryview_ndim, 0, (char *)0, 0}, + {(char *)"itemsize", __pyx_getprop___pyx_memoryview_itemsize, 0, (char *)0, 0}, + {(char *)"nbytes", __pyx_getprop___pyx_memoryview_nbytes, 0, (char *)0, 0}, + {(char *)"size", __pyx_getprop___pyx_memoryview_size, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PySequenceMethods __pyx_tp_as_sequence_memoryview = { + __pyx_memoryview___len__, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_memoryview, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_memoryview = { + __pyx_memoryview___len__, /*mp_length*/ + __pyx_memoryview___getitem__, /*mp_subscript*/ + __pyx_mp_ass_subscript_memoryview, /*mp_ass_subscript*/ +}; + +static PyBufferProcs __pyx_tp_as_buffer_memoryview = { + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getreadbuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getwritebuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getsegcount*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getcharbuffer*/ + #endif + __pyx_memoryview_getbuffer, /*bf_getbuffer*/ + 0, /*bf_releasebuffer*/ +}; + +static PyTypeObject __pyx_type___pyx_memoryview = { + PyVarObject_HEAD_INIT(0, 0) + "core.memoryview", /*tp_name*/ + sizeof(struct __pyx_memoryview_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_memoryview, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_memoryview___repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_memoryview, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_memoryview, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + __pyx_memoryview___str__, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + &__pyx_tp_as_buffer_memoryview, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_memoryview, /*tp_traverse*/ + __pyx_tp_clear_memoryview, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_memoryview, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_memoryview, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_memoryview, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif +}; +static struct __pyx_vtabstruct__memoryviewslice __pyx_vtable__memoryviewslice; + +static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_memoryviewslice_obj *p; + PyObject *o = __pyx_tp_new_memoryview(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_memoryviewslice_obj *)o); + p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_memoryview*)__pyx_vtabptr__memoryviewslice; + p->from_object = Py_None; Py_INCREF(Py_None); + p->from_slice.memview = NULL; + return o; +} + +static void __pyx_tp_dealloc__memoryviewslice(PyObject *o) { + struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_memoryviewslice___dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->from_object); + PyObject_GC_Track(o); + __pyx_tp_dealloc_memoryview(o); +} + +static int __pyx_tp_traverse__memoryviewslice(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; + e = __pyx_tp_traverse_memoryview(o, v, a); if (e) return e; + if (p->from_object) { + e = (*v)(p->from_object, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear__memoryviewslice(PyObject *o) { + PyObject* tmp; + struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; + __pyx_tp_clear_memoryview(o); + tmp = ((PyObject*)p->from_object); + p->from_object = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + __PYX_XDEC_MEMVIEW(&p->from_slice, 1); + return 0; +} + +static PyObject *__pyx_getprop___pyx_memoryviewslice_base(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(o); +} + +static PyMethodDef __pyx_methods__memoryviewslice[] = { + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets__memoryviewslice[] = { + {(char *)"base", __pyx_getprop___pyx_memoryviewslice_base, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type___pyx_memoryviewslice = { + PyVarObject_HEAD_INIT(0, 0) + "core._memoryviewslice", /*tp_name*/ + sizeof(struct __pyx_memoryviewslice_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc__memoryviewslice, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + #if CYTHON_COMPILING_IN_PYPY + __pyx_memoryview___repr__, /*tp_repr*/ + #else + 0, /*tp_repr*/ + #endif + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + #if CYTHON_COMPILING_IN_PYPY + __pyx_memoryview___str__, /*tp_str*/ + #else + 0, /*tp_str*/ + #endif + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + "Internal class for passing memoryview slices to Python", /*tp_doc*/ + __pyx_tp_traverse__memoryviewslice, /*tp_traverse*/ + __pyx_tp_clear__memoryviewslice, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods__memoryviewslice, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets__memoryviewslice, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new__memoryviewslice, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif +}; + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_core(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_core}, + {0, NULL} +}; +#endif + +static struct PyModuleDef __pyx_moduledef = { + PyModuleDef_HEAD_INIT, + "core", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif +#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}, + {&__pyx_kp_s_Buffer_view_does_not_expose_stri, __pyx_k_Buffer_view_does_not_expose_stri, sizeof(__pyx_k_Buffer_view_does_not_expose_stri), 0, 0, 1, 0}, + {&__pyx_kp_s_Can_only_create_a_buffer_that_is, __pyx_k_Can_only_create_a_buffer_that_is, sizeof(__pyx_k_Can_only_create_a_buffer_that_is), 0, 0, 1, 0}, + {&__pyx_kp_s_Cannot_assign_to_read_only_memor, __pyx_k_Cannot_assign_to_read_only_memor, sizeof(__pyx_k_Cannot_assign_to_read_only_memor), 0, 0, 1, 0}, + {&__pyx_kp_s_Cannot_create_writable_memory_vi, __pyx_k_Cannot_create_writable_memory_vi, sizeof(__pyx_k_Cannot_create_writable_memory_vi), 0, 0, 1, 0}, + {&__pyx_kp_s_Cannot_index_with_type_s, __pyx_k_Cannot_index_with_type_s, sizeof(__pyx_k_Cannot_index_with_type_s), 0, 0, 1, 0}, + {&__pyx_n_s_Ellipsis, __pyx_k_Ellipsis, sizeof(__pyx_k_Ellipsis), 0, 0, 1, 1}, + {&__pyx_kp_s_Empty_shape_tuple_for_cython_arr, __pyx_k_Empty_shape_tuple_for_cython_arr, sizeof(__pyx_k_Empty_shape_tuple_for_cython_arr), 0, 0, 1, 0}, + {&__pyx_kp_s_Incompatible_checksums_s_vs_0xb0, __pyx_k_Incompatible_checksums_s_vs_0xb0, sizeof(__pyx_k_Incompatible_checksums_s_vs_0xb0), 0, 0, 1, 0}, + {&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1}, + {&__pyx_kp_s_Indirect_dimensions_not_supporte, __pyx_k_Indirect_dimensions_not_supporte, sizeof(__pyx_k_Indirect_dimensions_not_supporte), 0, 0, 1, 0}, + {&__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_k_Invalid_mode_expected_c_or_fortr, sizeof(__pyx_k_Invalid_mode_expected_c_or_fortr), 0, 0, 1, 0}, + {&__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_k_Invalid_shape_in_axis_d_d, sizeof(__pyx_k_Invalid_shape_in_axis_d_d), 0, 0, 1, 0}, + {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, + {&__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_k_MemoryView_of_r_at_0x_x, sizeof(__pyx_k_MemoryView_of_r_at_0x_x), 0, 0, 1, 0}, + {&__pyx_kp_s_MemoryView_of_r_object, __pyx_k_MemoryView_of_r_object, sizeof(__pyx_k_MemoryView_of_r_object), 0, 0, 1, 0}, + {&__pyx_n_b_O, __pyx_k_O, sizeof(__pyx_k_O), 0, 0, 0, 1}, + {&__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_k_Out_of_bounds_on_buffer_access_a, sizeof(__pyx_k_Out_of_bounds_on_buffer_access_a), 0, 0, 1, 0}, + {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_kp_s_Unable_to_convert_item_to_object, __pyx_k_Unable_to_convert_item_to_object, sizeof(__pyx_k_Unable_to_convert_item_to_object), 0, 0, 1, 0}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_View_MemoryView, __pyx_k_View_MemoryView, sizeof(__pyx_k_View_MemoryView), 0, 0, 1, 1}, + {&__pyx_n_s_X, __pyx_k_X, sizeof(__pyx_k_X), 0, 0, 1, 1}, + {&__pyx_n_s_accum_n, __pyx_k_accum_n, sizeof(__pyx_k_accum_n), 0, 0, 1, 1}, + {&__pyx_n_s_accum_w, __pyx_k_accum_w, sizeof(__pyx_k_accum_w), 0, 0, 1, 1}, + {&__pyx_n_s_activation, __pyx_k_activation, sizeof(__pyx_k_activation), 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_alp, __pyx_k_alp, sizeof(__pyx_k_alp), 0, 0, 1, 1}, + {&__pyx_n_s_alpha, __pyx_k_alpha, sizeof(__pyx_k_alpha), 0, 0, 1, 1}, + {&__pyx_n_s_an, __pyx_k_an, sizeof(__pyx_k_an), 0, 0, 1, 1}, + {&__pyx_n_s_base, __pyx_k_base, sizeof(__pyx_k_base), 0, 0, 1, 1}, + {&__pyx_n_s_best, __pyx_k_best, sizeof(__pyx_k_best), 0, 0, 1, 1}, + {&__pyx_n_s_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 0, 1, 1}, + {&__pyx_n_u_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 1, 0, 1}, + {&__pyx_n_s_class, __pyx_k_class, sizeof(__pyx_k_class), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_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_core, __pyx_k_core, sizeof(__pyx_k_core), 0, 0, 1, 1}, + {&__pyx_n_s_count_modified_cells, __pyx_k_count_modified_cells, sizeof(__pyx_k_count_modified_cells), 0, 0, 1, 1}, + {&__pyx_n_s_create_map_batch, __pyx_k_create_map_batch, sizeof(__pyx_k_create_map_batch), 0, 0, 1, 1}, + {&__pyx_n_s_create_map_online, __pyx_k_create_map_online, sizeof(__pyx_k_create_map_online), 0, 0, 1, 1}, + {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, + {&__pyx_n_s_dist_lib, __pyx_k_dist_lib, sizeof(__pyx_k_dist_lib), 0, 0, 1, 1}, + {&__pyx_n_s_dtype_is_object, __pyx_k_dtype_is_object, sizeof(__pyx_k_dtype_is_object), 0, 0, 1, 1}, + {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1}, + {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1}, + {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1}, + {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1}, + {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1}, + {&__pyx_n_s_fortran, __pyx_k_fortran, sizeof(__pyx_k_fortran), 0, 0, 1, 1}, + {&__pyx_n_u_fortran, __pyx_k_fortran, sizeof(__pyx_k_fortran), 0, 1, 0, 1}, + {&__pyx_n_s_get_best_cell, __pyx_k_get_best_cell, sizeof(__pyx_k_get_best_cell), 0, 0, 1, 1}, + {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, + {&__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_k_got_differing_extents_in_dimensi, sizeof(__pyx_k_got_differing_extents_in_dimensi), 0, 0, 1, 0}, + {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, + {&__pyx_n_s_id, __pyx_k_id, sizeof(__pyx_k_id), 0, 0, 1, 1}, + {&__pyx_n_s_imp, __pyx_k_imp, sizeof(__pyx_k_imp), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_importance, __pyx_k_importance, sizeof(__pyx_k_importance), 0, 0, 1, 1}, + {&__pyx_n_s_inputs, __pyx_k_inputs, sizeof(__pyx_k_inputs), 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_j, __pyx_k_j, sizeof(__pyx_k_j), 0, 0, 1, 1}, + {&__pyx_n_s_k, __pyx_k_k, sizeof(__pyx_k_k), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_memview, __pyx_k_memview, sizeof(__pyx_k_memview), 0, 0, 1, 1}, + {&__pyx_n_s_mode, __pyx_k_mode, sizeof(__pyx_k_mode), 0, 0, 1, 1}, + {&__pyx_n_s_n_col, __pyx_k_n_col, sizeof(__pyx_k_n_col), 0, 0, 1, 1}, + {&__pyx_n_s_n_pix, __pyx_k_n_pix, sizeof(__pyx_k_n_pix), 0, 0, 1, 1}, + {&__pyx_n_s_n_row, __pyx_k_n_row, sizeof(__pyx_k_n_row), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, + {&__pyx_n_s_nc, __pyx_k_nc, sizeof(__pyx_k_nc), 0, 0, 1, 1}, + {&__pyx_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 0, 0, 1, 1}, + {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, + {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, + {&__pyx_n_s_npix, __pyx_k_npix, sizeof(__pyx_k_npix), 0, 0, 1, 1}, + {&__pyx_n_s_nr, __pyx_k_nr, sizeof(__pyx_k_nr), 0, 0, 1, 1}, + {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, + {&__pyx_n_s_obj, __pyx_k_obj, sizeof(__pyx_k_obj), 0, 0, 1, 1}, + {&__pyx_n_s_pack, __pyx_k_pack, sizeof(__pyx_k_pack), 0, 0, 1, 1}, + {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_PickleError, __pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_checksum, __pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_getbuffer, __pyx_k_pyx_getbuffer, sizeof(__pyx_k_pyx_getbuffer), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_result, __pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_type, __pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_Enum, __pyx_k_pyx_unpickle_Enum, sizeof(__pyx_k_pyx_unpickle_Enum), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, + {&__pyx_n_s_random_indices, __pyx_k_random_indices, sizeof(__pyx_k_random_indices), 0, 0, 1, 1}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, + {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, + {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, + {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_shape, __pyx_k_shape, sizeof(__pyx_k_shape), 0, 0, 1, 1}, + {&__pyx_n_s_sig, __pyx_k_sig, sizeof(__pyx_k_sig), 0, 0, 1, 1}, + {&__pyx_n_s_sigma, __pyx_k_sigma, sizeof(__pyx_k_sigma), 0, 0, 1, 1}, + {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1}, + {&__pyx_kp_s_somsphere_cython_core_pyx, __pyx_k_somsphere_cython_core_pyx, sizeof(__pyx_k_somsphere_cython_core_pyx), 0, 0, 1, 0}, + {&__pyx_n_s_somsphere_utils, __pyx_k_somsphere_utils, sizeof(__pyx_k_somsphere_utils), 0, 0, 1, 1}, + {&__pyx_n_s_start, __pyx_k_start, sizeof(__pyx_k_start), 0, 0, 1, 1}, + {&__pyx_n_s_step, __pyx_k_step, sizeof(__pyx_k_step), 0, 0, 1, 1}, + {&__pyx_n_s_stop, __pyx_k_stop, sizeof(__pyx_k_stop), 0, 0, 1, 1}, + {&__pyx_kp_s_strided_and_direct, __pyx_k_strided_and_direct, sizeof(__pyx_k_strided_and_direct), 0, 0, 1, 0}, + {&__pyx_kp_s_strided_and_direct_or_indirect, __pyx_k_strided_and_direct_or_indirect, sizeof(__pyx_k_strided_and_direct_or_indirect), 0, 0, 1, 0}, + {&__pyx_kp_s_strided_and_indirect, __pyx_k_strided_and_indirect, sizeof(__pyx_k_strided_and_indirect), 0, 0, 1, 0}, + {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, + {&__pyx_n_s_struct, __pyx_k_struct, sizeof(__pyx_k_struct), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_timeit, __pyx_k_timeit, sizeof(__pyx_k_timeit), 0, 0, 1, 1}, + {&__pyx_n_s_transpose, __pyx_k_transpose, sizeof(__pyx_k_transpose), 0, 0, 1, 1}, + {&__pyx_kp_s_unable_to_allocate_array_data, __pyx_k_unable_to_allocate_array_data, sizeof(__pyx_k_unable_to_allocate_array_data), 0, 0, 1, 0}, + {&__pyx_kp_s_unable_to_allocate_shape_and_str, __pyx_k_unable_to_allocate_shape_and_str, sizeof(__pyx_k_unable_to_allocate_shape_and_str), 0, 0, 1, 0}, + {&__pyx_n_s_unpack, __pyx_k_unpack, sizeof(__pyx_k_unpack), 0, 0, 1, 1}, + {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, + {&__pyx_n_s_weights, __pyx_k_weights, sizeof(__pyx_k_weights), 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, 14, __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) + __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, 404, __pyx_L1_error) + __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(1, 613, __pyx_L1_error) + __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(1, 832, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "core.pyx":19 + * weights=weights, n_pix=npix) + * for j in range(nc): + * accum_w[j, :] += count_modified_cells(best, dist_lib, sig) * inputs[j] # <<<<<<<<<<<<<< + * an += count_modified_cells(best, dist_lib, sig) + * + */ + __pyx_slice_ = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice_)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice_); + __Pyx_GIVEREF(__pyx_slice_); + + /* "View.MemoryView":133 + * + * if not self.ndim: + * raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<< + * + * if itemsize <= 0: + */ + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_Empty_shape_tuple_for_cython_arr); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "View.MemoryView":136 + * + * if itemsize <= 0: + * raise ValueError("itemsize <= 0 for cython.array") # <<<<<<<<<<<<<< + * + * if not isinstance(format, bytes): + */ + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s_itemsize_0_for_cython_array); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "View.MemoryView":148 + * + * if not self._shape: + * raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_shape_and_str); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "View.MemoryView":176 + * self.data = malloc(self.len) + * if not self.data: + * raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<< + * + * if self.dtype_is_object: + */ + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_array_data); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "View.MemoryView":192 + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): + * raise ValueError("Can only create a buffer that is contiguous in memory.") # <<<<<<<<<<<<<< + * info.buf = self.data + * info.len = self.len + */ + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_Can_only_create_a_buffer_that_is); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + + /* "(tree fragment)":4 + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + */ + __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + + /* "View.MemoryView":418 + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<< + * + * have_slices, index = _unellipsify(index, self.view.ndim) + */ + __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_Cannot_assign_to_read_only_memor); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 418, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); + + /* "View.MemoryView":495 + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + * raise ValueError("Unable to convert item to object") # <<<<<<<<<<<<<< + * else: + * if len(self.view.format) == 1: + */ + __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_Unable_to_convert_item_to_object); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 495, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + + /* "View.MemoryView":520 + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: + * raise ValueError("Cannot create writable memory view from read-only memoryview") # <<<<<<<<<<<<<< + * + * if flags & PyBUF_ND: + */ + __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_Cannot_create_writable_memory_vi); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 520, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + + /* "View.MemoryView":570 + * if self.view.strides == NULL: + * + * raise ValueError("Buffer view does not expose strides") # <<<<<<<<<<<<<< + * + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) + */ + __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_s_Buffer_view_does_not_expose_stri); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 570, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + + /* "View.MemoryView":577 + * def suboffsets(self): + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< + * + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) + */ + __pyx_tuple__13 = PyTuple_New(1); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 577, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_INCREF(__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_int_neg_1); + PyTuple_SET_ITEM(__pyx_tuple__13, 0, __pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_tuple__13); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__14); + __Pyx_GIVEREF(__pyx_tuple__14); + + /* "(tree fragment)":4 + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + */ + __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__15); + __Pyx_GIVEREF(__pyx_tuple__15); + + /* "View.MemoryView":703 + * 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, 703, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__16); + __Pyx_GIVEREF(__pyx_tuple__16); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + __pyx_tuple__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); + + /* "(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); + + /* "core.pyx":6 + * from somsphere.utils import get_best_cell, count_modified_cells, timeit + * + * def create_map_batch(X, n_row, n_col, accum_w, accum_n, sigma, importance, n_pix, dist_lib, weights): # <<<<<<<<<<<<<< + * cdef int i, j, k + * cdef int nr = n_row + */ + __pyx_tuple__19 = PyTuple_Pack(22, __pyx_n_s_X, __pyx_n_s_n_row, __pyx_n_s_n_col, __pyx_n_s_accum_w, __pyx_n_s_accum_n, __pyx_n_s_sigma, __pyx_n_s_importance, __pyx_n_s_n_pix, __pyx_n_s_dist_lib, __pyx_n_s_weights, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_k, __pyx_n_s_nr, __pyx_n_s_nc, __pyx_n_s_npix, __pyx_n_s_sig, __pyx_n_s_imp, __pyx_n_s_an, __pyx_n_s_inputs, __pyx_n_s_best, __pyx_n_s_activation); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__19); + __Pyx_GIVEREF(__pyx_tuple__19); + __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(10, 0, 22, 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_somsphere_cython_core_pyx, __pyx_n_s_create_map_batch, 6, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(0, 6, __pyx_L1_error) + + /* "core.pyx":25 + * weights[k] = accum_w[k] / an + * + * def create_map_online(X, n_row, alpha, sigma, random_indices, importance, n_pix, dist_lib, weights): # <<<<<<<<<<<<<< + * cdef int i + * cdef int nr = n_row + */ + __pyx_tuple__21 = PyTuple_Pack(18, __pyx_n_s_X, __pyx_n_s_n_row, __pyx_n_s_alpha, __pyx_n_s_sigma, __pyx_n_s_random_indices, __pyx_n_s_importance, __pyx_n_s_n_pix, __pyx_n_s_dist_lib, __pyx_n_s_weights, __pyx_n_s_i, __pyx_n_s_nr, __pyx_n_s_npix, __pyx_n_s_alp, __pyx_n_s_sig, __pyx_n_s_imp, __pyx_n_s_inputs, __pyx_n_s_best, __pyx_n_s_activation); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__21); + __Pyx_GIVEREF(__pyx_tuple__21); + __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(9, 0, 18, 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_somsphere_cython_core_pyx, __pyx_n_s_create_map_online, 25, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 25, __pyx_L1_error) + + /* "View.MemoryView":286 + * 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); + + /* "View.MemoryView":287 + * + * 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); + + /* "View.MemoryView":288 + * 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); + + /* "View.MemoryView":291 + * + * + * 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); + + /* "View.MemoryView":292 + * + * 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); + + /* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + __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_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_184977713 = PyInt_FromLong(184977713L); if (unlikely(!__pyx_int_184977713)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ + +static int __Pyx_modinit_global_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + generic = Py_None; Py_INCREF(Py_None); + strided = Py_None; Py_INCREF(Py_None); + indirect = Py_None; Py_INCREF(Py_None); + contiguous = Py_None; Py_INCREF(Py_None); + indirect_contiguous = Py_None; Py_INCREF(Py_None); + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_init_code(void) { + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + __pyx_vtabptr_array = &__pyx_vtable_array; + __pyx_vtable_array.get_memview = (PyObject *(*)(struct __pyx_array_obj *))__pyx_array_get_memview; + if (PyType_Ready(&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 105, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_type___pyx_array.tp_print = 0; + #endif + 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) + __pyx_array_type = &__pyx_type___pyx_array; + if (PyType_Ready(&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(1, 279, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_type___pyx_MemviewEnum.tp_print = 0; + #endif + 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) + __pyx_MemviewEnum_type = &__pyx_type___pyx_MemviewEnum; + __pyx_vtabptr_memoryview = &__pyx_vtable_memoryview; + __pyx_vtable_memoryview.get_item_pointer = (char *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_get_item_pointer; + __pyx_vtable_memoryview.is_slice = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_is_slice; + __pyx_vtable_memoryview.setitem_slice_assignment = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_slice_assignment; + __pyx_vtable_memoryview.setitem_slice_assign_scalar = (PyObject *(*)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_setitem_slice_assign_scalar; + __pyx_vtable_memoryview.setitem_indexed = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_indexed; + __pyx_vtable_memoryview.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryview_convert_item_to_object; + __pyx_vtable_memoryview.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryview_assign_item_from_object; + if (PyType_Ready(&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 330, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_type___pyx_memoryview.tp_print = 0; + #endif + 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) + __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, 965, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_type___pyx_memoryviewslice.tp_print = 0; + #endif + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryviewslice.tp_dictoffset && __pyx_type___pyx_memoryviewslice.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type___pyx_memoryviewslice.tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + if (__Pyx_SetVtable(__pyx_type___pyx_memoryviewslice.tp_dict, __pyx_vtabptr__memoryviewslice) < 0) __PYX_ERR(1, 965, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 965, __pyx_L1_error) + __pyx_memoryviewslice_type = &__pyx_type___pyx_memoryviewslice; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_type_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + + +#ifndef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void +#else +#define __Pyx_PyMODINIT_FUNC void +#endif +#else +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * +#else +#define __Pyx_PyMODINIT_FUNC PyObject * +#endif +#endif + + +#if PY_MAJOR_VERSION < 3 +__Pyx_PyMODINIT_FUNC initcore(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC initcore(void) +#else +__Pyx_PyMODINIT_FUNC PyInit_core(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_core(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + #if PY_VERSION_HEX >= 0x030700A1 + static PY_INT64_T main_interpreter_id = -1; + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); + if (main_interpreter_id == -1) { + main_interpreter_id = current_id; + return (unlikely(current_id == -1)) ? -1 : 0; + } else if (unlikely(main_interpreter_id != current_id)) + #else + static PyInterpreterState *main_interpreter = NULL; + PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; + if (!main_interpreter) { + main_interpreter = current_interpreter; + } else if (unlikely(main_interpreter != current_interpreter)) + #endif + { + PyErr_SetString( + PyExc_ImportError, + "Interpreter change detected - this module can only be loaded into one interpreter per process."); + return -1; + } + return 0; +} +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) { + 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); + } + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, 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"); + if (unlikely(!modname)) goto bad; + module = PyModule_NewObject(modname); + Py_DECREF(modname); + if (unlikely(!module)) goto bad; + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; + return module; +bad: + Py_XDECREF(module); + return NULL; +} + + +static CYTHON_SMALL_CODE int __pyx_pymod_exec_core(PyObject *__pyx_pyinit_module) +#endif +#endif +{ + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + static PyThread_type_lock __pyx_t_3[8]; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module 'core' has already been imported. Re-initialisation is not supported."); + return -1; + } + #elif PY_MAJOR_VERSION >= 3 + if (__pyx_m) return __Pyx_NewRef(__pyx_m); + #endif + #if CYTHON_REFNANNY +__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); +if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); +} +#endif + __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_core(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pxy_PyFrame_Initialize_Offsets + __Pxy_PyFrame_Initialize_Offsets(); + #endif + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("core", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_b); + __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_cython_runtime); + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_core) { + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "core")) { + if (unlikely(PyDict_SetItemString(modules, "core", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_global_init_code(); + (void)__Pyx_modinit_variable_export_code(); + (void)__Pyx_modinit_function_export_code(); + if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_type_import_code(); + (void)__Pyx_modinit_variable_import_code(); + (void)__Pyx_modinit_function_import_code(); + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + + /* "core.pyx":2 + * #cython: language_level=3 + * import numpy # <<<<<<<<<<<<<< + * + * from somsphere.utils import get_best_cell, count_modified_cells, timeit + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_numpy, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "core.pyx":4 + * import numpy + * + * from somsphere.utils import get_best_cell, count_modified_cells, timeit # <<<<<<<<<<<<<< + * + * def create_map_batch(X, n_row, n_col, accum_w, accum_n, sigma, importance, n_pix, dist_lib, weights): + */ + __pyx_t_1 = PyList_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_get_best_cell); + __Pyx_GIVEREF(__pyx_n_s_get_best_cell); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_get_best_cell); + __Pyx_INCREF(__pyx_n_s_count_modified_cells); + __Pyx_GIVEREF(__pyx_n_s_count_modified_cells); + PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_count_modified_cells); + __Pyx_INCREF(__pyx_n_s_timeit); + __Pyx_GIVEREF(__pyx_n_s_timeit); + PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_timeit); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_somsphere_utils, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_get_best_cell); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_best_cell, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_count_modified_cells); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_count_modified_cells, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_timeit); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_timeit, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "core.pyx":6 + * from somsphere.utils import get_best_cell, count_modified_cells, timeit + * + * def create_map_batch(X, n_row, n_col, accum_w, accum_n, sigma, importance, n_pix, dist_lib, weights): # <<<<<<<<<<<<<< + * cdef int i, j, k + * cdef int nr = n_row + */ + __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_4core_1create_map_batch, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_create_map_batch, __pyx_t_2) < 0) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "core.pyx":25 + * weights[k] = accum_w[k] / an + * + * def create_map_online(X, n_row, alpha, sigma, random_indices, importance, n_pix, dist_lib, weights): # <<<<<<<<<<<<<< + * cdef int i + * cdef int nr = n_row + */ + __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_4core_3create_map_online, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_create_map_online, __pyx_t_2) < 0) __PYX_ERR(0, 25, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "core.pyx":1 + * #cython: language_level=3 # <<<<<<<<<<<<<< + * import numpy + * + */ + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":209 + * info.obj = self + * + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< + * + * def __dealloc__(array self): + */ + __pyx_t_2 = __pyx_capsule_create(((void *)(&__pyx_array_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem((PyObject *)__pyx_array_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_2) < 0) __PYX_ERR(1, 209, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_array_type); + + /* "View.MemoryView":286 + * return self.name + * + * cdef generic = Enum("") # <<<<<<<<<<<<<< + * cdef strided = Enum("") # default + * cdef indirect = Enum("") + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XGOTREF(generic); + __Pyx_DECREF_SET(generic, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":287 + * + * cdef generic = Enum("") + * cdef strided = Enum("") # default # <<<<<<<<<<<<<< + * cdef indirect = Enum("") + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XGOTREF(strided); + __Pyx_DECREF_SET(strided, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":288 + * cdef generic = Enum("") + * cdef strided = Enum("") # default + * cdef indirect = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XGOTREF(indirect); + __Pyx_DECREF_SET(indirect, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":291 + * + * + * cdef contiguous = Enum("") # <<<<<<<<<<<<<< + * cdef indirect_contiguous = Enum("") + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XGOTREF(contiguous); + __Pyx_DECREF_SET(contiguous, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":292 + * + * cdef contiguous = Enum("") + * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__27, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XGOTREF(indirect_contiguous); + __Pyx_DECREF_SET(indirect_contiguous, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":316 + * + * DEF THREAD_LOCKS_PREALLOCATED = 8 + * cdef int __pyx_memoryview_thread_locks_used = 0 # <<<<<<<<<<<<<< + * cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [ + * PyThread_allocate_lock(), + */ + __pyx_memoryview_thread_locks_used = 0; + + /* "View.MemoryView":317 + * DEF THREAD_LOCKS_PREALLOCATED = 8 + * cdef int __pyx_memoryview_thread_locks_used = 0 + * cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [ # <<<<<<<<<<<<<< + * PyThread_allocate_lock(), + * PyThread_allocate_lock(), + */ + __pyx_t_3[0] = PyThread_allocate_lock(); + __pyx_t_3[1] = PyThread_allocate_lock(); + __pyx_t_3[2] = PyThread_allocate_lock(); + __pyx_t_3[3] = PyThread_allocate_lock(); + __pyx_t_3[4] = PyThread_allocate_lock(); + __pyx_t_3[5] = PyThread_allocate_lock(); + __pyx_t_3[6] = PyThread_allocate_lock(); + __pyx_t_3[7] = PyThread_allocate_lock(); + memcpy(&(__pyx_memoryview_thread_locks[0]), __pyx_t_3, sizeof(__pyx_memoryview_thread_locks[0]) * (8)); + + /* "View.MemoryView":549 + * info.obj = self + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 549, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem((PyObject *)__pyx_memoryview_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_2) < 0) __PYX_ERR(1, 549, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_memoryview_type); + + /* "View.MemoryView":995 + * return self.from_object + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 995, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem((PyObject *)__pyx_memoryviewslice_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_2) < 0) __PYX_ERR(1, 995, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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 + */ + __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum, NULL, __pyx_n_s_View_MemoryView); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Enum, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":11 + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init core", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_CLEAR(__pyx_m); + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init core"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #elif PY_MAJOR_VERSION >= 3 + return __pyx_m; + #else + return; + #endif +} + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule(modname); if (!m) goto end; @@ -2022,742 +18038,1984 @@ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } -#endif - -/* RaiseArgTupleInvalid */ -static void __Pyx_RaiseArgtupleInvalid( - const char* func_name, - int exact, - Py_ssize_t num_min, - Py_ssize_t num_max, - Py_ssize_t num_found) -{ - Py_ssize_t num_expected; - const char *more_or_less; - if (num_found < num_min) { - num_expected = num_min; - more_or_less = "at least"; +#endif + +/* PyObjectGetAttrStr */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* RaiseArgTupleInvalid */ +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* RaiseDoubleKeywords */ +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +/* ParseKeywords */ +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +/* GetItemInt */ +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (!j) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyList_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyTuple_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { + PyObject *r = PyList_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return m->sq_item(o, i); + } + } +#else + if (is_list || PySequence_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} + +/* PyDictVersioning */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { + PyObject **dictptr = NULL; + Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; + if (offset) { +#if CYTHON_COMPILING_IN_CPYTHON + dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); +#else + dictptr = _PyObject_GetDictPtr(obj); +#endif + } + return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; +} +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) + return 0; + return obj_dict_version == __Pyx_get_object_dict_version(obj); +} +#endif + +/* GetModuleGlobalName */ +#if CYTHON_USE_DICT_VERSIONS +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) +#else +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) +#endif +{ + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 + result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } else if (unlikely(PyErr_Occurred())) { + return NULL; + } +#else + result = PyDict_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } +#endif +#else + result = PyObject_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); +} + +/* PyObjectCall */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* RaiseTooManyValuesToUnpack */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +/* RaiseNeedMoreValuesToUnpack */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +/* IterFinish */ +static CYTHON_INLINE int __Pyx_IterFinish(void) { +#if CYTHON_FAST_THREAD_STATE + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* exc_type = tstate->curexc_type; + if (unlikely(exc_type)) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) { + PyObject *exc_value, *exc_tb; + exc_value = tstate->curexc_value; + exc_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; + Py_DECREF(exc_type); + Py_XDECREF(exc_value); + Py_XDECREF(exc_tb); + return 0; + } else { + return -1; + } + } + return 0; +#else + if (unlikely(PyErr_Occurred())) { + if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { + PyErr_Clear(); + return 0; + } else { + return -1; + } + } + return 0; +#endif +} + +/* UnpackItemEndCheck */ +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { + if (unlikely(retval)) { + Py_DECREF(retval); + __Pyx_RaiseTooManyValuesError(expected); + return -1; + } else { + return __Pyx_IterFinish(); + } + return 0; +} + +/* ObjectGetItem */ +#if CYTHON_USE_TYPE_SLOTS +static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) { + PyObject *runerr; + Py_ssize_t key_value; + PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence; + if (unlikely(!(m && m->sq_item))) { + PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name); + return NULL; + } + key_value = __Pyx_PyIndex_AsSsize_t(index); + if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { + return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); + } + if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { + PyErr_Clear(); + PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name); + } + return NULL; +} +static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) { + PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping; + if (likely(m && m->mp_subscript)) { + return m->mp_subscript(obj, key); + } + return __Pyx_PyObject_GetIndex(obj, key); +} +#endif + +/* PyFunctionFastCall */ +#if CYTHON_FAST_PYCALL +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + fastlocals = __Pyx_PyFrame_GetLocalsplus(f); + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; + } + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; +#endif + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + return NULL; + } + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && +#endif + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif +#endif + +/* PyCFunctionFastCall */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { + PyCFunctionObject *func = (PyCFunctionObject*)func_obj; + PyCFunction meth = PyCFunction_GET_FUNCTION(func); + PyObject *self = PyCFunction_GET_SELF(func); + int flags = PyCFunction_GET_FLAGS(func); + assert(PyCFunction_Check(func)); + assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); + assert(nargs >= 0); + assert(nargs == 0 || args != NULL); + /* _PyCFunction_FastCallDict() must not be called with an exception set, + because it may clear it (directly or indirectly) and so the + caller loses its exception */ + assert(!PyErr_Occurred()); + if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { + return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); + } else { + return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); + } +} +#endif + +/* MemviewSliceInit */ +static int +__Pyx_init_memviewslice(struct __pyx_memoryview_obj *memview, + int ndim, + __Pyx_memviewslice *memviewslice, + int memview_is_new_reference) +{ + __Pyx_RefNannyDeclarations + int i, retval=-1; + Py_buffer *buf = &memview->view; + __Pyx_RefNannySetupContext("init_memviewslice", 0); + if (unlikely(memviewslice->memview || memviewslice->data)) { + PyErr_SetString(PyExc_ValueError, + "memviewslice is already initialized!"); + goto fail; + } + if (buf->strides) { + for (i = 0; i < ndim; i++) { + memviewslice->strides[i] = buf->strides[i]; + } + } else { + Py_ssize_t stride = buf->itemsize; + for (i = ndim - 1; i >= 0; i--) { + memviewslice->strides[i] = stride; + stride *= buf->shape[i]; + } + } + for (i = 0; i < ndim; i++) { + memviewslice->shape[i] = buf->shape[i]; + if (buf->suboffsets) { + memviewslice->suboffsets[i] = buf->suboffsets[i]; + } else { + memviewslice->suboffsets[i] = -1; + } + } + memviewslice->memview = memview; + memviewslice->data = (char *)buf->buf; + if (__pyx_add_acquisition_count(memview) == 0 && !memview_is_new_reference) { + Py_INCREF(memview); + } + retval = 0; + goto no_fail; +fail: + memviewslice->memview = 0; + memviewslice->data = 0; + retval = -1; +no_fail: + __Pyx_RefNannyFinishContext(); + return retval; +} +#ifndef Py_NO_RETURN +#define Py_NO_RETURN +#endif +static void __pyx_fatalerror(const char *fmt, ...) Py_NO_RETURN { + va_list vargs; + char msg[200]; +#ifdef HAVE_STDARG_PROTOTYPES + va_start(vargs, fmt); +#else + va_start(vargs); +#endif + vsnprintf(msg, 200, fmt, vargs); + va_end(vargs); + Py_FatalError(msg); +} +static CYTHON_INLINE int +__pyx_add_acquisition_count_locked(__pyx_atomic_int *acquisition_count, + PyThread_type_lock lock) +{ + int result; + PyThread_acquire_lock(lock, 1); + result = (*acquisition_count)++; + PyThread_release_lock(lock); + return result; +} +static CYTHON_INLINE int +__pyx_sub_acquisition_count_locked(__pyx_atomic_int *acquisition_count, + PyThread_type_lock lock) +{ + int result; + PyThread_acquire_lock(lock, 1); + result = (*acquisition_count)--; + PyThread_release_lock(lock); + return result; +} +static CYTHON_INLINE void +__Pyx_INC_MEMVIEW(__Pyx_memviewslice *memslice, int have_gil, int lineno) +{ + int first_time; + struct __pyx_memoryview_obj *memview = memslice->memview; + if (unlikely(!memview || (PyObject *) memview == Py_None)) + return; + if (unlikely(__pyx_get_slice_count(memview) < 0)) + __pyx_fatalerror("Acquisition count is %d (line %d)", + __pyx_get_slice_count(memview), lineno); + first_time = __pyx_add_acquisition_count(memview) == 0; + if (unlikely(first_time)) { + if (have_gil) { + Py_INCREF((PyObject *) memview); + } else { + PyGILState_STATE _gilstate = PyGILState_Ensure(); + Py_INCREF((PyObject *) memview); + PyGILState_Release(_gilstate); + } + } +} +static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW(__Pyx_memviewslice *memslice, + int have_gil, int lineno) { + int last_time; + struct __pyx_memoryview_obj *memview = memslice->memview; + if (unlikely(!memview || (PyObject *) memview == Py_None)) { + memslice->memview = NULL; + return; + } + if (unlikely(__pyx_get_slice_count(memview) <= 0)) + __pyx_fatalerror("Acquisition count is %d (line %d)", + __pyx_get_slice_count(memview), lineno); + last_time = __pyx_sub_acquisition_count(memview) == 1; + memslice->data = NULL; + if (unlikely(last_time)) { + if (have_gil) { + Py_CLEAR(memslice->memview); + } else { + PyGILState_STATE _gilstate = PyGILState_Ensure(); + Py_CLEAR(memslice->memview); + PyGILState_Release(_gilstate); + } + } else { + memslice->memview = NULL; + } +} + +/* SetItemInt */ +static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { + int r; + if (!j) return -1; + r = PyObject_SetItem(o, j, v); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list, + CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o)); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o)))) { + PyObject* old = PyList_GET_ITEM(o, n); + Py_INCREF(v); + PyList_SET_ITEM(o, n, v); + Py_DECREF(old); + return 1; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_ass_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return -1; + PyErr_Clear(); + } + } + return m->sq_ass_item(o, i, v); + } + } +#else +#if CYTHON_COMPILING_IN_PYPY + if (is_list || (PySequence_Check(o) && !PyDict_Check(o))) +#else + if (is_list || PySequence_Check(o)) +#endif + { + return PySequence_SetItem(o, i, v); + } +#endif + return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v); +} + +/* 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) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallOneArg */ +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, &arg, 1); + } +#endif + if (likely(PyCFunction_Check(func))) { + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); +#if CYTHON_FAST_PYCCALL + } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); +#endif + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + else if (exact) { + #if PY_MAJOR_VERSION == 2 + if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; + } + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); + return 0; +} + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +} +#endif + +/* RaiseException */ +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + __Pyx_PyThreadState_declare + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } } else { - num_expected = num_max; - more_or_less = "at most"; + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; } - if (exact) { - more_or_less = "exactly"; + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); } - PyErr_Format(PyExc_TypeError, - "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", - func_name, more_or_less, num_expected, - (num_expected == 1) ? "" : "s", num_found); + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif + } +bad: + Py_XDECREF(owned_instance); + return; } +#endif -/* RaiseDoubleKeywords */ -static void __Pyx_RaiseDoubleKeywordsError( - const char* func_name, - PyObject* kw_name) -{ - PyErr_Format(PyExc_TypeError, - #if PY_MAJOR_VERSION >= 3 - "%s() got multiple values for keyword argument '%U'", func_name, kw_name); - #else - "%s() got multiple values for keyword argument '%s'", func_name, - PyString_AsString(kw_name)); - #endif +/* BytesEquals */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result; +#if CYTHON_USE_UNICODE_INTERNALS + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + return (equals == Py_NE); + } +#endif + result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +#endif } -/* ParseKeywords */ -static int __Pyx_ParseOptionalKeywords( - PyObject *kwds, - PyObject **argnames[], - PyObject *kwds2, - PyObject *values[], - Py_ssize_t num_pos_args, - const char* function_name) -{ - PyObject *key = 0, *value = 0; - Py_ssize_t pos = 0; - PyObject*** name; - PyObject*** first_kw_arg = argnames + num_pos_args; - while (PyDict_Next(kwds, &pos, &key, &value)) { - name = first_kw_arg; - while (*name && (**name != key)) name++; - if (*name) { - values[name-argnames] = value; - continue; +/* UnicodeEquals */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY + return PyObject_RichCompareBool(s1, s2, equals); +#else +#if PY_MAJOR_VERSION < 3 + PyObject* owned_ref = NULL; +#endif + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + goto return_eq; + } + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); +#if PY_MAJOR_VERSION < 3 + if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { + owned_ref = PyUnicode_FromObject(s2); + if (unlikely(!owned_ref)) + return -1; + s2 = owned_ref; + s2_is_unicode = 1; + } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { + owned_ref = PyUnicode_FromObject(s1); + if (unlikely(!owned_ref)) + return -1; + s1 = owned_ref; + s1_is_unicode = 1; + } else if (((!s2_is_unicode) & (!s1_is_unicode))) { + return __Pyx_PyBytes_Equals(s1, s2, equals); + } +#endif + if (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length; + int kind; + void *data1, *data2; + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + length = __Pyx_PyUnicode_GET_LENGTH(s1); + if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { + goto return_ne; } - name = first_kw_arg; - #if PY_MAJOR_VERSION < 3 - if (likely(PyString_Check(key))) { - while (*name) { - if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) - && _PyString_Eq(**name, key)) { - values[name-argnames] = value; - break; - } - name++; - } - if (*name) continue; - else { - PyObject*** argname = argnames; - while (argname != first_kw_arg) { - if ((**argname == key) || ( - (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) - && _PyString_Eq(**argname, key))) { - goto arg_passed_twice; - } - argname++; - } - } - } else +#if CYTHON_USE_UNICODE_INTERNALS + { + Py_hash_t hash1, hash2; + #if CYTHON_PEP393_ENABLED + hash1 = ((PyASCIIObject*)s1)->hash; + hash2 = ((PyASCIIObject*)s2)->hash; + #else + hash1 = ((PyUnicodeObject*)s1)->hash; + hash2 = ((PyUnicodeObject*)s2)->hash; #endif - if (likely(PyUnicode_Check(key))) { - while (*name) { - int cmp = (**name == key) ? 0 : - #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : - #endif - PyUnicode_Compare(**name, key); - if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; - if (cmp == 0) { - values[name-argnames] = value; - break; - } - name++; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + goto return_ne; } - if (*name) continue; - else { - PyObject*** argname = argnames; - while (argname != first_kw_arg) { - int cmp = (**argname == key) ? 0 : - #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : - #endif - PyUnicode_Compare(**argname, key); - if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; - if (cmp == 0) goto arg_passed_twice; - argname++; - } - } - } else - goto invalid_keyword_type; - if (kwds2) { - if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } +#endif + kind = __Pyx_PyUnicode_KIND(s1); + if (kind != __Pyx_PyUnicode_KIND(s2)) { + goto return_ne; + } + data1 = __Pyx_PyUnicode_DATA(s1); + data2 = __Pyx_PyUnicode_DATA(s2); + if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { + goto return_ne; + } else if (length == 1) { + goto return_eq; } else { - goto invalid_keyword; + int result = memcmp(data1, data2, (size_t)(length * kind)); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ) ? (result == 0) : (result != 0); } + } else if ((s1 == Py_None) & s2_is_unicode) { + goto return_ne; + } else if ((s2 == Py_None) & s1_is_unicode) { + goto return_ne; + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; } - return 0; -arg_passed_twice: - __Pyx_RaiseDoubleKeywordsError(function_name, key); - goto bad; -invalid_keyword_type: - PyErr_Format(PyExc_TypeError, - "%.200s() keywords must be strings", function_name); - goto bad; -invalid_keyword: - PyErr_Format(PyExc_TypeError, +return_eq: #if PY_MAJOR_VERSION < 3 - "%.200s() got an unexpected keyword argument '%.200s'", - function_name, PyString_AsString(key)); - #else - "%s() got an unexpected keyword argument '%U'", - function_name, key); + Py_XDECREF(owned_ref); #endif -bad: - return -1; + return (equals == Py_EQ); +return_ne: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_NE); +#endif } -/* PyObjectGetAttrStr */ +/* None */ +static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t a, Py_ssize_t b) { + Py_ssize_t q = a / b; + Py_ssize_t r = a - q*b; + q -= ((r != 0) & ((r ^ b) < 0)); + return q; +} + +/* GetAttr */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { #if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { - PyTypeObject* tp = Py_TYPE(obj); - if (likely(tp->tp_getattro)) - return tp->tp_getattro(obj, attr_name); -#if PY_MAJOR_VERSION < 3 - if (likely(tp->tp_getattr)) - return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#if PY_MAJOR_VERSION >= 3 + if (likely(PyUnicode_Check(n))) +#else + if (likely(PyString_Check(n))) #endif - return PyObject_GetAttr(obj, attr_name); -} + return __Pyx_PyObject_GetAttrStr(o, n); #endif + return PyObject_GetAttr(o, n); +} -/* GetBuiltinName */ -static PyObject *__Pyx_GetBuiltinName(PyObject *name) { - PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); - if (unlikely(!result)) { - PyErr_Format(PyExc_NameError, +/* decode_c_string */ +static CYTHON_INLINE PyObject* __Pyx_decode_c_string( + const char* cstring, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + Py_ssize_t length; + if (unlikely((start < 0) | (stop < 0))) { + size_t slen = strlen(cstring); + if (unlikely(slen > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, + "c-string too long to convert to Python"); + return NULL; + } + length = (Py_ssize_t) slen; + if (start < 0) { + start += length; + if (start < 0) + start = 0; + } + if (stop < 0) + stop += length; + } + if (unlikely(stop <= start)) + return __Pyx_NewRef(__pyx_empty_unicode); + length = stop - start; + cstring += start; + if (decode_func) { + return decode_func(cstring, length, errors); + } else { + return PyUnicode_Decode(cstring, length, encoding, errors); + } +} + +/* PyErrExceptionMatches */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 - "name '%U' is not defined", name); -#else - "name '%.200s' is not defined", PyString_AS_STRING(name)); + for (i=0; icurexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; + if (unlikely(PyTuple_Check(err))) + return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } +#endif -/* PyDictVersioning */ -#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { - PyObject *dict = Py_TYPE(obj)->tp_dict; - return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; +/* GetAttr3 */ +static PyObject *__Pyx_GetAttr3Default(PyObject *d) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + return NULL; + __Pyx_PyErr_Clear(); + Py_INCREF(d); + return d; +} +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { + PyObject *r = __Pyx_GetAttr(o, n); + return (likely(r)) ? r : __Pyx_GetAttr3Default(d); +} + +/* RaiseNoneIterError */ +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +} + +/* ExtTypeTest */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +/* 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; } -static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { - PyObject **dictptr = NULL; - Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; - if (offset) { -#if CYTHON_COMPILING_IN_CPYTHON - dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); -#else - dictptr = _PyObject_GetDictPtr(obj); #endif - } - return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; + +/* SaveResetException */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + *type = exc_info->exc_type; + *value = exc_info->exc_value; + *tb = exc_info->exc_traceback; + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + #endif + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); } -static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { - PyObject *dict = Py_TYPE(obj)->tp_dict; - if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) - return 0; - return obj_dict_version == __Pyx_get_object_dict_version(obj); +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = type; + exc_info->exc_value = value; + exc_info->exc_traceback = tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); } #endif -/* GetModuleGlobalName */ -#if CYTHON_USE_DICT_VERSIONS -static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) +/* GetException */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) #else -static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #endif { - 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); - } else if (unlikely(PyErr_Occurred())) { - return NULL; - } + PyObject *local_type, *local_value, *local_tb; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; #else - 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); - } + PyErr_Fetch(&local_type, &local_value, &local_tb); #endif + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) #else - 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); + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + #if PY_MAJOR_VERSION >= 3 + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; } - PyErr_Clear(); + #endif + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if CYTHON_USE_EXC_INFO_STACK + { + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = local_type; + exc_info->exc_value = local_value; + exc_info->exc_traceback = local_tb; + } + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); #endif - return __Pyx_GetBuiltinName(name); + return 0; +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; } -/* PyCFunctionFastCall */ -#if CYTHON_FAST_PYCCALL -static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { - PyCFunctionObject *func = (PyCFunctionObject*)func_obj; - PyCFunction meth = PyCFunction_GET_FUNCTION(func); - PyObject *self = PyCFunction_GET_SELF(func); - int flags = PyCFunction_GET_FLAGS(func); - assert(PyCFunction_Check(func)); - assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); - assert(nargs >= 0); - assert(nargs == 0 || args != NULL); - /* _PyCFunction_FastCallDict() must not be called with an exception set, - because it may clear it (directly or indirectly) and so the - caller loses its exception */ - assert(!PyErr_Occurred()); - if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { - return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); - } else { - return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); - } +/* SwapException */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = *type; + exc_info->exc_value = *value; + exc_info->exc_traceback = *tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = *type; + tstate->exc_value = *value; + tstate->exc_traceback = *tb; + #endif + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; } -#endif - -/* PyFunctionFastCall */ -#if CYTHON_FAST_PYCALL -static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, - PyObject *globals) { - PyFrameObject *f; - PyThreadState *tstate = __Pyx_PyThreadState_Current; - PyObject **fastlocals; - Py_ssize_t i; - PyObject *result; - assert(globals != NULL); - /* XXX Perhaps we should create a specialized - PyFrame_New() that doesn't take locals, but does - take builtins without sanity checking them. - */ - assert(tstate != NULL); - f = PyFrame_New(tstate, co, globals, NULL); - if (f == NULL) { - return NULL; - } - fastlocals = __Pyx_PyFrame_GetLocalsplus(f); - for (i = 0; i < na; i++) { - Py_INCREF(*args); - fastlocals[i] = *args++; - } - result = PyEval_EvalFrameEx(f,0); - ++tstate->recursion_depth; - Py_DECREF(f); - --tstate->recursion_depth; - return result; +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); + PyErr_SetExcInfo(*type, *value, *tb); + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; } -#if 1 || PY_VERSION_HEX < 0x030600B1 -static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { - PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); - PyObject *globals = PyFunction_GET_GLOBALS(func); - PyObject *argdefs = PyFunction_GET_DEFAULTS(func); - PyObject *closure; -#if PY_MAJOR_VERSION >= 3 - PyObject *kwdefs; -#endif - PyObject *kwtuple, **k; - PyObject **d; - Py_ssize_t nd; - Py_ssize_t nk; - PyObject *result; - assert(kwargs == NULL || PyDict_Check(kwargs)); - nk = kwargs ? PyDict_Size(kwargs) : 0; - if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { - return NULL; - } - if ( -#if PY_MAJOR_VERSION >= 3 - co->co_kwonlyargcount == 0 && -#endif - likely(kwargs == NULL || nk == 0) && - co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { - if (argdefs == NULL && co->co_argcount == nargs) { - result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); - goto done; - } - else if (nargs == 0 && argdefs != NULL - && co->co_argcount == Py_SIZE(argdefs)) { - /* function called with no arguments, but all parameters have - a default value: use default values as arguments .*/ - args = &PyTuple_GET_ITEM(argdefs, 0); - result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); - goto done; - } - } - if (kwargs != NULL) { - Py_ssize_t pos, i; - kwtuple = PyTuple_New(2 * nk); - if (kwtuple == NULL) { - result = NULL; - goto done; - } - k = &PyTuple_GET_ITEM(kwtuple, 0); - pos = i = 0; - while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { - Py_INCREF(k[i]); - Py_INCREF(k[i+1]); - i += 2; - } - nk = i / 2; - } - else { - kwtuple = NULL; - k = NULL; - } - closure = PyFunction_GET_CLOSURE(func); -#if PY_MAJOR_VERSION >= 3 - kwdefs = PyFunction_GET_KW_DEFAULTS(func); #endif - if (argdefs != NULL) { - d = &PyTuple_GET_ITEM(argdefs, 0); - nd = Py_SIZE(argdefs); - } + +/* Import */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_MAJOR_VERSION < 3 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; else { - d = NULL; - nd = 0; + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; } -#if PY_MAJOR_VERSION >= 3 - result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, kwdefs, closure); -#else - result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, closure); -#endif - Py_XDECREF(kwtuple); -done: - Py_LeaveRecursiveCall(); - return result; + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_MAJOR_VERSION < 3 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; } -#endif -#endif -/* PyObjectCall */ +/* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { - PyObject *result; - ternaryfunc call = func->ob_type->tp_call; - if (unlikely(!call)) - return PyObject_Call(func, arg, kw); - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - result = (*call)(func, arg, kw); - Py_LeaveRecursiveCall(); - if (unlikely(!result) && unlikely(!PyErr_Occurred())) { - PyErr_SetString( - PyExc_SystemError, - "NULL result without error in PyObject_Call"); +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = a->tp_base; + if (a == b) + return 1; } - return result; + return b == &PyBaseObject_Type; } -#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); +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (a == b) return 1; + mro = a->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) + return 1; + } + return 0; } - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(function)) { - PyObject *args[2] = {arg1, arg2}; - return __Pyx_PyCFunction_FastCall(function, args, 2); + return __Pyx_InBases(a, b); +} +#if PY_MAJOR_VERSION == 2 +static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { + PyObject *exception, *value, *tb; + int res; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&exception, &value, &tb); + res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; } - #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; + if (!res) { + res = PyObject_IsSubclass(err, exc_type2); + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + } + __Pyx_ErrRestore(exception, value, tb); + return res; } - -/* PyObjectCallMethO */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { - PyObject *self, *result; - PyCFunction cfunc; - cfunc = PyCFunction_GET_FUNCTION(func); - self = PyCFunction_GET_SELF(func); - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - result = cfunc(self, arg); - Py_LeaveRecursiveCall(); - if (unlikely(!result) && unlikely(!PyErr_Occurred())) { - PyErr_SetString( - PyExc_SystemError, - "NULL result without error in PyObject_Call"); +#else +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { + int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; + if (!res) { + res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } - return result; + return res; } #endif - -/* PyObjectCallOneArg */ -#if CYTHON_COMPILING_IN_CPYTHON -static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *result; - PyObject *args = PyTuple_New(1); - if (unlikely(!args)) return NULL; - Py_INCREF(arg); - PyTuple_SET_ITEM(args, 0, arg); - result = __Pyx_PyObject_Call(func, args, NULL); - Py_DECREF(args); - return result; -} -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { -#if CYTHON_FAST_PYCALL - if (PyFunction_Check(func)) { - return __Pyx_PyFunction_FastCall(func, &arg, 1); +static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + assert(PyExceptionClass_Check(exc_type)); + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; i= 0 || (x^b) >= 0)) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_add(op1, op2); } #endif #if CYTHON_USE_PYLONG_INTERNALS if (likely(PyLong_CheckExact(op1))) { - int unequal; - unsigned long uintval; - Py_ssize_t size = Py_SIZE(op1); + const long b = intval; + long a, x; +#ifdef HAVE_LONG_LONG + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla, llx; +#endif const digit* digits = ((PyLongObject*)op1)->ob_digit; - if (intval == 0) { - if (size == 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; - } else if (intval < 0) { - if (size >= 0) - Py_RETURN_FALSE; - intval = -intval; - size = -size; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; } else { - if (size <= 0) - Py_RETURN_FALSE; - } - uintval = (unsigned long) intval; -#if PyLong_SHIFT * 4 < SIZEOF_LONG*8 - if (uintval >> (PyLong_SHIFT * 4)) { - unequal = (size != 5) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) - | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[4] != ((uintval >> (4 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); - } else + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; #endif -#if PyLong_SHIFT * 3 < SIZEOF_LONG*8 - if (uintval >> (PyLong_SHIFT * 3)) { - unequal = (size != 4) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) - | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); - } else + } + CYTHON_FALLTHROUGH; + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; #endif -#if PyLong_SHIFT * 2 < SIZEOF_LONG*8 - if (uintval >> (PyLong_SHIFT * 2)) { - unequal = (size != 3) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) - | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); - } else + } + CYTHON_FALLTHROUGH; + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; #endif -#if PyLong_SHIFT * 1 < SIZEOF_LONG*8 - if (uintval >> (PyLong_SHIFT * 1)) { - unequal = (size != 2) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) - | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); - } else + } + CYTHON_FALLTHROUGH; + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + default: return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + } + x = a + b; + return PyLong_FromLong(x); +#ifdef HAVE_LONG_LONG + long_long: + llx = lla + llb; + return PyLong_FromLongLong(llx); +#endif + + + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + double result; + PyFPE_START_PROTECT("add", return NULL) + result = ((double)a) + (double)b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); + } + return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); +} +#endif + +/* None */ +static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { + PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); +} + +/* None */ +static CYTHON_INLINE long __Pyx_div_long(long a, long b) { + long q = a / b; + long r = a - q*b; + q -= ((r != 0) & ((r ^ b) < 0)); + return q; +} + +/* ImportFrom */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Format(PyExc_ImportError, + #if PY_MAJOR_VERSION < 3 + "cannot import name %.230s", PyString_AS_STRING(name)); + #else + "cannot import name %S", name); + #endif + } + return value; +} + +/* HasAttr */ +static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { + PyObject *r; + if (unlikely(!__Pyx_PyBaseString_Check(n))) { + PyErr_SetString(PyExc_TypeError, + "hasattr(): attribute name must be string"); + return -1; + } + r = __Pyx_GetAttr(o, n); + if (unlikely(!r)) { + PyErr_Clear(); + return 0; + } else { + Py_DECREF(r); + return 1; + } +} + +/* PyObject_GenericGetAttrNoDict */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'%.50s' object has no attribute '%U'", + tp->tp_name, attr_name); +#else + "'%.50s' object has no attribute '%.400s'", + tp->tp_name, PyString_AS_STRING(attr_name)); #endif - unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK)); - if (unequal == 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { + PyObject *descr; + PyTypeObject *tp = Py_TYPE(obj); + if (unlikely(!PyString_Check(attr_name))) { + return PyObject_GenericGetAttr(obj, attr_name); + } + assert(!tp->tp_dictoffset); + descr = _PyType_Lookup(tp, attr_name); + if (unlikely(!descr)) { + return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); } + Py_INCREF(descr); + #if PY_MAJOR_VERSION < 3 + if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) #endif - if (PyFloat_CheckExact(op1)) { - const long b = intval; - double a = PyFloat_AS_DOUBLE(op1); - if ((double)a == (double)b) Py_RETURN_TRUE; else Py_RETURN_FALSE; + { + descrgetfunc f = Py_TYPE(descr)->tp_descr_get; + if (unlikely(f)) { + PyObject *res = f(descr, obj, (PyObject *)tp); + Py_DECREF(descr); + return res; + } } - return ( - PyObject_RichCompare(op1, op2, Py_EQ)); + return descr; } +#endif -/* SliceObject */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj, - Py_ssize_t cstart, Py_ssize_t cstop, - PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice, - int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) { -#if CYTHON_USE_TYPE_SLOTS - PyMappingMethods* mp; -#if PY_MAJOR_VERSION < 3 - PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence; - if (likely(ms && ms->sq_slice)) { - if (!has_cstart) { - if (_py_start && (*_py_start != Py_None)) { - cstart = __Pyx_PyIndex_AsSsize_t(*_py_start); - if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; - } else - cstart = 0; - } - if (!has_cstop) { - if (_py_stop && (*_py_stop != Py_None)) { - cstop = __Pyx_PyIndex_AsSsize_t(*_py_stop); - if ((cstop == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; - } else - cstop = PY_SSIZE_T_MAX; - } - if (wraparound && unlikely((cstart < 0) | (cstop < 0)) && likely(ms->sq_length)) { - Py_ssize_t l = ms->sq_length(obj); - if (likely(l >= 0)) { - if (cstop < 0) { - cstop += l; - if (cstop < 0) cstop = 0; - } - if (cstart < 0) { - cstart += l; - if (cstart < 0) cstart = 0; - } - } else { - if (!PyErr_ExceptionMatches(PyExc_OverflowError)) - goto bad; - PyErr_Clear(); - } - } - return ms->sq_slice(obj, cstart, cstop); +/* PyObject_GenericGetAttr */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { + if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { + return PyObject_GenericGetAttr(obj, attr_name); } + return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); +} #endif - mp = Py_TYPE(obj)->tp_as_mapping; - if (likely(mp && mp->mp_subscript)) -#endif - { - PyObject* result; - PyObject *py_slice, *py_start, *py_stop; - if (_py_slice) { - py_slice = *_py_slice; - } else { - PyObject* owned_start = NULL; - PyObject* owned_stop = NULL; - if (_py_start) { - py_start = *_py_start; - } else { - if (has_cstart) { - owned_start = py_start = PyInt_FromSsize_t(cstart); - if (unlikely(!py_start)) goto bad; - } else - py_start = Py_None; - } - if (_py_stop) { - py_stop = *_py_stop; - } else { - if (has_cstop) { - owned_stop = py_stop = PyInt_FromSsize_t(cstop); - if (unlikely(!py_stop)) { - Py_XDECREF(owned_start); - goto bad; - } - } else - py_stop = Py_None; - } - py_slice = PySlice_New(py_start, py_stop, Py_None); - Py_XDECREF(owned_start); - Py_XDECREF(owned_stop); - if (unlikely(!py_slice)) goto bad; - } -#if CYTHON_USE_TYPE_SLOTS - result = mp->mp_subscript(obj, py_slice); + +/* SetVTable */ +static int __Pyx_SetVtable(PyObject *dict, void *vtable) { +#if PY_VERSION_HEX >= 0x02070000 + PyObject *ob = PyCapsule_New(vtable, 0, 0); #else - result = PyObject_GetItem(obj, py_slice); + PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); #endif - if (!_py_slice) { - Py_DECREF(py_slice); - } - return result; - } - PyErr_Format(PyExc_TypeError, - "'%.200s' object is unsliceable", Py_TYPE(obj)->tp_name); + if (!ob) + goto bad; + if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) + goto bad; + Py_DECREF(ob); + return 0; bad: - return NULL; + Py_XDECREF(ob); + return -1; } -/* Import */ -static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { - PyObject *empty_list = 0; - PyObject *module = 0; - PyObject *global_dict = 0; - PyObject *empty_dict = 0; - PyObject *list; - #if PY_MAJOR_VERSION < 3 - PyObject *py_import; - py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); - if (!py_import) - goto bad; - #endif - if (from_list) - list = from_list; - else { - empty_list = PyList_New(0); - if (!empty_list) - goto bad; - list = empty_list; +/* PyObjectGetAttrStrNoError */ +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { + return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); } - global_dict = PyModule_GetDict(__pyx_m); - if (!global_dict) - goto bad; - empty_dict = PyDict_New(); - if (!empty_dict) - goto bad; - { - #if PY_MAJOR_VERSION >= 3 - if (level == -1) { - if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { - module = PyImport_ImportModuleLevelObject( - name, global_dict, empty_dict, list, 1); - if (!module) { - if (!PyErr_ExceptionMatches(PyExc_ImportError)) - goto bad; - PyErr_Clear(); - } - } - level = 0; - } - #endif - if (!module) { - #if PY_MAJOR_VERSION < 3 - PyObject *py_level = PyInt_FromLong(level); - if (!py_level) - goto bad; - module = PyObject_CallFunctionObjArgs(py_import, - name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); - Py_DECREF(py_level); - #else - module = PyImport_ImportModuleLevelObject( - name, global_dict, empty_dict, list, level); - #endif - } +#endif + result = __Pyx_PyObject_GetAttrStr(obj, attr_name); + if (unlikely(!result)) { + __Pyx_PyObject_GetAttrStr_ClearAttributeError(); } -bad: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(py_import); - #endif - Py_XDECREF(empty_list); - Py_XDECREF(empty_dict); - return module; + return result; } -/* PyErrFetchRestore */ -#if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - tmp_type = tstate->curexc_type; - tmp_value = tstate->curexc_value; - tmp_tb = tstate->curexc_traceback; - tstate->curexc_type = type; - tstate->curexc_value = value; - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); -} -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - *type = tstate->curexc_type; - *value = tstate->curexc_value; - *tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; +/* SetupReduce */ +static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { + int ret; + PyObject *name_attr; + name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name_2); + if (likely(name_attr)) { + ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); + } else { + ret = -1; + } + if (unlikely(ret < 0)) { + PyErr_Clear(); + ret = 0; + } + Py_XDECREF(name_attr); + return ret; } +static int __Pyx_setup_reduce(PyObject* type_obj) { + int ret = 0; + PyObject *object_reduce = NULL; + PyObject *object_reduce_ex = NULL; + PyObject *reduce = NULL; + PyObject *reduce_ex = NULL; + PyObject *reduce_cython = NULL; + PyObject *setstate = NULL; + PyObject *setstate_cython = NULL; +#if CYTHON_USE_PYTYPE_LOOKUP + if (_PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD; +#else + if (PyObject_HasAttr(type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD; +#endif +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#else + object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #endif + reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; + if (reduce_ex == object_reduce_ex) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; +#else + object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; +#endif + reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; + if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { + reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); + if (likely(reduce_cython)) { + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (reduce == object_reduce || PyErr_Occurred()) { + goto __PYX_BAD; + } + setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); + if (!setstate) PyErr_Clear(); + if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { + setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); + if (likely(setstate_cython)) { + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (!setstate || PyErr_Occurred()) { + goto __PYX_BAD; + } + } + PyType_Modified((PyTypeObject*)type_obj); + } + } + goto __PYX_GOOD; +__PYX_BAD: + if (!PyErr_Occurred()) + PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); + ret = -1; +__PYX_GOOD: +#if !CYTHON_USE_PYTYPE_LOOKUP + Py_XDECREF(object_reduce); + Py_XDECREF(object_reduce_ex); +#endif + Py_XDECREF(reduce); + Py_XDECREF(reduce_ex); + Py_XDECREF(reduce_cython); + Py_XDECREF(setstate); + Py_XDECREF(setstate_cython); + return ret; +} /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK @@ -2966,59 +20224,420 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, Py_XDECREF(py_frame); } +#if PY_MAJOR_VERSION < 3 +static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { + if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); + if (__Pyx_TypeCheck(obj, __pyx_array_type)) return __pyx_array_getbuffer(obj, view, flags); + if (__Pyx_TypeCheck(obj, __pyx_memoryview_type)) return __pyx_memoryview_getbuffer(obj, view, flags); + PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); + return -1; +} +static void __Pyx_ReleaseBuffer(Py_buffer *view) { + PyObject *obj = view->obj; + if (!obj) return; + if (PyObject_CheckBuffer(obj)) { + PyBuffer_Release(view); + return; + } + if ((0)) {} + view->obj = NULL; + Py_DECREF(obj); +} +#endif + + +/* MemviewSliceIsContig */ +static int +__pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim) +{ + int i, index, step, start; + Py_ssize_t itemsize = mvs.memview->view.itemsize; + if (order == 'F') { + step = 1; + start = 0; + } else { + step = -1; + start = ndim - 1; + } + for (i = 0; i < ndim; i++) { + index = start + step * i; + if (mvs.suboffsets[index] >= 0 || mvs.strides[index] != itemsize) + return 0; + itemsize *= mvs.shape[index]; + } + return 1; +} + +/* OverlappingSlices */ +static void +__pyx_get_array_memory_extents(__Pyx_memviewslice *slice, + void **out_start, void **out_end, + int ndim, size_t itemsize) +{ + char *start, *end; + int i; + start = end = slice->data; + for (i = 0; i < ndim; i++) { + Py_ssize_t stride = slice->strides[i]; + Py_ssize_t extent = slice->shape[i]; + if (extent == 0) { + *out_start = *out_end = start; + return; + } else { + if (stride > 0) + end += stride * (extent - 1); + else + start += stride * (extent - 1); + } + } + *out_start = start; + *out_end = end + itemsize; +} +static int +__pyx_slices_overlap(__Pyx_memviewslice *slice1, + __Pyx_memviewslice *slice2, + int ndim, size_t itemsize) +{ + void *start1, *end1, *start2, *end2; + __pyx_get_array_memory_extents(slice1, &start1, &end1, ndim, itemsize); + __pyx_get_array_memory_extents(slice2, &start2, &end2, ndim, itemsize); + return (start1 < end2) && (start2 < end1); +} + +/* Capsule */ +static CYTHON_INLINE PyObject * +__pyx_capsule_create(void *p, CYTHON_UNUSED const char *sig) +{ + PyObject *cobj; +#if PY_VERSION_HEX >= 0x02070000 + cobj = PyCapsule_New(p, sig, NULL); +#else + cobj = PyCObject_FromVoidPtr(p, NULL); +#endif + return cobj; +} + +/* CIntFromPyVerify */ +#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + /* 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_int(int value) { + const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { - if (sizeof(long) < sizeof(long)) { + if (sizeof(int) < sizeof(long)) { return PyInt_FromLong((long) value); - } else if (sizeof(long) <= sizeof(unsigned long)) { + } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +/* MemviewDtypeToObject */ +static CYTHON_INLINE PyObject *__pyx_memview_get_double(const char *itemp) { + return (PyObject *) PyFloat_FromDouble(*(double *) itemp); +} +static CYTHON_INLINE int __pyx_memview_set_double(const char *itemp, PyObject *obj) { + double value = __pyx_PyFloat_AsDouble(obj); + if ((value == (double)-1) && PyErr_Occurred()) + return 0; + *(double *) itemp = value; + return 1; +} + +/* MemviewSliceCopyTemplate */ +static __Pyx_memviewslice +__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, + const char *mode, int ndim, + size_t sizeof_dtype, int contig_flag, + int dtype_is_object) +{ + __Pyx_RefNannyDeclarations + int i; + __Pyx_memviewslice new_mvs = { 0, 0, { 0 }, { 0 }, { 0 } }; + struct __pyx_memoryview_obj *from_memview = from_mvs->memview; + Py_buffer *buf = &from_memview->view; + PyObject *shape_tuple = NULL; + PyObject *temp_int = NULL; + struct __pyx_array_obj *array_obj = NULL; + struct __pyx_memoryview_obj *memview_obj = NULL; + __Pyx_RefNannySetupContext("__pyx_memoryview_copy_new_contig", 0); + for (i = 0; i < ndim; i++) { + if (unlikely(from_mvs->suboffsets[i] >= 0)) { + PyErr_Format(PyExc_ValueError, "Cannot copy memoryview slice with " + "indirect dimensions (axis %d)", i); + goto fail; + } + } + shape_tuple = PyTuple_New(ndim); + if (unlikely(!shape_tuple)) { + goto fail; + } + __Pyx_GOTREF(shape_tuple); + for(i = 0; i < ndim; i++) { + temp_int = PyInt_FromSsize_t(from_mvs->shape[i]); + if(unlikely(!temp_int)) { + goto fail; + } else { + PyTuple_SET_ITEM(shape_tuple, i, temp_int); + temp_int = NULL; + } + } + array_obj = __pyx_array_new(shape_tuple, sizeof_dtype, buf->format, (char *) mode, NULL); + if (unlikely(!array_obj)) { + goto fail; + } + __Pyx_GOTREF(array_obj); + memview_obj = (struct __pyx_memoryview_obj *) __pyx_memoryview_new( + (PyObject *) array_obj, contig_flag, + dtype_is_object, + from_mvs->memview->typeinfo); + if (unlikely(!memview_obj)) + goto fail; + if (unlikely(__Pyx_init_memviewslice(memview_obj, ndim, &new_mvs, 1) < 0)) + goto fail; + if (unlikely(__pyx_memoryview_copy_contents(*from_mvs, new_mvs, ndim, ndim, + dtype_is_object) < 0)) + goto fail; + goto no_fail; +fail: + __Pyx_XDECREF(new_mvs.memview); + new_mvs.memview = NULL; + new_mvs.data = NULL; +no_fail: + __Pyx_XDECREF(shape_tuple); + __Pyx_XDECREF(temp_int); + __Pyx_XDECREF(array_obj); + __Pyx_RefNannyFinishContext(); + return new_mvs; +} + +/* CIntFromPy */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif - } - } else { - if (sizeof(long) <= sizeof(long)) { - return PyInt_FromLong((long) value); + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif + } } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; } - { - int one = 1; int little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&value; - return _PyLong_FromByteArray(bytes, sizeof(long), - little, !is_unsigned); - } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; } -/* CIntFromPyVerify */ -#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ - __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) -#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ - __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) -#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ - {\ - func_type value = func_value;\ - if (sizeof(target_type) < sizeof(func_type)) {\ - if (unlikely(value != (func_type) (target_type) value)) {\ - func_type zero = 0;\ - if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ - return (target_type) -1;\ - if (is_unsigned && unlikely(value < zero))\ - goto raise_neg_overflow;\ - else\ - goto raise_overflow;\ - }\ - }\ - return (target_type) value;\ - } - /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; @@ -3208,20 +20827,51 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { return (long) -1; } +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + /* CIntFromPy */ -static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { - const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; +static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) { + const char neg_one = (char) ((char) 0 - (char) 1), const_zero = (char) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(int) < sizeof(long)) { - __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + if (sizeof(char) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(char, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } - return (int) val; + return (char) val; } } else #endif @@ -3230,32 +20880,32 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { - case 0: return (int) 0; - case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 0: return (char) 0; + case 1: __PYX_VERIFY_RETURN_INT(char, digit, digits[0]) case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(char) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { - return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) >= 2 * PyLong_SHIFT) { + return (char) (((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); } } break; case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(char) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { - return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) >= 3 * PyLong_SHIFT) { + return (char) (((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); } } break; case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(char) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { - return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) >= 4 * PyLong_SHIFT) { + return (char) (((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); } } break; @@ -3269,86 +20919,86 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) - return (int) -1; + return (char) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif - if (sizeof(int) <= sizeof(unsigned long)) { - __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) + if (sizeof(char) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(char, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { - __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } else if (sizeof(char) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(char, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { - case 0: return (int) 0; - case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case 0: return (char) 0; + case -1: __PYX_VERIFY_RETURN_INT(char, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(char, digit, +digits[0]) case -2: - if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(char) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { + return (char) (((char)-1)*(((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); } } break; case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(char) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { + return (char) ((((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); } } break; case -3: - if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { + return (char) (((char)-1)*(((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); } } break; case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(char) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { + return (char) ((((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); } } break; case -4: - if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) { + return (char) (((char)-1)*(((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); } } break; case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(char) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) { + return (char) ((((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); } } break; } #endif - if (sizeof(int) <= sizeof(long)) { - __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) + if (sizeof(char) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(char, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { - __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) + } else if (sizeof(char) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(char, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } @@ -3357,7 +21007,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else - int val; + char val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { @@ -3377,128 +21027,786 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { return val; } #endif - return (int) -1; + return (char) -1; } } else { - int val; + char val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (int) -1; - val = __Pyx_PyInt_As_int(tmp); + if (!tmp) return (char) -1; + val = __Pyx_PyInt_As_char(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, - "value too large to convert to int"); - return (int) -1; + "value too large to convert to char"); + return (char) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to int"); - return (int) -1; + "can't convert negative value to char"); + return (char) -1; } -/* FastTypeChecks */ -#if CYTHON_COMPILING_IN_CPYTHON -static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { - while (a) { - a = a->tp_base; - if (a == b) - return 1; - } - return b == &PyBaseObject_Type; +/* IsLittleEndian */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) +{ + union { + uint32_t u32; + uint8_t u8[4]; + } S; + S.u32 = 0x01020304; + return S.u8[0] == 4; } -static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { - PyObject *mro; - if (a == b) return 1; - mro = a->tp_mro; - if (likely(mro)) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(mro); - for (i = 0; i < n; i++) { - if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) - return 1; + +/* BufferFormatCheck */ +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type) { + stack[0].field = &ctx->root; + stack[0].parent_offset = 0; + ctx->root.type = type; + ctx->root.name = "buffer dtype"; + ctx->root.offset = 0; + ctx->head = stack; + ctx->head->field = &ctx->root; + ctx->fmt_offset = 0; + ctx->head->parent_offset = 0; + ctx->new_packmode = '@'; + ctx->enc_packmode = '@'; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->is_complex = 0; + ctx->is_valid_array = 0; + ctx->struct_alignment = 0; + while (type->typegroup == 'S') { + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = 0; + type = type->fields->type; + } +} +static int __Pyx_BufFmt_ParseNumber(const char** ts) { + int count; + const char* t = *ts; + if (*t < '0' || *t > '9') { + return -1; + } else { + count = *t++ - '0'; + while (*t >= '0' && *t <= '9') { + count *= 10; + count += *t++ - '0'; } - return 0; } - return __Pyx_InBases(a, b); + *ts = t; + return count; } -#if PY_MAJOR_VERSION == 2 -static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { - PyObject *exception, *value, *tb; - int res; - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ErrFetch(&exception, &value, &tb); - res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; - if (unlikely(res == -1)) { - PyErr_WriteUnraisable(err); - res = 0; +static int __Pyx_BufFmt_ExpectNumber(const char **ts) { + int number = __Pyx_BufFmt_ParseNumber(ts); + if (number == -1) + PyErr_Format(PyExc_ValueError,\ + "Does not understand character buffer dtype format string ('%c')", **ts); + return number; +} +static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { + PyErr_Format(PyExc_ValueError, + "Unexpected format string character: '%c'", ch); +} +static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { + switch (ch) { + case '?': return "'bool'"; + case 'c': return "'char'"; + case 'b': return "'signed char'"; + case 'B': return "'unsigned char'"; + case 'h': return "'short'"; + case 'H': return "'unsigned short'"; + case 'i': return "'int'"; + case 'I': return "'unsigned int'"; + case 'l': return "'long'"; + case 'L': return "'unsigned long'"; + case 'q': return "'long long'"; + case 'Q': return "'unsigned long long'"; + case 'f': return (is_complex ? "'complex float'" : "'float'"); + case 'd': return (is_complex ? "'complex double'" : "'double'"); + case 'g': return (is_complex ? "'complex long double'" : "'long double'"); + case 'T': return "a struct"; + case 'O': return "Python object"; + case 'P': return "a pointer"; + case 's': case 'p': return "a string"; + case 0: return "end"; + default: return "unparseable format string"; + } +} +static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return 2; + case 'i': case 'I': case 'l': case 'L': return 4; + case 'q': case 'Q': return 8; + case 'f': return (is_complex ? 8 : 4); + case 'd': return (is_complex ? 16 : 8); + case 'g': { + PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); + return 0; } - if (!res) { - res = PyObject_IsSubclass(err, exc_type2); - if (unlikely(res == -1)) { - PyErr_WriteUnraisable(err); - res = 0; - } + case 'O': case 'P': return sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; } - __Pyx_ErrRestore(exception, value, tb); - return res; } -#else -static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { - int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; - if (!res) { - res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); +static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(short); + case 'i': case 'I': return sizeof(int); + case 'l': case 'L': return sizeof(long); + #ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(PY_LONG_LONG); + #endif + case 'f': return sizeof(float) * (is_complex ? 2 : 1); + case 'd': return sizeof(double) * (is_complex ? 2 : 1); + case 'g': return sizeof(long double) * (is_complex ? 2 : 1); + case 'O': case 'P': return sizeof(void*); + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; } - return res; + } } +typedef struct { char c; short x; } __Pyx_st_short; +typedef struct { char c; int x; } __Pyx_st_int; +typedef struct { char c; long x; } __Pyx_st_long; +typedef struct { char c; float x; } __Pyx_st_float; +typedef struct { char c; double x; } __Pyx_st_double; +typedef struct { char c; long double x; } __Pyx_st_longdouble; +typedef struct { char c; void *x; } __Pyx_st_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; #endif -static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { - Py_ssize_t i, n; - assert(PyExceptionClass_Check(exc_type)); - n = PyTuple_GET_SIZE(tuple); -#if PY_MAJOR_VERSION >= 3 - for (i=0; ihead == NULL || ctx->head->field == &ctx->root) { + const char* expected; + const char* quote; + if (ctx->head == NULL) { + expected = "end"; + quote = ""; + } else { + expected = ctx->head->field->type->name; + quote = "'"; + } + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected %s%s%s but got %s", + quote, expected, quote, + __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); + } else { + __Pyx_StructField* field = ctx->head->field; + __Pyx_StructField* parent = (ctx->head - 1)->field; + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", + field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), + parent->type->name, field->name); + } +} +static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { + char group; + size_t size, offset, arraysize = 1; + if (ctx->enc_type == 0) return 0; + if (ctx->head->field->type->arraysize[0]) { + int i, ndim = 0; + if (ctx->enc_type == 's' || ctx->enc_type == 'p') { + ctx->is_valid_array = ctx->head->field->type->ndim == 1; + ndim = 1; + if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { + PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %zu", + ctx->head->field->type->arraysize[0], ctx->enc_count); + return -1; + } + } + if (!ctx->is_valid_array) { + PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", + ctx->head->field->type->ndim, ndim); + return -1; + } + for (i = 0; i < ctx->head->field->type->ndim; i++) { + arraysize *= ctx->head->field->type->arraysize[i]; + } + ctx->is_valid_array = 0; + ctx->enc_count = 1; + } + group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); + do { + __Pyx_StructField* field = ctx->head->field; + __Pyx_TypeInfo* type = field->type; + if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { + size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); + } else { + size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); + } + if (ctx->enc_packmode == '@') { + size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); + size_t align_mod_offset; + if (align_at == 0) return -1; + align_mod_offset = ctx->fmt_offset % align_at; + if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; + if (ctx->struct_alignment == 0) + ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, + ctx->is_complex); + } + if (type->size != size || type->typegroup != group) { + if (type->typegroup == 'C' && type->fields != NULL) { + size_t parent_offset = ctx->head->parent_offset + field->offset; + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = parent_offset; + continue; + } + if ((type->typegroup == 'H' || group == 'H') && type->size == size) { + } else { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + } + offset = ctx->head->parent_offset + field->offset; + if (ctx->fmt_offset != offset) { + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", + (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); + return -1; + } + ctx->fmt_offset += size; + if (arraysize) + ctx->fmt_offset += (arraysize - 1) * size; + --ctx->enc_count; + while (1) { + if (field == &ctx->root) { + ctx->head = NULL; + if (ctx->enc_count != 0) { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + break; + } + ctx->head->field = ++field; + if (field->type == NULL) { + --ctx->head; + field = ctx->head->field; + continue; + } else if (field->type->typegroup == 'S') { + size_t parent_offset = ctx->head->parent_offset + field->offset; + if (field->type->fields->type == NULL) continue; + field = field->type->fields; + ++ctx->head; + ctx->head->field = field; + ctx->head->parent_offset = parent_offset; + break; + } else { + break; + } + } + } while (ctx->enc_count); + ctx->enc_type = 0; + ctx->is_complex = 0; + return 0; +} +static PyObject * +__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) +{ + const char *ts = *tsp; + int i = 0, number, ndim; + ++ts; + if (ctx->new_count != 1) { + PyErr_SetString(PyExc_ValueError, + "Cannot handle repeated arrays in format string"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ndim = ctx->head->field->type->ndim; + while (*ts && *ts != ')') { + switch (*ts) { + case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; + default: break; + } + number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) + return PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %d", + ctx->head->field->type->arraysize[i], number); + if (*ts != ',' && *ts != ')') + return PyErr_Format(PyExc_ValueError, + "Expected a comma in format string, got '%c'", *ts); + if (*ts == ',') ts++; + i++; + } + if (i != ndim) + return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", + ctx->head->field->type->ndim, i); + if (!*ts) { + PyErr_SetString(PyExc_ValueError, + "Unexpected end of format string, expected ')'"); + return NULL; + } + ctx->is_valid_array = 1; + ctx->new_count = 1; + *tsp = ++ts; + return Py_None; +} +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { + int got_Z = 0; + while (1) { + switch(*ts) { + case 0: + if (ctx->enc_type != 0 && ctx->head == NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + if (ctx->head != NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + return ts; + case ' ': + case '\r': + case '\n': + ++ts; + break; + case '<': + if (!__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '>': + case '!': + if (__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '=': + case '@': + case '^': + ctx->new_packmode = *ts++; + break; + case 'T': + { + const char* ts_after_sub; + size_t i, struct_count = ctx->new_count; + size_t struct_alignment = ctx->struct_alignment; + ctx->new_count = 1; + ++ts; + if (*ts != '{') { + PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + ctx->enc_count = 0; + ctx->struct_alignment = 0; + ++ts; + ts_after_sub = ts; + for (i = 0; i != struct_count; ++i) { + ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); + if (!ts_after_sub) return NULL; + } + ts = ts_after_sub; + if (struct_alignment) ctx->struct_alignment = struct_alignment; + } + break; + case '}': + { + size_t alignment = ctx->struct_alignment; + ++ts; + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + if (alignment && ctx->fmt_offset % alignment) { + ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); + } + } + return ts; + case 'x': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->fmt_offset += ctx->new_count; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->enc_packmode = ctx->new_packmode; + ++ts; + break; + case 'Z': + got_Z = 1; + ++ts; + if (*ts != 'f' && *ts != 'd' && *ts != 'g') { + __Pyx_BufFmt_RaiseUnexpectedChar('Z'); + return NULL; + } + CYTHON_FALLTHROUGH; + case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': + case 'l': case 'L': case 'q': case 'Q': + case 'f': case 'd': case 'g': + case 'O': case 'p': + if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) && + (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) { + ctx->enc_count += ctx->new_count; + ctx->new_count = 1; + got_Z = 0; + ++ts; + break; + } + CYTHON_FALLTHROUGH; + case 's': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_count = ctx->new_count; + ctx->enc_packmode = ctx->new_packmode; + ctx->enc_type = *ts; + ctx->is_complex = got_Z; + ++ts; + ctx->new_count = 1; + got_Z = 0; + break; + case ':': + ++ts; + while(*ts != ':') ++ts; + ++ts; + break; + case '(': + if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; + break; + default: + { + int number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + ctx->new_count = (size_t)number; + } + } + } +} + +/* TypeInfoCompare */ + static int +__pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b) +{ + int i; + if (!a || !b) + return 0; + if (a == b) + return 1; + if (a->size != b->size || a->typegroup != b->typegroup || + a->is_unsigned != b->is_unsigned || a->ndim != b->ndim) { + if (a->typegroup == 'H' || b->typegroup == 'H') { + return a->size == b->size; } else { + return 0; + } + } + if (a->ndim) { + for (i = 0; i < a->ndim; i++) + if (a->arraysize[i] != b->arraysize[i]) + return 0; + } + if (a->typegroup == 'S') { + if (a->flags != b->flags) + return 0; + if (a->fields || b->fields) { + if (!(a->fields && b->fields)) + return 0; + for (i = 0; a->fields[i].type && b->fields[i].type; i++) { + __Pyx_StructField *field_a = a->fields + i; + __Pyx_StructField *field_b = b->fields + i; + if (field_a->offset != field_b->offset || + !__pyx_typeinfo_cmp(field_a->type, field_b->type)) + return 0; + } + return !a->fields[i].type && !b->fields[i].type; + } + } + return 1; +} + +/* MemviewSliceValidateAndInit */ + static int +__pyx_check_strides(Py_buffer *buf, int dim, int ndim, int spec) +{ + if (buf->shape[dim] <= 1) + return 1; + if (buf->strides) { + if (spec & __Pyx_MEMVIEW_CONTIG) { + if (spec & (__Pyx_MEMVIEW_PTR|__Pyx_MEMVIEW_FULL)) { + if (unlikely(buf->strides[dim] != sizeof(void *))) { + PyErr_Format(PyExc_ValueError, + "Buffer is not indirectly contiguous " + "in dimension %d.", dim); + goto fail; + } + } else if (unlikely(buf->strides[dim] != buf->itemsize)) { + PyErr_SetString(PyExc_ValueError, + "Buffer and memoryview are not contiguous " + "in the same dimension."); + goto fail; + } + } + if (spec & __Pyx_MEMVIEW_FOLLOW) { + Py_ssize_t stride = buf->strides[dim]; + if (stride < 0) + stride = -stride; + if (unlikely(stride < buf->itemsize)) { + PyErr_SetString(PyExc_ValueError, + "Buffer and memoryview are not contiguous " + "in the same dimension."); + goto fail; + } + } + } else { + if (unlikely(spec & __Pyx_MEMVIEW_CONTIG && dim != ndim - 1)) { + PyErr_Format(PyExc_ValueError, + "C-contiguous buffer is not contiguous in " + "dimension %d", dim); + goto fail; + } else if (unlikely(spec & (__Pyx_MEMVIEW_PTR))) { + PyErr_Format(PyExc_ValueError, + "C-contiguous buffer is not indirect in " + "dimension %d", dim); + goto fail; + } else if (unlikely(buf->suboffsets)) { + PyErr_SetString(PyExc_ValueError, + "Buffer exposes suboffsets but no strides"); + goto fail; } } + return 1; +fail: return 0; } -static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject* exc_type) { - if (likely(err == exc_type)) return 1; - if (likely(PyExceptionClass_Check(err))) { - if (likely(PyExceptionClass_Check(exc_type))) { - return __Pyx_inner_PyErr_GivenExceptionMatches2(err, NULL, exc_type); - } else if (likely(PyTuple_Check(exc_type))) { - return __Pyx_PyErr_GivenExceptionMatchesTuple(err, exc_type); - } else { +static int +__pyx_check_suboffsets(Py_buffer *buf, int dim, CYTHON_UNUSED int ndim, int spec) +{ + if (spec & __Pyx_MEMVIEW_DIRECT) { + if (unlikely(buf->suboffsets && buf->suboffsets[dim] >= 0)) { + PyErr_Format(PyExc_ValueError, + "Buffer not compatible with direct access " + "in dimension %d.", dim); + goto fail; } } - return PyErr_GivenExceptionMatches(err, exc_type); + if (spec & __Pyx_MEMVIEW_PTR) { + if (unlikely(!buf->suboffsets || (buf->suboffsets[dim] < 0))) { + PyErr_Format(PyExc_ValueError, + "Buffer is not indirectly accessible " + "in dimension %d.", dim); + goto fail; + } + } + return 1; +fail: + return 0; } -static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *exc_type1, PyObject *exc_type2) { - assert(PyExceptionClass_Check(exc_type1)); - assert(PyExceptionClass_Check(exc_type2)); - if (likely(err == exc_type1 || err == exc_type2)) return 1; - if (likely(PyExceptionClass_Check(err))) { - return __Pyx_inner_PyErr_GivenExceptionMatches2(err, exc_type1, exc_type2); +static int +__pyx_verify_contig(Py_buffer *buf, int ndim, int c_or_f_flag) +{ + int i; + if (c_or_f_flag & __Pyx_IS_F_CONTIG) { + Py_ssize_t stride = 1; + for (i = 0; i < ndim; i++) { + if (unlikely(stride * buf->itemsize != buf->strides[i] && buf->shape[i] > 1)) { + PyErr_SetString(PyExc_ValueError, + "Buffer not fortran contiguous."); + goto fail; + } + stride = stride * buf->shape[i]; + } + } else if (c_or_f_flag & __Pyx_IS_C_CONTIG) { + Py_ssize_t stride = 1; + for (i = ndim - 1; i >- 1; i--) { + if (unlikely(stride * buf->itemsize != buf->strides[i] && buf->shape[i] > 1)) { + PyErr_SetString(PyExc_ValueError, + "Buffer not C contiguous."); + goto fail; + } + stride = stride * buf->shape[i]; + } } - return (PyErr_GivenExceptionMatches(err, exc_type1) || PyErr_GivenExceptionMatches(err, exc_type2)); + return 1; +fail: + return 0; +} +static int __Pyx_ValidateAndInit_memviewslice( + int *axes_specs, + int c_or_f_flag, + int buf_flags, + int ndim, + __Pyx_TypeInfo *dtype, + __Pyx_BufFmt_StackElem stack[], + __Pyx_memviewslice *memviewslice, + PyObject *original_obj) +{ + struct __pyx_memoryview_obj *memview, *new_memview; + __Pyx_RefNannyDeclarations + Py_buffer *buf; + int i, spec = 0, retval = -1; + __Pyx_BufFmt_Context ctx; + int from_memoryview = __pyx_memoryview_check(original_obj); + __Pyx_RefNannySetupContext("ValidateAndInit_memviewslice", 0); + if (from_memoryview && __pyx_typeinfo_cmp(dtype, ((struct __pyx_memoryview_obj *) + original_obj)->typeinfo)) { + memview = (struct __pyx_memoryview_obj *) original_obj; + new_memview = NULL; + } else { + memview = (struct __pyx_memoryview_obj *) __pyx_memoryview_new( + original_obj, buf_flags, 0, dtype); + new_memview = memview; + if (unlikely(!memview)) + goto fail; + } + buf = &memview->view; + if (unlikely(buf->ndim != ndim)) { + PyErr_Format(PyExc_ValueError, + "Buffer has wrong number of dimensions (expected %d, got %d)", + ndim, buf->ndim); + goto fail; + } + if (new_memview) { + __Pyx_BufFmt_Init(&ctx, stack, dtype); + if (unlikely(!__Pyx_BufFmt_CheckString(&ctx, buf->format))) goto fail; + } + if (unlikely((unsigned) buf->itemsize != dtype->size)) { + PyErr_Format(PyExc_ValueError, + "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "u byte%s) " + "does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "u byte%s)", + buf->itemsize, + (buf->itemsize > 1) ? "s" : "", + dtype->name, + dtype->size, + (dtype->size > 1) ? "s" : ""); + goto fail; + } + if (buf->len > 0) { + for (i = 0; i < ndim; i++) { + spec = axes_specs[i]; + if (unlikely(!__pyx_check_strides(buf, i, ndim, spec))) + goto fail; + if (unlikely(!__pyx_check_suboffsets(buf, i, ndim, spec))) + goto fail; + } + if (unlikely(buf->strides && !__pyx_verify_contig(buf, ndim, c_or_f_flag))) + goto fail; + } + if (unlikely(__Pyx_init_memviewslice(memview, ndim, memviewslice, + new_memview != NULL) == -1)) { + goto fail; + } + retval = 0; + goto no_fail; +fail: + Py_XDECREF(new_memview); + retval = -1; +no_fail: + __Pyx_RefNannyFinishContext(); + return retval; +} + +/* ObjectToMemviewSlice */ + static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_ds_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) }; + int retcode; + if (obj == Py_None) { + result.memview = (struct __pyx_memoryview_obj *) Py_None; + return result; + } + retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, 0, + PyBUF_RECORDS_RO | writable_flag, 1, + &__Pyx_TypeInfo_double, stack, + &result, obj); + if (unlikely(retcode == -1)) + goto __pyx_fail; + return result; +__pyx_fail: + result.memview = NULL; + result.data = NULL; + return result; } -#endif /* 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()); @@ -3514,7 +21822,7 @@ static int __Pyx_check_binary_version(void) { } /* 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) { diff --git a/somsphere/cython/core.pyx b/somsphere/cython/core.pyx index 9acd5db..ab96b7e 100644 --- a/somsphere/cython/core.pyx +++ b/somsphere/cython/core.pyx @@ -1,12 +1,37 @@ #cython: language_level=3 import numpy -def get_best_cell(inputs, importance, n_pix, weights, return_vals=1): - """ - Return the closest cell to the input object - It can return more than one value if needed - """ - activations = numpy.sum(numpy.transpose([importance]) * ( - numpy.transpose(numpy.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0) - - return numpy.argmin(activations) if return_vals == 1 else numpy.argsort(activations)[0:return_vals], activations +from somsphere.utils import get_best_cell, count_modified_cells, timeit + +def create_map_batch(X, n_row, n_col, accum_w, accum_n, sigma, importance, n_pix, dist_lib, weights): + cdef int i, j, k + cdef int nr = n_row + cdef int nc = n_col + cdef int npix = n_pix + cdef double sig = sigma + cdef double[:] imp = importance + cdef double[:] an = accum_n + for i in range(nr): + inputs = X[i] + best, activation = get_best_cell(inputs=inputs, importance=imp, + weights=weights, n_pix=npix) + for j in range(nc): + accum_w[j, :] += count_modified_cells(best, dist_lib, sig) * inputs[j] + an += count_modified_cells(best, dist_lib, sig) + + for k in range(nc): + weights[k] = accum_w[k] / an + +def create_map_online(X, n_row, alpha, sigma, random_indices, importance, n_pix, dist_lib, weights): + cdef int i + cdef int nr = n_row + cdef int npix = n_pix + cdef double alp = alp + cdef double sig = sigma + cdef double[:] imp = importance + for i in range(nr): + inputs = X[random_indices[i]] + best, activation = get_best_cell(inputs=inputs, importance=imp, + weights=weights, n_pix=npix) + weights += alp * count_modified_cells(best, dist_lib, sig) * numpy.transpose( + (inputs - numpy.transpose(weights))) diff --git a/somsphere/utils/__init__.py b/somsphere/utils/__init__.py index 8104cde..c46c862 100644 --- a/somsphere/utils/__init__.py +++ b/somsphere/utils/__init__.py @@ -1,8 +1,35 @@ +import time +from functools import wraps +from timeit import timeit + import healpy as hp import numpy -from somsphere import Topology -from somsphere.models import DY +from somsphere.models import DY, Topology + + +def timeit(my_func): + @wraps(my_func) + def timed(*args, **kw): + tstart = time.time() + output = my_func(*args, **kw) + tend = time.time() + + print('"{}" took {:.3f} ms to execute\n'.format(my_func.__name__, (tend - tstart) * 1000)) + return output + + return timed + + +def get_best_cell(inputs, importance, n_pix, weights, return_vals=1): + """ + Return the closest cell to the input object + It can return more than one value if needed + """ + activations = numpy.sum(numpy.transpose([importance]) * ( + numpy.transpose(numpy.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0) + + return numpy.argmin(activations) if return_vals == 1 else numpy.argsort(activations)[0:return_vals], activations def get_index(ix, iy, nx, ny): @@ -58,6 +85,41 @@ def get_neighbors(ix, iy, nx, ny, index=False, hex=False): return numpy.array(ins) +def calc_distance(a, b, c, d): + return numpy.sqrt((a - b) ** 2 + (c - d) ** 2) + + +def is_power_2(value): + """ + Check if passed value is a power of 2 + """ + return value != 0 and ((value & (value - 1)) == 0) + + +def get_alpha(alpha_end, alpha_start, curr_t, total_t): + """ + Get value of alpha at a given time + """ + return alpha_start * numpy.power(alpha_end / alpha_start, float(curr_t) / float(total_t)) + + +def get_sigma(sigma_f, sigma_0, curr_t, total_t): + """ + Get value of sigma at a given time + """ + return sigma_0 * numpy.power(sigma_f / sigma_0, float(curr_t) / float(total_t)) + + +def count_modified_cells(bmu, map_d, sigma): + """ + Neighborhood function which quantifies how much cells around the best matching one are modified + + :param int bmu: best matching unit + :param float map_d: array of distances computed with :func:`geometry` + """ + return numpy.exp(-(map_d[bmu] ** 2) / sigma ** 2) + + def get_map_size(n_top, topology: Topology): if topology == Topology.SPHERE: return 12 * n_top ** 2 @@ -145,38 +207,3 @@ def compute_distance(topology: Topology, n_top, periodic=False): dist_lib[j, i] = dist_lib[i, j] return dist_lib, n_pix - - -def calc_distance(a, b, c, d): - return numpy.sqrt((a - b) ** 2 + (c - d) ** 2) - - -def is_power_2(value): - """ - Check if passed value is a power of 2 - """ - return value != 0 and ((value & (value - 1)) == 0) - - -def get_alpha(alpha_end, alpha_start, curr_t, total_t): - """ - Get value of alpha at a given time - """ - return alpha_start * numpy.power(alpha_end / alpha_start, float(curr_t) / float(total_t)) - - -def get_sigma(sigma_f, sigma_0, curr_t, total_t): - """ - Get value of sigma at a given time - """ - return sigma_0 * numpy.power(sigma_f / sigma_0, float(curr_t) / float(total_t)) - - -def count_modified_cells(bmu, map_d, sigma): - """ - Neighborhood function which quantifies how much cells around the best matching one are modified - - :param int bmu: best matching unit - :param float map_d: array of distances computed with :func:`geometry` - """ - return numpy.exp(-(map_d[bmu] ** 2) / sigma ** 2) From 3d200c2557074c9530502102f7aaa77726935643 Mon Sep 17 00:00:00 2001 From: Ruiqi Li Date: Mon, 5 Oct 2020 21:28:36 -0400 Subject: [PATCH 5/7] discussion --- Example.ipynb | 41 +- core.cpython-38-x86_64-linux-gnu.c | 1 + somsphere/__init__.py | 127 +- somsphere/cython/core.c | 24061 ++++++--------------------- somsphere/cython/core.html | 2230 +++ somsphere/cython/core.pyx | 130 +- somsphere/utils/__init__.py | 22 +- test/test_somap.py | 14 + 8 files changed, 7895 insertions(+), 18731 deletions(-) create mode 100644 core.cpython-38-x86_64-linux-gnu.c create mode 100644 somsphere/cython/core.html diff --git a/Example.ipynb b/Example.ipynb index 052cdf6..75e8ef0 100644 --- a/Example.ipynb +++ b/Example.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 16, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -27,7 +27,7 @@ "(5000, 9)" ] }, - "execution_count": 17, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -40,7 +40,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -49,7 +49,7 @@ "(5000,)" ] }, - "execution_count": 18, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -62,7 +62,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -72,40 +72,51 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Finished in 27.136485815048218\n" + "\"__create_map_online\" took 25723.258 ms to execute\n", + "\n" ] } ], "source": [ - "start = time.time()\n", - "M.create_map(Data_X, Data_Y) #This actually creates the map using only Data_X\n", - "print(f\"Finished in {time.time() - start}\")" + "M.create_map(Data_X, Data_Y) #This actually creates the map using only Data_X" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'M' is not defined", + "output_type": "error", + "traceback": [ + "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", + "\u001B[0;31mNameError\u001B[0m Traceback (most recent call last)", + "\u001B[0;32m\u001B[0m in \u001B[0;36m\u001B[0;34m\u001B[0m\n\u001B[0;32m----> 1\u001B[0;31m \u001B[0mM\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mevaluate_map\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m \u001B[0;31m# Will evaluate Data_Y, basically will take mean for every value of Y per cell\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m", + "\u001B[0;31mNameError\u001B[0m: name 'M' is not defined" + ] + } + ], "source": [ "M.evaluate_map() # Will evaluate Data_Y, basically will take mean for every value of Y per cell" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/core.cpython-38-x86_64-linux-gnu.c b/core.cpython-38-x86_64-linux-gnu.c new file mode 100644 index 0000000..06f2230 --- /dev/null +++ b/core.cpython-38-x86_64-linux-gnu.c @@ -0,0 +1 @@ +#error Do not use this file, it is the result of a failed Cython compilation. diff --git a/somsphere/__init__.py b/somsphere/__init__.py index f28fb68..3f303ea 100644 --- a/somsphere/__init__.py +++ b/somsphere/__init__.py @@ -18,7 +18,8 @@ from matplotlib.colors import colorConverter from somsphere.models import Topology, DY, SomType -from somsphere.utils import compute_distance, get_best_cell, get_sigma, get_alpha, is_power_2, timeit +from somsphere.utils import compute_distance, get_sigma, get_alpha, is_power_2, timeit, count_modified_cells, \ + get_best_cell class SOMap(object): @@ -33,7 +34,7 @@ class SOMap(object): for hex Size=n_top*(n_top+1[2]) if n_top is even[odd] and for sphere Size=12*n_top*n_top and top must be power of 2 :param int n_iter: Number of iteration the entire sample is processed - :param str periodic: Use periodic boundary conditions ('yes'/'no'), valid for 'hex' and 'grid' only + :param bool periodic: Use periodic boundary conditions, valid for 'hex' and 'grid' only :param dict dict_dim: dictionary with attributes names :param float alpha_start: Initial value of alpha :param float alpha_end: End value of alpha @@ -68,69 +69,73 @@ def create_map(self, X, Y, importance=None, inputs_weights=None, random_order=Tr self.X[0][0] if self.som_type == SomType.ONLINE: - self.__create_map_online(n_row=n_row, random_order=random_order, eval_map=eval_map) + self.__create_map_online(n_row=n_row, n_col=n_col, random_order=random_order, eval_map=eval_map) elif self.som_type == SomType.BATCH: self.__create_map_batch(n_row=n_row, n_col=n_col, eval_map=eval_map) else: raise Exception(f"Unknown type: {self.som_type}") - @timeit - def __create_map_online(self, n_row, random_order=True, eval_map=False): - t, total_t = 0, self.n_iter * n_row - sigma_0 = self.dist_lib.max() - sigma_f = numpy.min(self.dist_lib[numpy.where(self.dist_lib > 0.)]) - - for it in range(self.n_iter): - alpha = get_alpha(self.alpha_end, self.alpha_start, t, total_t) - sigma = get_sigma(sigma_f, sigma_0, t, total_t) - random_indices = random.sample(range(n_row), n_row) if random_order else numpy.arange( - n_row) - core.create_map_online(X=self.X, n_row=n_row, alpha=alpha, sigma=sigma, - random_indices=random_indices, importance=self.importance, - weights=self.weights, n_pix=self.n_pix, dist_lib=self.dist_lib) - - # for i in range(n_row): - # inputs = self.X[random_indices[i]] - # best, activation = get_best_cell(inputs=inputs, importance=self.importance, - # weights=self.weights, n_pix=self.n_pix) - # self.weights += alpha * count_modified_cells(best, self.dist_lib, sigma) * numpy.transpose( - # (inputs - numpy.transpose(self.weights))) - - t += n_row - - if eval_map: - self.evaluate_map() - self.save_map(itn=it) + def __create_map_online(self, n_row, n_col, random_order=True, eval_map=False): + + core.create_map_online(self.X, self.n_iter, n_row, n_col, self.n_pix, self.alpha_start, self.alpha_end, + self.importance, self.dist_lib, self.weights, random_order) + # t, total_t = 0, self.n_iter * n_row + # sigma_0 = self.dist_lib.max() + # sigma_f = numpy.min(self.dist_lib[numpy.where(self.dist_lib > 0.)]) + # + # for it in range(self.n_iter): + # alpha = get_alpha(self.alpha_end, self.alpha_start, t, total_t) + # sigma = get_sigma(sigma_f, sigma_0, t, total_t) + # random_indices = random.sample(range(n_row), n_row) if random_order else numpy.arange( + # n_row) + # # core.create_map_online(X=self.X, n_row=n_row, alpha=alpha, sigma=sigma, + # # random_indices=random_indices, importance=self.importance, + # # weights=self.weights, n_pix=self.n_pix, dist_lib=self.dist_lib) + # + # for i in range(n_row): + # inputs = self.X[random_indices[i]] + # best, activation = get_best_cell(inputs=inputs, importance=self.importance, + # weights=self.weights, n_pix=self.n_pix, return_vals=1) + # self.weights += alpha * count_modified_cells(1, self.dist_lib, sigma) * numpy.transpose( + # (inputs - numpy.transpose(self.weights))) + # continue + + # t += n_row + + # if eval_map: + # self.evaluate_map() + # self.save_map(itn=it) @timeit def __create_map_batch(self, n_row, n_col, eval_map=False): - t, total_t = 0, self.n_iter * n_row - sigma_0 = self.dist_lib.max() - sigma_f = numpy.min(self.dist_lib[numpy.where(self.dist_lib > 0.)]) - - for it in range(self.n_iter): - sigma = get_sigma(sigma_f, sigma_0, t, total_t) - accum_w = numpy.zeros((n_col, self.n_pix)) - accum_n = numpy.zeros(self.n_pix) - core.create_map_batch(X=self.X, n_row=n_row, n_col=n_col, accum_n=accum_n, accum_w=accum_w, sigma=sigma, - importance=self.importance, weights=self.weights, n_pix=self.n_pix, - dist_lib=self.dist_lib) - # for i in range(n_row): - # inputs = self.X[i] - # best, activation = get_best_cell(inputs=inputs, importance=self.importance, - # weights=self.weights, n_pix=self.n_pix) - # for kk in range(n_col): - # accum_w[kk, :] += count_modified_cells(best, self.dist_lib, sigma) * inputs[kk] - # accum_n += count_modified_cells(best, self.dist_lib, sigma) - # - # for kk in range(n_col): - # self.weights[kk] = accum_w[kk] / accum_n - - t += n_row - - if eval_map: - self.evaluate_map() - self.save_map(itn=it) + return + # t, total_t = 0, self.n_iter * n_row + # sigma_0 = self.dist_lib.max() + # sigma_f = numpy.min(self.dist_lib[numpy.where(self.dist_lib > 0.)]) + # + # for it in range(self.n_iter): + # sigma = get_sigma(sigma_f, sigma_0, t, total_t) + # accum_w = numpy.zeros((n_col, self.n_pix)) + # accum_n = numpy.zeros(self.n_pix) + # core.create_map_batch(X=self.X, n_row=n_row, n_col=n_col, accum_n=accum_n, accum_w=accum_w, sigma=sigma, + # importance=self.importance, weights=self.weights, n_pix=self.n_pix, + # dist_lib=self.dist_lib) + # for i in range(n_row): + # inputs = self.X[i] + # best, activation = get_best_cell(inputs=inputs, importance=self.importance, + # weights=self.weights, n_pix=self.n_pix) + # for kk in range(n_col): + # accum_w[kk, :] += count_modified_cells(best, self.dist_lib, sigma) * inputs[kk] + # accum_n += count_modified_cells(best, self.dist_lib, sigma) + # + # for kk in range(n_col): + # self.weights[kk] = accum_w[kk] / accum_n + # + # t += n_row + # + # if eval_map: + # self.evaluate_map() + # self.save_map(itn=it) def evaluate_map(self, input_x=None, input_y=None): """ @@ -148,8 +153,8 @@ def evaluate_map(self, input_x=None, input_y=None): in_y = self.Y if input_y is None else input_y for i in range(len(in_x)): inputs = in_x[i] - best, activation = get_best_cell(inputs=inputs, importance=self.importance, weights=self.weights, - n_pix=self.n_pix) + best, activation = core.get_best_cell(inputs=inputs, importance=self.importance, weights=self.weights, + n_pix=self.n_pix) if best not in self.y_vals: self.y_vals[best] = [] self.y_vals[best].append(in_y[i]) @@ -168,8 +173,8 @@ def predict(self, line, best=True): :param bool best: Set to True to get only the best cell; otherwise the 10 closest cells will be returned :return: array with the cell content """ - bests, _ = get_best_cell(inputs=line, importance=self.importance, weights=self.weights, n_pix=self.n_pix, - return_vals=10) + bests, _ = core.get_best_cell(inputs=line, importance=self.importance, weights=self.weights, n_pix=self.n_pix, + return_vals=10) if best: return bests[0] for ib in range(10): diff --git a/somsphere/cython/core.c b/somsphere/cython/core.c index 5ac34eb..84c71b7 100644 --- a/somsphere/cython/core.c +++ b/somsphere/cython/core.c @@ -3,6 +3,7 @@ /* BEGIN: Cython Metadata { "distutils": { + "depends": [], "name": "core", "sources": [ "somsphere/cython/core.pyx" @@ -617,11 +618,13 @@ static CYTHON_INLINE float __PYX_NAN() { #define __PYX_HAVE__core #define __PYX_HAVE_API__core /* Early includes */ -#include "pythread.h" #include -#include #include -#include "pystate.h" +#include "numpy/arrayobject.h" +#include "numpy/ufuncobject.h" + + /* NumPy API declarations from "numpy/__init__.pxd" */ + #ifdef _OPENMP #include #endif /* _OPENMP */ @@ -828,250 +831,294 @@ static int __pyx_clineno = 0; static const char * __pyx_cfilenm= __FILE__; static const char *__pyx_filename; +/* Header.proto */ +#if !defined(CYTHON_CCOMPLEX) + #if defined(__cplusplus) + #define CYTHON_CCOMPLEX 1 + #elif defined(_Complex_I) + #define CYTHON_CCOMPLEX 1 + #else + #define CYTHON_CCOMPLEX 0 + #endif +#endif +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #include + #else + #include + #endif +#endif +#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) + #undef _Complex_I + #define _Complex_I 1.0fj +#endif + static const char *__pyx_f[] = { "somsphere/cython/core.pyx", - "stringsource", + "__init__.pxd", + "type.pxd", }; -/* MemviewSliceStruct.proto */ -struct __pyx_memoryview_obj; -typedef struct { - struct __pyx_memoryview_obj *memview; - char *data; - Py_ssize_t shape[8]; - Py_ssize_t strides[8]; - Py_ssize_t suboffsets[8]; -} __Pyx_memviewslice; -#define __Pyx_MemoryView_Len(m) (m.shape[0]) - -/* Atomics.proto */ -#include -#ifndef CYTHON_ATOMICS - #define CYTHON_ATOMICS 1 -#endif -#define __pyx_atomic_int_type int -#if CYTHON_ATOMICS && __GNUC__ >= 4 && (__GNUC_MINOR__ > 1 ||\ - (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL >= 2)) &&\ - !defined(__i386__) - #define __pyx_atomic_incr_aligned(value, lock) __sync_fetch_and_add(value, 1) - #define __pyx_atomic_decr_aligned(value, lock) __sync_fetch_and_sub(value, 1) - #ifdef __PYX_DEBUG_ATOMICS - #warning "Using GNU atomics" - #endif -#elif CYTHON_ATOMICS && defined(_MSC_VER) && 0 - #include - #undef __pyx_atomic_int_type - #define __pyx_atomic_int_type LONG - #define __pyx_atomic_incr_aligned(value, lock) InterlockedIncrement(value) - #define __pyx_atomic_decr_aligned(value, lock) InterlockedDecrement(value) - #ifdef __PYX_DEBUG_ATOMICS - #pragma message ("Using MSVC atomics") - #endif -#elif CYTHON_ATOMICS && (defined(__ICC) || defined(__INTEL_COMPILER)) && 0 - #define __pyx_atomic_incr_aligned(value, lock) _InterlockedIncrement(value) - #define __pyx_atomic_decr_aligned(value, lock) _InterlockedDecrement(value) - #ifdef __PYX_DEBUG_ATOMICS - #warning "Using Intel atomics" - #endif -#else - #undef CYTHON_ATOMICS - #define CYTHON_ATOMICS 0 - #ifdef __PYX_DEBUG_ATOMICS - #warning "Not using atomics" - #endif -#endif -typedef volatile __pyx_atomic_int_type __pyx_atomic_int; -#if CYTHON_ATOMICS - #define __pyx_add_acquisition_count(memview)\ - __pyx_atomic_incr_aligned(__pyx_get_slice_count_pointer(memview), memview->lock) - #define __pyx_sub_acquisition_count(memview)\ - __pyx_atomic_decr_aligned(__pyx_get_slice_count_pointer(memview), memview->lock) -#else - #define __pyx_add_acquisition_count(memview)\ - __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) - #define __pyx_sub_acquisition_count(memview)\ - __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) -#endif -/* ForceInitThreads.proto */ -#ifndef __PYX_FORCE_INIT_THREADS - #define __PYX_FORCE_INIT_THREADS 0 -#endif +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":697 + * # in Cython to enable them only on the right systems. + * + * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + */ +typedef npy_int8 __pyx_t_5numpy_int8_t; -/* NoFastGil.proto */ -#define __Pyx_PyGILState_Ensure PyGILState_Ensure -#define __Pyx_PyGILState_Release PyGILState_Release -#define __Pyx_FastGIL_Remember() -#define __Pyx_FastGIL_Forget() -#define __Pyx_FastGilFuncInit() - -/* BufferFormatStructs.proto */ -#define IS_UNSIGNED(type) (((type) -1) > 0) -struct __Pyx_StructField_; -#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) -typedef struct { - const char* name; - struct __Pyx_StructField_* fields; - size_t size; - size_t arraysize[8]; - int ndim; - char typegroup; - char is_unsigned; - int flags; -} __Pyx_TypeInfo; -typedef struct __Pyx_StructField_ { - __Pyx_TypeInfo* type; - const char* name; - size_t offset; -} __Pyx_StructField; -typedef struct { - __Pyx_StructField* field; - size_t parent_offset; -} __Pyx_BufFmt_StackElem; -typedef struct { - __Pyx_StructField root; - __Pyx_BufFmt_StackElem* head; - size_t fmt_offset; - size_t new_count, enc_count; - size_t struct_alignment; - int is_complex; - char enc_type; - char new_packmode; - char enc_packmode; - char is_valid_array; -} __Pyx_BufFmt_Context; +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":698 + * + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t + */ +typedef npy_int16 __pyx_t_5numpy_int16_t; +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":699 + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< + * ctypedef npy_int64 int64_t + * #ctypedef npy_int96 int96_t + */ +typedef npy_int32 __pyx_t_5numpy_int32_t; -/*--- Type declarations ---*/ -struct __pyx_array_obj; -struct __pyx_MemviewEnum_obj; -struct __pyx_memoryview_obj; -struct __pyx_memoryviewslice_obj; +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":700 + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< + * #ctypedef npy_int96 int96_t + * #ctypedef npy_int128 int128_t + */ +typedef npy_int64 __pyx_t_5numpy_int64_t; -/* "View.MemoryView":105 +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":704 + * #ctypedef npy_int128 int128_t * - * @cname("__pyx_array") - * cdef class array: # <<<<<<<<<<<<<< + * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + */ +typedef npy_uint8 __pyx_t_5numpy_uint8_t; + +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":705 * - * cdef: + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t */ -struct __pyx_array_obj { - PyObject_HEAD - struct __pyx_vtabstruct_array *__pyx_vtab; - char *data; - Py_ssize_t len; - char *format; - int ndim; - Py_ssize_t *_shape; - Py_ssize_t *_strides; - Py_ssize_t itemsize; - PyObject *mode; - PyObject *_format; - void (*callback_free_data)(void *); - int free_data; - int dtype_is_object; -}; +typedef npy_uint16 __pyx_t_5numpy_uint16_t; + +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":706 + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< + * ctypedef npy_uint64 uint64_t + * #ctypedef npy_uint96 uint96_t + */ +typedef npy_uint32 __pyx_t_5numpy_uint32_t; +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":707 + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< + * #ctypedef npy_uint96 uint96_t + * #ctypedef npy_uint128 uint128_t + */ +typedef npy_uint64 __pyx_t_5numpy_uint64_t; -/* "View.MemoryView":279 +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":711 + * #ctypedef npy_uint128 uint128_t * - * @cname('__pyx_MemviewEnum') - * cdef class Enum(object): # <<<<<<<<<<<<<< - * cdef object name - * def __init__(self, name): + * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< + * ctypedef npy_float64 float64_t + * #ctypedef npy_float80 float80_t */ -struct __pyx_MemviewEnum_obj { - PyObject_HEAD - PyObject *name; -}; +typedef npy_float32 __pyx_t_5numpy_float32_t; + +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":712 + * + * ctypedef npy_float32 float32_t + * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< + * #ctypedef npy_float80 float80_t + * #ctypedef npy_float128 float128_t + */ +typedef npy_float64 __pyx_t_5numpy_float64_t; +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":721 + * # The int types are mapped a bit surprising -- + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t + */ +typedef npy_long __pyx_t_5numpy_int_t; -/* "View.MemoryView":330 +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":722 + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong longlong_t * - * @cname('__pyx_memoryview') - * cdef class memoryview(object): # <<<<<<<<<<<<<< + */ +typedef npy_longlong __pyx_t_5numpy_long_t; + +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":723 + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< * - * cdef object obj + * ctypedef npy_ulong uint_t */ -struct __pyx_memoryview_obj { - PyObject_HEAD - struct __pyx_vtabstruct_memoryview *__pyx_vtab; - PyObject *obj; - PyObject *_size; - PyObject *_array_interface; - PyThread_type_lock lock; - __pyx_atomic_int acquisition_count[2]; - __pyx_atomic_int *acquisition_count_aligned_p; - Py_buffer view; - int flags; - int dtype_is_object; - __Pyx_TypeInfo *typeinfo; -}; +typedef npy_longlong __pyx_t_5numpy_longlong_t; +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":725 + * ctypedef npy_longlong longlong_t + * + * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t + */ +typedef npy_ulong __pyx_t_5numpy_uint_t; -/* "View.MemoryView":965 +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":726 * - * @cname('__pyx_memoryviewslice') - * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< - * "Internal class for passing memoryview slices to Python" + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulonglong_t * */ -struct __pyx_memoryviewslice_obj { - struct __pyx_memoryview_obj __pyx_base; - __Pyx_memviewslice from_slice; - PyObject *from_object; - PyObject *(*to_object_func)(char *); - int (*to_dtype_func)(char *, PyObject *); -}; +typedef npy_ulonglong __pyx_t_5numpy_ulong_t; +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":727 + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_intp intp_t + */ +typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":729 + * ctypedef npy_ulonglong ulonglong_t + * + * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< + * ctypedef npy_uintp uintp_t + * + */ +typedef npy_intp __pyx_t_5numpy_intp_t; -/* "View.MemoryView":105 +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":730 * - * @cname("__pyx_array") - * cdef class array: # <<<<<<<<<<<<<< + * ctypedef npy_intp intp_t + * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< * - * cdef: + * ctypedef npy_double float_t */ +typedef npy_uintp __pyx_t_5numpy_uintp_t; -struct __pyx_vtabstruct_array { - PyObject *(*get_memview)(struct __pyx_array_obj *); -}; -static struct __pyx_vtabstruct_array *__pyx_vtabptr_array; +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":732 + * ctypedef npy_uintp uintp_t + * + * ctypedef npy_double float_t # <<<<<<<<<<<<<< + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t + */ +typedef npy_double __pyx_t_5numpy_float_t; +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":733 + * + * ctypedef npy_double float_t + * ctypedef npy_double double_t # <<<<<<<<<<<<<< + * ctypedef npy_longdouble longdouble_t + * + */ +typedef npy_double __pyx_t_5numpy_double_t; -/* "View.MemoryView":330 +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":734 + * ctypedef npy_double float_t + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< * - * @cname('__pyx_memoryview') - * cdef class memoryview(object): # <<<<<<<<<<<<<< + * ctypedef npy_cfloat cfloat_t + */ +typedef npy_longdouble __pyx_t_5numpy_longdouble_t; + +/* "core.pyx":10 * - * cdef object obj + * DTYPE = np.float + * ctypedef cnp.float_t DTYPE_t # <<<<<<<<<<<<<< + * # def create_map_batch(np.ndarray X, int n_iter, int n_row, int n_col, int n_pix, np.ndarray importance, + * # np.ndarray dist_lib, np.ndarray weights): */ +typedef __pyx_t_5numpy_float_t __pyx_t_4core_DTYPE_t; +/* Declarations.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< float > __pyx_t_float_complex; + #else + typedef float _Complex __pyx_t_float_complex; + #endif +#else + typedef struct { float real, imag; } __pyx_t_float_complex; +#endif +static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); -struct __pyx_vtabstruct_memoryview { - char *(*get_item_pointer)(struct __pyx_memoryview_obj *, PyObject *); - PyObject *(*is_slice)(struct __pyx_memoryview_obj *, PyObject *); - PyObject *(*setitem_slice_assignment)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); - PyObject *(*setitem_slice_assign_scalar)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *); - PyObject *(*setitem_indexed)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); - PyObject *(*convert_item_to_object)(struct __pyx_memoryview_obj *, char *); - PyObject *(*assign_item_from_object)(struct __pyx_memoryview_obj *, char *, PyObject *); -}; -static struct __pyx_vtabstruct_memoryview *__pyx_vtabptr_memoryview; +/* Declarations.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< double > __pyx_t_double_complex; + #else + typedef double _Complex __pyx_t_double_complex; + #endif +#else + typedef struct { double real, imag; } __pyx_t_double_complex; +#endif +static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); + + +/*--- Type declarations ---*/ +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":736 + * ctypedef npy_longdouble longdouble_t + * + * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t + */ +typedef npy_cfloat __pyx_t_5numpy_cfloat_t; -/* "View.MemoryView":965 +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":737 * - * @cname('__pyx_memoryviewslice') - * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< - * "Internal class for passing memoryview slices to Python" + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< + * ctypedef npy_clongdouble clongdouble_t * */ +typedef npy_cdouble __pyx_t_5numpy_cdouble_t; -struct __pyx_vtabstruct__memoryviewslice { - struct __pyx_vtabstruct_memoryview __pyx_base; -}; -static struct __pyx_vtabstruct__memoryviewslice *__pyx_vtabptr__memoryviewslice; +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":738 + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cdouble complex_t + */ +typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; + +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":740 + * ctypedef npy_clongdouble clongdouble_t + * + * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew1(a): + */ +typedef npy_cdouble __pyx_t_5numpy_complex_t; /* --- Runtime support code (head) --- */ /* Refnanny.proto */ @@ -1159,28 +1206,6 @@ static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ const char* function_name); -/* GetItemInt.proto */ -#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ - (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ - __Pyx_GetItemInt_Generic(o, to_py_func(i)))) -#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ - (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, - int wraparound, int boundscheck); -#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ - (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, - int wraparound, int boundscheck); -static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, - int is_list, int wraparound, int boundscheck); - /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) @@ -1228,32 +1253,6 @@ static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_ve static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif -/* PyObjectCall.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); -#else -#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) -#endif - -/* RaiseTooManyValuesToUnpack.proto */ -static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); - -/* RaiseNeedMoreValuesToUnpack.proto */ -static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); - -/* IterFinish.proto */ -static CYTHON_INLINE int __Pyx_IterFinish(void); - -/* UnpackItemEndCheck.proto */ -static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); - -/* ObjectGetItem.proto */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key); -#else -#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) -#endif - /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ @@ -1284,41 +1283,21 @@ static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObje #define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) #endif -/* MemviewSliceInit.proto */ -#define __Pyx_BUF_MAX_NDIMS %(BUF_MAX_NDIMS)d -#define __Pyx_MEMVIEW_DIRECT 1 -#define __Pyx_MEMVIEW_PTR 2 -#define __Pyx_MEMVIEW_FULL 4 -#define __Pyx_MEMVIEW_CONTIG 8 -#define __Pyx_MEMVIEW_STRIDED 16 -#define __Pyx_MEMVIEW_FOLLOW 32 -#define __Pyx_IS_C_CONTIG 1 -#define __Pyx_IS_F_CONTIG 2 -static int __Pyx_init_memviewslice( - struct __pyx_memoryview_obj *memview, - int ndim, - __Pyx_memviewslice *memviewslice, - int memview_is_new_reference); -static CYTHON_INLINE int __pyx_add_acquisition_count_locked( - __pyx_atomic_int *acquisition_count, PyThread_type_lock lock); -static CYTHON_INLINE int __pyx_sub_acquisition_count_locked( - __pyx_atomic_int *acquisition_count, PyThread_type_lock lock); -#define __pyx_get_slice_count_pointer(memview) (memview->acquisition_count_aligned_p) -#define __pyx_get_slice_count(memview) (*__pyx_get_slice_count_pointer(memview)) -#define __PYX_INC_MEMVIEW(slice, have_gil) __Pyx_INC_MEMVIEW(slice, have_gil, __LINE__) -#define __PYX_XDEC_MEMVIEW(slice, have_gil) __Pyx_XDEC_MEMVIEW(slice, have_gil, __LINE__) -static CYTHON_INLINE void __Pyx_INC_MEMVIEW(__Pyx_memviewslice *, int, int); -static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW(__Pyx_memviewslice *, int, int); - -/* SetItemInt.proto */ -#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\ - (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\ - __Pyx_SetItemInt_Generic(o, to_py_func(i), v))) -static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); -static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, - int is_list, int wraparound, int boundscheck); +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* ArgTypeTest.proto */ +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ + ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + __Pyx__ArgTypeTest(obj, type, name, exact)) +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); + +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /* PyObjectCall2Args.proto */ static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); @@ -1331,11 +1310,73 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); -/* ArgTypeTest.proto */ -#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ - ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ - __Pyx__ArgTypeTest(obj, type, name, exact)) -static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); +/* SliceObject.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice( + PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, + PyObject** py_start, PyObject** py_stop, PyObject** py_slice, + int has_cstart, int has_cstop, int wraparound); + +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound, int boundscheck); + +/* PyObjectCallNoArg.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); +#else +#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) +#endif + +/* ObjectGetItem.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key); +#else +#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) +#endif + +/* RaiseTooManyValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +/* RaiseNeedMoreValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +/* IterFinish.proto */ +static CYTHON_INLINE int __Pyx_IterFinish(void); + +/* UnpackItemEndCheck.proto */ +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); + +/* DictGetItem.proto */ +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); +#define __Pyx_PyObject_Dict_GetItem(obj, name)\ + (likely(PyDict_CheckExact(obj)) ?\ + __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) +#else +#define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) +#define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) +#endif + +/* RaiseNoneIterError.proto */ +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE @@ -1376,71 +1417,6 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); -/* IncludeStringH.proto */ -#include - -/* BytesEquals.proto */ -static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); - -/* UnicodeEquals.proto */ -static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); - -/* StrEquals.proto */ -#if PY_MAJOR_VERSION >= 3 -#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals -#else -#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals -#endif - -/* None.proto */ -static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t, Py_ssize_t); - -/* UnaryNegOverflows.proto */ -#define UNARY_NEG_WOULD_OVERFLOW(x)\ - (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x))) - -static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ -static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *); /*proto*/ -/* GetAttr.proto */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); - -/* decode_c_string_utf16.proto */ -static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors) { - int byteorder = 0; - return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); -} -static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16LE(const char *s, Py_ssize_t size, const char *errors) { - int byteorder = -1; - return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); -} -static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16BE(const char *s, Py_ssize_t size, const char *errors) { - int byteorder = 1; - return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); -} - -/* decode_c_string.proto */ -static CYTHON_INLINE PyObject* __Pyx_decode_c_string( - const char* cstring, Py_ssize_t start, Py_ssize_t stop, - const char* encoding, const char* errors, - PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); - -/* PyErrExceptionMatches.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) -static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); -#else -#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) -#endif - -/* GetAttr3.proto */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); - -/* RaiseNoneIterError.proto */ -static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); - -/* ExtTypeTest.proto */ -static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); - /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); @@ -1457,6 +1433,14 @@ static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject #define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) #endif +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + /* GetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) @@ -1465,121 +1449,23 @@ static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif -/* SwapException.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#else -static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); +/* TypeImport.proto */ +#ifndef __PYX_HAVE_RT_ImportType_proto +#define __PYX_HAVE_RT_ImportType_proto +enum __Pyx_ImportType_CheckSize { + __Pyx_ImportType_CheckSize_Error = 0, + __Pyx_ImportType_CheckSize_Warn = 1, + __Pyx_ImportType_CheckSize_Ignore = 2 +}; +static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); #endif /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); -/* FastTypeChecks.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) -static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); -static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); -static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); -#else -#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) -#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) -#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) -#endif -#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) - -static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ -/* ListCompAppend.proto */ -#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS -static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { - PyListObject* L = (PyListObject*) list; - Py_ssize_t len = Py_SIZE(list); - if (likely(L->allocated > len)) { - Py_INCREF(x); - PyList_SET_ITEM(list, len, x); - __Pyx_SET_SIZE(list, len + 1); - return 0; - } - return PyList_Append(list, x); -} -#else -#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) -#endif - -/* PyIntBinop.proto */ -#if !CYTHON_COMPILING_IN_PYPY -static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); -#else -#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace, zerodivision_check)\ - (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) -#endif - -/* ListExtend.proto */ -static CYTHON_INLINE int __Pyx_PyList_Extend(PyObject* L, PyObject* v) { -#if CYTHON_COMPILING_IN_CPYTHON - PyObject* none = _PyList_Extend((PyListObject*)L, v); - if (unlikely(!none)) - return -1; - Py_DECREF(none); - return 0; -#else - return PyList_SetSlice(L, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, v); -#endif -} - -/* ListAppend.proto */ -#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS -static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { - PyListObject* L = (PyListObject*) list; - Py_ssize_t len = Py_SIZE(list); - if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { - Py_INCREF(x); - PyList_SET_ITEM(list, len, x); - __Pyx_SET_SIZE(list, len + 1); - return 0; - } - return PyList_Append(list, x); -} -#else -#define __Pyx_PyList_Append(L,x) PyList_Append(L,x) -#endif - -/* None.proto */ -static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); - -/* None.proto */ -static CYTHON_INLINE long __Pyx_div_long(long, long); - /* ImportFrom.proto */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); -/* HasAttr.proto */ -static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); - -/* PyObject_GenericGetAttrNoDict.proto */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr -#endif - -/* PyObject_GenericGetAttr.proto */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr -#endif - -/* SetVTable.proto */ -static int __Pyx_SetVtable(PyObject *dict, void *vtable); - -/* PyObjectGetAttrStrNoError.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); - -/* SetupReduce.proto */ -static int __Pyx_setup_reduce(PyObject* type_obj); - /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) @@ -1606,91 +1492,131 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); -#if PY_MAJOR_VERSION < 3 - static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); - static void __Pyx_ReleaseBuffer(Py_buffer *view); +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +/* RealImag.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #define __Pyx_CREAL(z) ((z).real()) + #define __Pyx_CIMAG(z) ((z).imag()) + #else + #define __Pyx_CREAL(z) (__real__(z)) + #define __Pyx_CIMAG(z) (__imag__(z)) + #endif #else - #define __Pyx_GetBuffer PyObject_GetBuffer - #define __Pyx_ReleaseBuffer PyBuffer_Release + #define __Pyx_CREAL(z) ((z).real) + #define __Pyx_CIMAG(z) ((z).imag) +#endif +#if defined(__cplusplus) && CYTHON_CCOMPLEX\ + && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103) + #define __Pyx_SET_CREAL(z,x) ((z).real(x)) + #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) +#else + #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) + #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) +#endif + +/* Arithmetic.proto */ +#if CYTHON_CCOMPLEX + #define __Pyx_c_eq_float(a, b) ((a)==(b)) + #define __Pyx_c_sum_float(a, b) ((a)+(b)) + #define __Pyx_c_diff_float(a, b) ((a)-(b)) + #define __Pyx_c_prod_float(a, b) ((a)*(b)) + #define __Pyx_c_quot_float(a, b) ((a)/(b)) + #define __Pyx_c_neg_float(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero_float(z) ((z)==(float)0) + #define __Pyx_c_conj_float(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs_float(z) (::std::abs(z)) + #define __Pyx_c_pow_float(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero_float(z) ((z)==0) + #define __Pyx_c_conj_float(z) (conjf(z)) + #if 1 + #define __Pyx_c_abs_float(z) (cabsf(z)) + #define __Pyx_c_pow_float(a, b) (cpowf(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex); + static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex); + #if 1 + static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex); + #endif #endif - -/* BufferStructDeclare.proto */ -typedef struct { - Py_ssize_t shape, strides, suboffsets; -} __Pyx_Buf_DimInfo; -typedef struct { - size_t refcount; - Py_buffer pybuffer; -} __Pyx_Buffer; -typedef struct { - __Pyx_Buffer *rcbuffer; - char *data; - __Pyx_Buf_DimInfo diminfo[8]; -} __Pyx_LocalBuf_ND; - -/* MemviewSliceIsContig.proto */ -static int __pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim); - -/* OverlappingSlices.proto */ -static int __pyx_slices_overlap(__Pyx_memviewslice *slice1, - __Pyx_memviewslice *slice2, - int ndim, size_t itemsize); - -/* Capsule.proto */ -static CYTHON_INLINE PyObject *__pyx_capsule_create(void *p, const char *sig); +/* Arithmetic.proto */ +#if CYTHON_CCOMPLEX + #define __Pyx_c_eq_double(a, b) ((a)==(b)) + #define __Pyx_c_sum_double(a, b) ((a)+(b)) + #define __Pyx_c_diff_double(a, b) ((a)-(b)) + #define __Pyx_c_prod_double(a, b) ((a)*(b)) + #define __Pyx_c_quot_double(a, b) ((a)/(b)) + #define __Pyx_c_neg_double(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero_double(z) ((z)==(double)0) + #define __Pyx_c_conj_double(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs_double(z) (::std::abs(z)) + #define __Pyx_c_pow_double(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero_double(z) ((z)==0) + #define __Pyx_c_conj_double(z) (conj(z)) + #if 1 + #define __Pyx_c_abs_double(z) (cabs(z)) + #define __Pyx_c_pow_double(a, b) (cpow(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex); + static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex); + #if 1 + static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex); + #endif +#endif /* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); - -/* MemviewDtypeToObject.proto */ -static CYTHON_INLINE PyObject *__pyx_memview_get_double(const char *itemp); -static CYTHON_INLINE int __pyx_memview_set_double(const char *itemp, PyObject *obj); - -/* MemviewSliceCopyTemplate.proto */ -static __Pyx_memviewslice -__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, - const char *mode, int ndim, - size_t sizeof_dtype, int contig_flag, - int dtype_is_object); +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); -/* CIntFromPy.proto */ -static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); - /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); /* CIntFromPy.proto */ -static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *); - -/* IsLittleEndian.proto */ -static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); - -/* BufferFormatCheck.proto */ -static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); -static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, - __Pyx_BufFmt_StackElem* stack, - __Pyx_TypeInfo* type); - -/* TypeInfoCompare.proto */ -static int __pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b); - -/* MemviewSliceValidateAndInit.proto */ -static int __Pyx_ValidateAndInit_memviewslice( - int *axes_specs, - int c_or_f_flag, - int buf_flags, - int ndim, - __Pyx_TypeInfo *dtype, - __Pyx_BufFmt_StackElem stack[], - __Pyx_memviewslice *memviewslice, - PyObject *original_obj); - -/* ObjectToMemviewSlice.proto */ -static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_ds_double(PyObject *, int writable_flag); +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +/* FastTypeChecks.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); +#else +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) +#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) +#endif +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ static int __Pyx_check_binary_version(void); @@ -1698,446 +1624,246 @@ static int __Pyx_check_binary_version(void); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); -static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self); /* proto*/ -static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto*/ -static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj); /* proto*/ -static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src); /* proto*/ -static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value); /* proto*/ -static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto*/ -static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/ -static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/ -static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/ -static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/ + +/* Module declarations from 'cpython.buffer' */ + +/* Module declarations from 'libc.string' */ + +/* Module declarations from 'libc.stdio' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.type' */ +static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; + +/* Module declarations from 'cpython' */ + +/* Module declarations from 'cpython.object' */ + +/* Module declarations from 'cpython.ref' */ + +/* Module declarations from 'cpython.mem' */ + +/* Module declarations from 'numpy' */ + +/* Module declarations from 'numpy' */ +static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; +static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; +static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; +static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; +static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; +static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/ /* Module declarations from 'core' */ -static PyTypeObject *__pyx_array_type = 0; -static PyTypeObject *__pyx_MemviewEnum_type = 0; -static PyTypeObject *__pyx_memoryview_type = 0; -static PyTypeObject *__pyx_memoryviewslice_type = 0; -static PyObject *generic = 0; -static PyObject *strided = 0; -static PyObject *indirect = 0; -static PyObject *contiguous = 0; -static PyObject *indirect_contiguous = 0; -static int __pyx_memoryview_thread_locks_used; -static PyThread_type_lock __pyx_memoryview_thread_locks[8]; -static struct __pyx_array_obj *__pyx_array_new(PyObject *, Py_ssize_t, char *, char *, char *); /*proto*/ -static void *__pyx_align_pointer(void *, size_t); /*proto*/ -static PyObject *__pyx_memoryview_new(PyObject *, int, int, __Pyx_TypeInfo *); /*proto*/ -static CYTHON_INLINE int __pyx_memoryview_check(PyObject *); /*proto*/ -static PyObject *_unellipsify(PyObject *, int); /*proto*/ -static PyObject *assert_direct_dimensions(Py_ssize_t *, int); /*proto*/ -static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *, PyObject *); /*proto*/ -static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int, int); /*proto*/ -static char *__pyx_pybuffer_index(Py_buffer *, char *, Py_ssize_t, Py_ssize_t); /*proto*/ -static int __pyx_memslice_transpose(__Pyx_memviewslice *); /*proto*/ -static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice, int, PyObject *(*)(char *), int (*)(char *, PyObject *), int); /*proto*/ -static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ -static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ -static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *); /*proto*/ -static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ -static Py_ssize_t abs_py_ssize_t(Py_ssize_t); /*proto*/ -static char __pyx_get_best_slice_order(__Pyx_memviewslice *, int); /*proto*/ -static void _copy_strided_to_strided(char *, Py_ssize_t *, char *, Py_ssize_t *, Py_ssize_t *, Py_ssize_t *, int, size_t); /*proto*/ -static void copy_strided_to_strided(__Pyx_memviewslice *, __Pyx_memviewslice *, int, size_t); /*proto*/ -static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *, int); /*proto*/ -static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *, Py_ssize_t *, Py_ssize_t, int, char); /*proto*/ -static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *, __Pyx_memviewslice *, char, int); /*proto*/ -static int __pyx_memoryview_err_extents(int, Py_ssize_t, Py_ssize_t); /*proto*/ -static int __pyx_memoryview_err_dim(PyObject *, char *, int); /*proto*/ -static int __pyx_memoryview_err(PyObject *, char *); /*proto*/ -static int __pyx_memoryview_copy_contents(__Pyx_memviewslice, __Pyx_memviewslice, int, int, int); /*proto*/ -static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *, int, int); /*proto*/ -static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *, int, int, int); /*proto*/ -static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/ -static void __pyx_memoryview_refcount_objects_in_slice(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/ -static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *, int, size_t, void *, int); /*proto*/ -static void __pyx_memoryview__slice_assign_scalar(char *, Py_ssize_t *, Py_ssize_t *, int, size_t, void *); /*proto*/ -static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *, PyObject *); /*proto*/ -static __Pyx_TypeInfo __Pyx_TypeInfo_double = { "double", NULL, sizeof(double), { 0 }, 0, 'R', 0, 0 }; #define __Pyx_MODULE_NAME "core" extern int __pyx_module_is_main_core; int __pyx_module_is_main_core = 0; /* Implementation of 'core' */ static PyObject *__pyx_builtin_range; +static PyObject *__pyx_builtin_RuntimeError; static PyObject *__pyx_builtin_ValueError; -static PyObject *__pyx_builtin_MemoryError; -static PyObject *__pyx_builtin_enumerate; -static PyObject *__pyx_builtin_TypeError; -static PyObject *__pyx_builtin_Ellipsis; -static PyObject *__pyx_builtin_id; -static PyObject *__pyx_builtin_IndexError; -static const char __pyx_k_O[] = "O"; +static PyObject *__pyx_builtin_ImportError; static const char __pyx_k_X[] = "X"; -static const char __pyx_k_c[] = "c"; static const char __pyx_k_i[] = "i"; -static const char __pyx_k_j[] = "j"; -static const char __pyx_k_k[] = "k"; -static const char __pyx_k_an[] = "an"; -static const char __pyx_k_id[] = "id"; -static const char __pyx_k_nc[] = "nc"; -static const char __pyx_k_nr[] = "nr"; -static const char __pyx_k_alp[] = "alp"; -static const char __pyx_k_imp[] = "imp"; -static const char __pyx_k_new[] = "__new__"; -static const char __pyx_k_obj[] = "obj"; -static const char __pyx_k_sig[] = "sig"; -static const char __pyx_k_base[] = "base"; +static const char __pyx_k_t[] = "t"; +static const char __pyx_k_it[] = "it"; +static const char __pyx_k_np[] = "np"; +static const char __pyx_k_bmu[] = "bmu"; +static const char __pyx_k_exp[] = "exp"; +static const char __pyx_k_max[] = "max"; +static const char __pyx_k_min[] = "min"; +static const char __pyx_k_sum[] = "sum"; +static const char __pyx_k_axis[] = "axis"; static const char __pyx_k_best[] = "best"; static const char __pyx_k_core[] = "core"; -static const char __pyx_k_dict[] = "__dict__"; static const char __pyx_k_main[] = "__main__"; -static const char __pyx_k_mode[] = "mode"; -static const char __pyx_k_name[] = "name"; -static const char __pyx_k_ndim[] = "ndim"; -static const char __pyx_k_npix[] = "npix"; -static const char __pyx_k_pack[] = "pack"; -static const char __pyx_k_size[] = "size"; -static const char __pyx_k_step[] = "step"; -static const char __pyx_k_stop[] = "stop"; +static const char __pyx_k_name[] = "__name__"; static const char __pyx_k_test[] = "__test__"; -static const char __pyx_k_ASCII[] = "ASCII"; +static const char __pyx_k_tile[] = "tile"; +static const char __pyx_k_DTYPE[] = "DTYPE"; static const char __pyx_k_alpha[] = "alpha"; -static const char __pyx_k_class[] = "__class__"; -static const char __pyx_k_error[] = "error"; -static const char __pyx_k_flags[] = "flags"; +static const char __pyx_k_dtype[] = "dtype"; +static const char __pyx_k_float[] = "float"; +static const char __pyx_k_map_d[] = "map_d"; static const char __pyx_k_n_col[] = "n_col"; static const char __pyx_k_n_pix[] = "n_pix"; static const char __pyx_k_n_row[] = "n_row"; static const char __pyx_k_numpy[] = "numpy"; +static const char __pyx_k_power[] = "power"; static const char __pyx_k_range[] = "range"; -static const char __pyx_k_shape[] = "shape"; static const char __pyx_k_sigma[] = "sigma"; -static const char __pyx_k_start[] = "start"; -static const char __pyx_k_encode[] = "encode"; -static const char __pyx_k_format[] = "format"; +static const char __pyx_k_where[] = "where"; +static const char __pyx_k_zeros[] = "zeros"; +static const char __pyx_k_arange[] = "arange"; +static const char __pyx_k_argmin[] = "argmin"; +static const char __pyx_k_curr_t[] = "curr_t"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_inputs[] = "inputs"; -static const char __pyx_k_name_2[] = "__name__"; -static const char __pyx_k_pickle[] = "pickle"; -static const char __pyx_k_reduce[] = "__reduce__"; -static const char __pyx_k_struct[] = "struct"; +static const char __pyx_k_n_iter[] = "n_iter"; +static const char __pyx_k_random[] = "random"; +static const char __pyx_k_sample[] = "sample"; static const char __pyx_k_timeit[] = "timeit"; -static const char __pyx_k_unpack[] = "unpack"; -static const char __pyx_k_update[] = "update"; -static const char __pyx_k_accum_n[] = "accum_n"; -static const char __pyx_k_accum_w[] = "accum_w"; -static const char __pyx_k_fortran[] = "fortran"; -static const char __pyx_k_memview[] = "memview"; +static const char __pyx_k_argsort[] = "argsort"; +static const char __pyx_k_sigma_0[] = "sigma_0"; +static const char __pyx_k_sigma_f[] = "sigma_f"; +static const char __pyx_k_total_t[] = "total_t"; static const char __pyx_k_weights[] = "weights"; -static const char __pyx_k_Ellipsis[] = "Ellipsis"; static const char __pyx_k_dist_lib[] = "dist_lib"; -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_setstate[] = "__setstate__"; -static const char __pyx_k_TypeError[] = "TypeError"; -static const char __pyx_k_enumerate[] = "enumerate"; -static const char __pyx_k_pyx_state[] = "__pyx_state"; -static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; +static const char __pyx_k_alpha_end[] = "alpha_end"; +static const char __pyx_k_get_alpha[] = "get_alpha"; +static const char __pyx_k_get_sigma[] = "get_sigma"; static const char __pyx_k_transpose[] = "transpose"; -static const char __pyx_k_IndexError[] = "IndexError"; static const char __pyx_k_ValueError[] = "ValueError"; static const char __pyx_k_activation[] = "activation"; static const char __pyx_k_importance[] = "importance"; -static const char __pyx_k_pyx_result[] = "__pyx_result"; -static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; -static const char __pyx_k_MemoryError[] = "MemoryError"; -static const char __pyx_k_PickleError[] = "PickleError"; -static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; -static const char __pyx_k_stringsource[] = "stringsource"; +static const char __pyx_k_ImportError[] = "ImportError"; +static const char __pyx_k_activations[] = "activations"; +static const char __pyx_k_alpha_start[] = "alpha_start"; +static const char __pyx_k_return_vals[] = "return_vals"; +static const char __pyx_k_RuntimeError[] = "RuntimeError"; +static const char __pyx_k_random_order[] = "random_order"; static const char __pyx_k_get_best_cell[] = "get_best_cell"; -static const char __pyx_k_pyx_getbuffer[] = "__pyx_getbuffer"; -static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; static const char __pyx_k_random_indices[] = "random_indices"; -static const char __pyx_k_View_MemoryView[] = "View.MemoryView"; -static const char __pyx_k_allocate_buffer[] = "allocate_buffer"; -static const char __pyx_k_dtype_is_object[] = "dtype_is_object"; -static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError"; -static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; static const char __pyx_k_somsphere_utils[] = "somsphere.utils"; -static const char __pyx_k_create_map_batch[] = "create_map_batch"; static const char __pyx_k_create_map_online[] = "create_map_online"; -static const char __pyx_k_pyx_unpickle_Enum[] = "__pyx_unpickle_Enum"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; -static const char __pyx_k_strided_and_direct[] = ""; static const char __pyx_k_count_modified_cells[] = "count_modified_cells"; -static const char __pyx_k_strided_and_indirect[] = ""; -static const char __pyx_k_contiguous_and_direct[] = ""; -static const char __pyx_k_MemoryView_of_r_object[] = ""; -static const char __pyx_k_MemoryView_of_r_at_0x_x[] = ""; -static const char __pyx_k_contiguous_and_indirect[] = ""; -static const char __pyx_k_Cannot_index_with_type_s[] = "Cannot index with type '%s'"; -static const char __pyx_k_Invalid_shape_in_axis_d_d[] = "Invalid shape in axis %d: %d."; static const char __pyx_k_somsphere_cython_core_pyx[] = "somsphere/cython/core.pyx"; -static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cython.array"; -static const char __pyx_k_unable_to_allocate_array_data[] = "unable to allocate array data."; -static const char __pyx_k_strided_and_direct_or_indirect[] = ""; -static const char __pyx_k_Buffer_view_does_not_expose_stri[] = "Buffer view does not expose strides"; -static const char __pyx_k_Can_only_create_a_buffer_that_is[] = "Can only create a buffer that is contiguous in memory."; -static const char __pyx_k_Cannot_assign_to_read_only_memor[] = "Cannot assign to read-only memoryview"; -static const char __pyx_k_Cannot_create_writable_memory_vi[] = "Cannot create writable memory view from read-only memoryview"; -static const char __pyx_k_Empty_shape_tuple_for_cython_arr[] = "Empty shape tuple for cython.array"; -static const char __pyx_k_Incompatible_checksums_s_vs_0xb0[] = "Incompatible checksums (%s vs 0xb068931 = (name))"; -static const char __pyx_k_Indirect_dimensions_not_supporte[] = "Indirect dimensions not supported"; -static const char __pyx_k_Invalid_mode_expected_c_or_fortr[] = "Invalid mode, expected 'c' or 'fortran', got %s"; -static const char __pyx_k_Out_of_bounds_on_buffer_access_a[] = "Out of bounds on buffer access (axis %d)"; -static const char __pyx_k_Unable_to_convert_item_to_object[] = "Unable to convert item to object"; -static const char __pyx_k_got_differing_extents_in_dimensi[] = "got differing extents in dimension %d (got %d and %d)"; -static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; -static const char __pyx_k_unable_to_allocate_shape_and_str[] = "unable to allocate shape and strides."; -static PyObject *__pyx_n_s_ASCII; -static PyObject *__pyx_kp_s_Buffer_view_does_not_expose_stri; -static PyObject *__pyx_kp_s_Can_only_create_a_buffer_that_is; -static PyObject *__pyx_kp_s_Cannot_assign_to_read_only_memor; -static PyObject *__pyx_kp_s_Cannot_create_writable_memory_vi; -static PyObject *__pyx_kp_s_Cannot_index_with_type_s; -static PyObject *__pyx_n_s_Ellipsis; -static PyObject *__pyx_kp_s_Empty_shape_tuple_for_cython_arr; -static PyObject *__pyx_kp_s_Incompatible_checksums_s_vs_0xb0; -static PyObject *__pyx_n_s_IndexError; -static PyObject *__pyx_kp_s_Indirect_dimensions_not_supporte; -static PyObject *__pyx_kp_s_Invalid_mode_expected_c_or_fortr; -static PyObject *__pyx_kp_s_Invalid_shape_in_axis_d_d; -static PyObject *__pyx_n_s_MemoryError; -static PyObject *__pyx_kp_s_MemoryView_of_r_at_0x_x; -static PyObject *__pyx_kp_s_MemoryView_of_r_object; -static PyObject *__pyx_n_b_O; -static PyObject *__pyx_kp_s_Out_of_bounds_on_buffer_access_a; -static PyObject *__pyx_n_s_PickleError; -static PyObject *__pyx_n_s_TypeError; -static PyObject *__pyx_kp_s_Unable_to_convert_item_to_object; +static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import"; +static const char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)"; +static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd"; +static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported"; +static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; +static const char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short."; +static PyObject *__pyx_n_s_DTYPE; +static PyObject *__pyx_kp_u_Format_string_allocated_too_shor; +static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2; +static PyObject *__pyx_n_s_ImportError; +static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor; +static PyObject *__pyx_n_s_RuntimeError; static PyObject *__pyx_n_s_ValueError; -static PyObject *__pyx_n_s_View_MemoryView; static PyObject *__pyx_n_s_X; -static PyObject *__pyx_n_s_accum_n; -static PyObject *__pyx_n_s_accum_w; static PyObject *__pyx_n_s_activation; -static PyObject *__pyx_n_s_allocate_buffer; -static PyObject *__pyx_n_s_alp; +static PyObject *__pyx_n_s_activations; static PyObject *__pyx_n_s_alpha; -static PyObject *__pyx_n_s_an; -static PyObject *__pyx_n_s_base; +static PyObject *__pyx_n_s_alpha_end; +static PyObject *__pyx_n_s_alpha_start; +static PyObject *__pyx_n_s_arange; +static PyObject *__pyx_n_s_argmin; +static PyObject *__pyx_n_s_argsort; +static PyObject *__pyx_n_s_axis; static PyObject *__pyx_n_s_best; -static PyObject *__pyx_n_s_c; -static PyObject *__pyx_n_u_c; -static PyObject *__pyx_n_s_class; +static PyObject *__pyx_n_s_bmu; static PyObject *__pyx_n_s_cline_in_traceback; -static PyObject *__pyx_kp_s_contiguous_and_direct; -static PyObject *__pyx_kp_s_contiguous_and_indirect; static PyObject *__pyx_n_s_core; static PyObject *__pyx_n_s_count_modified_cells; -static PyObject *__pyx_n_s_create_map_batch; static PyObject *__pyx_n_s_create_map_online; -static PyObject *__pyx_n_s_dict; +static PyObject *__pyx_n_s_curr_t; static PyObject *__pyx_n_s_dist_lib; -static PyObject *__pyx_n_s_dtype_is_object; -static PyObject *__pyx_n_s_encode; -static PyObject *__pyx_n_s_enumerate; -static PyObject *__pyx_n_s_error; -static PyObject *__pyx_n_s_flags; -static PyObject *__pyx_n_s_format; -static PyObject *__pyx_n_s_fortran; -static PyObject *__pyx_n_u_fortran; +static PyObject *__pyx_n_s_dtype; +static PyObject *__pyx_n_s_exp; +static PyObject *__pyx_n_s_float; +static PyObject *__pyx_n_s_get_alpha; static PyObject *__pyx_n_s_get_best_cell; -static PyObject *__pyx_n_s_getstate; -static PyObject *__pyx_kp_s_got_differing_extents_in_dimensi; +static PyObject *__pyx_n_s_get_sigma; static PyObject *__pyx_n_s_i; -static PyObject *__pyx_n_s_id; -static PyObject *__pyx_n_s_imp; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_importance; static PyObject *__pyx_n_s_inputs; -static PyObject *__pyx_n_s_itemsize; -static PyObject *__pyx_kp_s_itemsize_0_for_cython_array; -static PyObject *__pyx_n_s_j; -static PyObject *__pyx_n_s_k; +static PyObject *__pyx_n_s_it; static PyObject *__pyx_n_s_main; -static PyObject *__pyx_n_s_memview; -static PyObject *__pyx_n_s_mode; +static PyObject *__pyx_n_s_map_d; +static PyObject *__pyx_n_s_max; +static PyObject *__pyx_n_s_min; static PyObject *__pyx_n_s_n_col; +static PyObject *__pyx_n_s_n_iter; static PyObject *__pyx_n_s_n_pix; static PyObject *__pyx_n_s_n_row; static PyObject *__pyx_n_s_name; -static PyObject *__pyx_n_s_name_2; -static PyObject *__pyx_n_s_nc; -static PyObject *__pyx_n_s_ndim; -static PyObject *__pyx_n_s_new; -static PyObject *__pyx_kp_s_no_default___reduce___due_to_non; -static PyObject *__pyx_n_s_npix; -static PyObject *__pyx_n_s_nr; +static PyObject *__pyx_n_s_np; static PyObject *__pyx_n_s_numpy; -static PyObject *__pyx_n_s_obj; -static PyObject *__pyx_n_s_pack; -static PyObject *__pyx_n_s_pickle; -static PyObject *__pyx_n_s_pyx_PickleError; -static PyObject *__pyx_n_s_pyx_checksum; -static PyObject *__pyx_n_s_pyx_getbuffer; -static PyObject *__pyx_n_s_pyx_result; -static PyObject *__pyx_n_s_pyx_state; -static PyObject *__pyx_n_s_pyx_type; -static PyObject *__pyx_n_s_pyx_unpickle_Enum; -static PyObject *__pyx_n_s_pyx_vtable; +static PyObject *__pyx_kp_u_numpy_core_multiarray_failed_to; +static PyObject *__pyx_kp_u_numpy_core_umath_failed_to_impor; +static PyObject *__pyx_n_s_power; +static PyObject *__pyx_n_s_random; static PyObject *__pyx_n_s_random_indices; +static PyObject *__pyx_n_s_random_order; static PyObject *__pyx_n_s_range; -static PyObject *__pyx_n_s_reduce; -static PyObject *__pyx_n_s_reduce_cython; -static PyObject *__pyx_n_s_reduce_ex; -static PyObject *__pyx_n_s_setstate; -static PyObject *__pyx_n_s_setstate_cython; -static PyObject *__pyx_n_s_shape; -static PyObject *__pyx_n_s_sig; +static PyObject *__pyx_n_s_return_vals; +static PyObject *__pyx_n_s_sample; static PyObject *__pyx_n_s_sigma; -static PyObject *__pyx_n_s_size; +static PyObject *__pyx_n_s_sigma_0; +static PyObject *__pyx_n_s_sigma_f; static PyObject *__pyx_kp_s_somsphere_cython_core_pyx; static PyObject *__pyx_n_s_somsphere_utils; -static PyObject *__pyx_n_s_start; -static PyObject *__pyx_n_s_step; -static PyObject *__pyx_n_s_stop; -static PyObject *__pyx_kp_s_strided_and_direct; -static PyObject *__pyx_kp_s_strided_and_direct_or_indirect; -static PyObject *__pyx_kp_s_strided_and_indirect; -static PyObject *__pyx_kp_s_stringsource; -static PyObject *__pyx_n_s_struct; +static PyObject *__pyx_n_s_sum; +static PyObject *__pyx_n_s_t; static PyObject *__pyx_n_s_test; +static PyObject *__pyx_n_s_tile; static PyObject *__pyx_n_s_timeit; +static PyObject *__pyx_n_s_total_t; static PyObject *__pyx_n_s_transpose; -static PyObject *__pyx_kp_s_unable_to_allocate_array_data; -static PyObject *__pyx_kp_s_unable_to_allocate_shape_and_str; -static PyObject *__pyx_n_s_unpack; -static PyObject *__pyx_n_s_update; +static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd; static PyObject *__pyx_n_s_weights; -static PyObject *__pyx_pf_4core_create_map_batch(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_n_row, PyObject *__pyx_v_n_col, PyObject *__pyx_v_accum_w, PyObject *__pyx_v_accum_n, PyObject *__pyx_v_sigma, PyObject *__pyx_v_importance, PyObject *__pyx_v_n_pix, PyObject *__pyx_v_dist_lib, PyObject *__pyx_v_weights); /* proto */ -static PyObject *__pyx_pf_4core_2create_map_online(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_n_row, CYTHON_UNUSED PyObject *__pyx_v_alpha, PyObject *__pyx_v_sigma, PyObject *__pyx_v_random_indices, PyObject *__pyx_v_importance, PyObject *__pyx_v_n_pix, PyObject *__pyx_v_dist_lib, PyObject *__pyx_v_weights); /* proto */ -static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer); /* proto */ -static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ -static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self); /* proto */ -static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr); /* proto */ -static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item); /* proto */ -static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /* proto */ -static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ -static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ -static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ -static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object); /* proto */ -static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto */ -static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto */ -static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ -static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ -static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ -static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_n_s_where; +static PyObject *__pyx_n_s_zeros; +static PyObject *__pyx_pf_4core_get_alpha(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_alpha_end, float __pyx_v_alpha_start, int __pyx_v_curr_t, int __pyx_v_total_t); /* proto */ +static PyObject *__pyx_pf_4core_2get_sigma(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_sigma_f, float __pyx_v_sigma_0, int __pyx_v_curr_t, int __pyx_v_total_t); /* proto */ +static PyObject *__pyx_pf_4core_4get_best_cell(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_inputs, PyArrayObject *__pyx_v_importance, int __pyx_v_n_pix, PyArrayObject *__pyx_v_weights, int __pyx_v_return_vals); /* proto */ +static PyObject *__pyx_pf_4core_6count_modified_cells(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_bmu, PyArrayObject *__pyx_v_map_d, float __pyx_v_sigma); /* proto */ +static PyObject *__pyx_pf_4core_8create_map_online(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_X, int __pyx_v_n_iter, int __pyx_v_n_row, int __pyx_v_n_col, int __pyx_v_n_pix, float __pyx_v_alpha_start, float __pyx_v_alpha_end, PyArrayObject *__pyx_v_importance, PyArrayObject *__pyx_v_dist_lib, PyArrayObject *__pyx_v_weights, int __pyx_v_random_order); /* proto */ +static PyObject *__pyx_float_0_; static PyObject *__pyx_int_0; static PyObject *__pyx_int_1; -static PyObject *__pyx_int_184977713; -static PyObject *__pyx_int_neg_1; -static PyObject *__pyx_slice_; +static PyObject *__pyx_int_2; +static PyObject *__pyx_tuple_; static PyObject *__pyx_tuple__2; static PyObject *__pyx_tuple__3; static PyObject *__pyx_tuple__4; static PyObject *__pyx_tuple__5; static PyObject *__pyx_tuple__6; -static PyObject *__pyx_tuple__7; static PyObject *__pyx_tuple__8; -static PyObject *__pyx_tuple__9; static PyObject *__pyx_tuple__10; -static PyObject *__pyx_tuple__11; static PyObject *__pyx_tuple__12; -static PyObject *__pyx_tuple__13; static PyObject *__pyx_tuple__14; -static PyObject *__pyx_tuple__15; -static PyObject *__pyx_tuple__16; -static PyObject *__pyx_tuple__17; -static PyObject *__pyx_tuple__18; -static PyObject *__pyx_tuple__19; -static PyObject *__pyx_tuple__21; -static PyObject *__pyx_tuple__23; -static PyObject *__pyx_tuple__24; -static PyObject *__pyx_tuple__25; -static PyObject *__pyx_tuple__26; -static PyObject *__pyx_tuple__27; -static PyObject *__pyx_tuple__28; -static PyObject *__pyx_codeobj__20; -static PyObject *__pyx_codeobj__22; -static PyObject *__pyx_codeobj__29; +static PyObject *__pyx_codeobj__7; +static PyObject *__pyx_codeobj__9; +static PyObject *__pyx_codeobj__11; +static PyObject *__pyx_codeobj__13; +static PyObject *__pyx_codeobj__15; /* Late includes */ -/* "core.pyx":6 - * from somsphere.utils import get_best_cell, count_modified_cells, timeit - * - * def create_map_batch(X, n_row, n_col, accum_w, accum_n, sigma, importance, n_pix, dist_lib, weights): # <<<<<<<<<<<<<< - * cdef int i, j, k - * cdef int nr = n_row +/* "core.pyx":38 + * # + * # t += n_row + * def get_alpha(float alpha_end, float alpha_start, int curr_t, int total_t): # <<<<<<<<<<<<<< + * """ + * Get value of alpha at a given time */ /* Python wrapper */ -static PyObject *__pyx_pw_4core_1create_map_batch(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyMethodDef __pyx_mdef_4core_1create_map_batch = {"create_map_batch", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_1create_map_batch, METH_VARARGS|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_4core_1create_map_batch(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_X = 0; - PyObject *__pyx_v_n_row = 0; - PyObject *__pyx_v_n_col = 0; - PyObject *__pyx_v_accum_w = 0; - PyObject *__pyx_v_accum_n = 0; - PyObject *__pyx_v_sigma = 0; - PyObject *__pyx_v_importance = 0; - PyObject *__pyx_v_n_pix = 0; - PyObject *__pyx_v_dist_lib = 0; - PyObject *__pyx_v_weights = 0; +static PyObject *__pyx_pw_4core_1get_alpha(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_4core_get_alpha[] = "\n Get value of alpha at a given time\n "; +static PyMethodDef __pyx_mdef_4core_1get_alpha = {"get_alpha", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_1get_alpha, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4core_get_alpha}; +static PyObject *__pyx_pw_4core_1get_alpha(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + float __pyx_v_alpha_end; + float __pyx_v_alpha_start; + int __pyx_v_curr_t; + int __pyx_v_total_t; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("create_map_batch (wrapper)", 0); + __Pyx_RefNannySetupContext("get_alpha (wrapper)", 0); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_X,&__pyx_n_s_n_row,&__pyx_n_s_n_col,&__pyx_n_s_accum_w,&__pyx_n_s_accum_n,&__pyx_n_s_sigma,&__pyx_n_s_importance,&__pyx_n_s_n_pix,&__pyx_n_s_dist_lib,&__pyx_n_s_weights,0}; - PyObject* values[10] = {0,0,0,0,0,0,0,0,0,0}; + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_alpha_end,&__pyx_n_s_alpha_start,&__pyx_n_s_curr_t,&__pyx_n_s_total_t,0}; + PyObject* values[4] = {0,0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { - case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9); - CYTHON_FALLTHROUGH; - case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); - CYTHON_FALLTHROUGH; - case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); - CYTHON_FALLTHROUGH; - case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); - CYTHON_FALLTHROUGH; - case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); - CYTHON_FALLTHROUGH; - 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); @@ -2152,604 +1878,435 @@ static PyObject *__pyx_pw_4core_1create_map_batch(PyObject *__pyx_self, PyObject kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_X)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha_end)) != 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_n_row)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha_start)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("create_map_batch", 1, 10, 10, 1); __PYX_ERR(0, 6, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("get_alpha", 1, 4, 4, 1); __PYX_ERR(0, 38, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_col)) != 0)) kw_args--; + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_curr_t)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("create_map_batch", 1, 10, 10, 2); __PYX_ERR(0, 6, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("get_alpha", 1, 4, 4, 2); __PYX_ERR(0, 38, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: - if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_accum_w)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("create_map_batch", 1, 10, 10, 3); __PYX_ERR(0, 6, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_accum_n)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("create_map_batch", 1, 10, 10, 4); __PYX_ERR(0, 6, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 5: - if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sigma)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("create_map_batch", 1, 10, 10, 5); __PYX_ERR(0, 6, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 6: - if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_importance)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("create_map_batch", 1, 10, 10, 6); __PYX_ERR(0, 6, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 7: - if (likely((values[7] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_pix)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("create_map_batch", 1, 10, 10, 7); __PYX_ERR(0, 6, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 8: - if (likely((values[8] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dist_lib)) != 0)) kw_args--; + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_total_t)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("create_map_batch", 1, 10, 10, 8); __PYX_ERR(0, 6, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 9: - if (likely((values[9] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_weights)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("create_map_batch", 1, 10, 10, 9); __PYX_ERR(0, 6, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("get_alpha", 1, 4, 4, 3); __PYX_ERR(0, 38, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create_map_batch") < 0)) __PYX_ERR(0, 6, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_alpha") < 0)) __PYX_ERR(0, 38, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 10) { + } 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); - values[4] = PyTuple_GET_ITEM(__pyx_args, 4); - values[5] = PyTuple_GET_ITEM(__pyx_args, 5); - values[6] = PyTuple_GET_ITEM(__pyx_args, 6); - values[7] = PyTuple_GET_ITEM(__pyx_args, 7); - values[8] = PyTuple_GET_ITEM(__pyx_args, 8); - values[9] = PyTuple_GET_ITEM(__pyx_args, 9); } - __pyx_v_X = values[0]; - __pyx_v_n_row = values[1]; - __pyx_v_n_col = values[2]; - __pyx_v_accum_w = values[3]; - __pyx_v_accum_n = values[4]; - __pyx_v_sigma = values[5]; - __pyx_v_importance = values[6]; - __pyx_v_n_pix = values[7]; - __pyx_v_dist_lib = values[8]; - __pyx_v_weights = values[9]; + __pyx_v_alpha_end = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_alpha_end == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L3_error) + __pyx_v_alpha_start = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_alpha_start == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L3_error) + __pyx_v_curr_t = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_curr_t == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L3_error) + __pyx_v_total_t = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_total_t == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("create_map_batch", 1, 10, 10, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 6, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("get_alpha", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 38, __pyx_L3_error) __pyx_L3_error:; - __Pyx_AddTraceback("core.create_map_batch", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("core.get_alpha", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_4core_create_map_batch(__pyx_self, __pyx_v_X, __pyx_v_n_row, __pyx_v_n_col, __pyx_v_accum_w, __pyx_v_accum_n, __pyx_v_sigma, __pyx_v_importance, __pyx_v_n_pix, __pyx_v_dist_lib, __pyx_v_weights); + __pyx_r = __pyx_pf_4core_get_alpha(__pyx_self, __pyx_v_alpha_end, __pyx_v_alpha_start, __pyx_v_curr_t, __pyx_v_total_t); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_4core_create_map_batch(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_n_row, PyObject *__pyx_v_n_col, PyObject *__pyx_v_accum_w, PyObject *__pyx_v_accum_n, PyObject *__pyx_v_sigma, PyObject *__pyx_v_importance, PyObject *__pyx_v_n_pix, PyObject *__pyx_v_dist_lib, PyObject *__pyx_v_weights) { - int __pyx_v_i; - int __pyx_v_j; - int __pyx_v_k; - int __pyx_v_nr; - int __pyx_v_nc; - int __pyx_v_npix; - double __pyx_v_sig; - __Pyx_memviewslice __pyx_v_imp = { 0, 0, { 0 }, { 0 }, { 0 } }; - __Pyx_memviewslice __pyx_v_an = { 0, 0, { 0 }, { 0 }, { 0 } }; - PyObject *__pyx_v_inputs = NULL; - PyObject *__pyx_v_best = NULL; - CYTHON_UNUSED PyObject *__pyx_v_activation = NULL; +static PyObject *__pyx_pf_4core_get_alpha(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_alpha_end, float __pyx_v_alpha_start, int __pyx_v_curr_t, int __pyx_v_total_t) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - int __pyx_t_1; - double __pyx_t_2; - __Pyx_memviewslice __pyx_t_3 = { 0, 0, { 0 }, { 0 }, { 0 } }; - int __pyx_t_4; - int __pyx_t_5; + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; + int __pyx_t_7; PyObject *__pyx_t_8 = NULL; - PyObject *__pyx_t_9 = NULL; - PyObject *(*__pyx_t_10)(PyObject *); - int __pyx_t_11; - int __pyx_t_12; - int __pyx_t_13; - PyObject *__pyx_t_14 = NULL; - PyObject *__pyx_t_15 = NULL; - int __pyx_t_16; - PyObject *__pyx_t_17 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("create_map_batch", 0); - - /* "core.pyx":8 - * def create_map_batch(X, n_row, n_col, accum_w, accum_n, sigma, importance, n_pix, dist_lib, weights): - * cdef int i, j, k - * cdef int nr = n_row # <<<<<<<<<<<<<< - * cdef int nc = n_col - * cdef int npix = n_pix - */ - __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_n_row); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 8, __pyx_L1_error) - __pyx_v_nr = __pyx_t_1; + __Pyx_RefNannySetupContext("get_alpha", 0); - /* "core.pyx":9 - * cdef int i, j, k - * cdef int nr = n_row - * cdef int nc = n_col # <<<<<<<<<<<<<< - * cdef int npix = n_pix - * cdef double sig = sigma - */ - __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_n_col); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 9, __pyx_L1_error) - __pyx_v_nc = __pyx_t_1; - - /* "core.pyx":10 - * cdef int nr = n_row - * cdef int nc = n_col - * cdef int npix = n_pix # <<<<<<<<<<<<<< - * cdef double sig = sigma - * cdef double[:] imp = importance - */ - __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_n_pix); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 10, __pyx_L1_error) - __pyx_v_npix = __pyx_t_1; - - /* "core.pyx":11 - * cdef int nc = n_col - * cdef int npix = n_pix - * cdef double sig = sigma # <<<<<<<<<<<<<< - * cdef double[:] imp = importance - * cdef double[:] an = accum_n - */ - __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_v_sigma); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 11, __pyx_L1_error) - __pyx_v_sig = __pyx_t_2; - - /* "core.pyx":12 - * cdef int npix = n_pix - * cdef double sig = sigma - * cdef double[:] imp = importance # <<<<<<<<<<<<<< - * cdef double[:] an = accum_n - * for i in range(nr): - */ - __pyx_t_3 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_importance, PyBUF_WRITABLE); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 12, __pyx_L1_error) - __pyx_v_imp = __pyx_t_3; - __pyx_t_3.memview = NULL; - __pyx_t_3.data = NULL; - - /* "core.pyx":13 - * cdef double sig = sigma - * cdef double[:] imp = importance - * cdef double[:] an = accum_n # <<<<<<<<<<<<<< - * for i in range(nr): - * inputs = X[i] - */ - __pyx_t_3 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_accum_n, PyBUF_WRITABLE); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 13, __pyx_L1_error) - __pyx_v_an = __pyx_t_3; - __pyx_t_3.memview = NULL; - __pyx_t_3.data = NULL; - - /* "core.pyx":14 - * cdef double[:] imp = importance - * cdef double[:] an = accum_n - * for i in range(nr): # <<<<<<<<<<<<<< - * inputs = X[i] - * best, activation = get_best_cell(inputs=inputs, importance=imp, - */ - __pyx_t_1 = __pyx_v_nr; - __pyx_t_4 = __pyx_t_1; - for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { - __pyx_v_i = __pyx_t_5; - - /* "core.pyx":15 - * cdef double[:] an = accum_n - * for i in range(nr): - * inputs = X[i] # <<<<<<<<<<<<<< - * best, activation = get_best_cell(inputs=inputs, importance=imp, - * weights=weights, n_pix=npix) - */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_X, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_XDECREF_SET(__pyx_v_inputs, __pyx_t_6); - __pyx_t_6 = 0; - - /* "core.pyx":16 - * for i in range(nr): - * inputs = X[i] - * best, activation = get_best_cell(inputs=inputs, importance=imp, # <<<<<<<<<<<<<< - * weights=weights, n_pix=npix) - * for j in range(nc): + /* "core.pyx":42 + * Get value of alpha at a given time + * """ + * return alpha_start * np.power(alpha_end / alpha_start, float(curr_t) / float(total_t)) # <<<<<<<<<<<<<< + * + * def get_sigma(float sigma_f, float sigma_0, int curr_t, int total_t): */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_get_best_cell); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 16, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 16, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_inputs, __pyx_v_inputs) < 0) __PYX_ERR(0, 16, __pyx_L1_error) - __pyx_t_8 = __pyx_memoryview_fromslice(__pyx_v_imp, 1, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_alpha_start); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_power); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(__pyx_v_alpha_start == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "float division"); + __PYX_ERR(0, 42, __pyx_L1_error) + } + __pyx_t_3 = PyFloat_FromDouble((__pyx_v_alpha_end / __pyx_v_alpha_start)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(((double)__pyx_v_total_t) == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "float division"); + __PYX_ERR(0, 42, __pyx_L1_error) + } + __pyx_t_5 = PyFloat_FromDouble((((double)__pyx_v_curr_t) / ((double)__pyx_v_total_t))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 42, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_importance, __pyx_t_8) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + if (__pyx_t_6) { + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; + } + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_5); + __pyx_t_3 = 0; + __pyx_t_5 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; - /* "core.pyx":17 - * inputs = X[i] - * best, activation = get_best_cell(inputs=inputs, importance=imp, - * weights=weights, n_pix=npix) # <<<<<<<<<<<<<< - * for j in range(nc): - * accum_w[j, :] += count_modified_cells(best, dist_lib, sig) * inputs[j] + /* "core.pyx":38 + * # + * # t += n_row + * def get_alpha(float alpha_end, float alpha_start, int curr_t, int total_t): # <<<<<<<<<<<<<< + * """ + * Get value of alpha at a given time */ - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_weights, __pyx_v_weights) < 0) __PYX_ERR(0, 16, __pyx_L1_error) - __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_npix); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 17, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_n_pix, __pyx_t_8) < 0) __PYX_ERR(0, 16, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "core.pyx":16 - * for i in range(nr): - * inputs = X[i] - * best, activation = get_best_cell(inputs=inputs, importance=imp, # <<<<<<<<<<<<<< - * weights=weights, n_pix=npix) - * for j in range(nc): - */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_empty_tuple, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 16, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if ((likely(PyTuple_CheckExact(__pyx_t_8))) || (PyList_CheckExact(__pyx_t_8))) { - PyObject* sequence = __pyx_t_8; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 16, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_7 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); - } else { - __pyx_t_7 = PyList_GET_ITEM(sequence, 0); - __pyx_t_6 = PyList_GET_ITEM(sequence, 1); - } - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(__pyx_t_6); - #else - __pyx_t_7 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 16, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 16, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - #endif - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - } else { - Py_ssize_t index = -1; - __pyx_t_9 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 16, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_10 = Py_TYPE(__pyx_t_9)->tp_iternext; - index = 0; __pyx_t_7 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_7)) goto __pyx_L5_unpacking_failed; - __Pyx_GOTREF(__pyx_t_7); - index = 1; __pyx_t_6 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed; - __Pyx_GOTREF(__pyx_t_6); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 2) < 0) __PYX_ERR(0, 16, __pyx_L1_error) - __pyx_t_10 = NULL; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - goto __pyx_L6_unpacking_done; - __pyx_L5_unpacking_failed:; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_10 = NULL; - if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 16, __pyx_L1_error) - __pyx_L6_unpacking_done:; - } - __Pyx_XDECREF_SET(__pyx_v_best, __pyx_t_7); - __pyx_t_7 = 0; - __Pyx_XDECREF_SET(__pyx_v_activation, __pyx_t_6); - __pyx_t_6 = 0; - - /* "core.pyx":18 - * best, activation = get_best_cell(inputs=inputs, importance=imp, - * weights=weights, n_pix=npix) - * for j in range(nc): # <<<<<<<<<<<<<< - * accum_w[j, :] += count_modified_cells(best, dist_lib, sig) * inputs[j] - * an += count_modified_cells(best, dist_lib, sig) - */ - __pyx_t_11 = __pyx_v_nc; - __pyx_t_12 = __pyx_t_11; - for (__pyx_t_13 = 0; __pyx_t_13 < __pyx_t_12; __pyx_t_13+=1) { - __pyx_v_j = __pyx_t_13; - - /* "core.pyx":19 - * weights=weights, n_pix=npix) - * for j in range(nc): - * accum_w[j, :] += count_modified_cells(best, dist_lib, sig) * inputs[j] # <<<<<<<<<<<<<< - * an += count_modified_cells(best, dist_lib, sig) + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("core.get_alpha", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "core.pyx":44 + * return alpha_start * np.power(alpha_end / alpha_start, float(curr_t) / float(total_t)) * + * def get_sigma(float sigma_f, float sigma_0, int curr_t, int total_t): # <<<<<<<<<<<<<< + * """ + * Get value of sigma at a given time */ - __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_j); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 19, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 19, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_8); - __Pyx_INCREF(__pyx_slice_); - __Pyx_GIVEREF(__pyx_slice_); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_slice_); - __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_v_accum_w, __pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 19, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_count_modified_cells); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 19, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_14 = PyFloat_FromDouble(__pyx_v_sig); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 19, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - __pyx_t_15 = NULL; - __pyx_t_16 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { - __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_9); - if (likely(__pyx_t_15)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); - __Pyx_INCREF(__pyx_t_15); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_9, function); - __pyx_t_16 = 1; - } + +/* Python wrapper */ +static PyObject *__pyx_pw_4core_3get_sigma(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_4core_2get_sigma[] = "\n Get value of sigma at a given time\n "; +static PyMethodDef __pyx_mdef_4core_3get_sigma = {"get_sigma", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_3get_sigma, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4core_2get_sigma}; +static PyObject *__pyx_pw_4core_3get_sigma(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + float __pyx_v_sigma_f; + float __pyx_v_sigma_0; + int __pyx_v_curr_t; + int __pyx_v_total_t; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_sigma (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sigma_f,&__pyx_n_s_sigma_0,&__pyx_n_s_curr_t,&__pyx_n_s_total_t,0}; + PyObject* values[4] = {0,0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_9)) { - PyObject *__pyx_temp[4] = {__pyx_t_15, __pyx_v_best, __pyx_v_dist_lib, __pyx_t_14}; - __pyx_t_7 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_16, 3+__pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 19, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { - PyObject *__pyx_temp[4] = {__pyx_t_15, __pyx_v_best, __pyx_v_dist_lib, __pyx_t_14}; - __pyx_t_7 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_16, 3+__pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 19, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - } else - #endif - { - __pyx_t_17 = PyTuple_New(3+__pyx_t_16); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 19, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_17); - if (__pyx_t_15) { - __Pyx_GIVEREF(__pyx_t_15); PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_15); __pyx_t_15 = NULL; + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sigma_f)) != 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_sigma_0)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("get_sigma", 1, 4, 4, 1); __PYX_ERR(0, 44, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_curr_t)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("get_sigma", 1, 4, 4, 2); __PYX_ERR(0, 44, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_total_t)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("get_sigma", 1, 4, 4, 3); __PYX_ERR(0, 44, __pyx_L3_error) } - __Pyx_INCREF(__pyx_v_best); - __Pyx_GIVEREF(__pyx_v_best); - PyTuple_SET_ITEM(__pyx_t_17, 0+__pyx_t_16, __pyx_v_best); - __Pyx_INCREF(__pyx_v_dist_lib); - __Pyx_GIVEREF(__pyx_v_dist_lib); - PyTuple_SET_ITEM(__pyx_t_17, 1+__pyx_t_16, __pyx_v_dist_lib); - __Pyx_GIVEREF(__pyx_t_14); - PyTuple_SET_ITEM(__pyx_t_17, 2+__pyx_t_16, __pyx_t_14); - __pyx_t_14 = 0; - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_17, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 19, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - } - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_inputs, __pyx_v_j, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 19, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_17 = PyNumber_Multiply(__pyx_t_7, __pyx_t_9); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 19, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_17); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = PyNumber_InPlaceAdd(__pyx_t_8, __pyx_t_17); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 19, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - if (unlikely(PyObject_SetItem(__pyx_v_accum_w, __pyx_t_6, __pyx_t_9) < 0)) __PYX_ERR(0, 19, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - } - - /* "core.pyx":20 - * for j in range(nc): - * accum_w[j, :] += count_modified_cells(best, dist_lib, sig) * inputs[j] - * an += count_modified_cells(best, dist_lib, sig) # <<<<<<<<<<<<<< - * - * for k in range(nc): - */ - __pyx_t_6 = __pyx_memoryview_fromslice(__pyx_v_an, 1, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 20, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GetModuleGlobalName(__pyx_t_17, __pyx_n_s_count_modified_cells); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 20, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_17); - __pyx_t_8 = PyFloat_FromDouble(__pyx_v_sig); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 20, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = NULL; - __pyx_t_11 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_17))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_17); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_17); - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_17, function); - __pyx_t_11 = 1; } - } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_17)) { - PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_best, __pyx_v_dist_lib, __pyx_t_8}; - __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_17, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 20, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_17)) { - PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_v_best, __pyx_v_dist_lib, __pyx_t_8}; - __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_17, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 20, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - } else - #endif - { - __pyx_t_14 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 20, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_14); - if (__pyx_t_7) { - __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_7); __pyx_t_7 = NULL; + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_sigma") < 0)) __PYX_ERR(0, 44, __pyx_L3_error) } - __Pyx_INCREF(__pyx_v_best); - __Pyx_GIVEREF(__pyx_v_best); - PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_11, __pyx_v_best); - __Pyx_INCREF(__pyx_v_dist_lib); - __Pyx_GIVEREF(__pyx_v_dist_lib); - PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_11, __pyx_v_dist_lib); - __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_14, 2+__pyx_t_11, __pyx_t_8); - __pyx_t_8 = 0; - __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_17, __pyx_t_14, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 20, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[3] = PyTuple_GET_ITEM(__pyx_args, 3); } - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - __pyx_t_17 = PyNumber_InPlaceAdd(__pyx_t_6, __pyx_t_9); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 20, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_17); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_3 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_t_17, PyBUF_WRITABLE); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 20, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - __PYX_XDEC_MEMVIEW(&__pyx_v_an, 1); - __pyx_v_an = __pyx_t_3; - __pyx_t_3.memview = NULL; - __pyx_t_3.data = NULL; + __pyx_v_sigma_f = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_sigma_f == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 44, __pyx_L3_error) + __pyx_v_sigma_0 = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_sigma_0 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 44, __pyx_L3_error) + __pyx_v_curr_t = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_curr_t == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 44, __pyx_L3_error) + __pyx_v_total_t = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_total_t == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 44, __pyx_L3_error) } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_sigma", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 44, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("core.get_sigma", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4core_2get_sigma(__pyx_self, __pyx_v_sigma_f, __pyx_v_sigma_0, __pyx_v_curr_t, __pyx_v_total_t); - /* "core.pyx":22 - * an += count_modified_cells(best, dist_lib, sig) - * - * for k in range(nc): # <<<<<<<<<<<<<< - * weights[k] = accum_w[k] / an - * - */ - __pyx_t_1 = __pyx_v_nc; - __pyx_t_4 = __pyx_t_1; - for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { - __pyx_v_k = __pyx_t_5; + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "core.pyx":23 - * - * for k in range(nc): - * weights[k] = accum_w[k] / an # <<<<<<<<<<<<<< +static PyObject *__pyx_pf_4core_2get_sigma(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_sigma_f, float __pyx_v_sigma_0, int __pyx_v_curr_t, int __pyx_v_total_t) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_sigma", 0); + + /* "core.pyx":48 + * Get value of sigma at a given time + * """ + * return sigma_0 * np.power(sigma_f / sigma_0, float(curr_t) / float(total_t)) # <<<<<<<<<<<<<< * - * def create_map_online(X, n_row, alpha, sigma, random_indices, importance, n_pix, dist_lib, weights): + * @timeit */ - __pyx_t_17 = __Pyx_GetItemInt(__pyx_v_accum_w, __pyx_v_k, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 23, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_17); - __pyx_t_9 = __pyx_memoryview_fromslice(__pyx_v_an, 1, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 23, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_6 = __Pyx_PyNumber_Divide(__pyx_t_17, __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 23, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely(__Pyx_SetItemInt(__pyx_v_weights, __pyx_v_k, __pyx_t_6, int, 1, __Pyx_PyInt_From_int, 0, 1, 1) < 0)) __PYX_ERR(0, 23, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_sigma_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_power); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(__pyx_v_sigma_0 == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "float division"); + __PYX_ERR(0, 48, __pyx_L1_error) + } + __pyx_t_3 = PyFloat_FromDouble((__pyx_v_sigma_f / __pyx_v_sigma_0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(((double)__pyx_v_total_t) == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "float division"); + __PYX_ERR(0, 48, __pyx_L1_error) + } + __pyx_t_5 = PyFloat_FromDouble((((double)__pyx_v_curr_t) / ((double)__pyx_v_total_t))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 48, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 48, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_6) { + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; + } + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_5); + __pyx_t_3 = 0; + __pyx_t_5 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; - /* "core.pyx":6 - * from somsphere.utils import get_best_cell, count_modified_cells, timeit + /* "core.pyx":44 + * return alpha_start * np.power(alpha_end / alpha_start, float(curr_t) / float(total_t)) * - * def create_map_batch(X, n_row, n_col, accum_w, accum_n, sigma, importance, n_pix, dist_lib, weights): # <<<<<<<<<<<<<< - * cdef int i, j, k - * cdef int nr = n_row + * def get_sigma(float sigma_f, float sigma_0, int curr_t, int total_t): # <<<<<<<<<<<<<< + * """ + * Get value of sigma at a given time */ /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; __pyx_L1_error:; - __PYX_XDEC_MEMVIEW(&__pyx_t_3, 1); + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_9); - __Pyx_XDECREF(__pyx_t_14); - __Pyx_XDECREF(__pyx_t_15); - __Pyx_XDECREF(__pyx_t_17); - __Pyx_AddTraceback("core.create_map_batch", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("core.get_sigma", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __PYX_XDEC_MEMVIEW(&__pyx_v_imp, 1); - __PYX_XDEC_MEMVIEW(&__pyx_v_an, 1); - __Pyx_XDECREF(__pyx_v_inputs); - __Pyx_XDECREF(__pyx_v_best); - __Pyx_XDECREF(__pyx_v_activation); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "core.pyx":25 - * weights[k] = accum_w[k] / an +/* "core.pyx":51 * - * def create_map_online(X, n_row, alpha, sigma, random_indices, importance, n_pix, dist_lib, weights): # <<<<<<<<<<<<<< - * cdef int i - * cdef int nr = n_row + * @timeit + * def get_best_cell(cnp.ndarray inputs, cnp.ndarray importance, int n_pix, cnp.ndarray weights, int return_vals): # <<<<<<<<<<<<<< + * """ + * Return the closest cell to the input object */ /* Python wrapper */ -static PyObject *__pyx_pw_4core_3create_map_online(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyMethodDef __pyx_mdef_4core_3create_map_online = {"create_map_online", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_3create_map_online, METH_VARARGS|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_4core_3create_map_online(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_X = 0; - PyObject *__pyx_v_n_row = 0; - CYTHON_UNUSED PyObject *__pyx_v_alpha = 0; - PyObject *__pyx_v_sigma = 0; - PyObject *__pyx_v_random_indices = 0; - PyObject *__pyx_v_importance = 0; - PyObject *__pyx_v_n_pix = 0; - PyObject *__pyx_v_dist_lib = 0; - PyObject *__pyx_v_weights = 0; +static PyObject *__pyx_pw_4core_5get_best_cell(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_4core_4get_best_cell[] = "\n Return the closest cell to the input object\n It can return more than one value if needed\n "; +static PyMethodDef __pyx_mdef_4core_5get_best_cell = {"get_best_cell", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_5get_best_cell, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4core_4get_best_cell}; +static PyObject *__pyx_pw_4core_5get_best_cell(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyArrayObject *__pyx_v_inputs = 0; + PyArrayObject *__pyx_v_importance = 0; + int __pyx_v_n_pix; + PyArrayObject *__pyx_v_weights = 0; + int __pyx_v_return_vals; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("create_map_online (wrapper)", 0); + __Pyx_RefNannySetupContext("get_best_cell (wrapper)", 0); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_X,&__pyx_n_s_n_row,&__pyx_n_s_alpha,&__pyx_n_s_sigma,&__pyx_n_s_random_indices,&__pyx_n_s_importance,&__pyx_n_s_n_pix,&__pyx_n_s_dist_lib,&__pyx_n_s_weights,0}; - PyObject* values[9] = {0,0,0,0,0,0,0,0,0}; + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_inputs,&__pyx_n_s_importance,&__pyx_n_s_n_pix,&__pyx_n_s_weights,&__pyx_n_s_return_vals,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 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); - CYTHON_FALLTHROUGH; - case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); - CYTHON_FALLTHROUGH; - case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); - CYTHON_FALLTHROUGH; - case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); - CYTHON_FALLTHROUGH; case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); CYTHON_FALLTHROUGH; case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); @@ -2766,61 +2323,37 @@ static PyObject *__pyx_pw_4core_3create_map_online(PyObject *__pyx_self, PyObjec kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_X)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_inputs)) != 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_n_row)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_importance)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 9, 9, 1); __PYX_ERR(0, 25, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("get_best_cell", 1, 5, 5, 1); __PYX_ERR(0, 51, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha)) != 0)) kw_args--; + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_pix)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 9, 9, 2); __PYX_ERR(0, 25, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("get_best_cell", 1, 5, 5, 2); __PYX_ERR(0, 51, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: - if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sigma)) != 0)) kw_args--; + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_weights)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 9, 9, 3); __PYX_ERR(0, 25, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("get_best_cell", 1, 5, 5, 3); __PYX_ERR(0, 51, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: - if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_random_indices)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 9, 9, 4); __PYX_ERR(0, 25, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 5: - if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_importance)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 9, 9, 5); __PYX_ERR(0, 25, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 6: - if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_pix)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 9, 9, 6); __PYX_ERR(0, 25, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 7: - if (likely((values[7] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dist_lib)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 9, 9, 7); __PYX_ERR(0, 25, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 8: - if (likely((values[8] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_weights)) != 0)) kw_args--; + if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_return_vals)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 9, 9, 8); __PYX_ERR(0, 25, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("get_best_cell", 1, 5, 5, 4); __PYX_ERR(0, 51, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create_map_online") < 0)) __PYX_ERR(0, 25, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_best_cell") < 0)) __PYX_ERR(0, 51, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 9) { + } else if (PyTuple_GET_SIZE(__pyx_args) != 5) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); @@ -2828,428 +2361,372 @@ static PyObject *__pyx_pw_4core_3create_map_online(PyObject *__pyx_self, PyObjec values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[3] = PyTuple_GET_ITEM(__pyx_args, 3); values[4] = PyTuple_GET_ITEM(__pyx_args, 4); - values[5] = PyTuple_GET_ITEM(__pyx_args, 5); - values[6] = PyTuple_GET_ITEM(__pyx_args, 6); - values[7] = PyTuple_GET_ITEM(__pyx_args, 7); - values[8] = PyTuple_GET_ITEM(__pyx_args, 8); } - __pyx_v_X = values[0]; - __pyx_v_n_row = values[1]; - __pyx_v_alpha = values[2]; - __pyx_v_sigma = values[3]; - __pyx_v_random_indices = values[4]; - __pyx_v_importance = values[5]; - __pyx_v_n_pix = values[6]; - __pyx_v_dist_lib = values[7]; - __pyx_v_weights = values[8]; + __pyx_v_inputs = ((PyArrayObject *)values[0]); + __pyx_v_importance = ((PyArrayObject *)values[1]); + __pyx_v_n_pix = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_n_pix == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 51, __pyx_L3_error) + __pyx_v_weights = ((PyArrayObject *)values[3]); + __pyx_v_return_vals = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_return_vals == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 51, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 9, 9, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 25, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("get_best_cell", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 51, __pyx_L3_error) __pyx_L3_error:; - __Pyx_AddTraceback("core.create_map_online", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("core.get_best_cell", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_4core_2create_map_online(__pyx_self, __pyx_v_X, __pyx_v_n_row, __pyx_v_alpha, __pyx_v_sigma, __pyx_v_random_indices, __pyx_v_importance, __pyx_v_n_pix, __pyx_v_dist_lib, __pyx_v_weights); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_inputs), __pyx_ptype_5numpy_ndarray, 1, "inputs", 0))) __PYX_ERR(0, 51, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_importance), __pyx_ptype_5numpy_ndarray, 1, "importance", 0))) __PYX_ERR(0, 51, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_weights), __pyx_ptype_5numpy_ndarray, 1, "weights", 0))) __PYX_ERR(0, 51, __pyx_L1_error) + __pyx_r = __pyx_pf_4core_4get_best_cell(__pyx_self, __pyx_v_inputs, __pyx_v_importance, __pyx_v_n_pix, __pyx_v_weights, __pyx_v_return_vals); /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_4core_2create_map_online(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_n_row, CYTHON_UNUSED PyObject *__pyx_v_alpha, PyObject *__pyx_v_sigma, PyObject *__pyx_v_random_indices, PyObject *__pyx_v_importance, PyObject *__pyx_v_n_pix, PyObject *__pyx_v_dist_lib, PyObject *__pyx_v_weights) { - int __pyx_v_i; - int __pyx_v_nr; - int __pyx_v_npix; - double __pyx_v_alp; - double __pyx_v_sig; - __Pyx_memviewslice __pyx_v_imp = { 0, 0, { 0 }, { 0 }, { 0 } }; - PyObject *__pyx_v_inputs = NULL; - PyObject *__pyx_v_best = NULL; - CYTHON_UNUSED PyObject *__pyx_v_activation = NULL; +static PyObject *__pyx_pf_4core_4get_best_cell(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_inputs, PyArrayObject *__pyx_v_importance, int __pyx_v_n_pix, PyArrayObject *__pyx_v_weights, int __pyx_v_return_vals) { + CYTHON_UNUSED PyArrayObject *__pyx_v_activation = 0; + PyObject *__pyx_v_activations = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - int __pyx_t_1; - double __pyx_t_2; - __Pyx_memviewslice __pyx_t_3 = { 0, 0, { 0 }, { 0 }, { 0 } }; - int __pyx_t_4; - int __pyx_t_5; + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; - PyObject *__pyx_t_9 = NULL; - PyObject *(*__pyx_t_10)(PyObject *); - PyObject *__pyx_t_11 = NULL; - int __pyx_t_12; - PyObject *__pyx_t_13 = NULL; + int __pyx_t_9; + PyObject *__pyx_t_10 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("create_map_online", 0); - __Pyx_INCREF(__pyx_v_weights); - - /* "core.pyx":27 - * def create_map_online(X, n_row, alpha, sigma, random_indices, importance, n_pix, dist_lib, weights): - * cdef int i - * cdef int nr = n_row # <<<<<<<<<<<<<< - * cdef int npix = n_pix - * cdef double alp = alp - */ - __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_n_row); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 27, __pyx_L1_error) - __pyx_v_nr = __pyx_t_1; - - /* "core.pyx":28 - * cdef int i - * cdef int nr = n_row - * cdef int npix = n_pix # <<<<<<<<<<<<<< - * cdef double alp = alp - * cdef double sig = sigma - */ - __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_n_pix); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 28, __pyx_L1_error) - __pyx_v_npix = __pyx_t_1; - - /* "core.pyx":30 - * cdef int npix = n_pix - * cdef double alp = alp - * cdef double sig = sigma # <<<<<<<<<<<<<< - * cdef double[:] imp = importance - * for i in range(nr): - */ - __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_v_sigma); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 30, __pyx_L1_error) - __pyx_v_sig = __pyx_t_2; - - /* "core.pyx":31 - * cdef double alp = alp - * cdef double sig = sigma - * cdef double[:] imp = importance # <<<<<<<<<<<<<< - * for i in range(nr): - * inputs = X[random_indices[i]] - */ - __pyx_t_3 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_importance, PyBUF_WRITABLE); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 31, __pyx_L1_error) - __pyx_v_imp = __pyx_t_3; - __pyx_t_3.memview = NULL; - __pyx_t_3.data = NULL; - - /* "core.pyx":32 - * cdef double sig = sigma - * cdef double[:] imp = importance - * for i in range(nr): # <<<<<<<<<<<<<< - * inputs = X[random_indices[i]] - * best, activation = get_best_cell(inputs=inputs, importance=imp, - */ - __pyx_t_1 = __pyx_v_nr; - __pyx_t_4 = __pyx_t_1; - for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { - __pyx_v_i = __pyx_t_5; - - /* "core.pyx":33 - * cdef double[:] imp = importance - * for i in range(nr): - * inputs = X[random_indices[i]] # <<<<<<<<<<<<<< - * best, activation = get_best_cell(inputs=inputs, importance=imp, - * weights=weights, n_pix=npix) - */ - __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_random_indices, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 33, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_v_X, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 33, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_XDECREF_SET(__pyx_v_inputs, __pyx_t_7); - __pyx_t_7 = 0; - - /* "core.pyx":34 - * for i in range(nr): - * inputs = X[random_indices[i]] - * best, activation = get_best_cell(inputs=inputs, importance=imp, # <<<<<<<<<<<<<< - * weights=weights, n_pix=npix) - * weights += alp * count_modified_cells(best, dist_lib, sig) * numpy.transpose( - */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_get_best_cell); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 34, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 34, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_inputs, __pyx_v_inputs) < 0) __PYX_ERR(0, 34, __pyx_L1_error) - __pyx_t_8 = __pyx_memoryview_fromslice(__pyx_v_imp, 1, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 34, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_importance, __pyx_t_8) < 0) __PYX_ERR(0, 34, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_RefNannySetupContext("get_best_cell", 0); - /* "core.pyx":35 - * inputs = X[random_indices[i]] - * best, activation = get_best_cell(inputs=inputs, importance=imp, - * weights=weights, n_pix=npix) # <<<<<<<<<<<<<< - * weights += alp * count_modified_cells(best, dist_lib, sig) * numpy.transpose( - * (inputs - numpy.transpose(weights))) + /* "core.pyx":56 + * It can return more than one value if needed + * """ + * cdef cnp.ndarray activation = np.zeros([n_pix, 1], dtype=DTYPE) # <<<<<<<<<<<<<< + * + * activations = np.sum(np.transpose([importance]) * (np.transpose(np.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0) */ - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_weights, __pyx_v_weights) < 0) __PYX_ERR(0, 34, __pyx_L1_error) - __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_npix); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 35, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_n_pix, __pyx_t_8) < 0) __PYX_ERR(0, 34, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_pix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyList_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyList_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyList_SET_ITEM(__pyx_t_3, 1, __pyx_int_1); + __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_DTYPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 56, __pyx_L1_error) + __pyx_v_activation = ((PyArrayObject *)__pyx_t_4); + __pyx_t_4 = 0; - /* "core.pyx":34 - * for i in range(nr): - * inputs = X[random_indices[i]] - * best, activation = get_best_cell(inputs=inputs, importance=imp, # <<<<<<<<<<<<<< - * weights=weights, n_pix=npix) - * weights += alp * count_modified_cells(best, dist_lib, sig) * numpy.transpose( + /* "core.pyx":58 + * cdef cnp.ndarray activation = np.zeros([n_pix, 1], dtype=DTYPE) + * + * activations = np.sum(np.transpose([importance]) * (np.transpose(np.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0) # <<<<<<<<<<<<<< + * + * return np.argmin(activations) if return_vals == 1 else np.argsort(activations)[0:return_vals], activations */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 34, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if ((likely(PyTuple_CheckExact(__pyx_t_8))) || (PyList_CheckExact(__pyx_t_8))) { - PyObject* sequence = __pyx_t_8; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 34, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1); - } else { - __pyx_t_6 = PyList_GET_ITEM(sequence, 0); - __pyx_t_7 = PyList_GET_ITEM(sequence, 1); - } - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(__pyx_t_7); - #else - __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 34, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 34, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - #endif - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - } else { - Py_ssize_t index = -1; - __pyx_t_9 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 34, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_10 = Py_TYPE(__pyx_t_9)->tp_iternext; - index = 0; __pyx_t_6 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed; - __Pyx_GOTREF(__pyx_t_6); - index = 1; __pyx_t_7 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_7)) goto __pyx_L5_unpacking_failed; - __Pyx_GOTREF(__pyx_t_7); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 2) < 0) __PYX_ERR(0, 34, __pyx_L1_error) - __pyx_t_10 = NULL; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - goto __pyx_L6_unpacking_done; - __pyx_L5_unpacking_failed:; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_10 = NULL; - if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 34, __pyx_L1_error) - __pyx_L6_unpacking_done:; - } - __Pyx_XDECREF_SET(__pyx_v_best, __pyx_t_6); - __pyx_t_6 = 0; - __Pyx_XDECREF_SET(__pyx_v_activation, __pyx_t_7); - __pyx_t_7 = 0; - - /* "core.pyx":36 - * best, activation = get_best_cell(inputs=inputs, importance=imp, - * weights=weights, n_pix=npix) - * weights += alp * count_modified_cells(best, dist_lib, sig) * numpy.transpose( # <<<<<<<<<<<<<< - * (inputs - numpy.transpose(weights))) - */ - __pyx_t_8 = PyFloat_FromDouble(__pyx_v_alp); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_count_modified_cells); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_9 = PyFloat_FromDouble(__pyx_v_sig); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_11 = NULL; - __pyx_t_12 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { - __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_6); - if (likely(__pyx_t_11)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); - __Pyx_INCREF(__pyx_t_11); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_6, function); - __pyx_t_12 = 1; - } + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_sum); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_transpose); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)__pyx_v_importance)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_importance)); + PyList_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_importance)); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_6)) { - PyObject *__pyx_temp[4] = {__pyx_t_11, __pyx_v_best, __pyx_v_dist_lib, __pyx_t_9}; - __pyx_t_7 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { - PyObject *__pyx_temp[4] = {__pyx_t_11, __pyx_v_best, __pyx_v_dist_lib, __pyx_t_9}; - __pyx_t_7 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - } else - #endif - { - __pyx_t_13 = PyTuple_New(3+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_13); - if (__pyx_t_11) { - __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_11); __pyx_t_11 = NULL; - } - __Pyx_INCREF(__pyx_v_best); - __Pyx_GIVEREF(__pyx_v_best); - PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_12, __pyx_v_best); - __Pyx_INCREF(__pyx_v_dist_lib); - __Pyx_GIVEREF(__pyx_v_dist_lib); - PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_12, __pyx_v_dist_lib); - __Pyx_GIVEREF(__pyx_t_9); - PyTuple_SET_ITEM(__pyx_t_13, 2+__pyx_t_12, __pyx_t_9); - __pyx_t_9 = 0; - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_13, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } + __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_transpose); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_tile); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_n_pix); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_int_1); + __pyx_t_6 = 0; + __pyx_t_6 = NULL; + __pyx_t_9 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_9 = 1; } - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyNumber_Multiply(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, ((PyObject *)__pyx_v_inputs), __pyx_t_8}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_numpy); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_transpose); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_13); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { + PyObject *__pyx_temp[3] = {__pyx_t_6, ((PyObject *)__pyx_v_inputs), __pyx_t_8}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else + #endif + { + __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + if (__pyx_t_6) { + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_6); __pyx_t_6 = NULL; + } + __Pyx_INCREF(((PyObject *)__pyx_v_inputs)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_inputs)); + PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, ((PyObject *)__pyx_v_inputs)); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_2 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyNumber_Subtract(__pyx_t_2, ((PyObject *)__pyx_v_weights)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_Power(__pyx_t_5, __pyx_int_2, Py_None); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyNumber_Multiply(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_axis, __pyx_int_0) < 0) __PYX_ERR(0, 58, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_activations = __pyx_t_4; + __pyx_t_4 = 0; - /* "core.pyx":37 - * weights=weights, n_pix=npix) - * weights += alp * count_modified_cells(best, dist_lib, sig) * numpy.transpose( - * (inputs - numpy.transpose(weights))) # <<<<<<<<<<<<<< + /* "core.pyx":60 + * activations = np.sum(np.transpose([importance]) * (np.transpose(np.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0) + * + * return np.argmin(activations) if return_vals == 1 else np.argsort(activations)[0:return_vals], activations # <<<<<<<<<<<<<< + * + * def count_modified_cells(int bmu, cnp.ndarray map_d, float sigma): */ - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_numpy); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 37, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_transpose); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 37, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_11); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_11))) { - __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_11); - if (likely(__pyx_t_9)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); - __Pyx_INCREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_r); + if (((__pyx_v_return_vals == 1) != 0)) { + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_argmin); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_11, function); + __Pyx_DECREF_SET(__pyx_t_3, function); } } - __pyx_t_8 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_9, __pyx_v_weights) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_v_weights); - __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 37, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = PyNumber_Subtract(__pyx_v_inputs, __pyx_t_8); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 37, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_11); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_13); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); - __Pyx_INCREF(__pyx_t_8); + __pyx_t_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_v_activations) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_activations); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = __pyx_t_5; + __pyx_t_5 = 0; + } else { + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_argsort); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_13, function); + __Pyx_DECREF_SET(__pyx_t_2, function); } } - __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_8, __pyx_t_11) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_11); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; - - /* "core.pyx":36 - * best, activation = get_best_cell(inputs=inputs, importance=imp, - * weights=weights, n_pix=npix) - * weights += alp * count_modified_cells(best, dist_lib, sig) * numpy.transpose( # <<<<<<<<<<<<<< - * (inputs - numpy.transpose(weights))) - */ - __pyx_t_13 = PyNumber_Multiply(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_13); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = PyNumber_InPlaceAdd(__pyx_v_weights, __pyx_t_13); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; - __Pyx_DECREF_SET(__pyx_v_weights, __pyx_t_7); - __pyx_t_7 = 0; + __pyx_t_5 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_activations) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_activations); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetSlice(__pyx_t_5, 0, __pyx_v_return_vals, NULL, NULL, NULL, 1, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_4 = __pyx_t_2; + __pyx_t_2 = 0; } + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); + __Pyx_INCREF(__pyx_v_activations); + __Pyx_GIVEREF(__pyx_v_activations); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_activations); + __pyx_t_4 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; - /* "core.pyx":25 - * weights[k] = accum_w[k] / an + /* "core.pyx":51 * - * def create_map_online(X, n_row, alpha, sigma, random_indices, importance, n_pix, dist_lib, weights): # <<<<<<<<<<<<<< - * cdef int i - * cdef int nr = n_row + * @timeit + * def get_best_cell(cnp.ndarray inputs, cnp.ndarray importance, int n_pix, cnp.ndarray weights, int return_vals): # <<<<<<<<<<<<<< + * """ + * Return the closest cell to the input object */ /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; __pyx_L1_error:; - __PYX_XDEC_MEMVIEW(&__pyx_t_3, 1); + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_9); - __Pyx_XDECREF(__pyx_t_11); - __Pyx_XDECREF(__pyx_t_13); - __Pyx_AddTraceback("core.create_map_online", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("core.get_best_cell", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __PYX_XDEC_MEMVIEW(&__pyx_v_imp, 1); - __Pyx_XDECREF(__pyx_v_inputs); - __Pyx_XDECREF(__pyx_v_best); - __Pyx_XDECREF(__pyx_v_activation); - __Pyx_XDECREF(__pyx_v_weights); + __Pyx_XDECREF((PyObject *)__pyx_v_activation); + __Pyx_XDECREF(__pyx_v_activations); __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): +/* "core.pyx":62 + * return np.argmin(activations) if return_vals == 1 else np.argsort(activations)[0:return_vals], activations * + * def count_modified_cells(int bmu, cnp.ndarray map_d, float sigma): # <<<<<<<<<<<<<< + * """ + * Neighborhood function which quantifies how much cells around the best matching one are modified */ /* 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; +static PyObject *__pyx_pw_4core_7count_modified_cells(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_4core_6count_modified_cells[] = "\n Neighborhood function which quantifies how much cells around the best matching one are modified\n\n :param int bmu: best matching unit\n :param nparray map_d: array of distances computed with :func:`geometry`\n "; +static PyMethodDef __pyx_mdef_4core_7count_modified_cells = {"count_modified_cells", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_7count_modified_cells, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4core_6count_modified_cells}; +static PyObject *__pyx_pw_4core_7count_modified_cells(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_v_bmu; + PyArrayObject *__pyx_v_map_d = 0; + float __pyx_v_sigma; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - int __pyx_r; + PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + __Pyx_RefNannySetupContext("count_modified_cells (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); + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_bmu,&__pyx_n_s_map_d,&__pyx_n_s_sigma,0}; + PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { - case 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); @@ -3262,1285 +2739,1373 @@ static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, P 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--; + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bmu)) != 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--; + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_map_d)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 1); __PYX_ERR(1, 122, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("count_modified_cells", 1, 3, 3, 1); __PYX_ERR(0, 62, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_format)) != 0)) kw_args--; + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sigma)) != 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--; } + __Pyx_RaiseArgtupleInvalid("count_modified_cells", 1, 3, 3, 2); __PYX_ERR(0, 62, __pyx_L3_error) } } 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; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "count_modified_cells") < 0)) __PYX_ERR(0, 62, __pyx_L3_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 if (PyTuple_GET_SIZE(__pyx_args) != 3) { + goto __pyx_L5_argtuple_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); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } + __pyx_v_bmu = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_bmu == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 62, __pyx_L3_error) + __pyx_v_map_d = ((PyArrayObject *)values[1]); + __pyx_v_sigma = __pyx_PyFloat_AsFloat(values[2]); if (unlikely((__pyx_v_sigma == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 62, __pyx_L3_error) } 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_RaiseArgtupleInvalid("count_modified_cells", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 62, __pyx_L3_error) __pyx_L3_error:; - __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("core.count_modified_cells", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); - return -1; + return NULL; __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): - * - */ + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_map_d), __pyx_ptype_5numpy_ndarray, 1, "map_d", 0))) __PYX_ERR(0, 62, __pyx_L1_error) + __pyx_r = __pyx_pf_4core_6count_modified_cells(__pyx_self, __pyx_v_bmu, __pyx_v_map_d, __pyx_v_sigma); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; - __pyx_r = -1; + __pyx_r = NULL; __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; +static PyObject *__pyx_pf_4core_6count_modified_cells(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_bmu, PyArrayObject *__pyx_v_map_d, float __pyx_v_sigma) { + PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - Py_ssize_t __pyx_t_1; - int __pyx_t_2; + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; + PyObject *__pyx_t_4 = NULL; 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__cinit__", 0); - __Pyx_INCREF(__pyx_v_format); + __Pyx_RefNannySetupContext("count_modified_cells", 0); - /* "View.MemoryView":129 - * cdef PyObject **p - * - * self.ndim = len(shape) # <<<<<<<<<<<<<< - * self.itemsize = itemsize + /* "core.pyx":69 + * :param nparray map_d: array of distances computed with :func:`geometry` + * """ + * return np.exp(-(map_d[bmu] ** 2) / sigma ** 2) # <<<<<<<<<<<<<< * + * def create_map_online(cnp.ndarray X, int n_iter, int n_row, int n_col, int n_pix, float alpha_start, float alpha_end, */ - 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_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_exp); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_map_d), __pyx_v_bmu, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyNumber_Power(__pyx_t_2, __pyx_int_2, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_Negative(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyFloat_FromDouble(powf(__pyx_v_sigma, 2.0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } } - __pyx_t_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)) { + __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "View.MemoryView":133 + /* "core.pyx":62 + * return np.argmin(activations) if return_vals == 1 else np.argsort(activations)[0:return_vals], activations * - * if not self.ndim: - * raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<< - * - * if itemsize <= 0: + * def count_modified_cells(int bmu, cnp.ndarray map_d, float sigma): # <<<<<<<<<<<<<< + * """ + * Neighborhood function which quantifies how much cells around the best matching one are modified */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, 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") - * - */ - } + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("core.count_modified_cells", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "View.MemoryView":135 - * raise ValueError("Empty shape tuple for cython.array") - * - * if itemsize <= 0: # <<<<<<<<<<<<<< - * raise ValueError("itemsize <= 0 for cython.array") +/* "core.pyx":71 + * return np.exp(-(map_d[bmu] ** 2) / sigma ** 2) * + * def create_map_online(cnp.ndarray X, int n_iter, int n_row, int n_col, int n_pix, float alpha_start, float alpha_end, # <<<<<<<<<<<<<< + * cnp.ndarray importance, cnp.ndarray dist_lib, cnp.ndarray weights, bint random_order): + * cdef int t = 0 */ - __pyx_t_2 = ((__pyx_v_itemsize <= 0) != 0); - if (unlikely(__pyx_t_2)) { - /* "View.MemoryView":136 - * - * 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__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 136, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 136, __pyx_L1_error) - - /* "View.MemoryView":135 - * raise ValueError("Empty shape tuple for cython.array") - * - * if itemsize <= 0: # <<<<<<<<<<<<<< - * raise ValueError("itemsize <= 0 for cython.array") - * - */ +/* Python wrapper */ +static PyObject *__pyx_pw_4core_9create_map_online(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_4core_9create_map_online = {"create_map_online", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_9create_map_online, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4core_9create_map_online(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyArrayObject *__pyx_v_X = 0; + int __pyx_v_n_iter; + int __pyx_v_n_row; + int __pyx_v_n_col; + int __pyx_v_n_pix; + float __pyx_v_alpha_start; + float __pyx_v_alpha_end; + PyArrayObject *__pyx_v_importance = 0; + PyArrayObject *__pyx_v_dist_lib = 0; + PyArrayObject *__pyx_v_weights = 0; + int __pyx_v_random_order; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("create_map_online (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_X,&__pyx_n_s_n_iter,&__pyx_n_s_n_row,&__pyx_n_s_n_col,&__pyx_n_s_n_pix,&__pyx_n_s_alpha_start,&__pyx_n_s_alpha_end,&__pyx_n_s_importance,&__pyx_n_s_dist_lib,&__pyx_n_s_weights,&__pyx_n_s_random_order,0}; + PyObject* values[11] = {0,0,0,0,0,0,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 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + 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_X)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_iter)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 1); __PYX_ERR(0, 71, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_row)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 2); __PYX_ERR(0, 71, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_col)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 3); __PYX_ERR(0, 71, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_pix)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 4); __PYX_ERR(0, 71, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha_start)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 5); __PYX_ERR(0, 71, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha_end)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 6); __PYX_ERR(0, 71, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 7: + if (likely((values[7] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_importance)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 7); __PYX_ERR(0, 71, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 8: + if (likely((values[8] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dist_lib)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 8); __PYX_ERR(0, 71, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 9: + if (likely((values[9] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_weights)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 9); __PYX_ERR(0, 71, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 10: + if (likely((values[10] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_random_order)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 10); __PYX_ERR(0, 71, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create_map_online") < 0)) __PYX_ERR(0, 71, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 11) { + 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); + values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + values[7] = PyTuple_GET_ITEM(__pyx_args, 7); + values[8] = PyTuple_GET_ITEM(__pyx_args, 8); + values[9] = PyTuple_GET_ITEM(__pyx_args, 9); + values[10] = PyTuple_GET_ITEM(__pyx_args, 10); + } + __pyx_v_X = ((PyArrayObject *)values[0]); + __pyx_v_n_iter = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_n_iter == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error) + __pyx_v_n_row = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_n_row == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error) + __pyx_v_n_col = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_n_col == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error) + __pyx_v_n_pix = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_n_pix == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error) + __pyx_v_alpha_start = __pyx_PyFloat_AsFloat(values[5]); if (unlikely((__pyx_v_alpha_start == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error) + __pyx_v_alpha_end = __pyx_PyFloat_AsFloat(values[6]); if (unlikely((__pyx_v_alpha_end == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error) + __pyx_v_importance = ((PyArrayObject *)values[7]); + __pyx_v_dist_lib = ((PyArrayObject *)values[8]); + __pyx_v_weights = ((PyArrayObject *)values[9]); + __pyx_v_random_order = __Pyx_PyObject_IsTrue(values[10]); if (unlikely((__pyx_v_random_order == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 72, __pyx_L3_error) } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 71, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("core.create_map_online", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_X), __pyx_ptype_5numpy_ndarray, 1, "X", 0))) __PYX_ERR(0, 71, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_importance), __pyx_ptype_5numpy_ndarray, 1, "importance", 0))) __PYX_ERR(0, 72, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dist_lib), __pyx_ptype_5numpy_ndarray, 1, "dist_lib", 0))) __PYX_ERR(0, 72, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_weights), __pyx_ptype_5numpy_ndarray, 1, "weights", 0))) __PYX_ERR(0, 72, __pyx_L1_error) + __pyx_r = __pyx_pf_4core_8create_map_online(__pyx_self, __pyx_v_X, __pyx_v_n_iter, __pyx_v_n_row, __pyx_v_n_col, __pyx_v_n_pix, __pyx_v_alpha_start, __pyx_v_alpha_end, __pyx_v_importance, __pyx_v_dist_lib, __pyx_v_weights, __pyx_v_random_order); - /* "View.MemoryView":138 - * raise ValueError("itemsize <= 0 for cython.array") - * - * if not isinstance(format, bytes): # <<<<<<<<<<<<<< - * format = format.encode('ASCII') - * self._format = format # keep a reference to the byte string - */ - __pyx_t_2 = PyBytes_Check(__pyx_v_format); - __pyx_t_4 = ((!(__pyx_t_2 != 0)) != 0); - if (__pyx_t_4) { + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "View.MemoryView":139 - * - * if not isinstance(format, bytes): - * format = format.encode('ASCII') # <<<<<<<<<<<<<< - * self._format = format # keep a reference to the byte string - * self.format = self._format - */ - __pyx_t_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_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; +static PyObject *__pyx_pf_4core_8create_map_online(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_X, int __pyx_v_n_iter, int __pyx_v_n_row, int __pyx_v_n_col, int __pyx_v_n_pix, float __pyx_v_alpha_start, float __pyx_v_alpha_end, PyArrayObject *__pyx_v_importance, PyArrayObject *__pyx_v_dist_lib, PyArrayObject *__pyx_v_weights, int __pyx_v_random_order) { + int __pyx_v_t; + int __pyx_v_total_t; + float __pyx_v_sigma_0; + float __pyx_v_sigma_f; + int __pyx_v_i; + int __pyx_v_best; + float __pyx_v_alpha; + float __pyx_v_sigma; + PyObject *__pyx_v_random_indices = 0; + PyArrayObject *__pyx_v_inputs = 0; + CYTHON_UNUSED PyArrayObject *__pyx_v_activation = 0; + CYTHON_UNUSED int __pyx_v_it; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + float __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_t_9; + int __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + int __pyx_t_12; + PyObject *__pyx_t_13 = NULL; + int __pyx_t_14; + int __pyx_t_15; + PyObject *(*__pyx_t_16)(PyObject *); + int __pyx_t_17; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("create_map_online", 0); + __Pyx_INCREF((PyObject *)__pyx_v_weights); - /* "View.MemoryView":138 - * raise ValueError("itemsize <= 0 for cython.array") - * - * if not isinstance(format, bytes): # <<<<<<<<<<<<<< - * format = format.encode('ASCII') - * self._format = format # keep a reference to the byte string + /* "core.pyx":73 + * def create_map_online(cnp.ndarray X, int n_iter, int n_row, int n_col, int n_pix, float alpha_start, float alpha_end, + * cnp.ndarray importance, cnp.ndarray dist_lib, cnp.ndarray weights, bint random_order): + * cdef int t = 0 # <<<<<<<<<<<<<< + * cdef int total_t = n_iter * n_row + * cdef float sigma_0 = dist_lib.max() */ - } + __pyx_v_t = 0; - /* "View.MemoryView":140 - * if not isinstance(format, bytes): - * format = format.encode('ASCII') - * self._format = format # keep a reference to the byte string # <<<<<<<<<<<<<< - * self.format = self._format - * + /* "core.pyx":74 + * cnp.ndarray importance, cnp.ndarray dist_lib, cnp.ndarray weights, bint random_order): + * cdef int t = 0 + * cdef int total_t = n_iter * n_row # <<<<<<<<<<<<<< + * cdef float sigma_0 = dist_lib.max() + * cdef float sigma_f = np.min(dist_lib[np.where(dist_lib > 0.)]) */ - 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); - __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_total_t = (__pyx_v_n_iter * __pyx_v_n_row); - /* "View.MemoryView":141 - * format = format.encode('ASCII') - * self._format = format # keep a reference to the byte string - * self.format = self._format # <<<<<<<<<<<<<< - * + /* "core.pyx":75 + * cdef int t = 0 + * cdef int total_t = n_iter * n_row + * cdef float sigma_0 = dist_lib.max() # <<<<<<<<<<<<<< + * cdef float sigma_f = np.min(dist_lib[np.where(dist_lib > 0.)]) * */ - if (unlikely(__pyx_v_self->_format == Py_None)) { - PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); - __PYX_ERR(1, 141, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_dist_lib), __pyx_n_s_max); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } } - __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; - - /* "View.MemoryView":144 - * - * - * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) # <<<<<<<<<<<<<< - * self._strides = self._shape + self.ndim - * - */ - __pyx_v_self->_shape = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * __pyx_v_self->ndim) * 2))); + __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_4 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 75, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_sigma_0 = __pyx_t_4; - /* "View.MemoryView":145 + /* "core.pyx":76 + * cdef int total_t = n_iter * n_row + * cdef float sigma_0 = dist_lib.max() + * cdef float sigma_f = np.min(dist_lib[np.where(dist_lib > 0.)]) # <<<<<<<<<<<<<< * - * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) - * self._strides = self._shape + self.ndim # <<<<<<<<<<<<<< - * - * if not self._shape: + * cdef int i, best */ - __pyx_v_self->_strides = (__pyx_v_self->_shape + __pyx_v_self->ndim); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_where); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyObject_RichCompare(((PyObject *)__pyx_v_dist_lib), __pyx_float_0_, Py_GT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 76, __pyx_L1_error) + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + __pyx_t_2 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_dist_lib), __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_6); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_4 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 76, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_sigma_f = __pyx_t_4; - /* "View.MemoryView":147 - * self._strides = self._shape + self.ndim - * - * if not self._shape: # <<<<<<<<<<<<<< - * raise MemoryError("unable to allocate shape and strides.") + /* "core.pyx":81 + * cdef float alpha, sigma + * cdef list random_indices + * cdef cnp.ndarray inputs = np.zeros([n_col, 1], dtype=DTYPE) # <<<<<<<<<<<<<< + * cdef cnp.ndarray activation = np.zeros([n_pix, 1], dtype=DTYPE) * */ - __pyx_t_4 = ((!(__pyx_v_self->_shape != 0)) != 0); - if (unlikely(__pyx_t_4)) { + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_col); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = PyList_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_1); + PyList_SET_ITEM(__pyx_t_6, 0, __pyx_t_1); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyList_SET_ITEM(__pyx_t_6, 1, __pyx_int_1); + __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_DTYPE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_2) < 0) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 81, __pyx_L1_error) + __pyx_v_inputs = ((PyArrayObject *)__pyx_t_2); + __pyx_t_2 = 0; - /* "View.MemoryView":148 - * - * if not self._shape: - * raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<< - * + /* "core.pyx":82 + * cdef list random_indices + * cdef cnp.ndarray inputs = np.zeros([n_col, 1], dtype=DTYPE) + * cdef cnp.ndarray activation = np.zeros([n_pix, 1], dtype=DTYPE) # <<<<<<<<<<<<<< * + * for it in range(n_iter): */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__4, 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_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_n_pix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyList_SET_ITEM(__pyx_t_1, 1, __pyx_int_1); + __pyx_t_2 = 0; + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __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_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_3) < 0) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 82, __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_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 82, __pyx_L1_error) + __pyx_v_activation = ((PyArrayObject *)__pyx_t_3); + __pyx_t_3 = 0; - /* "View.MemoryView":147 - * self._strides = self._shape + self.ndim - * - * if not self._shape: # <<<<<<<<<<<<<< - * raise MemoryError("unable to allocate shape and strides.") + /* "core.pyx":84 + * cdef cnp.ndarray activation = np.zeros([n_pix, 1], dtype=DTYPE) * + * for it in range(n_iter): # <<<<<<<<<<<<<< + * alpha = get_alpha(alpha_end, alpha_start, t, total_t) + * sigma = get_sigma(sigma_f, sigma_0, t, total_t) */ - } + __pyx_t_8 = __pyx_v_n_iter; + __pyx_t_9 = __pyx_t_8; + for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) { + __pyx_v_it = __pyx_t_10; - /* "View.MemoryView":151 - * + /* "core.pyx":85 * - * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< - * if dim <= 0: - * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * for it in range(n_iter): + * alpha = get_alpha(alpha_end, alpha_start, t, total_t) # <<<<<<<<<<<<<< + * sigma = get_sigma(sigma_f, sigma_0, t, total_t) + * random_indices = random.sample(range(n_row), n_row) if random_order else np.arange( */ - __pyx_t_8 = 0; - __pyx_t_3 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0; - for (;;) { - if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_3)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(1, 151, __pyx_L1_error) - #else - __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 151, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_get_alpha); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_alpha_end); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_alpha_start); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 85, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - #endif - __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_5); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 151, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_dim = __pyx_t_9; - __pyx_v_idx = __pyx_t_8; - __pyx_t_8 = (__pyx_t_8 + 1); - - /* "View.MemoryView":152 - * - * for idx, dim in enumerate(shape): - * if dim <= 0: # <<<<<<<<<<<<<< - * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) - * self._shape[idx] = dim - */ - __pyx_t_4 = ((__pyx_v_dim <= 0) != 0); - if (unlikely(__pyx_t_4)) { - - /* "View.MemoryView":153 - * 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_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_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_GOTREF(__pyx_t_10); + __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_total_t); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_11 = NULL; + __pyx_t_12 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_12 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[5] = {__pyx_t_11, __pyx_t_2, __pyx_t_6, __pyx_t_5, __pyx_t_7}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_12, 4+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[5] = {__pyx_t_11, __pyx_t_2, __pyx_t_6, __pyx_t_5, __pyx_t_7}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_12, 4+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_Raise(__pyx_t_10, 0, 0, 0); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __PYX_ERR(1, 153, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else + #endif + { + __pyx_t_13 = PyTuple_New(4+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + if (__pyx_t_11) { + __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_11); __pyx_t_11 = NULL; + } + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_12, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_12, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_13, 2+__pyx_t_12, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_13, 3+__pyx_t_12, __pyx_t_7); + __pyx_t_2 = 0; + __pyx_t_6 = 0; + __pyx_t_5 = 0; + __pyx_t_7 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_13, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_t_3); if (unlikely((__pyx_t_4 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_alpha = __pyx_t_4; - /* "View.MemoryView":152 - * - * for idx, dim in enumerate(shape): - * if dim <= 0: # <<<<<<<<<<<<<< - * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) - * self._shape[idx] = dim + /* "core.pyx":86 + * for it in range(n_iter): + * alpha = get_alpha(alpha_end, alpha_start, t, total_t) + * sigma = get_sigma(sigma_f, sigma_0, t, total_t) # <<<<<<<<<<<<<< + * random_indices = random.sample(range(n_row), n_row) if random_order else np.arange( + * n_row) */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_get_sigma); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_13 = PyFloat_FromDouble(__pyx_v_sigma_f); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_7 = PyFloat_FromDouble(__pyx_v_sigma_0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_total_t); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = NULL; + __pyx_t_12 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_12 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[5] = {__pyx_t_2, __pyx_t_13, __pyx_t_7, __pyx_t_5, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_12, 4+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { + PyObject *__pyx_temp[5] = {__pyx_t_2, __pyx_t_13, __pyx_t_7, __pyx_t_5, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_12, 4+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_11 = PyTuple_New(4+__pyx_t_12); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + if (__pyx_t_2) { + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_2); __pyx_t_2 = NULL; + } + __Pyx_GIVEREF(__pyx_t_13); + PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_12, __pyx_t_13); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_12, __pyx_t_7); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_12, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_11, 3+__pyx_t_12, __pyx_t_6); + __pyx_t_13 = 0; + __pyx_t_7 = 0; + __pyx_t_5 = 0; + __pyx_t_6 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_t_3); if (unlikely((__pyx_t_4 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_sigma = __pyx_t_4; - /* "View.MemoryView":154 - * if dim <= 0: - * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) - * self._shape[idx] = dim # <<<<<<<<<<<<<< + /* "core.pyx":87 + * alpha = get_alpha(alpha_end, alpha_start, t, total_t) + * sigma = get_sigma(sigma_f, sigma_0, t, total_t) + * random_indices = random.sample(range(n_row), n_row) if random_order else np.arange( # <<<<<<<<<<<<<< + * n_row) * - * cdef char order */ - (__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim; + if ((__pyx_v_random_order != 0)) { + __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_random); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_sample); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_11 = __Pyx_PyInt_From_int(__pyx_v_n_row); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_t_11); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_11 = __Pyx_PyInt_From_int(__pyx_v_n_row); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_7 = NULL; + __pyx_t_12 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_12 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_5, __pyx_t_11}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_5, __pyx_t_11}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } else + #endif + { + __pyx_t_13 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_12, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_11); + PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_12, __pyx_t_11); + __pyx_t_5 = 0; + __pyx_t_11 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_13, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(0, 87, __pyx_L1_error) + __pyx_t_3 = __pyx_t_1; + __pyx_t_1 = 0; + } else { + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_arange); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "View.MemoryView":151 - * + /* "core.pyx":88 + * sigma = get_sigma(sigma_f, sigma_0, t, total_t) + * random_indices = random.sample(range(n_row), n_row) if random_order else np.arange( + * n_row) # <<<<<<<<<<<<<< * - * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< - * if dim <= 0: - * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * for i in range(n_row): */ - } - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_n_row); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_11 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_13); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_13, function); + } + } + __pyx_t_1 = (__pyx_t_11) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_11, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_6); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; - /* "View.MemoryView":157 + /* "core.pyx":87 + * alpha = get_alpha(alpha_end, alpha_start, t, total_t) + * sigma = get_sigma(sigma_f, sigma_0, t, total_t) + * random_indices = random.sample(range(n_row), n_row) if random_order else np.arange( # <<<<<<<<<<<<<< + * n_row) * - * 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) - if (__pyx_t_4) { - - /* "View.MemoryView":158 - * cdef char order - * if mode == 'fortran': - * order = b'F' # <<<<<<<<<<<<<< - * self.mode = u'fortran' - * elif mode == 'c': - */ - __pyx_v_order = 'F'; - - /* "View.MemoryView":159 - * if mode == 'fortran': - * order = b'F' - * self.mode = u'fortran' # <<<<<<<<<<<<<< - * elif mode == 'c': - * order = b'C' + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(0, 87, __pyx_L1_error) + __pyx_t_3 = __pyx_t_1; + __pyx_t_1 = 0; + } + __Pyx_XDECREF_SET(__pyx_v_random_indices, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "core.pyx":90 + * n_row) + * + * for i in range(n_row): # <<<<<<<<<<<<<< + * inputs = X[random_indices[i]] + * best, activation = get_best_cell(inputs=inputs, importance=importance, */ - __Pyx_INCREF(__pyx_n_u_fortran); - __Pyx_GIVEREF(__pyx_n_u_fortran); - __Pyx_GOTREF(__pyx_v_self->mode); - __Pyx_DECREF(__pyx_v_self->mode); - __pyx_v_self->mode = __pyx_n_u_fortran; + __pyx_t_12 = __pyx_v_n_row; + __pyx_t_14 = __pyx_t_12; + for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) { + __pyx_v_i = __pyx_t_15; - /* "View.MemoryView":157 + /* "core.pyx":91 * - * cdef char order - * if mode == 'fortran': # <<<<<<<<<<<<<< - * order = b'F' - * self.mode = u'fortran' + * for i in range(n_row): + * inputs = X[random_indices[i]] # <<<<<<<<<<<<<< + * best, activation = get_best_cell(inputs=inputs, importance=importance, + * weights=weights, n_pix=n_pix, return_vals=1) */ - goto __pyx_L10; - } + if (unlikely(__pyx_v_random_indices == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 91, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_GetItemInt_List(__pyx_v_random_indices, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_X), __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 91, __pyx_L1_error) + __Pyx_DECREF_SET(__pyx_v_inputs, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; - /* "View.MemoryView":160 - * order = b'F' - * self.mode = u'fortran' - * elif mode == 'c': # <<<<<<<<<<<<<< - * order = b'C' - * self.mode = u'c' + /* "core.pyx":92 + * for i in range(n_row): + * inputs = X[random_indices[i]] + * best, activation = get_best_cell(inputs=inputs, importance=importance, # <<<<<<<<<<<<<< + * weights=weights, n_pix=n_pix, return_vals=1) + * weights += alpha * count_modified_cells(best, dist_lib, sigma) * np.transpose( */ - __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) - if (likely(__pyx_t_4)) { - - /* "View.MemoryView":161 - * self.mode = u'fortran' - * elif mode == 'c': - * order = b'C' # <<<<<<<<<<<<<< - * self.mode = u'c' - * else: + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_get_best_cell); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 92, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 92, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_inputs, ((PyObject *)__pyx_v_inputs)) < 0) __PYX_ERR(0, 92, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_importance, ((PyObject *)__pyx_v_importance)) < 0) __PYX_ERR(0, 92, __pyx_L1_error) + + /* "core.pyx":93 + * inputs = X[random_indices[i]] + * best, activation = get_best_cell(inputs=inputs, importance=importance, + * weights=weights, n_pix=n_pix, return_vals=1) # <<<<<<<<<<<<<< + * weights += alpha * count_modified_cells(best, dist_lib, sigma) * np.transpose( + * (inputs - np.transpose(weights))) + */ + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_weights, ((PyObject *)__pyx_v_weights)) < 0) __PYX_ERR(0, 92, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyInt_From_int(__pyx_v_n_pix); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_n_pix, __pyx_t_13) < 0) __PYX_ERR(0, 92, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_return_vals, __pyx_int_1) < 0) __PYX_ERR(0, 92, __pyx_L1_error) + + /* "core.pyx":92 + * for i in range(n_row): + * inputs = X[random_indices[i]] + * best, activation = get_best_cell(inputs=inputs, importance=importance, # <<<<<<<<<<<<<< + * weights=weights, n_pix=n_pix, return_vals=1) + * weights += alpha * count_modified_cells(best, dist_lib, sigma) * np.transpose( */ - __pyx_v_order = 'C'; + __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 92, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if ((likely(PyTuple_CheckExact(__pyx_t_13))) || (PyList_CheckExact(__pyx_t_13))) { + PyObject* sequence = __pyx_t_13; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 92, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_1 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_3 = PyList_GET_ITEM(sequence, 0); + __pyx_t_1 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + #else + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 92, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 92, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_6 = PyObject_GetIter(__pyx_t_13); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 92, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_16 = Py_TYPE(__pyx_t_6)->tp_iternext; + index = 0; __pyx_t_3 = __pyx_t_16(__pyx_t_6); if (unlikely(!__pyx_t_3)) goto __pyx_L7_unpacking_failed; + __Pyx_GOTREF(__pyx_t_3); + index = 1; __pyx_t_1 = __pyx_t_16(__pyx_t_6); if (unlikely(!__pyx_t_1)) goto __pyx_L7_unpacking_failed; + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_16(__pyx_t_6), 2) < 0) __PYX_ERR(0, 92, __pyx_L1_error) + __pyx_t_16 = NULL; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L8_unpacking_done; + __pyx_L7_unpacking_failed:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_16 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 92, __pyx_L1_error) + __pyx_L8_unpacking_done:; + } + __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 92, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 92, __pyx_L1_error) + __pyx_v_best = __pyx_t_17; + __Pyx_DECREF_SET(__pyx_v_activation, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; - /* "View.MemoryView":162 - * elif mode == 'c': - * order = b'C' - * self.mode = u'c' # <<<<<<<<<<<<<< - * else: - * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) + /* "core.pyx":94 + * best, activation = get_best_cell(inputs=inputs, importance=importance, + * weights=weights, n_pix=n_pix, return_vals=1) + * weights += alpha * count_modified_cells(best, dist_lib, sigma) * np.transpose( # <<<<<<<<<<<<<< + * (inputs - np.transpose(weights))) */ - __Pyx_INCREF(__pyx_n_u_c); - __Pyx_GIVEREF(__pyx_n_u_c); - __Pyx_GOTREF(__pyx_v_self->mode); - __Pyx_DECREF(__pyx_v_self->mode); - __pyx_v_self->mode = __pyx_n_u_c; - - /* "View.MemoryView":160 - * order = b'F' - * self.mode = u'fortran' - * elif mode == 'c': # <<<<<<<<<<<<<< - * order = b'C' - * self.mode = u'c' + __pyx_t_13 = PyFloat_FromDouble(__pyx_v_alpha); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_count_modified_cells); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_best); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_11 = PyFloat_FromDouble(__pyx_v_sigma); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_5 = NULL; + __pyx_t_17 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_17 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_t_6, ((PyObject *)__pyx_v_dist_lib), __pyx_t_11}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_17, 3+__pyx_t_17); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_t_6, ((PyObject *)__pyx_v_dist_lib), __pyx_t_11}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_17, 3+__pyx_t_17); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } else + #endif + { + __pyx_t_7 = PyTuple_New(3+__pyx_t_17); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_17, __pyx_t_6); + __Pyx_INCREF(((PyObject *)__pyx_v_dist_lib)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_dist_lib)); + PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_17, ((PyObject *)__pyx_v_dist_lib)); + __Pyx_GIVEREF(__pyx_t_11); + PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_17, __pyx_t_11); + __pyx_t_6 = 0; + __pyx_t_11 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_Multiply(__pyx_t_13, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_n_s_np); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_transpose); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + + /* "core.pyx":95 + * weights=weights, n_pix=n_pix, return_vals=1) + * weights += alpha * count_modified_cells(best, dist_lib, sigma) * np.transpose( + * (inputs - np.transpose(weights))) # <<<<<<<<<<<<<< */ - goto __pyx_L10; - } + __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_np); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_transpose); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_11 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + __pyx_t_13 = (__pyx_t_11) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_11, ((PyObject *)__pyx_v_weights)) : __Pyx_PyObject_CallOneArg(__pyx_t_6, ((PyObject *)__pyx_v_weights)); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = PyNumber_Subtract(((PyObject *)__pyx_v_inputs), __pyx_t_13); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_t_13 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __pyx_t_1 = (__pyx_t_13) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_13, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - /* "View.MemoryView":164 - * self.mode = u'c' - * else: - * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) # <<<<<<<<<<<<<< - * - * self.len = fill_contig_strides_array(self._shape, self._strides, + /* "core.pyx":94 + * best, activation = get_best_cell(inputs=inputs, importance=importance, + * weights=weights, n_pix=n_pix, return_vals=1) + * weights += alpha * count_modified_cells(best, dist_lib, sigma) * np.transpose( # <<<<<<<<<<<<<< + * (inputs - np.transpose(weights))) */ - /*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_GOTREF(__pyx_t_10); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_10, 0, 0, 0); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __PYX_ERR(1, 164, __pyx_L1_error) + __pyx_t_7 = PyNumber_Multiply(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyNumber_InPlaceAdd(((PyObject *)__pyx_v_weights), __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_DECREF_SET(__pyx_v_weights, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + } } - __pyx_L10:; - /* "View.MemoryView":166 - * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) - * - * self.len = fill_contig_strides_array(self._shape, self._strides, # <<<<<<<<<<<<<< - * itemsize, self.ndim, order) + /* "core.pyx":71 + * return np.exp(-(map_d[bmu] ** 2) / sigma ** 2) * + * def create_map_online(cnp.ndarray X, int n_iter, int n_row, int n_col, int n_pix, float alpha_start, float alpha_end, # <<<<<<<<<<<<<< + * cnp.ndarray importance, cnp.ndarray dist_lib, cnp.ndarray weights, bint random_order): + * cdef int t = 0 */ - __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 - * itemsize, self.ndim, order) - * - * self.free_data = allocate_buffer # <<<<<<<<<<<<<< - * self.dtype_is_object = format == b'O' - * if allocate_buffer: - */ - __pyx_v_self->free_data = __pyx_v_allocate_buffer; + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_AddTraceback("core.create_map_online", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_random_indices); + __Pyx_XDECREF((PyObject *)__pyx_v_inputs); + __Pyx_XDECREF((PyObject *)__pyx_v_activation); + __Pyx_XDECREF((PyObject *)__pyx_v_weights); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "View.MemoryView":170 +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":742 + * ctypedef npy_cdouble complex_t * - * self.free_data = allocate_buffer - * self.dtype_is_object = format == b'O' # <<<<<<<<<<<<<< - * if allocate_buffer: + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) * */ - __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_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_v_self->dtype_is_object = __pyx_t_4; - - /* "View.MemoryView":171 - * self.free_data = allocate_buffer - * self.dtype_is_object = format == b'O' - * if allocate_buffer: # <<<<<<<<<<<<<< + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":743 * + * cdef inline object PyArray_MultiIterNew1(a): + * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< * + * cdef inline object PyArray_MultiIterNew2(a, b): */ - __pyx_t_4 = (__pyx_v_allocate_buffer != 0); - if (__pyx_t_4) { + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 743, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "View.MemoryView":174 + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":742 + * ctypedef npy_cdouble complex_t * - * - * self.data = malloc(self.len) # <<<<<<<<<<<<<< - * if not self.data: - * raise MemoryError("unable to allocate array data.") - */ - __pyx_v_self->data = ((char *)malloc(__pyx_v_self->len)); - - /* "View.MemoryView":175 - * - * self.data = malloc(self.len) - * if not self.data: # <<<<<<<<<<<<<< - * raise MemoryError("unable to allocate array data.") - * - */ - __pyx_t_4 = ((!(__pyx_v_self->data != 0)) != 0); - if (unlikely(__pyx_t_4)) { - - /* "View.MemoryView":176 - * self.data = malloc(self.len) - * if not self.data: - * raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<< - * - * if self.dtype_is_object: - */ - __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 176, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - __Pyx_Raise(__pyx_t_10, 0, 0, 0); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __PYX_ERR(1, 176, __pyx_L1_error) - - /* "View.MemoryView":175 - * - * self.data = malloc(self.len) - * if not self.data: # <<<<<<<<<<<<<< - * raise MemoryError("unable to allocate array data.") - * - */ - } - - /* "View.MemoryView":178 - * raise MemoryError("unable to allocate array data.") - * - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * p = self.data - * for i in range(self.len / itemsize): - */ - __pyx_t_4 = (__pyx_v_self->dtype_is_object != 0); - if (__pyx_t_4) { - - /* "View.MemoryView":179 - * - * if self.dtype_is_object: - * p = self.data # <<<<<<<<<<<<<< - * for i in range(self.len / itemsize): - * p[i] = Py_None - */ - __pyx_v_p = ((PyObject **)__pyx_v_self->data); - - /* "View.MemoryView":180 - * if self.dtype_is_object: - * p = self.data - * for i in range(self.len / itemsize): # <<<<<<<<<<<<<< - * p[i] = Py_None - * Py_INCREF(Py_None) - */ - if (unlikely(__pyx_v_itemsize == 0)) { - PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); - __PYX_ERR(1, 180, __pyx_L1_error) - } - else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_self->len))) { - PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); - __PYX_ERR(1, 180, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_div_Py_ssize_t(__pyx_v_self->len, __pyx_v_itemsize); - __pyx_t_9 = __pyx_t_1; - for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_9; __pyx_t_11+=1) { - __pyx_v_i = __pyx_t_11; - - /* "View.MemoryView":181 - * p = self.data - * for i in range(self.len / itemsize): - * p[i] = Py_None # <<<<<<<<<<<<<< - * Py_INCREF(Py_None) - * - */ - (__pyx_v_p[__pyx_v_i]) = Py_None; - - /* "View.MemoryView":182 - * for i in range(self.len / itemsize): - * p[i] = Py_None - * Py_INCREF(Py_None) # <<<<<<<<<<<<<< - * - * @cname('getbuffer') - */ - Py_INCREF(Py_None); - } - - /* "View.MemoryView":178 - * raise MemoryError("unable to allocate array data.") - * - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * p = self.data - * for i in range(self.len / itemsize): - */ - } - - /* "View.MemoryView":171 - * self.free_data = allocate_buffer - * self.dtype_is_object = format == b'O' - * if 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): + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) * */ /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_10); - __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_format); + __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "View.MemoryView":185 +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":745 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) * - * @cname('getbuffer') - * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< - * cdef int bufmode = -1 - * if self.mode == u"c": */ -/* Python wrapper */ -static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ -static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); - __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(((struct __pyx_array_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { - int __pyx_v_bufmode; - int __pyx_r; +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { + PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - char *__pyx_t_4; - Py_ssize_t __pyx_t_5; - int __pyx_t_6; - Py_ssize_t *__pyx_t_7; + PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - if (__pyx_v_info == NULL) { - PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); - return -1; - } - __Pyx_RefNannySetupContext("__getbuffer__", 0); - __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(__pyx_v_info->obj); - - /* "View.MemoryView":186 - * @cname('getbuffer') - * def __getbuffer__(self, Py_buffer *info, int flags): - * cdef int bufmode = -1 # <<<<<<<<<<<<<< - * if self.mode == u"c": - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - */ - __pyx_v_bufmode = -1; - - /* "View.MemoryView":187 - * def __getbuffer__(self, Py_buffer *info, int flags): - * cdef int bufmode = -1 - * if self.mode == u"c": # <<<<<<<<<<<<<< - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * elif self.mode == u"fortran": - */ - __pyx_t_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_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":188 - * cdef int bufmode = -1 - * if self.mode == u"c": - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< - * elif self.mode == u"fortran": - * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - */ - __pyx_v_bufmode = (PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); - - /* "View.MemoryView":187 - * def __getbuffer__(self, Py_buffer *info, int flags): - * cdef int bufmode = -1 - * if self.mode == u"c": # <<<<<<<<<<<<<< - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * elif self.mode == u"fortran": - */ - goto __pyx_L3; - } - - /* "View.MemoryView":189 - * if self.mode == u"c": - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * elif self.mode == u"fortran": # <<<<<<<<<<<<<< - * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * if not (flags & bufmode): - */ - __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_1 = (__pyx_t_2 != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":190 - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * elif self.mode == u"fortran": - * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< - * if not (flags & bufmode): - * raise ValueError("Can only create a buffer that is contiguous in memory.") - */ - __pyx_v_bufmode = (PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); - - /* "View.MemoryView":189 - * if self.mode == u"c": - * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * elif self.mode == u"fortran": # <<<<<<<<<<<<<< - * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * if not (flags & bufmode): - */ - } - __pyx_L3:; - - /* "View.MemoryView":191 - * elif self.mode == u"fortran": - * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * if not (flags & bufmode): # <<<<<<<<<<<<<< - * raise ValueError("Can only create a buffer that is contiguous in memory.") - * info.buf = self.data - */ - __pyx_t_1 = ((!((__pyx_v_flags & __pyx_v_bufmode) != 0)) != 0); - if (unlikely(__pyx_t_1)) { - - /* "View.MemoryView":192 - * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * if not (flags & bufmode): - * raise ValueError("Can only create a buffer that is contiguous in memory.") # <<<<<<<<<<<<<< - * info.buf = self.data - * info.len = self.len - */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 192, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 192, __pyx_L1_error) - - /* "View.MemoryView":191 - * elif self.mode == u"fortran": - * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * if not (flags & bufmode): # <<<<<<<<<<<<<< - * raise ValueError("Can only create a buffer that is contiguous in memory.") - * info.buf = self.data - */ - } - - /* "View.MemoryView":193 - * if not (flags & bufmode): - * raise ValueError("Can only create a buffer that is contiguous in memory.") - * info.buf = self.data # <<<<<<<<<<<<<< - * info.len = self.len - * info.ndim = self.ndim - */ - __pyx_t_4 = __pyx_v_self->data; - __pyx_v_info->buf = __pyx_t_4; - - /* "View.MemoryView":194 - * raise ValueError("Can only create a buffer that is contiguous in memory.") - * info.buf = self.data - * info.len = self.len # <<<<<<<<<<<<<< - * info.ndim = self.ndim - * info.shape = self._shape - */ - __pyx_t_5 = __pyx_v_self->len; - __pyx_v_info->len = __pyx_t_5; - - /* "View.MemoryView":195 - * info.buf = self.data - * info.len = self.len - * info.ndim = self.ndim # <<<<<<<<<<<<<< - * info.shape = self._shape - * info.strides = self._strides - */ - __pyx_t_6 = __pyx_v_self->ndim; - __pyx_v_info->ndim = __pyx_t_6; - - /* "View.MemoryView":196 - * info.len = self.len - * info.ndim = self.ndim - * info.shape = self._shape # <<<<<<<<<<<<<< - * info.strides = self._strides - * info.suboffsets = NULL - */ - __pyx_t_7 = __pyx_v_self->_shape; - __pyx_v_info->shape = __pyx_t_7; - - /* "View.MemoryView":197 - * info.ndim = self.ndim - * info.shape = self._shape - * info.strides = self._strides # <<<<<<<<<<<<<< - * info.suboffsets = NULL - * info.itemsize = self.itemsize - */ - __pyx_t_7 = __pyx_v_self->_strides; - __pyx_v_info->strides = __pyx_t_7; - - /* "View.MemoryView":198 - * info.shape = self._shape - * info.strides = self._strides - * info.suboffsets = NULL # <<<<<<<<<<<<<< - * info.itemsize = self.itemsize - * info.readonly = 0 - */ - __pyx_v_info->suboffsets = NULL; - - /* "View.MemoryView":199 - * info.strides = self._strides - * info.suboffsets = NULL - * info.itemsize = self.itemsize # <<<<<<<<<<<<<< - * info.readonly = 0 - * - */ - __pyx_t_5 = __pyx_v_self->itemsize; - __pyx_v_info->itemsize = __pyx_t_5; - - /* "View.MemoryView":200 - * info.suboffsets = NULL - * info.itemsize = self.itemsize - * info.readonly = 0 # <<<<<<<<<<<<<< - * - * if flags & PyBUF_FORMAT: - */ - __pyx_v_info->readonly = 0; - - /* "View.MemoryView":202 - * info.readonly = 0 - * - * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< - * info.format = self.format - * else: - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":203 - * - * if flags & PyBUF_FORMAT: - * info.format = self.format # <<<<<<<<<<<<<< - * else: - * info.format = NULL - */ - __pyx_t_4 = __pyx_v_self->format; - __pyx_v_info->format = __pyx_t_4; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); - /* "View.MemoryView":202 - * info.readonly = 0 + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":746 * - * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< - * info.format = self.format - * else: - */ - goto __pyx_L5; - } - - /* "View.MemoryView":205 - * info.format = self.format - * else: - * info.format = NULL # <<<<<<<<<<<<<< + * cdef inline object PyArray_MultiIterNew2(a, b): + * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< * - * info.obj = self + * cdef inline object PyArray_MultiIterNew3(a, b, c): */ - /*else*/ { - __pyx_v_info->format = NULL; - } - __pyx_L5:; + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 746, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "View.MemoryView":207 - * info.format = NULL - * - * info.obj = self # <<<<<<<<<<<<<< + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":745 + * return PyArray_MultiIterNew(1, a) * - * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") - */ - __Pyx_INCREF(((PyObject *)__pyx_v_self)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); - __pyx_v_info->obj = ((PyObject *)__pyx_v_self); - - /* "View.MemoryView":185 + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) * - * @cname('getbuffer') - * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< - * cdef int bufmode = -1 - * if self.mode == u"c": */ /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.array.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - if (__pyx_v_info->obj != NULL) { - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; - } - goto __pyx_L2; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; - if (__pyx_v_info->obj == Py_None) { - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; - } - __pyx_L2:; + __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "View.MemoryView":211 - * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":748 + * return PyArray_MultiIterNew(2, a, b) * - * def __dealloc__(array self): # <<<<<<<<<<<<<< - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) - */ - -/* Python wrapper */ -static void __pyx_array___dealloc__(PyObject *__pyx_v_self); /*proto*/ -static void __pyx_array___dealloc__(PyObject *__pyx_v_self) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); - __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(((struct __pyx_array_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self) { - __Pyx_RefNannyDeclarations - int __pyx_t_1; - __Pyx_RefNannySetupContext("__dealloc__", 0); - - /* "View.MemoryView":212 + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) * - * def __dealloc__(array self): - * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< - * self.callback_free_data(self.data) - * elif self.free_data: */ - __pyx_t_1 = ((__pyx_v_self->callback_free_data != NULL) != 0); - if (__pyx_t_1) { - /* "View.MemoryView":213 - * def __dealloc__(array self): - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) # <<<<<<<<<<<<<< - * elif self.free_data: - * if self.dtype_is_object: - */ - __pyx_v_self->callback_free_data(__pyx_v_self->data); +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); - /* "View.MemoryView":212 + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":749 * - * def __dealloc__(array self): - * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< - * self.callback_free_data(self.data) - * elif self.free_data: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":214 - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) - * elif self.free_data: # <<<<<<<<<<<<<< - * if self.dtype_is_object: - * refcount_objects_in_slice(self.data, self._shape, - */ - __pyx_t_1 = (__pyx_v_self->free_data != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":215 - * self.callback_free_data(self.data) - * elif self.free_data: - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * refcount_objects_in_slice(self.data, self._shape, - * self._strides, self.ndim, False) - */ - __pyx_t_1 = (__pyx_v_self->dtype_is_object != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":216 - * elif self.free_data: - * if self.dtype_is_object: - * refcount_objects_in_slice(self.data, self._shape, # <<<<<<<<<<<<<< - * self._strides, self.ndim, False) - * free(self.data) - */ - __pyx_memoryview_refcount_objects_in_slice(__pyx_v_self->data, __pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_self->ndim, 0); - - /* "View.MemoryView":215 - * self.callback_free_data(self.data) - * elif self.free_data: - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * refcount_objects_in_slice(self.data, self._shape, - * self._strides, self.ndim, False) - */ - } - - /* "View.MemoryView":218 - * refcount_objects_in_slice(self.data, self._shape, - * self._strides, self.ndim, False) - * free(self.data) # <<<<<<<<<<<<<< - * PyObject_Free(self._shape) + * cdef inline object PyArray_MultiIterNew3(a, b, c): + * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ - free(__pyx_v_self->data); - - /* "View.MemoryView":214 - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) - * elif self.free_data: # <<<<<<<<<<<<<< - * if self.dtype_is_object: - * refcount_objects_in_slice(self.data, self._shape, - */ - } - __pyx_L3:; + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 749, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "View.MemoryView":219 - * self._strides, self.ndim, False) - * free(self.data) - * PyObject_Free(self._shape) # <<<<<<<<<<<<<< + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":748 + * return PyArray_MultiIterNew(2, a, b) * - * @property - */ - PyObject_Free(__pyx_v_self->_shape); - - /* "View.MemoryView":211 - * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) * - * def __dealloc__(array self): # <<<<<<<<<<<<<< - * if self.callback_free_data != NULL: - * self.callback_free_data(self.data) */ /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); + return __pyx_r; } -/* "View.MemoryView":222 +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":751 + * return PyArray_MultiIterNew(3, a, b, c) * - * @property - * def memview(self): # <<<<<<<<<<<<<< - * return self.get_memview() + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) * */ -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_15View_dot_MemoryView_5array_7memview___get__(((struct __pyx_array_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self) { +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); - /* "View.MemoryView":223 - * @property - * def memview(self): - * return self.get_memview() # <<<<<<<<<<<<<< + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":752 * - * @cname('get_memview') + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = ((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 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 752, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "View.MemoryView":222 + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":751 + * return PyArray_MultiIterNew(3, a, b, c) * - * @property - * def memview(self): # <<<<<<<<<<<<<< - * return self.get_memview() + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.array.memview.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "View.MemoryView":226 +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":754 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) * - * @cname('get_memview') - * cdef get_memview(self): # <<<<<<<<<<<<<< - * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE - * return memoryview(self, flags, self.dtype_is_object) */ -static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) { - int __pyx_v_flags; +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_memview", 0); + __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); - /* "View.MemoryView":227 - * @cname('get_memview') - * cdef get_memview(self): - * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE # <<<<<<<<<<<<<< - * return memoryview(self, flags, self.dtype_is_object) + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":755 * - */ - __pyx_v_flags = ((PyBUF_ANY_CONTIGUOUS | PyBUF_FORMAT) | PyBUF_WRITABLE); - - /* "View.MemoryView":228 - * cdef get_memview(self): - * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE - * return memoryview(self, flags, self.dtype_is_object) # <<<<<<<<<<<<<< + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< * - * def __len__(self): + * cdef inline tuple PyDataType_SHAPE(dtype d): */ __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 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 755, __pyx_L1_error) __Pyx_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_GOTREF(__pyx_t_2); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 228, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(((PyObject *)__pyx_v_self)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); - PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self)); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + __pyx_r = __pyx_t_1; __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_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 + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":754 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) * - * @cname('get_memview') - * cdef get_memview(self): # <<<<<<<<<<<<<< - * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE - * return memoryview(self, flags, self.dtype_is_object) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.array.get_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -4548,679 +4113,943 @@ static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) { return __pyx_r; } -/* "View.MemoryView":230 - * return memoryview(self, flags, self.dtype_is_object) - * - * def __len__(self): # <<<<<<<<<<<<<< - * return self._shape[0] +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":757 + * return PyArray_MultiIterNew(5, a, b, c, d, e) * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape */ -/* Python wrapper */ -static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self); /*proto*/ -static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self) { - Py_ssize_t __pyx_r; +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { + PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); - __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(((struct __pyx_array_obj *)__pyx_v_self)); + int __pyx_t_1; + __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":758 + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: + */ + __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); + if (__pyx_t_1) { -static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self) { - Py_ssize_t __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__len__", 0); + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":759 + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape # <<<<<<<<<<<<<< + * else: + * return () + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); + __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); + goto __pyx_L0; - /* "View.MemoryView":231 + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":758 * - * def __len__(self): - * return self._shape[0] # <<<<<<<<<<<<<< - * - * def __getattr__(self, attr): + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: */ - __pyx_r = (__pyx_v_self->_shape[0]); - goto __pyx_L0; + } - /* "View.MemoryView":230 - * return memoryview(self, flags, self.dtype_is_object) + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":761 + * return d.subarray.shape + * else: + * return () # <<<<<<<<<<<<<< * - * def __len__(self): # <<<<<<<<<<<<<< - * return self._shape[0] + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_r = __pyx_empty_tuple; + goto __pyx_L0; + } + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":757 + * return PyArray_MultiIterNew(5, a, b, c, d, e) * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape */ /* function exit code */ __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "View.MemoryView":233 - * return self._shape[0] - * - * def __getattr__(self, attr): # <<<<<<<<<<<<<< - * return getattr(self.memview, attr) +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":763 + * return () * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. */ -/* Python wrapper */ -static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr); /*proto*/ -static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0); - __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_attr)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr) { - PyObject *__pyx_r = NULL; +static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) { + PyArray_Descr *__pyx_v_child = 0; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + PyObject *__pyx_v_fields = 0; + PyObject *__pyx_v_childname = NULL; + PyObject *__pyx_v_new_offset = NULL; + PyObject *__pyx_v_t = NULL; + char *__pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__getattr__", 0); - - /* "View.MemoryView":234 - * - * def __getattr__(self, attr): - * return getattr(self.memview, attr) # <<<<<<<<<<<<<< + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + long __pyx_t_8; + char *__pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_util_dtypestring", 0); + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":768 * - * def __getitem__(self, item): + * cdef dtype child + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * cdef tuple fields */ - __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_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_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; + __pyx_v_endian_detector = 1; - /* "View.MemoryView":233 - * return self._shape[0] - * - * def __getattr__(self, attr): # <<<<<<<<<<<<<< - * return getattr(self.memview, attr) + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":769 + * cdef dtype child + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + * cdef tuple fields * */ + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.array.__getattr__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":236 - * return getattr(self.memview, attr) - * - * def __getitem__(self, item): # <<<<<<<<<<<<<< - * return self.memview[item] + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":772 + * cdef tuple fields * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields */ + if (unlikely(__pyx_v_descr->names == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(1, 772, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 772, __pyx_L1_error) + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 772, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); + __pyx_t_3 = 0; -/* Python wrapper */ -static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item); /*proto*/ -static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); - __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__getitem__", 0); - - /* "View.MemoryView":237 + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":773 * - * def __getitem__(self, item): - * return self.memview[item] # <<<<<<<<<<<<<< + * for childname in descr.names: + * fields = descr.fields[childname] # <<<<<<<<<<<<<< + * child, new_offset = fields * - * 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_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_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; + if (unlikely(__pyx_v_descr->fields == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 773, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 773, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 773, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; - /* "View.MemoryView":236 - * return getattr(self.memview, attr) - * - * def __getitem__(self, item): # <<<<<<<<<<<<<< - * return self.memview[item] + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":774 + * for childname in descr.names: + * fields = descr.fields[childname] + * child, new_offset = fields # <<<<<<<<<<<<<< * + * if (end - f) - (new_offset - offset[0]) < 15: */ + if (likely(__pyx_v_fields != Py_None)) { + PyObject* sequence = __pyx_v_fields; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(1, 774, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 774, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 774, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 774, __pyx_L1_error) + } + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 774, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); + __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); + __pyx_t_4 = 0; - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":239 - * return self.memview[item] + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":776 + * child, new_offset = fields * - * def __setitem__(self, item, value): # <<<<<<<<<<<<<< - * self.memview[item] = value + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * */ + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 776, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 776, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 776, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); + if (unlikely(__pyx_t_6)) { -/* Python wrapper */ -static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /*proto*/ -static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); - __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item), ((PyObject *)__pyx_v_value)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { - int __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setitem__", 0); - - /* "View.MemoryView":240 - * - * def __setitem__(self, item, value): - * self.memview[item] = value # <<<<<<<<<<<<<< + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":777 * + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< * + * if ((child.byteorder == c'>' and little_endian) or */ - __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_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) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 777, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 777, __pyx_L1_error) - /* "View.MemoryView":239 - * return self.memview[item] + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":776 + * child, new_offset = fields * - * def __setitem__(self, item, value): # <<<<<<<<<<<<<< - * self.memview[item] = value + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") * */ + } - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":779 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") */ + __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0); + if (!__pyx_t_7) { + goto __pyx_L8_next_or; + } else { + } + __pyx_t_7 = (__pyx_v_little_endian != 0); + if (!__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_L8_next_or:; -/* Python wrapper */ -static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf___pyx_array___reduce_cython__(((struct __pyx_array_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__reduce_cython__", 0); - - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":780 + * + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * # One could encode it in the format string and have Cython */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(1, 2, __pyx_L1_error) + __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0); + if (__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_6 = __pyx_t_7; + __pyx_L7_bool_binop_done:; - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":779 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") */ + if (unlikely(__pyx_t_6)) { - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.array.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":781 + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * # One could encode it in the format string and have Cython + * # complain instead, BUT: < and > in format strings also imply */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 781, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 781, __pyx_L1_error) -/* Python wrapper */ -static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf___pyx_array_2__setstate_cython__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setstate_cython__", 0); - - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":779 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(1, 4, __pyx_L1_error) + } - /* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":791 + * + * # Output padding bytes + * while offset[0] < new_offset: # <<<<<<<<<<<<<< + * f[0] = 120 # "x"; pad byte + * f += 1 */ + while (1) { + __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 791, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 791, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 791, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!__pyx_t_6) break; - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":792 + * # Output padding bytes + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< + * f += 1 + * offset[0] += 1 + */ + (__pyx_v_f[0]) = 0x78; -/* "View.MemoryView":244 + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":793 + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte + * f += 1 # <<<<<<<<<<<<<< + * offset[0] += 1 * - * @cname("__pyx_array_new") - * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< - * char *mode, char *buf): - * cdef array result */ + __pyx_v_f = (__pyx_v_f + 1); -static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, char *__pyx_v_format, char *__pyx_v_mode, char *__pyx_v_buf) { - struct __pyx_array_obj *__pyx_v_result = 0; - struct __pyx_array_obj *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("array_cwrapper", 0); - - /* "View.MemoryView":248 - * cdef array result + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":794 + * f[0] = 120 # "x"; pad byte + * f += 1 + * offset[0] += 1 # <<<<<<<<<<<<<< * - * if buf == NULL: # <<<<<<<<<<<<<< - * result = array(shape, itemsize, format, mode.decode('ASCII')) - * else: + * offset[0] += child.itemsize */ - __pyx_t_1 = ((__pyx_v_buf == NULL) != 0); - if (__pyx_t_1) { + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); + } - /* "View.MemoryView":249 + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":796 + * offset[0] += 1 * - * if buf == NULL: - * result = array(shape, itemsize, format, mode.decode('ASCII')) # <<<<<<<<<<<<<< - * else: - * result = array(shape, itemsize, format, mode.decode('ASCII'), + * offset[0] += child.itemsize # <<<<<<<<<<<<<< + * + * if not PyDataType_HASFIELDS(child): */ - __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 249, __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_GOTREF(__pyx_t_5); - __Pyx_INCREF(__pyx_v_shape); - __Pyx_GIVEREF(__pyx_v_shape); - PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_shape); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4); - __pyx_t_2 = 0; - __pyx_t_3 = 0; - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_4); - __pyx_t_4 = 0; + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); - /* "View.MemoryView":248 - * cdef array result + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":798 + * offset[0] += child.itemsize * - * if buf == NULL: # <<<<<<<<<<<<<< - * result = array(shape, itemsize, format, mode.decode('ASCII')) - * else: + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: */ - goto __pyx_L3; - } + __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); + if (__pyx_t_6) { - /* "View.MemoryView":251 - * result = array(shape, itemsize, format, mode.decode('ASCII')) - * else: - * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< - * allocate_buffer=False) - * result.data = buf + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":799 + * + * if not PyDataType_HASFIELDS(child): + * t = child.type_num # <<<<<<<<<<<<<< + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") */ - /*else*/ { - __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 251, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 251, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 251, __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_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_v_shape); - __Pyx_GIVEREF(__pyx_v_shape); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_shape); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_5); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_3); - __pyx_t_4 = 0; - __pyx_t_5 = 0; - __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 799, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); + __pyx_t_4 = 0; - /* "View.MemoryView":252 - * else: - * result = array(shape, itemsize, format, mode.decode('ASCII'), - * allocate_buffer=False) # <<<<<<<<<<<<<< - * result.data = buf + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":800 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") * */ - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 252, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_allocate_buffer, Py_False) < 0) __PYX_ERR(1, 252, __pyx_L1_error) + __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); + if (unlikely(__pyx_t_6)) { - /* "View.MemoryView":251 - * result = array(shape, itemsize, format, mode.decode('ASCII')) - * else: - * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< - * allocate_buffer=False) - * result.data = buf + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":801 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + * + * # Until ticket #99 is fixed, use integers to avoid warnings */ - __pyx_t_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_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_5); - __pyx_t_5 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 801, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(1, 801, __pyx_L1_error) - /* "View.MemoryView":253 - * result = array(shape, itemsize, format, mode.decode('ASCII'), - * allocate_buffer=False) - * result.data = buf # <<<<<<<<<<<<<< + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":800 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") * - * return result */ - __pyx_v_result->data = __pyx_v_buf; - } - __pyx_L3:; + } + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":804 + * + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 804, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 804, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 804, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 98; + goto __pyx_L15; + } + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":805 + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 805, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 805, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 805, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 66; + goto __pyx_L15; + } + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":806 + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 806, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 806, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 806, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x68; + goto __pyx_L15; + } + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":807 + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 807, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 807, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 807, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 72; + goto __pyx_L15; + } + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":808 + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 808, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 808, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 808, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x69; + goto __pyx_L15; + } + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":809 + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 809, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 809, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 809, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 73; + goto __pyx_L15; + } + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":810 + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 810, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 810, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 810, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x6C; + goto __pyx_L15; + } + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":811 + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 811, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 811, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 811, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 76; + goto __pyx_L15; + } + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":812 + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 812, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 812, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 812, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x71; + goto __pyx_L15; + } + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":813 + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 813, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 813, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 813, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 81; + goto __pyx_L15; + } + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":814 + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 814, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 814, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 814, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x66; + goto __pyx_L15; + } + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":815 + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 815, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 815, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 815, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x64; + goto __pyx_L15; + } + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":816 + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 816, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 816, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 816, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x67; + goto __pyx_L15; + } + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":817 + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 817, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 817, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 817, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x66; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":818 + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 818, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 818, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 818, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x64; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":819 + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 819, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 819, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 819, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x67; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":820 + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 820, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 820, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 820, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (likely(__pyx_t_6)) { + (__pyx_v_f[0]) = 79; + goto __pyx_L15; + } + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":822 + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * f += 1 + * else: + */ + /*else*/ { + __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 822, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 822, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(1, 822, __pyx_L1_error) + } + __pyx_L15:; + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":823 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * f += 1 # <<<<<<<<<<<<<< + * else: + * # Cython ignores struct boundary information ("T{...}"), + */ + __pyx_v_f = (__pyx_v_f + 1); + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":798 + * offset[0] += child.itemsize + * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: + */ + goto __pyx_L13; + } + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":827 + * # Cython ignores struct boundary information ("T{...}"), + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< + * return f + * + */ + /*else*/ { + __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 827, __pyx_L1_error) + __pyx_v_f = __pyx_t_9; + } + __pyx_L13:; - /* "View.MemoryView":255 - * result.data = buf + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":772 + * cdef tuple fields * - * return result # <<<<<<<<<<<<<< + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":828 + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) + * return f # <<<<<<<<<<<<<< * * */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); - __Pyx_INCREF(((PyObject *)__pyx_v_result)); - __pyx_r = __pyx_v_result; + __pyx_r = __pyx_v_f; goto __pyx_L0; - /* "View.MemoryView":244 + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":763 + * return () * - * @cname("__pyx_array_new") - * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< - * char *mode, char *buf): - * cdef array result + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("View.MemoryView.array_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; + __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_result); - __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_XDECREF((PyObject *)__pyx_v_child); + __Pyx_XDECREF(__pyx_v_fields); + __Pyx_XDECREF(__pyx_v_childname); + __Pyx_XDECREF(__pyx_v_new_offset); + __Pyx_XDECREF(__pyx_v_t); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "View.MemoryView":281 - * cdef class Enum(object): - * cdef object name - * def __init__(self, name): # <<<<<<<<<<<<<< - * self.name = name - * def __repr__(self): +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":943 + * int _import_umath() except -1 + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) */ -/* Python wrapper */ -static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_name = 0; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - int __pyx_r; +static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; - PyObject* values[1] = {0}; - if (unlikely(__pyx_kwds)) { - Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { - case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 281, __pyx_L3_error) - } - } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - } - __pyx_v_name = values[0]; - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 281, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("View.MemoryView.Enum.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return -1; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v_name); + __Pyx_RefNannySetupContext("set_array_base", 0); - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":944 + * + * cdef inline void set_array_base(ndarray arr, object base): + * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< + * PyArray_SetBaseObject(arr, base) + * + */ + Py_INCREF(__pyx_v_base); -static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name) { - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__", 0); - - /* "View.MemoryView":282 - * cdef object name - * def __init__(self, name): - * self.name = name # <<<<<<<<<<<<<< - * def __repr__(self): - * return self.name + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":945 + * cdef inline void set_array_base(ndarray arr, object base): + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< + * + * cdef inline object get_array_base(ndarray arr): */ - __Pyx_INCREF(__pyx_v_name); - __Pyx_GIVEREF(__pyx_v_name); - __Pyx_GOTREF(__pyx_v_self->name); - __Pyx_DECREF(__pyx_v_self->name); - __pyx_v_self->name = __pyx_v_name; - - /* "View.MemoryView":281 - * cdef class Enum(object): - * cdef object name - * def __init__(self, name): # <<<<<<<<<<<<<< - * self.name = name - * def __repr__(self): + (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":943 + * int _import_umath() except -1 + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) */ /* function exit code */ - __pyx_r = 0; __Pyx_RefNannyFinishContext(); - return __pyx_r; } -/* "View.MemoryView":283 - * def __init__(self, name): - * self.name = name - * def __repr__(self): # <<<<<<<<<<<<<< - * return self.name +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":947 + * PyArray_SetBaseObject(arr, base) * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: */ -/* Python wrapper */ -static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; +static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { + PyObject *__pyx_v_base; + PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); - __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); + int __pyx_t_1; + __Pyx_RefNannySetupContext("get_array_base", 0); - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":948 + * + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< + * if base is NULL: + * return None + */ + __pyx_v_base = PyArray_BASE(__pyx_v_arr); -static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__repr__", 0); + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":949 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base + */ + __pyx_t_1 = ((__pyx_v_base == NULL) != 0); + if (__pyx_t_1) { + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":950 + * base = PyArray_BASE(arr) + * if base is NULL: + * return None # <<<<<<<<<<<<<< + * return base + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; - /* "View.MemoryView":284 - * self.name = name - * def __repr__(self): - * return self.name # <<<<<<<<<<<<<< + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":949 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base + */ + } + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":951 + * if base is NULL: + * return None + * return base # <<<<<<<<<<<<<< * - * cdef generic = Enum("") + * # Versions of the import_* functions which are more suitable for */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->name); - __pyx_r = __pyx_v_self->name; + __Pyx_INCREF(((PyObject *)__pyx_v_base)); + __pyx_r = ((PyObject *)__pyx_v_base); goto __pyx_L0; - /* "View.MemoryView":283 - * def __init__(self, name): - * self.name = name - * def __repr__(self): # <<<<<<<<<<<<<< - * return self.name + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":947 + * PyArray_SetBaseObject(arr, base) * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: */ /* function exit code */ @@ -5230,12815 +5059,1170 @@ static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr_ return __pyx_r; } -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":955 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * __pyx_import_array() */ -/* Python wrapper */ -static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf___pyx_MemviewEnum___reduce_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { - PyObject *__pyx_v_state = 0; - PyObject *__pyx_v__dict = 0; - int __pyx_v_use_setstate; - PyObject *__pyx_r = NULL; +static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { + int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - int __pyx_t_3; - PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__reduce_cython__", 0); - - /* "(tree fragment)":5 - * cdef object _dict - * cdef bint use_setstate - * state = (self.name,) # <<<<<<<<<<<<<< - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: + __Pyx_RefNannySetupContext("import_array", 0); + + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":956 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: */ - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v_self->name); - __Pyx_GIVEREF(__pyx_v_self->name); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->name); - __pyx_v_state = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { - /* "(tree fragment)":6 - * cdef bint use_setstate - * state = (self.name,) - * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< - * if _dict is not None: - * state += (_dict,) + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":957 + * cdef inline int import_array() except -1: + * try: + * __pyx_import_array() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") */ - __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v__dict = __pyx_t_1; - __pyx_t_1 = 0; - - /* "(tree fragment)":7 - * state = (self.name,) - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True - */ - __pyx_t_2 = (__pyx_v__dict != Py_None); - __pyx_t_3 = (__pyx_t_2 != 0); - if (__pyx_t_3) { - - /* "(tree fragment)":8 - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: - * state += (_dict,) # <<<<<<<<<<<<<< - * use_setstate = True - * else: - */ - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_v__dict); - __Pyx_GIVEREF(__pyx_v__dict); - 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_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 - * if _dict is not None: - * state += (_dict,) - * use_setstate = True # <<<<<<<<<<<<<< - * else: - * use_setstate = self.name is not None - */ - __pyx_v_use_setstate = 1; - - /* "(tree fragment)":7 - * state = (self.name,) - * _dict = getattr(self, '__dict__', None) - * if _dict is not None: # <<<<<<<<<<<<<< - * state += (_dict,) - * use_setstate = True - */ - goto __pyx_L3; - } - - /* "(tree fragment)":11 - * use_setstate = True - * else: - * use_setstate = self.name is not None # <<<<<<<<<<<<<< - * if use_setstate: - * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state - */ - /*else*/ { - __pyx_t_3 = (__pyx_v_self->name != Py_None); - __pyx_v_use_setstate = __pyx_t_3; - } - __pyx_L3:; + __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 957, __pyx_L3_error) - /* "(tree fragment)":12 - * else: - * use_setstate = self.name is not None - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state - * else: + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":956 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: */ - __pyx_t_3 = (__pyx_v_use_setstate != 0); - if (__pyx_t_3) { + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; - /* "(tree fragment)":13 - * use_setstate = self.name is not None - * if use_setstate: - * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state # <<<<<<<<<<<<<< - * else: - * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":958 + * try: + * __pyx_import_array() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.multiarray failed to import") + * */ - __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_GOTREF(__pyx_t_4); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_184977713); - __Pyx_GIVEREF(__pyx_int_184977713); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); - __Pyx_INCREF(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_GOTREF(__pyx_t_5); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state); - __pyx_t_4 = 0; - __pyx_t_1 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; - goto __pyx_L0; + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 958, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); - /* "(tree fragment)":12 - * else: - * use_setstate = self.name is not None - * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state - * else: + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":959 + * __pyx_import_array() + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_umath() except -1: */ - } + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 959, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 959, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; - /* "(tree fragment)":15 - * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state - * else: - * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_Enum__set_state(self, __pyx_state) + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":956 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: */ - /*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_GOTREF(__pyx_t_5); - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_184977713); - __Pyx_GIVEREF(__pyx_int_184977713); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); - __Pyx_INCREF(__pyx_v_state); - __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state); - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); - __pyx_t_5 = 0; - __pyx_t_1 = 0; - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; - goto __pyx_L0; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; } - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * cdef tuple state - * cdef object _dict + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":955 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * __pyx_import_array() */ /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("View.MemoryView.Enum.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_state); - __Pyx_XDECREF(__pyx_v__dict); - __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "(tree fragment)":16 - * else: - * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_Enum__set_state(self, __pyx_state) +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":961 + * raise ImportError("numpy.core.multiarray failed to import") + * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() */ -/* Python wrapper */ -static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; +static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { + int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setstate_cython__", 0); - - /* "(tree fragment)":17 - * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) - * def __setstate_cython__(self, __pyx_state): - * __pyx_unpickle_Enum__set_state(self, __pyx_state) # <<<<<<<<<<<<<< - */ - 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) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "(tree fragment)":16 - * else: - * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * __pyx_unpickle_Enum__set_state(self, __pyx_state) - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + __Pyx_RefNannySetupContext("import_umath", 0); -/* "View.MemoryView":298 + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":962 * - * @cname('__pyx_align_pointer') - * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< - * "Align pointer memory on a given boundary" - * cdef Py_intptr_t aligned_p = memory + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { -static void *__pyx_align_pointer(void *__pyx_v_memory, size_t __pyx_v_alignment) { - Py_intptr_t __pyx_v_aligned_p; - size_t __pyx_v_offset; - void *__pyx_r; - int __pyx_t_1; - - /* "View.MemoryView":300 - * cdef void *align_pointer(void *memory, size_t alignment) nogil: - * "Align pointer memory on a given boundary" - * cdef Py_intptr_t aligned_p = memory # <<<<<<<<<<<<<< - * cdef size_t offset - * + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":963 + * cdef inline int import_umath() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.umath failed to import") */ - __pyx_v_aligned_p = ((Py_intptr_t)__pyx_v_memory); + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 963, __pyx_L3_error) - /* "View.MemoryView":304 + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":962 * - * with cython.cdivision(True): - * offset = aligned_p % alignment # <<<<<<<<<<<<<< - * - * if offset > 0: + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: */ - __pyx_v_offset = (__pyx_v_aligned_p % __pyx_v_alignment); + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; - /* "View.MemoryView":306 - * offset = aligned_p % alignment - * - * if offset > 0: # <<<<<<<<<<<<<< - * aligned_p += alignment - offset + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":964 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.umath failed to import") * */ - __pyx_t_1 = ((__pyx_v_offset > 0) != 0); - if (__pyx_t_1) { + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 964, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); - /* "View.MemoryView":307 + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":965 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * - * if offset > 0: - * aligned_p += alignment - offset # <<<<<<<<<<<<<< - * - * return aligned_p + * cdef inline int import_ufunc() except -1: */ - __pyx_v_aligned_p = (__pyx_v_aligned_p + (__pyx_v_alignment - __pyx_v_offset)); + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 965, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 965, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; - /* "View.MemoryView":306 - * offset = aligned_p % alignment - * - * if offset > 0: # <<<<<<<<<<<<<< - * aligned_p += alignment - offset + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":962 * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; } - /* "View.MemoryView":309 - * aligned_p += alignment - offset - * - * return aligned_p # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = ((void *)__pyx_v_aligned_p); - goto __pyx_L0; - - /* "View.MemoryView":298 + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":961 + * raise ImportError("numpy.core.multiarray failed to import") * - * @cname('__pyx_align_pointer') - * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< - * "Align pointer memory on a given boundary" - * cdef Py_intptr_t aligned_p = memory + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() */ /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; __pyx_L0:; + __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "View.MemoryView":345 - * cdef __Pyx_TypeInfo *typeinfo +/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":967 + * raise ImportError("numpy.core.umath failed to import") * - * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< - * self.obj = obj - * self.flags = flags + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() */ -/* Python wrapper */ -static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_obj = 0; - int __pyx_v_flags; - int __pyx_v_dtype_is_object; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_obj,&__pyx_n_s_flags,&__pyx_n_s_dtype_is_object,0}; - PyObject* values[3] = {0,0,0}; - if (unlikely(__pyx_kwds)) { - Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { - case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_obj)) != 0)) kw_args--; - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, 1); __PYX_ERR(1, 345, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dtype_is_object); - if (value) { values[2] = value; kw_args--; } - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 345, __pyx_L3_error) - } - } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } - } - __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) - 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) - } 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_L3_error:; - __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return -1; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_obj, __pyx_v_flags, __pyx_v_dtype_is_object); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object) { +static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { int __pyx_r; __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__cinit__", 0); + __Pyx_RefNannySetupContext("import_ufunc", 0); - /* "View.MemoryView":346 + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":968 * - * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): - * self.obj = obj # <<<<<<<<<<<<<< - * self.flags = flags - * if type(self) is memoryview or obj is not None: - */ - __Pyx_INCREF(__pyx_v_obj); - __Pyx_GIVEREF(__pyx_v_obj); - __Pyx_GOTREF(__pyx_v_self->obj); - __Pyx_DECREF(__pyx_v_self->obj); - __pyx_v_self->obj = __pyx_v_obj; - - /* "View.MemoryView":347 - * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): - * self.obj = obj - * self.flags = flags # <<<<<<<<<<<<<< - * if type(self) is memoryview or obj is not None: - * __Pyx_GetBuffer(obj, &self.view, flags) - */ - __pyx_v_self->flags = __pyx_v_flags; - - /* "View.MemoryView":348 - * self.obj = obj - * self.flags = flags - * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< - * __Pyx_GetBuffer(obj, &self.view, flags) - * if self.view.obj == NULL: + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: */ - __pyx_t_2 = (((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))) == ((PyObject *)__pyx_memoryview_type)); - __pyx_t_3 = (__pyx_t_2 != 0); - if (!__pyx_t_3) { - } else { - __pyx_t_1 = __pyx_t_3; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_3 = (__pyx_v_obj != Py_None); - __pyx_t_2 = (__pyx_t_3 != 0); - __pyx_t_1 = __pyx_t_2; - __pyx_L4_bool_binop_done:; - if (__pyx_t_1) { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { - /* "View.MemoryView":349 - * self.flags = flags - * if type(self) is memoryview or obj is not None: - * __Pyx_GetBuffer(obj, &self.view, flags) # <<<<<<<<<<<<<< - * if self.view.obj == NULL: - * (<__pyx_buffer *> &self.view).obj = Py_None - */ - __pyx_t_4 = __Pyx_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 349, __pyx_L1_error) - - /* "View.MemoryView":350 - * if type(self) is memoryview or obj is not None: - * __Pyx_GetBuffer(obj, &self.view, flags) - * if self.view.obj == NULL: # <<<<<<<<<<<<<< - * (<__pyx_buffer *> &self.view).obj = Py_None - * Py_INCREF(Py_None) - */ - __pyx_t_1 = ((((PyObject *)__pyx_v_self->view.obj) == NULL) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":351 - * __Pyx_GetBuffer(obj, &self.view, flags) - * if self.view.obj == NULL: - * (<__pyx_buffer *> &self.view).obj = Py_None # <<<<<<<<<<<<<< - * Py_INCREF(Py_None) - * + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":969 + * cdef inline int import_ufunc() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.umath failed to import") */ - ((Py_buffer *)(&__pyx_v_self->view))->obj = Py_None; + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 969, __pyx_L3_error) - /* "View.MemoryView":352 - * if self.view.obj == NULL: - * (<__pyx_buffer *> &self.view).obj = Py_None - * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":968 * - * global __pyx_memoryview_thread_locks_used - */ - Py_INCREF(Py_None); - - /* "View.MemoryView":350 - * if type(self) is memoryview or obj is not None: - * __Pyx_GetBuffer(obj, &self.view, flags) - * if self.view.obj == NULL: # <<<<<<<<<<<<<< - * (<__pyx_buffer *> &self.view).obj = Py_None - * Py_INCREF(Py_None) + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: */ } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; - /* "View.MemoryView":348 - * self.obj = obj - * self.flags = flags - * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< - * __Pyx_GetBuffer(obj, &self.view, flags) - * if self.view.obj == NULL: - */ - } - - /* "View.MemoryView":355 + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":970 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.umath failed to import") * - * global __pyx_memoryview_thread_locks_used - * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< - * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] - * __pyx_memoryview_thread_locks_used += 1 */ - __pyx_t_1 = ((__pyx_memoryview_thread_locks_used < 8) != 0); - if (__pyx_t_1) { + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 970, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); - /* "View.MemoryView":356 - * global __pyx_memoryview_thread_locks_used - * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: - * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] # <<<<<<<<<<<<<< - * __pyx_memoryview_thread_locks_used += 1 - * if self.lock is NULL: - */ - __pyx_v_self->lock = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); - - /* "View.MemoryView":357 - * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: - * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] - * __pyx_memoryview_thread_locks_used += 1 # <<<<<<<<<<<<<< - * if self.lock is NULL: - * self.lock = PyThread_allocate_lock() + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":971 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef extern from *: */ - __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used + 1); + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 971, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 971, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; - /* "View.MemoryView":355 + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":968 * - * global __pyx_memoryview_thread_locks_used - * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< - * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] - * __pyx_memoryview_thread_locks_used += 1 + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; } - /* "View.MemoryView":358 - * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] - * __pyx_memoryview_thread_locks_used += 1 - * if self.lock is NULL: # <<<<<<<<<<<<<< - * self.lock = PyThread_allocate_lock() - * if self.lock is NULL: - */ - __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":359 - * __pyx_memoryview_thread_locks_used += 1 - * if self.lock is NULL: - * self.lock = PyThread_allocate_lock() # <<<<<<<<<<<<<< - * if self.lock is NULL: - * raise MemoryError - */ - __pyx_v_self->lock = PyThread_allocate_lock(); - - /* "View.MemoryView":360 - * if self.lock is NULL: - * self.lock = PyThread_allocate_lock() - * if self.lock is NULL: # <<<<<<<<<<<<<< - * raise MemoryError - * - */ - __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); - if (unlikely(__pyx_t_1)) { - - /* "View.MemoryView":361 - * self.lock = PyThread_allocate_lock() - * if self.lock is NULL: - * raise MemoryError # <<<<<<<<<<<<<< - * - * if flags & PyBUF_FORMAT: - */ - PyErr_NoMemory(); __PYX_ERR(1, 361, __pyx_L1_error) - - /* "View.MemoryView":360 - * if self.lock is NULL: - * self.lock = PyThread_allocate_lock() - * if self.lock is NULL: # <<<<<<<<<<<<<< - * raise MemoryError - * - */ - } - - /* "View.MemoryView":358 - * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] - * __pyx_memoryview_thread_locks_used += 1 - * if self.lock is NULL: # <<<<<<<<<<<<<< - * self.lock = PyThread_allocate_lock() - * if self.lock is NULL: - */ - } - - /* "View.MemoryView":363 - * raise MemoryError - * - * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< - * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') - * else: - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":364 - * - * if flags & PyBUF_FORMAT: - * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') # <<<<<<<<<<<<<< - * else: - * self.dtype_is_object = dtype_is_object - */ - __pyx_t_2 = (((__pyx_v_self->view.format[0]) == 'O') != 0); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L11_bool_binop_done; - } - __pyx_t_2 = (((__pyx_v_self->view.format[1]) == '\x00') != 0); - __pyx_t_1 = __pyx_t_2; - __pyx_L11_bool_binop_done:; - __pyx_v_self->dtype_is_object = __pyx_t_1; - - /* "View.MemoryView":363 - * raise MemoryError - * - * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< - * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') - * else: - */ - goto __pyx_L10; - } - - /* "View.MemoryView":366 - * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') - * else: - * self.dtype_is_object = dtype_is_object # <<<<<<<<<<<<<< - * - * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( - */ - /*else*/ { - __pyx_v_self->dtype_is_object = __pyx_v_dtype_is_object; - } - __pyx_L10:; - - /* "View.MemoryView":368 - * self.dtype_is_object = dtype_is_object - * - * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( # <<<<<<<<<<<<<< - * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) - * self.typeinfo = NULL - */ - __pyx_v_self->acquisition_count_aligned_p = ((__pyx_atomic_int *)__pyx_align_pointer(((void *)(&(__pyx_v_self->acquisition_count[0]))), (sizeof(__pyx_atomic_int)))); - - /* "View.MemoryView":370 - * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( - * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) - * self.typeinfo = NULL # <<<<<<<<<<<<<< - * - * def __dealloc__(memoryview self): - */ - __pyx_v_self->typeinfo = NULL; - - /* "View.MemoryView":345 - * cdef __Pyx_TypeInfo *typeinfo - * - * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< - * self.obj = obj - * self.flags = flags + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":967 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; - __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "View.MemoryView":372 - * self.typeinfo = NULL - * - * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< - * if self.obj is not None: - * __Pyx_ReleaseBuffer(&self.view) - */ +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; -/* Python wrapper */ -static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self); /*proto*/ -static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); - __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(((struct __pyx_memoryview_obj *)__pyx_v_self)); +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_core(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_core}, + {0, NULL} +}; +#endif - /* function exit code */ - __Pyx_RefNannyFinishContext(); +static struct PyModuleDef __pyx_moduledef = { + PyModuleDef_HEAD_INIT, + "core", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif +#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_DTYPE, __pyx_k_DTYPE, sizeof(__pyx_k_DTYPE), 0, 0, 1, 1}, + {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, + {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0}, + {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, + {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0}, + {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_X, __pyx_k_X, sizeof(__pyx_k_X), 0, 0, 1, 1}, + {&__pyx_n_s_activation, __pyx_k_activation, sizeof(__pyx_k_activation), 0, 0, 1, 1}, + {&__pyx_n_s_activations, __pyx_k_activations, sizeof(__pyx_k_activations), 0, 0, 1, 1}, + {&__pyx_n_s_alpha, __pyx_k_alpha, sizeof(__pyx_k_alpha), 0, 0, 1, 1}, + {&__pyx_n_s_alpha_end, __pyx_k_alpha_end, sizeof(__pyx_k_alpha_end), 0, 0, 1, 1}, + {&__pyx_n_s_alpha_start, __pyx_k_alpha_start, sizeof(__pyx_k_alpha_start), 0, 0, 1, 1}, + {&__pyx_n_s_arange, __pyx_k_arange, sizeof(__pyx_k_arange), 0, 0, 1, 1}, + {&__pyx_n_s_argmin, __pyx_k_argmin, sizeof(__pyx_k_argmin), 0, 0, 1, 1}, + {&__pyx_n_s_argsort, __pyx_k_argsort, sizeof(__pyx_k_argsort), 0, 0, 1, 1}, + {&__pyx_n_s_axis, __pyx_k_axis, sizeof(__pyx_k_axis), 0, 0, 1, 1}, + {&__pyx_n_s_best, __pyx_k_best, sizeof(__pyx_k_best), 0, 0, 1, 1}, + {&__pyx_n_s_bmu, __pyx_k_bmu, sizeof(__pyx_k_bmu), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_core, __pyx_k_core, sizeof(__pyx_k_core), 0, 0, 1, 1}, + {&__pyx_n_s_count_modified_cells, __pyx_k_count_modified_cells, sizeof(__pyx_k_count_modified_cells), 0, 0, 1, 1}, + {&__pyx_n_s_create_map_online, __pyx_k_create_map_online, sizeof(__pyx_k_create_map_online), 0, 0, 1, 1}, + {&__pyx_n_s_curr_t, __pyx_k_curr_t, sizeof(__pyx_k_curr_t), 0, 0, 1, 1}, + {&__pyx_n_s_dist_lib, __pyx_k_dist_lib, sizeof(__pyx_k_dist_lib), 0, 0, 1, 1}, + {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, + {&__pyx_n_s_exp, __pyx_k_exp, sizeof(__pyx_k_exp), 0, 0, 1, 1}, + {&__pyx_n_s_float, __pyx_k_float, sizeof(__pyx_k_float), 0, 0, 1, 1}, + {&__pyx_n_s_get_alpha, __pyx_k_get_alpha, sizeof(__pyx_k_get_alpha), 0, 0, 1, 1}, + {&__pyx_n_s_get_best_cell, __pyx_k_get_best_cell, sizeof(__pyx_k_get_best_cell), 0, 0, 1, 1}, + {&__pyx_n_s_get_sigma, __pyx_k_get_sigma, sizeof(__pyx_k_get_sigma), 0, 0, 1, 1}, + {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_importance, __pyx_k_importance, sizeof(__pyx_k_importance), 0, 0, 1, 1}, + {&__pyx_n_s_inputs, __pyx_k_inputs, sizeof(__pyx_k_inputs), 0, 0, 1, 1}, + {&__pyx_n_s_it, __pyx_k_it, sizeof(__pyx_k_it), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_map_d, __pyx_k_map_d, sizeof(__pyx_k_map_d), 0, 0, 1, 1}, + {&__pyx_n_s_max, __pyx_k_max, sizeof(__pyx_k_max), 0, 0, 1, 1}, + {&__pyx_n_s_min, __pyx_k_min, sizeof(__pyx_k_min), 0, 0, 1, 1}, + {&__pyx_n_s_n_col, __pyx_k_n_col, sizeof(__pyx_k_n_col), 0, 0, 1, 1}, + {&__pyx_n_s_n_iter, __pyx_k_n_iter, sizeof(__pyx_k_n_iter), 0, 0, 1, 1}, + {&__pyx_n_s_n_pix, __pyx_k_n_pix, sizeof(__pyx_k_n_pix), 0, 0, 1, 1}, + {&__pyx_n_s_n_row, __pyx_k_n_row, sizeof(__pyx_k_n_row), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, + {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, + {&__pyx_kp_u_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 1, 0, 0}, + {&__pyx_kp_u_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 1, 0, 0}, + {&__pyx_n_s_power, __pyx_k_power, sizeof(__pyx_k_power), 0, 0, 1, 1}, + {&__pyx_n_s_random, __pyx_k_random, sizeof(__pyx_k_random), 0, 0, 1, 1}, + {&__pyx_n_s_random_indices, __pyx_k_random_indices, sizeof(__pyx_k_random_indices), 0, 0, 1, 1}, + {&__pyx_n_s_random_order, __pyx_k_random_order, sizeof(__pyx_k_random_order), 0, 0, 1, 1}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_n_s_return_vals, __pyx_k_return_vals, sizeof(__pyx_k_return_vals), 0, 0, 1, 1}, + {&__pyx_n_s_sample, __pyx_k_sample, sizeof(__pyx_k_sample), 0, 0, 1, 1}, + {&__pyx_n_s_sigma, __pyx_k_sigma, sizeof(__pyx_k_sigma), 0, 0, 1, 1}, + {&__pyx_n_s_sigma_0, __pyx_k_sigma_0, sizeof(__pyx_k_sigma_0), 0, 0, 1, 1}, + {&__pyx_n_s_sigma_f, __pyx_k_sigma_f, sizeof(__pyx_k_sigma_f), 0, 0, 1, 1}, + {&__pyx_kp_s_somsphere_cython_core_pyx, __pyx_k_somsphere_cython_core_pyx, sizeof(__pyx_k_somsphere_cython_core_pyx), 0, 0, 1, 0}, + {&__pyx_n_s_somsphere_utils, __pyx_k_somsphere_utils, sizeof(__pyx_k_somsphere_utils), 0, 0, 1, 1}, + {&__pyx_n_s_sum, __pyx_k_sum, sizeof(__pyx_k_sum), 0, 0, 1, 1}, + {&__pyx_n_s_t, __pyx_k_t, sizeof(__pyx_k_t), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_tile, __pyx_k_tile, sizeof(__pyx_k_tile), 0, 0, 1, 1}, + {&__pyx_n_s_timeit, __pyx_k_timeit, sizeof(__pyx_k_timeit), 0, 0, 1, 1}, + {&__pyx_n_s_total_t, __pyx_k_total_t, sizeof(__pyx_k_total_t), 0, 0, 1, 1}, + {&__pyx_n_s_transpose, __pyx_k_transpose, sizeof(__pyx_k_transpose), 0, 0, 1, 1}, + {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0}, + {&__pyx_n_s_weights, __pyx_k_weights, sizeof(__pyx_k_weights), 0, 0, 1, 1}, + {&__pyx_n_s_where, __pyx_k_where, sizeof(__pyx_k_where), 0, 0, 1, 1}, + {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 84, __pyx_L1_error) + __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 777, __pyx_L1_error) + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 781, __pyx_L1_error) + __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 959, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; } -static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self) { - int __pyx_v_i; +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - int __pyx_t_4; - int __pyx_t_5; - PyThread_type_lock __pyx_t_6; - PyThread_type_lock __pyx_t_7; - __Pyx_RefNannySetupContext("__dealloc__", 0); + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - /* "View.MemoryView":373 + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":777 * - * def __dealloc__(memoryview self): - * if self.obj is not None: # <<<<<<<<<<<<<< - * __Pyx_ReleaseBuffer(&self.view) - * elif (<__pyx_buffer *> &self.view).obj == Py_None: - */ - __pyx_t_1 = (__pyx_v_self->obj != Py_None); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":374 - * def __dealloc__(memoryview self): - * if self.obj is not None: - * __Pyx_ReleaseBuffer(&self.view) # <<<<<<<<<<<<<< - * elif (<__pyx_buffer *> &self.view).obj == Py_None: + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< * + * if ((child.byteorder == c'>' and little_endian) or */ - __Pyx_ReleaseBuffer((&__pyx_v_self->view)); + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 777, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); - /* "View.MemoryView":373 - * - * def __dealloc__(memoryview self): - * if self.obj is not None: # <<<<<<<<<<<<<< - * __Pyx_ReleaseBuffer(&self.view) - * elif (<__pyx_buffer *> &self.view).obj == Py_None: + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":781 + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * # One could encode it in the format string and have Cython + * # complain instead, BUT: < and > in format strings also imply */ - goto __pyx_L3; - } + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 781, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); - /* "View.MemoryView":375 - * if self.obj is not None: - * __Pyx_ReleaseBuffer(&self.view) - * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<< + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":801 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< * - * (<__pyx_buffer *> &self.view).obj = NULL + * # Until ticket #99 is fixed, use integers to avoid warnings */ - __pyx_t_2 = ((((Py_buffer *)(&__pyx_v_self->view))->obj == Py_None) != 0); - if (__pyx_t_2) { + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 801, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); - /* "View.MemoryView":377 - * elif (<__pyx_buffer *> &self.view).obj == Py_None: - * - * (<__pyx_buffer *> &self.view).obj = NULL # <<<<<<<<<<<<<< - * Py_DECREF(Py_None) + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":959 + * __pyx_import_array() + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * + * cdef inline int import_umath() except -1: */ - ((Py_buffer *)(&__pyx_v_self->view))->obj = NULL; + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 959, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); - /* "View.MemoryView":378 - * - * (<__pyx_buffer *> &self.view).obj = NULL - * Py_DECREF(Py_None) # <<<<<<<<<<<<<< + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":965 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * - * cdef int i + * cdef inline int import_ufunc() except -1: */ - Py_DECREF(Py_None); + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 965, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); - /* "View.MemoryView":375 - * if self.obj is not None: - * __Pyx_ReleaseBuffer(&self.view) - * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<< - * - * (<__pyx_buffer *> &self.view).obj = NULL - */ - } - __pyx_L3:; - - /* "View.MemoryView":382 - * cdef int i - * global __pyx_memoryview_thread_locks_used - * if self.lock != NULL: # <<<<<<<<<<<<<< - * for i in range(__pyx_memoryview_thread_locks_used): - * if __pyx_memoryview_thread_locks[i] is self.lock: - */ - __pyx_t_2 = ((__pyx_v_self->lock != NULL) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":383 - * global __pyx_memoryview_thread_locks_used - * if self.lock != NULL: - * for i in range(__pyx_memoryview_thread_locks_used): # <<<<<<<<<<<<<< - * if __pyx_memoryview_thread_locks[i] is self.lock: - * __pyx_memoryview_thread_locks_used -= 1 - */ - __pyx_t_3 = __pyx_memoryview_thread_locks_used; - __pyx_t_4 = __pyx_t_3; - for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { - __pyx_v_i = __pyx_t_5; - - /* "View.MemoryView":384 - * if self.lock != NULL: - * for i in range(__pyx_memoryview_thread_locks_used): - * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< - * __pyx_memoryview_thread_locks_used -= 1 - * if i != __pyx_memoryview_thread_locks_used: + /* "core.pyx":38 + * # + * # t += n_row + * def get_alpha(float alpha_end, float alpha_start, int curr_t, int total_t): # <<<<<<<<<<<<<< + * """ + * Get value of alpha at a given time */ - __pyx_t_2 = (((__pyx_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock) != 0); - if (__pyx_t_2) { + __pyx_tuple__6 = PyTuple_Pack(4, __pyx_n_s_alpha_end, __pyx_n_s_alpha_start, __pyx_n_s_curr_t, __pyx_n_s_total_t); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(4, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_somsphere_cython_core_pyx, __pyx_n_s_get_alpha, 38, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 38, __pyx_L1_error) - /* "View.MemoryView":385 - * for i in range(__pyx_memoryview_thread_locks_used): - * if __pyx_memoryview_thread_locks[i] is self.lock: - * __pyx_memoryview_thread_locks_used -= 1 # <<<<<<<<<<<<<< - * if i != __pyx_memoryview_thread_locks_used: - * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( - */ - __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used - 1); - - /* "View.MemoryView":386 - * if __pyx_memoryview_thread_locks[i] is self.lock: - * __pyx_memoryview_thread_locks_used -= 1 - * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< - * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( - * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) - */ - __pyx_t_2 = ((__pyx_v_i != __pyx_memoryview_thread_locks_used) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":388 - * if i != __pyx_memoryview_thread_locks_used: - * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( - * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) # <<<<<<<<<<<<<< - * break - * else: - */ - __pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); - __pyx_t_7 = (__pyx_memoryview_thread_locks[__pyx_v_i]); - - /* "View.MemoryView":387 - * __pyx_memoryview_thread_locks_used -= 1 - * if i != __pyx_memoryview_thread_locks_used: - * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( # <<<<<<<<<<<<<< - * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) - * break - */ - (__pyx_memoryview_thread_locks[__pyx_v_i]) = __pyx_t_6; - (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_7; - - /* "View.MemoryView":386 - * if __pyx_memoryview_thread_locks[i] is self.lock: - * __pyx_memoryview_thread_locks_used -= 1 - * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< - * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( - * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + /* "core.pyx":44 + * return alpha_start * np.power(alpha_end / alpha_start, float(curr_t) / float(total_t)) + * + * def get_sigma(float sigma_f, float sigma_0, int curr_t, int total_t): # <<<<<<<<<<<<<< + * """ + * Get value of sigma at a given time */ - } + __pyx_tuple__8 = PyTuple_Pack(4, __pyx_n_s_sigma_f, __pyx_n_s_sigma_0, __pyx_n_s_curr_t, __pyx_n_s_total_t); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 44, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(4, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_somsphere_cython_core_pyx, __pyx_n_s_get_sigma, 44, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 44, __pyx_L1_error) - /* "View.MemoryView":389 - * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( - * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) - * break # <<<<<<<<<<<<<< - * else: - * PyThread_free_lock(self.lock) - */ - goto __pyx_L6_break; - - /* "View.MemoryView":384 - * if self.lock != NULL: - * for i in range(__pyx_memoryview_thread_locks_used): - * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< - * __pyx_memoryview_thread_locks_used -= 1 - * if i != __pyx_memoryview_thread_locks_used: + /* "core.pyx":51 + * + * @timeit + * def get_best_cell(cnp.ndarray inputs, cnp.ndarray importance, int n_pix, cnp.ndarray weights, int return_vals): # <<<<<<<<<<<<<< + * """ + * Return the closest cell to the input object */ - } - } - /*else*/ { + __pyx_tuple__10 = PyTuple_Pack(7, __pyx_n_s_inputs, __pyx_n_s_importance, __pyx_n_s_n_pix, __pyx_n_s_weights, __pyx_n_s_return_vals, __pyx_n_s_activation, __pyx_n_s_activations); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 51, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(5, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_somsphere_cython_core_pyx, __pyx_n_s_get_best_cell, 51, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(0, 51, __pyx_L1_error) - /* "View.MemoryView":391 - * break - * else: - * PyThread_free_lock(self.lock) # <<<<<<<<<<<<<< + /* "core.pyx":62 + * return np.argmin(activations) if return_vals == 1 else np.argsort(activations)[0:return_vals], activations * - * cdef char *get_item_pointer(memoryview self, object index) except NULL: - */ - PyThread_free_lock(__pyx_v_self->lock); - } - __pyx_L6_break:; - - /* "View.MemoryView":382 - * cdef int i - * global __pyx_memoryview_thread_locks_used - * if self.lock != NULL: # <<<<<<<<<<<<<< - * for i in range(__pyx_memoryview_thread_locks_used): - * if __pyx_memoryview_thread_locks[i] is self.lock: + * def count_modified_cells(int bmu, cnp.ndarray map_d, float sigma): # <<<<<<<<<<<<<< + * """ + * Neighborhood function which quantifies how much cells around the best matching one are modified */ - } + __pyx_tuple__12 = PyTuple_Pack(3, __pyx_n_s_bmu, __pyx_n_s_map_d, __pyx_n_s_sigma); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + __pyx_codeobj__13 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_somsphere_cython_core_pyx, __pyx_n_s_count_modified_cells, 62, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__13)) __PYX_ERR(0, 62, __pyx_L1_error) - /* "View.MemoryView":372 - * self.typeinfo = NULL + /* "core.pyx":71 + * return np.exp(-(map_d[bmu] ** 2) / sigma ** 2) * - * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< - * if self.obj is not None: - * __Pyx_ReleaseBuffer(&self.view) + * def create_map_online(cnp.ndarray X, int n_iter, int n_row, int n_col, int n_pix, float alpha_start, float alpha_end, # <<<<<<<<<<<<<< + * cnp.ndarray importance, cnp.ndarray dist_lib, cnp.ndarray weights, bint random_order): + * cdef int t = 0 */ + __pyx_tuple__14 = PyTuple_Pack(23, __pyx_n_s_X, __pyx_n_s_n_iter, __pyx_n_s_n_row, __pyx_n_s_n_col, __pyx_n_s_n_pix, __pyx_n_s_alpha_start, __pyx_n_s_alpha_end, __pyx_n_s_importance, __pyx_n_s_dist_lib, __pyx_n_s_weights, __pyx_n_s_random_order, __pyx_n_s_t, __pyx_n_s_total_t, __pyx_n_s_sigma_0, __pyx_n_s_sigma_f, __pyx_n_s_i, __pyx_n_s_best, __pyx_n_s_alpha, __pyx_n_s_sigma, __pyx_n_s_random_indices, __pyx_n_s_inputs, __pyx_n_s_activation, __pyx_n_s_it); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__14); + __Pyx_GIVEREF(__pyx_tuple__14); + __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(11, 0, 23, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_somsphere_cython_core_pyx, __pyx_n_s_create_map_online, 71, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(0, 71, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} - /* function exit code */ +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_float_0_ = PyFloat_FromDouble(0.); if (unlikely(!__pyx_float_0_)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __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) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ __Pyx_RefNannyFinishContext(); + return 0; } -/* "View.MemoryView":393 - * PyThread_free_lock(self.lock) - * - * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< - * cdef Py_ssize_t dim - * cdef char *itemp = self.view.buf - */ +static int __Pyx_modinit_variable_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} -static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { - Py_ssize_t __pyx_v_dim; - char *__pyx_v_itemp; - PyObject *__pyx_v_idx = NULL; - char *__pyx_r; +static int __Pyx_modinit_function_export_code(void) { __Pyx_RefNannyDeclarations - Py_ssize_t __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - Py_ssize_t __pyx_t_3; - PyObject *(*__pyx_t_4)(PyObject *); - PyObject *__pyx_t_5 = NULL; - Py_ssize_t __pyx_t_6; - char *__pyx_t_7; + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_import_code(void) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_item_pointer", 0); - - /* "View.MemoryView":395 - * cdef char *get_item_pointer(memoryview self, object index) except NULL: - * cdef Py_ssize_t dim - * cdef char *itemp = self.view.buf # <<<<<<<<<<<<<< - * - * for dim, idx in enumerate(index): - */ - __pyx_v_itemp = ((char *)__pyx_v_self->view.buf); - - /* "View.MemoryView":397 - * cdef char *itemp = self.view.buf - * - * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< - * itemp = pybuffer_index(&self.view, itemp, idx, dim) - * - */ - __pyx_t_1 = 0; - if (likely(PyList_CheckExact(__pyx_v_index)) || PyTuple_CheckExact(__pyx_v_index)) { - __pyx_t_2 = __pyx_v_index; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; - __pyx_t_4 = NULL; - } else { - __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 397, __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, 397, __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, 397, __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, 397, __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, 397, __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, 397, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - #endif - } - } else { - __pyx_t_5 = __pyx_t_4(__pyx_t_2); - if (unlikely(!__pyx_t_5)) { - PyObject* exc_type = PyErr_Occurred(); - if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 397, __pyx_L1_error) - } - break; - } - __Pyx_GOTREF(__pyx_t_5); - } - __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_5); - __pyx_t_5 = 0; - __pyx_v_dim = __pyx_t_1; - __pyx_t_1 = (__pyx_t_1 + 1); - - /* "View.MemoryView":398 - * - * 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, 398, __pyx_L1_error) - __pyx_t_7 = __pyx_pybuffer_index((&__pyx_v_self->view), __pyx_v_itemp, __pyx_t_6, __pyx_v_dim); if (unlikely(__pyx_t_7 == ((char *)NULL))) __PYX_ERR(1, 398, __pyx_L1_error) - __pyx_v_itemp = __pyx_t_7; - - /* "View.MemoryView":397 - * cdef char *itemp = self.view.buf - * - * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< - * itemp = pybuffer_index(&self.view, itemp, idx, dim) - * - */ - } - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "View.MemoryView":400 - * itemp = pybuffer_index(&self.view, itemp, idx, dim) - * - * return itemp # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = __pyx_v_itemp; - goto __pyx_L0; - - /* "View.MemoryView":393 - * PyThread_free_lock(self.lock) - * - * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< - * cdef Py_ssize_t dim - * cdef char *itemp = self.view.buf - */ - - /* function exit code */ + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyTypeObject), + #else + sizeof(PyHeapTypeObject), + #endif + __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 207, __pyx_L1_error) + __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 230, __pyx_L1_error) + __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 234, __pyx_L1_error) + __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 246, __pyx_L1_error) + __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 839, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_RefNannyFinishContext(); + return 0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("View.MemoryView.memoryview.get_item_pointer", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_idx); + __Pyx_XDECREF(__pyx_t_1); __Pyx_RefNannyFinishContext(); - return __pyx_r; + return -1; } -/* "View.MemoryView":403 - * - * - * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< - * if index is Ellipsis: - * return self - */ - -/* Python wrapper */ -static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index); /*proto*/ -static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index) { - PyObject *__pyx_r = 0; +static int __Pyx_modinit_variable_import_code(void) { __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index)); - - /* function exit code */ + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); - return __pyx_r; + return 0; } -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { - PyObject *__pyx_v_have_slices = NULL; - PyObject *__pyx_v_indices = NULL; - char *__pyx_v_itemp; - PyObject *__pyx_r = NULL; +static int __Pyx_modinit_function_import_code(void) { __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - char *__pyx_t_6; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__getitem__", 0); + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} - /* "View.MemoryView":404 - * - * def __getitem__(memoryview self, object index): - * if index is Ellipsis: # <<<<<<<<<<<<<< - * return self - * - */ - __pyx_t_1 = (__pyx_v_index == __pyx_builtin_Ellipsis); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":405 - * def __getitem__(memoryview self, object index): - * if index is Ellipsis: - * return self # <<<<<<<<<<<<<< - * - * have_slices, indices = _unellipsify(index, self.view.ndim) - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_self)); - __pyx_r = ((PyObject *)__pyx_v_self); - goto __pyx_L0; - /* "View.MemoryView":404 - * - * def __getitem__(memoryview self, object index): - * if index is Ellipsis: # <<<<<<<<<<<<<< - * return self - * - */ - } +#ifndef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void +#else +#define __Pyx_PyMODINIT_FUNC void +#endif +#else +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * +#else +#define __Pyx_PyMODINIT_FUNC PyObject * +#endif +#endif - /* "View.MemoryView":407 - * 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, 407, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (likely(__pyx_t_3 != Py_None)) { - PyObject* sequence = __pyx_t_3; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 407, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); + +#if PY_MAJOR_VERSION < 3 +__Pyx_PyMODINIT_FUNC initcore(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC initcore(void) +#else +__Pyx_PyMODINIT_FUNC PyInit_core(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_core(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + #if PY_VERSION_HEX >= 0x030700A1 + static PY_INT64_T main_interpreter_id = -1; + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); + if (main_interpreter_id == -1) { + main_interpreter_id = current_id; + return (unlikely(current_id == -1)) ? -1 : 0; + } else if (unlikely(main_interpreter_id != current_id)) #else - __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 407, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 407, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); + 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 - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else { - __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 407, __pyx_L1_error) - } - __pyx_v_have_slices = __pyx_t_4; - __pyx_t_4 = 0; - __pyx_v_indices = __pyx_t_5; - __pyx_t_5 = 0; - - /* "View.MemoryView":410 - * - * 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, 410, __pyx_L1_error) - if (__pyx_t_2) { - - /* "View.MemoryView":411 - * cdef char *itemp - * if have_slices: - * return memview_slice(self, indices) # <<<<<<<<<<<<<< - * else: - * itemp = self.get_item_pointer(indices) - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 411, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L0; - - /* "View.MemoryView":410 - * - * cdef char *itemp - * if have_slices: # <<<<<<<<<<<<<< - * return memview_slice(self, indices) - * else: - */ - } - - /* "View.MemoryView":413 - * return memview_slice(self, indices) - * else: - * itemp = self.get_item_pointer(indices) # <<<<<<<<<<<<<< - * return self.convert_item_to_object(itemp) - * - */ - /*else*/ { - __pyx_t_6 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_6 == ((char *)NULL))) __PYX_ERR(1, 413, __pyx_L1_error) - __pyx_v_itemp = __pyx_t_6; - - /* "View.MemoryView":414 - * else: - * itemp = self.get_item_pointer(indices) - * return self.convert_item_to_object(itemp) # <<<<<<<<<<<<<< - * - * def __setitem__(memoryview self, object index, object value): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 414, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L0; - } - - /* "View.MemoryView":403 - * - * - * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< - * if index is Ellipsis: - * return self - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("View.MemoryView.memoryview.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_have_slices); - __Pyx_XDECREF(__pyx_v_indices); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; + { + PyErr_SetString( + PyExc_ImportError, + "Interpreter change detected - this module can only be loaded into one interpreter per process."); + return -1; + } + return 0; } - -/* "View.MemoryView":416 - * return self.convert_item_to_object(itemp) - * - * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< - * if self.view.readonly: - * raise TypeError("Cannot assign to read-only memoryview") - */ - -/* Python wrapper */ -static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /*proto*/ -static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index), ((PyObject *)__pyx_v_value)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { + 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); + } + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, 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"); + if (unlikely(!modname)) goto bad; + module = PyModule_NewObject(modname); + Py_DECREF(modname); + if (unlikely(!module)) goto bad; + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; + return module; +bad: + Py_XDECREF(module); + return NULL; } -static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { - PyObject *__pyx_v_have_slices = NULL; - PyObject *__pyx_v_obj = NULL; - int __pyx_r; - __Pyx_RefNannyDeclarations - int __pyx_t_1; + +static CYTHON_SMALL_CODE int __pyx_pymod_exec_core(PyObject *__pyx_pyinit_module) +#endif +#endif +{ + PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setitem__", 0); - __Pyx_INCREF(__pyx_v_index); + __Pyx_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module 'core' has already been imported. Re-initialisation is not supported."); + return -1; + } + #elif PY_MAJOR_VERSION >= 3 + if (__pyx_m) return __Pyx_NewRef(__pyx_m); + #endif + #if CYTHON_REFNANNY +__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); +if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); +} +#endif + __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_core(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pxy_PyFrame_Initialize_Offsets + __Pxy_PyFrame_Initialize_Offsets(); + #endif + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("core", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_b); + __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_cython_runtime); + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_core) { + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "core")) { + if (unlikely(PyDict_SetItemString(modules, "core", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_global_init_code(); + (void)__Pyx_modinit_variable_export_code(); + (void)__Pyx_modinit_function_export_code(); + (void)__Pyx_modinit_type_init_code(); + if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_variable_import_code(); + (void)__Pyx_modinit_function_import_code(); + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif - /* "View.MemoryView":417 - * - * def __setitem__(memoryview self, object index, object value): - * if self.view.readonly: # <<<<<<<<<<<<<< - * raise TypeError("Cannot assign to read-only memoryview") + /* "core.pyx":2 + * #cython: language_level=3 + * import random # <<<<<<<<<<<<<< * + * import numpy as np */ - __pyx_t_1 = (__pyx_v_self->view.readonly != 0); - if (unlikely(__pyx_t_1)) { + __pyx_t_1 = __Pyx_Import(__pyx_n_s_random, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_random, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "View.MemoryView":418 - * def __setitem__(memoryview self, object index, object value): - * if self.view.readonly: - * raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<< + /* "core.pyx":4 + * import random + * + * import numpy as np # <<<<<<<<<<<<<< + * cimport numpy as cnp * - * have_slices, index = _unellipsify(index, self.view.ndim) */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 418, __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, 418, __pyx_L1_error) + __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "View.MemoryView":417 + /* "core.pyx":7 + * cimport numpy as cnp * - * def __setitem__(memoryview self, object index, object value): - * if self.view.readonly: # <<<<<<<<<<<<<< - * raise TypeError("Cannot assign to read-only memoryview") + * from somsphere.utils import timeit # <<<<<<<<<<<<<< * + * DTYPE = np.float */ - } + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_timeit); + __Pyx_GIVEREF(__pyx_n_s_timeit); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_timeit); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_somsphere_utils, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_timeit); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_timeit, __pyx_t_1) < 0) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "View.MemoryView":420 - * raise TypeError("Cannot assign to read-only memoryview") - * - * have_slices, index = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< + /* "core.pyx":9 + * from somsphere.utils import timeit * - * if have_slices: + * DTYPE = np.float # <<<<<<<<<<<<<< + * ctypedef cnp.float_t DTYPE_t + * # def create_map_batch(np.ndarray X, int n_iter, int n_row, int n_col, int n_pix, np.ndarray importance, */ - __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 420, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (likely(__pyx_t_2 != Py_None)) { - PyObject* sequence = __pyx_t_2; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 420, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(__pyx_t_4); - #else - __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 420, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 420, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } else { - __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 420, __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; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_float); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_DTYPE, __pyx_t_1) < 0) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "View.MemoryView":422 - * have_slices, index = _unellipsify(index, self.view.ndim) - * - * if have_slices: # <<<<<<<<<<<<<< - * obj = self.is_slice(value) - * if obj: + /* "core.pyx":38 + * # + * # t += n_row + * def get_alpha(float alpha_end, float alpha_start, int curr_t, int total_t): # <<<<<<<<<<<<<< + * """ + * Get value of alpha at a given time */ - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 422, __pyx_L1_error) - if (__pyx_t_1) { + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_4core_1get_alpha, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_alpha, __pyx_t_1) < 0) __PYX_ERR(0, 38, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "View.MemoryView":423 + /* "core.pyx":44 + * return alpha_start * np.power(alpha_end / alpha_start, float(curr_t) / float(total_t)) * - * if have_slices: - * obj = self.is_slice(value) # <<<<<<<<<<<<<< - * if obj: - * self.setitem_slice_assignment(self[index], obj) + * def get_sigma(float sigma_f, float sigma_0, int curr_t, int total_t): # <<<<<<<<<<<<<< + * """ + * Get value of sigma at a given time */ - __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, 423, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_v_obj = __pyx_t_2; - __pyx_t_2 = 0; + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_4core_3get_sigma, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 44, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_sigma, __pyx_t_1) < 0) __PYX_ERR(0, 44, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "View.MemoryView":424 - * if have_slices: - * obj = self.is_slice(value) - * if obj: # <<<<<<<<<<<<<< - * self.setitem_slice_assignment(self[index], obj) - * else: + /* "core.pyx":50 + * return sigma_0 * np.power(sigma_f / sigma_0, float(curr_t) / float(total_t)) + * + * @timeit # <<<<<<<<<<<<<< + * def get_best_cell(cnp.ndarray inputs, cnp.ndarray importance, int n_pix, cnp.ndarray weights, int return_vals): + * """ */ - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_obj); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 424, __pyx_L1_error) - if (__pyx_t_1) { + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_timeit); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); - /* "View.MemoryView":425 - * obj = self.is_slice(value) - * if obj: - * self.setitem_slice_assignment(self[index], obj) # <<<<<<<<<<<<<< - * else: - * self.setitem_slice_assign_scalar(self[index], value) + /* "core.pyx":51 + * + * @timeit + * def get_best_cell(cnp.ndarray inputs, cnp.ndarray importance, int n_pix, cnp.ndarray weights, int return_vals): # <<<<<<<<<<<<<< + * """ + * Return the closest cell to the input object */ - __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 425, __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, 425, __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; + __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_4core_5get_best_cell, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 51, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); - /* "View.MemoryView":424 - * if have_slices: - * obj = self.is_slice(value) - * if obj: # <<<<<<<<<<<<<< - * self.setitem_slice_assignment(self[index], obj) - * else: + /* "core.pyx":50 + * return sigma_0 * np.power(sigma_f / sigma_0, float(curr_t) / float(total_t)) + * + * @timeit # <<<<<<<<<<<<<< + * def get_best_cell(cnp.ndarray inputs, cnp.ndarray importance, int n_pix, cnp.ndarray weights, int return_vals): + * """ */ - goto __pyx_L5; - } + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 50, __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; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_best_cell, __pyx_t_3) < 0) __PYX_ERR(0, 51, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "View.MemoryView":427 - * self.setitem_slice_assignment(self[index], obj) - * else: - * self.setitem_slice_assign_scalar(self[index], value) # <<<<<<<<<<<<<< - * else: - * self.setitem_indexed(index, value) + /* "core.pyx":62 + * return np.argmin(activations) if return_vals == 1 else np.argsort(activations)[0:return_vals], activations + * + * def count_modified_cells(int bmu, cnp.ndarray map_d, float sigma): # <<<<<<<<<<<<<< + * """ + * Neighborhood function which quantifies how much cells around the best matching one are modified */ - /*else*/ { - __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 427, __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, 427, __pyx_L1_error) - __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_4), __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 427, __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:; + __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_4core_7count_modified_cells, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_count_modified_cells, __pyx_t_3) < 0) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "View.MemoryView":422 - * have_slices, index = _unellipsify(index, self.view.ndim) + /* "core.pyx":71 + * return np.exp(-(map_d[bmu] ** 2) / sigma ** 2) * - * if have_slices: # <<<<<<<<<<<<<< - * obj = self.is_slice(value) - * if obj: + * def create_map_online(cnp.ndarray X, int n_iter, int n_row, int n_col, int n_pix, float alpha_start, float alpha_end, # <<<<<<<<<<<<<< + * cnp.ndarray importance, cnp.ndarray dist_lib, cnp.ndarray weights, bint random_order): + * cdef int t = 0 */ - goto __pyx_L4; - } + __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_4core_9create_map_online, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_create_map_online, __pyx_t_3) < 0) __PYX_ERR(0, 71, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "View.MemoryView":429 - * self.setitem_slice_assign_scalar(self[index], value) - * else: - * self.setitem_indexed(index, value) # <<<<<<<<<<<<<< + /* "core.pyx":1 + * #cython: language_level=3 # <<<<<<<<<<<<<< + * import random * - * 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, 429, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - __pyx_L4:; + __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "View.MemoryView":416 - * return self.convert_item_to_object(itemp) + /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":967 + * raise ImportError("numpy.core.umath failed to import") * - * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< - * if self.view.readonly: - * raise TypeError("Cannot assign to read-only memoryview") + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() */ - /* function exit code */ - __pyx_r = 0; + /*--- Wrapped vars code ---*/ + goto __pyx_L0; __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("View.MemoryView.memoryview.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init core", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_CLEAR(__pyx_m); + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init core"); + } __pyx_L0:; - __Pyx_XDECREF(__pyx_v_have_slices); - __Pyx_XDECREF(__pyx_v_obj); - __Pyx_XDECREF(__pyx_v_index); __Pyx_RefNannyFinishContext(); - return __pyx_r; + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #elif PY_MAJOR_VERSION >= 3 + return __pyx_m; + #else + return; + #endif } -/* "View.MemoryView":431 - * self.setitem_indexed(index, value) - * - * cdef is_slice(self, obj): # <<<<<<<<<<<<<< - * if not isinstance(obj, memoryview): - * try: - */ - -static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - int __pyx_t_9; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("is_slice", 0); - __Pyx_INCREF(__pyx_v_obj); - - /* "View.MemoryView":432 - * - * cdef is_slice(self, obj): - * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< - * try: - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - */ - __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_obj, __pyx_memoryview_type); - __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":433 - * cdef is_slice(self, obj): - * if not isinstance(obj, memoryview): - * try: # <<<<<<<<<<<<<< - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - * self.dtype_is_object) - */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); - __Pyx_XGOTREF(__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_4); - __Pyx_XGOTREF(__pyx_t_5); - /*try:*/ { - - /* "View.MemoryView":434 - * if not isinstance(obj, memoryview): - * try: - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< - * self.dtype_is_object) - * except TypeError: - */ - __pyx_t_6 = __Pyx_PyInt_From_int(((__pyx_v_self->flags & (~PyBUF_WRITABLE)) | PyBUF_ANY_CONTIGUOUS)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 434, __pyx_L4_error) - __Pyx_GOTREF(__pyx_t_6); - - /* "View.MemoryView":435 - * try: - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - * self.dtype_is_object) # <<<<<<<<<<<<<< - * except TypeError: - * return None - */ - __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 435, __pyx_L4_error) - __Pyx_GOTREF(__pyx_t_7); - - /* "View.MemoryView":434 - * if not isinstance(obj, memoryview): - * try: - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< - * self.dtype_is_object) - * except TypeError: - */ - __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 434, __pyx_L4_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_INCREF(__pyx_v_obj); - __Pyx_GIVEREF(__pyx_v_obj); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_obj); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7); - __pyx_t_6 = 0; - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 434, __pyx_L4_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF_SET(__pyx_v_obj, __pyx_t_7); - __pyx_t_7 = 0; - - /* "View.MemoryView":433 - * cdef is_slice(self, obj): - * if not isinstance(obj, memoryview): - * try: # <<<<<<<<<<<<<< - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - * self.dtype_is_object) - */ - } - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - goto __pyx_L9_try_end; - __pyx_L4_error:; - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - - /* "View.MemoryView":436 - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - * self.dtype_is_object) - * except TypeError: # <<<<<<<<<<<<<< - * return None - * - */ - __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); - if (__pyx_t_9) { - __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_6) < 0) __PYX_ERR(1, 436, __pyx_L6_except_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GOTREF(__pyx_t_6); - - /* "View.MemoryView":437 - * self.dtype_is_object) - * except TypeError: - * return None # <<<<<<<<<<<<<< - * - * return obj - */ - __Pyx_XDECREF(__pyx_r); - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - goto __pyx_L7_except_return; - } - goto __pyx_L6_except_error; - __pyx_L6_except_error:; - - /* "View.MemoryView":433 - * cdef is_slice(self, obj): - * if not isinstance(obj, memoryview): - * try: # <<<<<<<<<<<<<< - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - * self.dtype_is_object) - */ - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_XGIVEREF(__pyx_t_4); - __Pyx_XGIVEREF(__pyx_t_5); - __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); - goto __pyx_L1_error; - __pyx_L7_except_return:; - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_XGIVEREF(__pyx_t_4); - __Pyx_XGIVEREF(__pyx_t_5); - __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); - goto __pyx_L0; - __pyx_L9_try_end:; - } - - /* "View.MemoryView":432 - * - * cdef is_slice(self, obj): - * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< - * try: - * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, - */ - } - - /* "View.MemoryView":439 - * return None - * - * return obj # <<<<<<<<<<<<<< - * - * cdef setitem_slice_assignment(self, dst, src): - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_obj); - __pyx_r = __pyx_v_obj; - goto __pyx_L0; - - /* "View.MemoryView":431 - * self.setitem_indexed(index, value) - * - * cdef is_slice(self, obj): # <<<<<<<<<<<<<< - * if not isinstance(obj, memoryview): - * try: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_obj); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":441 - * return obj - * - * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice dst_slice - * cdef __Pyx_memviewslice src_slice - */ - -static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src) { - __Pyx_memviewslice __pyx_v_dst_slice; - __Pyx_memviewslice __pyx_v_src_slice; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_memviewslice *__pyx_t_1; - __Pyx_memviewslice *__pyx_t_2; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - int __pyx_t_5; - int __pyx_t_6; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("setitem_slice_assignment", 0); - - /* "View.MemoryView":445 - * 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, 445, __pyx_L1_error) - __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_src), (&__pyx_v_src_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 445, __pyx_L1_error) - - /* "View.MemoryView":446 - * - * 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, 446, __pyx_L1_error) - __pyx_t_2 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice)); if (unlikely(__pyx_t_2 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 446, __pyx_L1_error) - - /* "View.MemoryView":447 - * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], - * get_slice_from_memview(dst, &dst_slice)[0], - * src.ndim, dst.ndim, self.dtype_is_object) # <<<<<<<<<<<<<< - * - * cdef setitem_slice_assign_scalar(self, memoryview dst, value): - */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 447, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 447, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_dst, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 447, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 447, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "View.MemoryView":445 - * cdef __Pyx_memviewslice src_slice - * - * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], # <<<<<<<<<<<<<< - * get_slice_from_memview(dst, &dst_slice)[0], - * src.ndim, dst.ndim, self.dtype_is_object) - */ - __pyx_t_6 = __pyx_memoryview_copy_contents((__pyx_t_1[0]), (__pyx_t_2[0]), __pyx_t_4, __pyx_t_5, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 445, __pyx_L1_error) - - /* "View.MemoryView":441 - * return obj - * - * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice dst_slice - * cdef __Pyx_memviewslice src_slice - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assignment", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":449 - * src.ndim, dst.ndim, self.dtype_is_object) - * - * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< - * cdef int array[128] - * cdef void *tmp = NULL - */ - -static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value) { - int __pyx_v_array[0x80]; - void *__pyx_v_tmp; - void *__pyx_v_item; - __Pyx_memviewslice *__pyx_v_dst_slice; - __Pyx_memviewslice __pyx_v_tmp_slice; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_memviewslice *__pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - int __pyx_t_5; - char const *__pyx_t_6; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - PyObject *__pyx_t_9 = NULL; - PyObject *__pyx_t_10 = NULL; - PyObject *__pyx_t_11 = NULL; - PyObject *__pyx_t_12 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("setitem_slice_assign_scalar", 0); - - /* "View.MemoryView":451 - * cdef setitem_slice_assign_scalar(self, memoryview dst, value): - * cdef int array[128] - * cdef void *tmp = NULL # <<<<<<<<<<<<<< - * cdef void *item - * - */ - __pyx_v_tmp = NULL; - - /* "View.MemoryView":456 - * cdef __Pyx_memviewslice *dst_slice - * cdef __Pyx_memviewslice tmp_slice - * dst_slice = get_slice_from_memview(dst, &tmp_slice) # <<<<<<<<<<<<<< - * - * if self.view.itemsize > sizeof(array): - */ - __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_dst, (&__pyx_v_tmp_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 456, __pyx_L1_error) - __pyx_v_dst_slice = __pyx_t_1; - - /* "View.MemoryView":458 - * dst_slice = get_slice_from_memview(dst, &tmp_slice) - * - * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< - * tmp = PyMem_Malloc(self.view.itemsize) - * if tmp == NULL: - */ - __pyx_t_2 = ((((size_t)__pyx_v_self->view.itemsize) > (sizeof(__pyx_v_array))) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":459 - * - * if self.view.itemsize > sizeof(array): - * tmp = PyMem_Malloc(self.view.itemsize) # <<<<<<<<<<<<<< - * if tmp == NULL: - * raise MemoryError - */ - __pyx_v_tmp = PyMem_Malloc(__pyx_v_self->view.itemsize); - - /* "View.MemoryView":460 - * if self.view.itemsize > sizeof(array): - * tmp = PyMem_Malloc(self.view.itemsize) - * if tmp == NULL: # <<<<<<<<<<<<<< - * raise MemoryError - * item = tmp - */ - __pyx_t_2 = ((__pyx_v_tmp == NULL) != 0); - if (unlikely(__pyx_t_2)) { - - /* "View.MemoryView":461 - * tmp = PyMem_Malloc(self.view.itemsize) - * if tmp == NULL: - * raise MemoryError # <<<<<<<<<<<<<< - * item = tmp - * else: - */ - PyErr_NoMemory(); __PYX_ERR(1, 461, __pyx_L1_error) - - /* "View.MemoryView":460 - * if self.view.itemsize > sizeof(array): - * tmp = PyMem_Malloc(self.view.itemsize) - * if tmp == NULL: # <<<<<<<<<<<<<< - * raise MemoryError - * item = tmp - */ - } - - /* "View.MemoryView":462 - * if tmp == NULL: - * raise MemoryError - * item = tmp # <<<<<<<<<<<<<< - * else: - * item = array - */ - __pyx_v_item = __pyx_v_tmp; - - /* "View.MemoryView":458 - * dst_slice = get_slice_from_memview(dst, &tmp_slice) - * - * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< - * tmp = PyMem_Malloc(self.view.itemsize) - * if tmp == NULL: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":464 - * item = tmp - * else: - * item = array # <<<<<<<<<<<<<< - * - * try: - */ - /*else*/ { - __pyx_v_item = ((void *)__pyx_v_array); - } - __pyx_L3:; - - /* "View.MemoryView":466 - * item = array - * - * try: # <<<<<<<<<<<<<< - * if self.dtype_is_object: - * ( item)[0] = value - */ - /*try:*/ { - - /* "View.MemoryView":467 - * - * try: - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * ( item)[0] = value - * else: - */ - __pyx_t_2 = (__pyx_v_self->dtype_is_object != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":468 - * try: - * if self.dtype_is_object: - * ( item)[0] = value # <<<<<<<<<<<<<< - * else: - * self.assign_item_from_object( item, value) - */ - (((PyObject **)__pyx_v_item)[0]) = ((PyObject *)__pyx_v_value); - - /* "View.MemoryView":467 - * - * try: - * if self.dtype_is_object: # <<<<<<<<<<<<<< - * ( item)[0] = value - * else: - */ - goto __pyx_L8; - } - - /* "View.MemoryView":470 - * ( item)[0] = value - * else: - * self.assign_item_from_object( item, value) # <<<<<<<<<<<<<< - * - * - */ - /*else*/ { - __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, ((char *)__pyx_v_item), __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 470, __pyx_L6_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } - __pyx_L8:; - - /* "View.MemoryView":474 - * - * - * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< - * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) - * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, - */ - __pyx_t_2 = ((__pyx_v_self->view.suboffsets != NULL) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":475 - * - * if self.view.suboffsets != NULL: - * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) # <<<<<<<<<<<<<< - * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, - * item, self.dtype_is_object) - */ - __pyx_t_3 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 475, __pyx_L6_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "View.MemoryView":474 - * - * - * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< - * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) - * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, - */ - } - - /* "View.MemoryView":476 - * if self.view.suboffsets != NULL: - * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) - * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, # <<<<<<<<<<<<<< - * item, self.dtype_is_object) - * finally: - */ - __pyx_memoryview_slice_assign_scalar(__pyx_v_dst_slice, __pyx_v_dst->view.ndim, __pyx_v_self->view.itemsize, __pyx_v_item, __pyx_v_self->dtype_is_object); - } - - /* "View.MemoryView":479 - * item, self.dtype_is_object) - * finally: - * PyMem_Free(tmp) # <<<<<<<<<<<<<< - * - * cdef setitem_indexed(self, index, value): - */ - /*finally:*/ { - /*normal exit:*/{ - PyMem_Free(__pyx_v_tmp); - goto __pyx_L7; - } - __pyx_L6_error:; - /*exception exit:*/{ - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); - if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); - __Pyx_XGOTREF(__pyx_t_7); - __Pyx_XGOTREF(__pyx_t_8); - __Pyx_XGOTREF(__pyx_t_9); - __Pyx_XGOTREF(__pyx_t_10); - __Pyx_XGOTREF(__pyx_t_11); - __Pyx_XGOTREF(__pyx_t_12); - __pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename; - { - PyMem_Free(__pyx_v_tmp); - } - if (PY_MAJOR_VERSION >= 3) { - __Pyx_XGIVEREF(__pyx_t_10); - __Pyx_XGIVEREF(__pyx_t_11); - __Pyx_XGIVEREF(__pyx_t_12); - __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); - } - __Pyx_XGIVEREF(__pyx_t_7); - __Pyx_XGIVEREF(__pyx_t_8); - __Pyx_XGIVEREF(__pyx_t_9); - __Pyx_ErrRestore(__pyx_t_7, __pyx_t_8, __pyx_t_9); - __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; - __pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_5; __pyx_filename = __pyx_t_6; - goto __pyx_L1_error; - } - __pyx_L7:; - } - - /* "View.MemoryView":449 - * src.ndim, dst.ndim, self.dtype_is_object) - * - * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< - * cdef int array[128] - * cdef void *tmp = NULL - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assign_scalar", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":481 - * PyMem_Free(tmp) - * - * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< - * cdef char *itemp = self.get_item_pointer(index) - * self.assign_item_from_object(itemp, value) - */ - -static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { - char *__pyx_v_itemp; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - char *__pyx_t_1; - PyObject *__pyx_t_2 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("setitem_indexed", 0); - - /* "View.MemoryView":482 - * - * 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, 482, __pyx_L1_error) - __pyx_v_itemp = __pyx_t_1; - - /* "View.MemoryView":483 - * 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, 483, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "View.MemoryView":481 - * PyMem_Free(tmp) - * - * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< - * cdef char *itemp = self.get_item_pointer(index) - * self.assign_item_from_object(itemp, value) - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_indexed", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":485 - * self.assign_item_from_object(itemp, value) - * - * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< - * """Only used if instantiated manually by the user, or if Cython doesn't - * know how to convert the type""" - */ - -static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp) { - PyObject *__pyx_v_struct = NULL; - PyObject *__pyx_v_bytesitem = 0; - PyObject *__pyx_v_result = NULL; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - int __pyx_t_8; - PyObject *__pyx_t_9 = NULL; - size_t __pyx_t_10; - int __pyx_t_11; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("convert_item_to_object", 0); - - /* "View.MemoryView":488 - * """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, 488, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_struct = __pyx_t_1; - __pyx_t_1 = 0; - - /* "View.MemoryView":491 - * 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, 491, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_bytesitem = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - - /* "View.MemoryView":492 - * - * bytesitem = itemp[:self.view.itemsize] - * try: # <<<<<<<<<<<<<< - * result = struct.unpack(self.view.format, bytesitem) - * except struct.error: - */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); - __Pyx_XGOTREF(__pyx_t_2); - __Pyx_XGOTREF(__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_4); - /*try:*/ { - - /* "View.MemoryView":493 - * 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, 493, __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, 493, __pyx_L3_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = NULL; - __pyx_t_8 = 0; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - __pyx_t_8 = 1; - } - } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_5)) { - PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 493, __pyx_L3_error) - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { - PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 493, __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, 493, __pyx_L3_error) - __Pyx_GOTREF(__pyx_t_9); - if (__pyx_t_7) { - __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; - } - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_6); - __Pyx_INCREF(__pyx_v_bytesitem); - __Pyx_GIVEREF(__pyx_v_bytesitem); - PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_bytesitem); - __pyx_t_6 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 493, __pyx_L3_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - } - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_result = __pyx_t_1; - __pyx_t_1 = 0; - - /* "View.MemoryView":492 - * - * bytesitem = itemp[:self.view.itemsize] - * try: # <<<<<<<<<<<<<< - * result = struct.unpack(self.view.format, bytesitem) - * except struct.error: - */ - } - - /* "View.MemoryView":497 - * raise ValueError("Unable to convert item to object") - * else: - * if len(self.view.format) == 1: # <<<<<<<<<<<<<< - * return result[0] - * return result - */ - /*else:*/ { - __pyx_t_10 = strlen(__pyx_v_self->view.format); - __pyx_t_11 = ((__pyx_t_10 == 1) != 0); - if (__pyx_t_11) { - - /* "View.MemoryView":498 - * else: - * if len(self.view.format) == 1: - * return result[0] # <<<<<<<<<<<<<< - * return result - * - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_result, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 498, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L6_except_return; - - /* "View.MemoryView":497 - * raise ValueError("Unable to convert item to object") - * else: - * if len(self.view.format) == 1: # <<<<<<<<<<<<<< - * return result[0] - * return result - */ - } - - /* "View.MemoryView":499 - * if len(self.view.format) == 1: - * return result[0] - * return result # <<<<<<<<<<<<<< - * - * cdef assign_item_from_object(self, char *itemp, object value): - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_result); - __pyx_r = __pyx_v_result; - goto __pyx_L6_except_return; - } - __pyx_L3_error:; - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - - /* "View.MemoryView":494 - * try: - * result = struct.unpack(self.view.format, bytesitem) - * except struct.error: # <<<<<<<<<<<<<< - * raise ValueError("Unable to convert item to object") - * else: - */ - __Pyx_ErrFetch(&__pyx_t_1, &__pyx_t_5, &__pyx_t_9); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 494, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_6); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_ErrRestore(__pyx_t_1, __pyx_t_5, __pyx_t_9); - __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_9 = 0; - if (__pyx_t_8) { - __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(1, 494, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_t_1); - - /* "View.MemoryView":495 - * result = struct.unpack(self.view.format, bytesitem) - * except struct.error: - * raise ValueError("Unable to convert item to object") # <<<<<<<<<<<<<< - * else: - * if len(self.view.format) == 1: - */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 495, __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, 495, __pyx_L5_except_error) - } - goto __pyx_L5_except_error; - __pyx_L5_except_error:; - - /* "View.MemoryView":492 - * - * bytesitem = itemp[:self.view.itemsize] - * try: # <<<<<<<<<<<<<< - * result = struct.unpack(self.view.format, bytesitem) - * except struct.error: - */ - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_XGIVEREF(__pyx_t_4); - __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); - goto __pyx_L1_error; - __pyx_L6_except_return:; - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_XGIVEREF(__pyx_t_4); - __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); - goto __pyx_L0; - } - - /* "View.MemoryView":485 - * self.assign_item_from_object(itemp, value) - * - * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< - * """Only used if instantiated manually by the user, or if Cython doesn't - * know how to convert the type""" - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_9); - __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_struct); - __Pyx_XDECREF(__pyx_v_bytesitem); - __Pyx_XDECREF(__pyx_v_result); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":501 - * return result - * - * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< - * """Only used if instantiated manually by the user, or if Cython doesn't - * know how to convert the type""" - */ - -static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) { - PyObject *__pyx_v_struct = NULL; - char __pyx_v_c; - PyObject *__pyx_v_bytesvalue = 0; - Py_ssize_t __pyx_v_i; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - int __pyx_t_3; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - int __pyx_t_7; - PyObject *__pyx_t_8 = NULL; - Py_ssize_t __pyx_t_9; - PyObject *__pyx_t_10 = NULL; - char *__pyx_t_11; - char *__pyx_t_12; - char *__pyx_t_13; - char *__pyx_t_14; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("assign_item_from_object", 0); - - /* "View.MemoryView":504 - * """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, 504, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_v_struct = __pyx_t_1; - __pyx_t_1 = 0; - - /* "View.MemoryView":509 - * cdef Py_ssize_t i - * - * if isinstance(value, tuple): # <<<<<<<<<<<<<< - * bytesvalue = struct.pack(self.view.format, *value) - * else: - */ - __pyx_t_2 = PyTuple_Check(__pyx_v_value); - __pyx_t_3 = (__pyx_t_2 != 0); - if (__pyx_t_3) { - - /* "View.MemoryView":510 - * - * 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, 510, __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, 510, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 510, __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, 510, __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, 510, __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, 510, __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, 510, __pyx_L1_error) - __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); - __pyx_t_4 = 0; - - /* "View.MemoryView":509 - * cdef Py_ssize_t i - * - * if isinstance(value, tuple): # <<<<<<<<<<<<<< - * bytesvalue = struct.pack(self.view.format, *value) - * else: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":512 - * bytesvalue = struct.pack(self.view.format, *value) - * else: - * bytesvalue = struct.pack(self.view.format, value) # <<<<<<<<<<<<<< - * - * for i, c in enumerate(bytesvalue): - */ - /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 512, __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, 512, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = NULL; - __pyx_t_7 = 0; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_6, function); - __pyx_t_7 = 1; - } - } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_6)) { - PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value}; - __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { - PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value}; - __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __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, 512, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - if (__pyx_t_5) { - __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; - } - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_1); - __Pyx_INCREF(__pyx_v_value); - __Pyx_GIVEREF(__pyx_v_value); - PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_value); - __pyx_t_1 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __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, 512, __pyx_L1_error) - __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); - __pyx_t_4 = 0; - } - __pyx_L3:; - - /* "View.MemoryView":514 - * bytesvalue = struct.pack(self.view.format, value) - * - * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< - * itemp[i] = c - * - */ - __pyx_t_9 = 0; - if (unlikely(__pyx_v_bytesvalue == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable"); - __PYX_ERR(1, 514, __pyx_L1_error) - } - __Pyx_INCREF(__pyx_v_bytesvalue); - __pyx_t_10 = __pyx_v_bytesvalue; - __pyx_t_12 = PyBytes_AS_STRING(__pyx_t_10); - __pyx_t_13 = (__pyx_t_12 + PyBytes_GET_SIZE(__pyx_t_10)); - for (__pyx_t_14 = __pyx_t_12; __pyx_t_14 < __pyx_t_13; __pyx_t_14++) { - __pyx_t_11 = __pyx_t_14; - __pyx_v_c = (__pyx_t_11[0]); - - /* "View.MemoryView":515 - * - * for i, c in enumerate(bytesvalue): - * itemp[i] = c # <<<<<<<<<<<<<< - * - * @cname('getbuffer') - */ - __pyx_v_i = __pyx_t_9; - - /* "View.MemoryView":514 - * bytesvalue = struct.pack(self.view.format, value) - * - * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< - * itemp[i] = c - * - */ - __pyx_t_9 = (__pyx_t_9 + 1); - - /* "View.MemoryView":515 - * - * for i, c in enumerate(bytesvalue): - * itemp[i] = c # <<<<<<<<<<<<<< - * - * @cname('getbuffer') - */ - (__pyx_v_itemp[__pyx_v_i]) = __pyx_v_c; - } - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - - /* "View.MemoryView":501 - * return result - * - * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< - * """Only used if instantiated manually by the user, or if Cython doesn't - * know how to convert the type""" - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_10); - __Pyx_AddTraceback("View.MemoryView.memoryview.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_struct); - __Pyx_XDECREF(__pyx_v_bytesvalue); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":518 - * - * @cname('getbuffer') - * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< - * if flags & PyBUF_WRITABLE and self.view.readonly: - * raise ValueError("Cannot create writable memory view from read-only memoryview") - */ - -/* Python wrapper */ -static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ -static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { - int __pyx_r; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - Py_ssize_t *__pyx_t_4; - char *__pyx_t_5; - void *__pyx_t_6; - int __pyx_t_7; - Py_ssize_t __pyx_t_8; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - if (__pyx_v_info == NULL) { - PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); - return -1; - } - __Pyx_RefNannySetupContext("__getbuffer__", 0); - __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(__pyx_v_info->obj); - - /* "View.MemoryView":519 - * @cname('getbuffer') - * def __getbuffer__(self, Py_buffer *info, int flags): - * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< - * raise ValueError("Cannot create writable memory view from read-only memoryview") - * - */ - __pyx_t_2 = ((__pyx_v_flags & PyBUF_WRITABLE) != 0); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_2 = (__pyx_v_self->view.readonly != 0); - __pyx_t_1 = __pyx_t_2; - __pyx_L4_bool_binop_done:; - if (unlikely(__pyx_t_1)) { - - /* "View.MemoryView":520 - * def __getbuffer__(self, Py_buffer *info, int flags): - * if flags & PyBUF_WRITABLE and self.view.readonly: - * raise ValueError("Cannot create writable memory view from read-only memoryview") # <<<<<<<<<<<<<< - * - * if flags & PyBUF_ND: - */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 520, __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, 520, __pyx_L1_error) - - /* "View.MemoryView":519 - * @cname('getbuffer') - * def __getbuffer__(self, Py_buffer *info, int flags): - * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< - * raise ValueError("Cannot create writable memory view from read-only memoryview") - * - */ - } - - /* "View.MemoryView":522 - * raise ValueError("Cannot create writable memory view from read-only memoryview") - * - * if flags & PyBUF_ND: # <<<<<<<<<<<<<< - * info.shape = self.view.shape - * else: - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":523 - * - * if flags & PyBUF_ND: - * info.shape = self.view.shape # <<<<<<<<<<<<<< - * else: - * info.shape = NULL - */ - __pyx_t_4 = __pyx_v_self->view.shape; - __pyx_v_info->shape = __pyx_t_4; - - /* "View.MemoryView":522 - * raise ValueError("Cannot create writable memory view from read-only memoryview") - * - * if flags & PyBUF_ND: # <<<<<<<<<<<<<< - * info.shape = self.view.shape - * else: - */ - goto __pyx_L6; - } - - /* "View.MemoryView":525 - * info.shape = self.view.shape - * else: - * info.shape = NULL # <<<<<<<<<<<<<< - * - * if flags & PyBUF_STRIDES: - */ - /*else*/ { - __pyx_v_info->shape = NULL; - } - __pyx_L6:; - - /* "View.MemoryView":527 - * info.shape = NULL - * - * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< - * info.strides = self.view.strides - * else: - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":528 - * - * if flags & PyBUF_STRIDES: - * info.strides = self.view.strides # <<<<<<<<<<<<<< - * else: - * info.strides = NULL - */ - __pyx_t_4 = __pyx_v_self->view.strides; - __pyx_v_info->strides = __pyx_t_4; - - /* "View.MemoryView":527 - * info.shape = NULL - * - * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< - * info.strides = self.view.strides - * else: - */ - goto __pyx_L7; - } - - /* "View.MemoryView":530 - * info.strides = self.view.strides - * else: - * info.strides = NULL # <<<<<<<<<<<<<< - * - * if flags & PyBUF_INDIRECT: - */ - /*else*/ { - __pyx_v_info->strides = NULL; - } - __pyx_L7:; - - /* "View.MemoryView":532 - * info.strides = NULL - * - * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< - * info.suboffsets = self.view.suboffsets - * else: - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_INDIRECT) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":533 - * - * if flags & PyBUF_INDIRECT: - * info.suboffsets = self.view.suboffsets # <<<<<<<<<<<<<< - * else: - * info.suboffsets = NULL - */ - __pyx_t_4 = __pyx_v_self->view.suboffsets; - __pyx_v_info->suboffsets = __pyx_t_4; - - /* "View.MemoryView":532 - * info.strides = NULL - * - * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< - * info.suboffsets = self.view.suboffsets - * else: - */ - goto __pyx_L8; - } - - /* "View.MemoryView":535 - * info.suboffsets = self.view.suboffsets - * else: - * info.suboffsets = NULL # <<<<<<<<<<<<<< - * - * if flags & PyBUF_FORMAT: - */ - /*else*/ { - __pyx_v_info->suboffsets = NULL; - } - __pyx_L8:; - - /* "View.MemoryView":537 - * info.suboffsets = NULL - * - * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< - * info.format = self.view.format - * else: - */ - __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":538 - * - * if flags & PyBUF_FORMAT: - * info.format = self.view.format # <<<<<<<<<<<<<< - * else: - * info.format = NULL - */ - __pyx_t_5 = __pyx_v_self->view.format; - __pyx_v_info->format = __pyx_t_5; - - /* "View.MemoryView":537 - * info.suboffsets = NULL - * - * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< - * info.format = self.view.format - * else: - */ - goto __pyx_L9; - } - - /* "View.MemoryView":540 - * info.format = self.view.format - * else: - * info.format = NULL # <<<<<<<<<<<<<< - * - * info.buf = self.view.buf - */ - /*else*/ { - __pyx_v_info->format = NULL; - } - __pyx_L9:; - - /* "View.MemoryView":542 - * info.format = NULL - * - * info.buf = self.view.buf # <<<<<<<<<<<<<< - * info.ndim = self.view.ndim - * info.itemsize = self.view.itemsize - */ - __pyx_t_6 = __pyx_v_self->view.buf; - __pyx_v_info->buf = __pyx_t_6; - - /* "View.MemoryView":543 - * - * info.buf = self.view.buf - * info.ndim = self.view.ndim # <<<<<<<<<<<<<< - * info.itemsize = self.view.itemsize - * info.len = self.view.len - */ - __pyx_t_7 = __pyx_v_self->view.ndim; - __pyx_v_info->ndim = __pyx_t_7; - - /* "View.MemoryView":544 - * info.buf = self.view.buf - * info.ndim = self.view.ndim - * info.itemsize = self.view.itemsize # <<<<<<<<<<<<<< - * info.len = self.view.len - * info.readonly = self.view.readonly - */ - __pyx_t_8 = __pyx_v_self->view.itemsize; - __pyx_v_info->itemsize = __pyx_t_8; - - /* "View.MemoryView":545 - * info.ndim = self.view.ndim - * info.itemsize = self.view.itemsize - * info.len = self.view.len # <<<<<<<<<<<<<< - * info.readonly = self.view.readonly - * info.obj = self - */ - __pyx_t_8 = __pyx_v_self->view.len; - __pyx_v_info->len = __pyx_t_8; - - /* "View.MemoryView":546 - * info.itemsize = self.view.itemsize - * info.len = self.view.len - * info.readonly = self.view.readonly # <<<<<<<<<<<<<< - * info.obj = self - * - */ - __pyx_t_1 = __pyx_v_self->view.readonly; - __pyx_v_info->readonly = __pyx_t_1; - - /* "View.MemoryView":547 - * info.len = self.view.len - * info.readonly = self.view.readonly - * info.obj = self # <<<<<<<<<<<<<< - * - * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") - */ - __Pyx_INCREF(((PyObject *)__pyx_v_self)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); - __pyx_v_info->obj = ((PyObject *)__pyx_v_self); - - /* "View.MemoryView":518 - * - * @cname('getbuffer') - * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< - * if flags & PyBUF_WRITABLE and self.view.readonly: - * raise ValueError("Cannot create writable memory view from read-only memoryview") - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.memoryview.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - if (__pyx_v_info->obj != NULL) { - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; - } - goto __pyx_L2; - __pyx_L0:; - if (__pyx_v_info->obj == Py_None) { - __Pyx_GOTREF(__pyx_v_info->obj); - __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; - } - __pyx_L2:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":553 - * - * @property - * def T(self): # <<<<<<<<<<<<<< - * cdef _memoryviewslice result = memoryview_copy(self) - * transpose_memslice(&result.from_slice) - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - struct __pyx_memoryviewslice_obj *__pyx_v_result = 0; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); - - /* "View.MemoryView":554 - * @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, 554, __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, 554, __pyx_L1_error) - __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_1); - __pyx_t_1 = 0; - - /* "View.MemoryView":555 - * 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, 555, __pyx_L1_error) - - /* "View.MemoryView":556 - * cdef _memoryviewslice result = memoryview_copy(self) - * transpose_memslice(&result.from_slice) - * return result # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_result)); - __pyx_r = ((PyObject *)__pyx_v_result); - goto __pyx_L0; - - /* "View.MemoryView":553 - * - * @property - * def T(self): # <<<<<<<<<<<<<< - * cdef _memoryviewslice result = memoryview_copy(self) - * transpose_memslice(&result.from_slice) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.memoryview.T.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_result); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":559 - * - * @property - * def base(self): # <<<<<<<<<<<<<< - * return self.obj - * - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - - /* "View.MemoryView":560 - * @property - * def base(self): - * return self.obj # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->obj); - __pyx_r = __pyx_v_self->obj; - goto __pyx_L0; - - /* "View.MemoryView":559 - * - * @property - * def base(self): # <<<<<<<<<<<<<< - * return self.obj - * - */ - - /* function exit code */ - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":563 - * - * @property - * def shape(self): # <<<<<<<<<<<<<< - * return tuple([length for length in self.view.shape[:self.view.ndim]]) - * - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - Py_ssize_t __pyx_v_length; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - Py_ssize_t *__pyx_t_2; - Py_ssize_t *__pyx_t_3; - Py_ssize_t *__pyx_t_4; - PyObject *__pyx_t_5 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); - - /* "View.MemoryView":564 - * @property - * def shape(self): - * return tuple([length for length in self.view.shape[:self.view.ndim]]) # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 564, __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, 564, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(1, 564, __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, 564, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; - goto __pyx_L0; - - /* "View.MemoryView":563 - * - * @property - * def shape(self): # <<<<<<<<<<<<<< - * return tuple([length for length in self.view.shape[:self.view.ndim]]) - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("View.MemoryView.memoryview.shape.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":567 - * - * @property - * def strides(self): # <<<<<<<<<<<<<< - * if self.view.strides == NULL: - * - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - Py_ssize_t __pyx_v_stride; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - Py_ssize_t *__pyx_t_3; - Py_ssize_t *__pyx_t_4; - Py_ssize_t *__pyx_t_5; - PyObject *__pyx_t_6 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); - - /* "View.MemoryView":568 - * @property - * def strides(self): - * if self.view.strides == NULL: # <<<<<<<<<<<<<< - * - * raise ValueError("Buffer view does not expose strides") - */ - __pyx_t_1 = ((__pyx_v_self->view.strides == NULL) != 0); - if (unlikely(__pyx_t_1)) { - - /* "View.MemoryView":570 - * if self.view.strides == NULL: - * - * raise ValueError("Buffer view does not expose strides") # <<<<<<<<<<<<<< - * - * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) - */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 570, __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, 570, __pyx_L1_error) - - /* "View.MemoryView":568 - * @property - * def strides(self): - * if self.view.strides == NULL: # <<<<<<<<<<<<<< - * - * raise ValueError("Buffer view does not expose strides") - */ - } - - /* "View.MemoryView":572 - * raise ValueError("Buffer view does not expose strides") - * - * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 572, __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, 572, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 572, __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, 572, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_r = __pyx_t_6; - __pyx_t_6 = 0; - goto __pyx_L0; - - /* "View.MemoryView":567 - * - * @property - * def strides(self): # <<<<<<<<<<<<<< - * if self.view.strides == NULL: - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_AddTraceback("View.MemoryView.memoryview.strides.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":575 - * - * @property - * def suboffsets(self): # <<<<<<<<<<<<<< - * if self.view.suboffsets == NULL: - * return (-1,) * self.view.ndim - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - Py_ssize_t __pyx_v_suboffset; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - Py_ssize_t *__pyx_t_4; - Py_ssize_t *__pyx_t_5; - Py_ssize_t *__pyx_t_6; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); - - /* "View.MemoryView":576 - * @property - * def suboffsets(self): - * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< - * return (-1,) * self.view.ndim - * - */ - __pyx_t_1 = ((__pyx_v_self->view.suboffsets == NULL) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":577 - * def suboffsets(self): - * if self.view.suboffsets == NULL: - * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< - * - * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 577, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyNumber_Multiply(__pyx_tuple__13, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 577, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L0; - - /* "View.MemoryView":576 - * @property - * def suboffsets(self): - * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< - * return (-1,) * self.view.ndim - * - */ - } - - /* "View.MemoryView":579 - * return (-1,) * self.view.ndim - * - * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 579, __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, 579, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_2))) __PYX_ERR(1, 579, __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, 579, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":575 - * - * @property - * def suboffsets(self): # <<<<<<<<<<<<<< - * if self.view.suboffsets == NULL: - * return (-1,) * self.view.ndim - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.memoryview.suboffsets.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":582 - * - * @property - * def ndim(self): # <<<<<<<<<<<<<< - * return self.view.ndim - * - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); - - /* "View.MemoryView":583 - * @property - * def ndim(self): - * return self.view.ndim # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 583, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "View.MemoryView":582 - * - * @property - * def ndim(self): # <<<<<<<<<<<<<< - * return self.view.ndim - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.memoryview.ndim.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":586 - * - * @property - * def itemsize(self): # <<<<<<<<<<<<<< - * return self.view.itemsize - * - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); - - /* "View.MemoryView":587 - * @property - * def itemsize(self): - * return self.view.itemsize # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 587, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "View.MemoryView":586 - * - * @property - * def itemsize(self): # <<<<<<<<<<<<<< - * return self.view.itemsize - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.memoryview.itemsize.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":590 - * - * @property - * def nbytes(self): # <<<<<<<<<<<<<< - * return self.size * self.view.itemsize - * - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); - - /* "View.MemoryView":591 - * @property - * def nbytes(self): - * return self.size * self.view.itemsize # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 591, __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, 591, __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, 591, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L0; - - /* "View.MemoryView":590 - * - * @property - * def nbytes(self): # <<<<<<<<<<<<<< - * return self.size * self.view.itemsize - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.memoryview.nbytes.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":594 - * - * @property - * def size(self): # <<<<<<<<<<<<<< - * if self._size is None: - * result = 1 - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_v_result = NULL; - PyObject *__pyx_v_length = NULL; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - Py_ssize_t *__pyx_t_3; - Py_ssize_t *__pyx_t_4; - Py_ssize_t *__pyx_t_5; - PyObject *__pyx_t_6 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); - - /* "View.MemoryView":595 - * @property - * def size(self): - * if self._size is None: # <<<<<<<<<<<<<< - * result = 1 - * - */ - __pyx_t_1 = (__pyx_v_self->_size == Py_None); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":596 - * def size(self): - * if self._size is None: - * result = 1 # <<<<<<<<<<<<<< - * - * for length in self.view.shape[:self.view.ndim]: - */ - __Pyx_INCREF(__pyx_int_1); - __pyx_v_result = __pyx_int_1; - - /* "View.MemoryView":598 - * result = 1 - * - * for length in self.view.shape[:self.view.ndim]: # <<<<<<<<<<<<<< - * result *= length - * - */ - __pyx_t_4 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); - for (__pyx_t_5 = __pyx_v_self->view.shape; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { - __pyx_t_3 = __pyx_t_5; - __pyx_t_6 = PyInt_FromSsize_t((__pyx_t_3[0])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 598, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_6); - __pyx_t_6 = 0; - - /* "View.MemoryView":599 - * - * 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, 599, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_6); - __pyx_t_6 = 0; - } - - /* "View.MemoryView":601 - * result *= length - * - * self._size = result # <<<<<<<<<<<<<< - * - * return self._size - */ - __Pyx_INCREF(__pyx_v_result); - __Pyx_GIVEREF(__pyx_v_result); - __Pyx_GOTREF(__pyx_v_self->_size); - __Pyx_DECREF(__pyx_v_self->_size); - __pyx_v_self->_size = __pyx_v_result; - - /* "View.MemoryView":595 - * @property - * def size(self): - * if self._size is None: # <<<<<<<<<<<<<< - * result = 1 - * - */ - } - - /* "View.MemoryView":603 - * self._size = result - * - * return self._size # <<<<<<<<<<<<<< - * - * def __len__(self): - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->_size); - __pyx_r = __pyx_v_self->_size; - goto __pyx_L0; - - /* "View.MemoryView":594 - * - * @property - * def size(self): # <<<<<<<<<<<<<< - * if self._size is None: - * result = 1 - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_6); - __Pyx_AddTraceback("View.MemoryView.memoryview.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_result); - __Pyx_XDECREF(__pyx_v_length); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":605 - * return self._size - * - * def __len__(self): # <<<<<<<<<<<<<< - * if self.view.ndim >= 1: - * return self.view.shape[0] - */ - -/* Python wrapper */ -static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self); /*proto*/ -static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self) { - Py_ssize_t __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self) { - Py_ssize_t __pyx_r; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - __Pyx_RefNannySetupContext("__len__", 0); - - /* "View.MemoryView":606 - * - * def __len__(self): - * if self.view.ndim >= 1: # <<<<<<<<<<<<<< - * return self.view.shape[0] - * - */ - __pyx_t_1 = ((__pyx_v_self->view.ndim >= 1) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":607 - * def __len__(self): - * if self.view.ndim >= 1: - * return self.view.shape[0] # <<<<<<<<<<<<<< - * - * return 0 - */ - __pyx_r = (__pyx_v_self->view.shape[0]); - goto __pyx_L0; - - /* "View.MemoryView":606 - * - * def __len__(self): - * if self.view.ndim >= 1: # <<<<<<<<<<<<<< - * return self.view.shape[0] - * - */ - } - - /* "View.MemoryView":609 - * return self.view.shape[0] - * - * return 0 # <<<<<<<<<<<<<< - * - * def __repr__(self): - */ - __pyx_r = 0; - goto __pyx_L0; - - /* "View.MemoryView":605 - * return self._size - * - * def __len__(self): # <<<<<<<<<<<<<< - * if self.view.ndim >= 1: - * return self.view.shape[0] - */ - - /* function exit code */ - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":611 - * return 0 - * - * def __repr__(self): # <<<<<<<<<<<<<< - * return "" % (self.base.__class__.__name__, - * id(self)) - */ - -/* Python wrapper */ -static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__repr__", 0); - - /* "View.MemoryView":612 - * - * def __repr__(self): - * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< - * id(self)) - * - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 612, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 612, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 612, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "View.MemoryView":613 - * 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, 613, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - - /* "View.MemoryView":612 - * - * def __repr__(self): - * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< - * id(self)) - * - */ - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 612, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); - __pyx_t_1 = 0; - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 612, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":611 - * return 0 - * - * def __repr__(self): # <<<<<<<<<<<<<< - * return "" % (self.base.__class__.__name__, - * id(self)) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.memoryview.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":615 - * id(self)) - * - * def __str__(self): # <<<<<<<<<<<<<< - * return "" % (self.base.__class__.__name__,) - * - */ - -/* Python wrapper */ -static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__str__", 0); - - /* "View.MemoryView":616 - * - * def __str__(self): - * return "" % (self.base.__class__.__name__,) # <<<<<<<<<<<<<< - * - * - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 616, __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, 616, __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, 616, __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, 616, __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, 616, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "View.MemoryView":615 - * id(self)) - * - * def __str__(self): # <<<<<<<<<<<<<< - * return "" % (self.base.__class__.__name__,) - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.memoryview.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":619 - * - * - * def is_c_contig(self): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice *mslice - * cdef __Pyx_memviewslice tmp - */ - -/* Python wrapper */ -static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("is_c_contig (wrapper)", 0); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self) { - __Pyx_memviewslice *__pyx_v_mslice; - __Pyx_memviewslice __pyx_v_tmp; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_memviewslice *__pyx_t_1; - PyObject *__pyx_t_2 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("is_c_contig", 0); - - /* "View.MemoryView":622 - * cdef __Pyx_memviewslice *mslice - * cdef __Pyx_memviewslice tmp - * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<< - * return slice_is_contig(mslice[0], 'C', self.view.ndim) - * - */ - __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 622, __pyx_L1_error) - __pyx_v_mslice = __pyx_t_1; - - /* "View.MemoryView":623 - * cdef __Pyx_memviewslice tmp - * mslice = get_slice_from_memview(self, &tmp) - * return slice_is_contig(mslice[0], 'C', self.view.ndim) # <<<<<<<<<<<<<< - * - * def is_f_contig(self): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'C', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 623, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":619 - * - * - * def is_c_contig(self): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice *mslice - * cdef __Pyx_memviewslice tmp - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.memoryview.is_c_contig", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":625 - * return slice_is_contig(mslice[0], 'C', self.view.ndim) - * - * def is_f_contig(self): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice *mslice - * cdef __Pyx_memviewslice tmp - */ - -/* Python wrapper */ -static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("is_f_contig (wrapper)", 0); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self) { - __Pyx_memviewslice *__pyx_v_mslice; - __Pyx_memviewslice __pyx_v_tmp; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_memviewslice *__pyx_t_1; - PyObject *__pyx_t_2 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("is_f_contig", 0); - - /* "View.MemoryView":628 - * cdef __Pyx_memviewslice *mslice - * cdef __Pyx_memviewslice tmp - * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<< - * return slice_is_contig(mslice[0], 'F', self.view.ndim) - * - */ - __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 628, __pyx_L1_error) - __pyx_v_mslice = __pyx_t_1; - - /* "View.MemoryView":629 - * cdef __Pyx_memviewslice tmp - * mslice = get_slice_from_memview(self, &tmp) - * return slice_is_contig(mslice[0], 'F', self.view.ndim) # <<<<<<<<<<<<<< - * - * def copy(self): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'F', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 629, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":625 - * return slice_is_contig(mslice[0], 'C', self.view.ndim) - * - * def is_f_contig(self): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice *mslice - * cdef __Pyx_memviewslice tmp - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.memoryview.is_f_contig", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":631 - * return slice_is_contig(mslice[0], 'F', self.view.ndim) - * - * def copy(self): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice mslice - * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS - */ - -/* Python wrapper */ -static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("copy (wrapper)", 0); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self) { - __Pyx_memviewslice __pyx_v_mslice; - int __pyx_v_flags; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_memviewslice __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("copy", 0); - - /* "View.MemoryView":633 - * def copy(self): - * cdef __Pyx_memviewslice mslice - * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS # <<<<<<<<<<<<<< - * - * slice_copy(self, &mslice) - */ - __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_F_CONTIGUOUS)); - - /* "View.MemoryView":635 - * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS - * - * slice_copy(self, &mslice) # <<<<<<<<<<<<<< - * mslice = slice_copy_contig(&mslice, "c", self.view.ndim, - * self.view.itemsize, - */ - __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_mslice)); - - /* "View.MemoryView":636 - * - * 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, 636, __pyx_L1_error) - __pyx_v_mslice = __pyx_t_1; - - /* "View.MemoryView":641 - * self.dtype_is_object) - * - * return memoryview_copy_from_slice(self, &mslice) # <<<<<<<<<<<<<< - * - * def copy_fortran(self): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_mslice)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 641, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":631 - * return slice_is_contig(mslice[0], 'F', self.view.ndim) - * - * def copy(self): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice mslice - * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.memoryview.copy", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":643 - * return memoryview_copy_from_slice(self, &mslice) - * - * def copy_fortran(self): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice src, dst - * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS - */ - -/* Python wrapper */ -static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("copy_fortran (wrapper)", 0); - __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self) { - __Pyx_memviewslice __pyx_v_src; - __Pyx_memviewslice __pyx_v_dst; - int __pyx_v_flags; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_memviewslice __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("copy_fortran", 0); - - /* "View.MemoryView":645 - * def copy_fortran(self): - * cdef __Pyx_memviewslice src, dst - * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS # <<<<<<<<<<<<<< - * - * slice_copy(self, &src) - */ - __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_C_CONTIGUOUS)); - - /* "View.MemoryView":647 - * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS - * - * slice_copy(self, &src) # <<<<<<<<<<<<<< - * dst = slice_copy_contig(&src, "fortran", self.view.ndim, - * self.view.itemsize, - */ - __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_src)); - - /* "View.MemoryView":648 - * - * 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, 648, __pyx_L1_error) - __pyx_v_dst = __pyx_t_1; - - /* "View.MemoryView":653 - * self.dtype_is_object) - * - * return memoryview_copy_from_slice(self, &dst) # <<<<<<<<<<<<<< - * - * - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_dst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 653, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":643 - * return memoryview_copy_from_slice(self, &mslice) - * - * def copy_fortran(self): # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice src, dst - * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView.memoryview.copy_fortran", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): - */ - -/* Python wrapper */ -static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf___pyx_memoryview___reduce_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__reduce_cython__", 0); - - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(1, 2, __pyx_L1_error) - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.memoryview.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - */ - -/* Python wrapper */ -static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf___pyx_memoryview_2__setstate_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setstate_cython__", 0); - - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< - */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(1, 4, __pyx_L1_error) - - /* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.memoryview.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":657 - * - * @cname('__pyx_memoryview_new') - * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<< - * cdef memoryview result = memoryview(o, flags, dtype_is_object) - * result.typeinfo = typeinfo - */ - -static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, int __pyx_v_dtype_is_object, __Pyx_TypeInfo *__pyx_v_typeinfo) { - struct __pyx_memoryview_obj *__pyx_v_result = 0; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("memoryview_cwrapper", 0); - - /* "View.MemoryView":658 - * @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, 658, __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, 658, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 658, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_v_o); - __Pyx_GIVEREF(__pyx_v_o); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_o); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); - __pyx_t_1 = 0; - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 658, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_result = ((struct __pyx_memoryview_obj *)__pyx_t_2); - __pyx_t_2 = 0; - - /* "View.MemoryView":659 - * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): - * cdef memoryview result = memoryview(o, flags, dtype_is_object) - * result.typeinfo = typeinfo # <<<<<<<<<<<<<< - * return result - * - */ - __pyx_v_result->typeinfo = __pyx_v_typeinfo; - - /* "View.MemoryView":660 - * cdef memoryview result = memoryview(o, flags, dtype_is_object) - * result.typeinfo = typeinfo - * return result # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_check') - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_result)); - __pyx_r = ((PyObject *)__pyx_v_result); - goto __pyx_L0; - - /* "View.MemoryView":657 - * - * @cname('__pyx_memoryview_new') - * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<< - * cdef memoryview result = memoryview(o, flags, dtype_is_object) - * result.typeinfo = typeinfo - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.memoryview_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_result); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":663 - * - * @cname('__pyx_memoryview_check') - * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< - * return isinstance(o, memoryview) - * - */ - -static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) { - int __pyx_r; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - __Pyx_RefNannySetupContext("memoryview_check", 0); - - /* "View.MemoryView":664 - * @cname('__pyx_memoryview_check') - * cdef inline bint memoryview_check(object o): - * return isinstance(o, memoryview) # <<<<<<<<<<<<<< - * - * cdef tuple _unellipsify(object index, int ndim): - */ - __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_o, __pyx_memoryview_type); - __pyx_r = __pyx_t_1; - goto __pyx_L0; - - /* "View.MemoryView":663 - * - * @cname('__pyx_memoryview_check') - * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< - * return isinstance(o, memoryview) - * - */ - - /* function exit code */ - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":666 - * return isinstance(o, memoryview) - * - * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< - * """ - * Replace all ellipses with full slices and fill incomplete indices with - */ - -static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { - PyObject *__pyx_v_tup = NULL; - PyObject *__pyx_v_result = NULL; - int __pyx_v_have_slices; - int __pyx_v_seen_ellipsis; - CYTHON_UNUSED PyObject *__pyx_v_idx = NULL; - PyObject *__pyx_v_item = NULL; - Py_ssize_t __pyx_v_nslices; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - Py_ssize_t __pyx_t_5; - PyObject *(*__pyx_t_6)(PyObject *); - PyObject *__pyx_t_7 = NULL; - Py_ssize_t __pyx_t_8; - int __pyx_t_9; - int __pyx_t_10; - PyObject *__pyx_t_11 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_unellipsify", 0); - - /* "View.MemoryView":671 - * full slices. - * """ - * if not isinstance(index, tuple): # <<<<<<<<<<<<<< - * tup = (index,) - * else: - */ - __pyx_t_1 = PyTuple_Check(__pyx_v_index); - __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":672 - * """ - * if not isinstance(index, tuple): - * tup = (index,) # <<<<<<<<<<<<<< - * else: - * tup = index - */ - __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 672, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_v_index); - __Pyx_GIVEREF(__pyx_v_index); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_index); - __pyx_v_tup = __pyx_t_3; - __pyx_t_3 = 0; - - /* "View.MemoryView":671 - * full slices. - * """ - * if not isinstance(index, tuple): # <<<<<<<<<<<<<< - * tup = (index,) - * else: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":674 - * tup = (index,) - * else: - * tup = index # <<<<<<<<<<<<<< - * - * result = [] - */ - /*else*/ { - __Pyx_INCREF(__pyx_v_index); - __pyx_v_tup = __pyx_v_index; - } - __pyx_L3:; - - /* "View.MemoryView":676 - * tup = index - * - * result = [] # <<<<<<<<<<<<<< - * have_slices = False - * seen_ellipsis = False - */ - __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 676, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_v_result = ((PyObject*)__pyx_t_3); - __pyx_t_3 = 0; - - /* "View.MemoryView":677 - * - * result = [] - * have_slices = False # <<<<<<<<<<<<<< - * seen_ellipsis = False - * for idx, item in enumerate(tup): - */ - __pyx_v_have_slices = 0; - - /* "View.MemoryView":678 - * result = [] - * have_slices = False - * seen_ellipsis = False # <<<<<<<<<<<<<< - * for idx, item in enumerate(tup): - * if item is Ellipsis: - */ - __pyx_v_seen_ellipsis = 0; - - /* "View.MemoryView":679 - * have_slices = False - * seen_ellipsis = False - * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< - * if item is Ellipsis: - * if not seen_ellipsis: - */ - __Pyx_INCREF(__pyx_int_0); - __pyx_t_3 = __pyx_int_0; - if (likely(PyList_CheckExact(__pyx_v_tup)) || PyTuple_CheckExact(__pyx_v_tup)) { - __pyx_t_4 = __pyx_v_tup; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0; - __pyx_t_6 = NULL; - } else { - __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_v_tup); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 679, __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, 679, __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, 679, __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, 679, __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, 679, __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, 679, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - #endif - } - } else { - __pyx_t_7 = __pyx_t_6(__pyx_t_4); - if (unlikely(!__pyx_t_7)) { - PyObject* exc_type = PyErr_Occurred(); - if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 679, __pyx_L1_error) - } - break; - } - __Pyx_GOTREF(__pyx_t_7); - } - __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_7); - __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_t_3); - __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_3); - __pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 679, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); - __pyx_t_3 = __pyx_t_7; - __pyx_t_7 = 0; - - /* "View.MemoryView":680 - * seen_ellipsis = False - * for idx, item in enumerate(tup): - * if item is Ellipsis: # <<<<<<<<<<<<<< - * if not seen_ellipsis: - * result.extend([slice(None)] * (ndim - len(tup) + 1)) - */ - __pyx_t_2 = (__pyx_v_item == __pyx_builtin_Ellipsis); - __pyx_t_1 = (__pyx_t_2 != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":681 - * for idx, item in enumerate(tup): - * if item is Ellipsis: - * if not seen_ellipsis: # <<<<<<<<<<<<<< - * result.extend([slice(None)] * (ndim - len(tup) + 1)) - * seen_ellipsis = True - */ - __pyx_t_1 = ((!(__pyx_v_seen_ellipsis != 0)) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":682 - * 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, 682, __pyx_L1_error) - __pyx_t_7 = PyList_New(1 * ((((__pyx_v_ndim - __pyx_t_8) + 1)<0) ? 0:((__pyx_v_ndim - __pyx_t_8) + 1))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 682, __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_); - __Pyx_GIVEREF(__pyx_slice_); - PyList_SET_ITEM(__pyx_t_7, __pyx_temp, __pyx_slice_); - } - } - __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_7); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 682, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "View.MemoryView":683 - * if not seen_ellipsis: - * result.extend([slice(None)] * (ndim - len(tup) + 1)) - * seen_ellipsis = True # <<<<<<<<<<<<<< - * else: - * result.append(slice(None)) - */ - __pyx_v_seen_ellipsis = 1; - - /* "View.MemoryView":681 - * for idx, item in enumerate(tup): - * if item is Ellipsis: - * if not seen_ellipsis: # <<<<<<<<<<<<<< - * result.extend([slice(None)] * (ndim - len(tup) + 1)) - * seen_ellipsis = True - */ - goto __pyx_L7; - } - - /* "View.MemoryView":685 - * seen_ellipsis = True - * else: - * result.append(slice(None)) # <<<<<<<<<<<<<< - * have_slices = True - * else: - */ - /*else*/ { - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_slice_); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 685, __pyx_L1_error) - } - __pyx_L7:; - - /* "View.MemoryView":686 - * else: - * result.append(slice(None)) - * have_slices = True # <<<<<<<<<<<<<< - * else: - * if not isinstance(item, slice) and not PyIndex_Check(item): - */ - __pyx_v_have_slices = 1; - - /* "View.MemoryView":680 - * seen_ellipsis = False - * for idx, item in enumerate(tup): - * if item is Ellipsis: # <<<<<<<<<<<<<< - * if not seen_ellipsis: - * result.extend([slice(None)] * (ndim - len(tup) + 1)) - */ - goto __pyx_L6; - } - - /* "View.MemoryView":688 - * have_slices = True - * else: - * if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<< - * raise TypeError("Cannot index with type '%s'" % type(item)) - * - */ - /*else*/ { - __pyx_t_2 = PySlice_Check(__pyx_v_item); - __pyx_t_10 = ((!(__pyx_t_2 != 0)) != 0); - if (__pyx_t_10) { - } else { - __pyx_t_1 = __pyx_t_10; - goto __pyx_L9_bool_binop_done; - } - __pyx_t_10 = ((!(PyIndex_Check(__pyx_v_item) != 0)) != 0); - __pyx_t_1 = __pyx_t_10; - __pyx_L9_bool_binop_done:; - if (unlikely(__pyx_t_1)) { - - /* "View.MemoryView":689 - * 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, 689, __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, 689, __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, 689, __pyx_L1_error) - - /* "View.MemoryView":688 - * have_slices = True - * else: - * if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<< - * raise TypeError("Cannot index with type '%s'" % type(item)) - * - */ - } - - /* "View.MemoryView":691 - * raise TypeError("Cannot index with type '%s'" % type(item)) - * - * have_slices = have_slices or isinstance(item, slice) # <<<<<<<<<<<<<< - * result.append(item) - * - */ - __pyx_t_10 = (__pyx_v_have_slices != 0); - if (!__pyx_t_10) { - } else { - __pyx_t_1 = __pyx_t_10; - goto __pyx_L11_bool_binop_done; - } - __pyx_t_10 = PySlice_Check(__pyx_v_item); - __pyx_t_2 = (__pyx_t_10 != 0); - __pyx_t_1 = __pyx_t_2; - __pyx_L11_bool_binop_done:; - __pyx_v_have_slices = __pyx_t_1; - - /* "View.MemoryView":692 - * - * 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, 692, __pyx_L1_error) - } - __pyx_L6:; - - /* "View.MemoryView":679 - * have_slices = False - * seen_ellipsis = False - * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< - * if item is Ellipsis: - * if not seen_ellipsis: - */ - } - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "View.MemoryView":694 - * 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, 694, __pyx_L1_error) - __pyx_v_nslices = (__pyx_v_ndim - __pyx_t_5); - - /* "View.MemoryView":695 - * - * nslices = ndim - len(result) - * if nslices: # <<<<<<<<<<<<<< - * result.extend([slice(None)] * nslices) - * - */ - __pyx_t_1 = (__pyx_v_nslices != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":696 - * 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, 696, __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_); - __Pyx_GIVEREF(__pyx_slice_); - PyList_SET_ITEM(__pyx_t_3, __pyx_temp, __pyx_slice_); - } - } - __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 696, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "View.MemoryView":695 - * - * nslices = ndim - len(result) - * if nslices: # <<<<<<<<<<<<<< - * result.extend([slice(None)] * nslices) - * - */ - } - - /* "View.MemoryView":698 - * result.extend([slice(None)] * nslices) - * - * return have_slices or nslices, tuple(result) # <<<<<<<<<<<<<< - * - * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): - */ - __Pyx_XDECREF(__pyx_r); - if (!__pyx_v_have_slices) { - } else { - __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_have_slices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 698, __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, 698, __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, 698, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 698, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_11); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_3); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_4); - __pyx_t_3 = 0; - __pyx_t_4 = 0; - __pyx_r = ((PyObject*)__pyx_t_11); - __pyx_t_11 = 0; - goto __pyx_L0; - - /* "View.MemoryView":666 - * return isinstance(o, memoryview) - * - * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< - * """ - * Replace all ellipses with full slices and fill incomplete indices with - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_11); - __Pyx_AddTraceback("View.MemoryView._unellipsify", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_tup); - __Pyx_XDECREF(__pyx_v_result); - __Pyx_XDECREF(__pyx_v_idx); - __Pyx_XDECREF(__pyx_v_item); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":700 - * return have_slices or nslices, tuple(result) - * - * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< - * for suboffset in suboffsets[:ndim]: - * if suboffset >= 0: - */ - -static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __pyx_v_ndim) { - Py_ssize_t __pyx_v_suboffset; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - Py_ssize_t *__pyx_t_1; - Py_ssize_t *__pyx_t_2; - Py_ssize_t *__pyx_t_3; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("assert_direct_dimensions", 0); - - /* "View.MemoryView":701 - * - * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): - * for suboffset in suboffsets[:ndim]: # <<<<<<<<<<<<<< - * if suboffset >= 0: - * raise ValueError("Indirect dimensions not supported") - */ - __pyx_t_2 = (__pyx_v_suboffsets + __pyx_v_ndim); - for (__pyx_t_3 = __pyx_v_suboffsets; __pyx_t_3 < __pyx_t_2; __pyx_t_3++) { - __pyx_t_1 = __pyx_t_3; - __pyx_v_suboffset = (__pyx_t_1[0]); - - /* "View.MemoryView":702 - * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): - * for suboffset in suboffsets[:ndim]: - * if suboffset >= 0: # <<<<<<<<<<<<<< - * raise ValueError("Indirect dimensions not supported") - * - */ - __pyx_t_4 = ((__pyx_v_suboffset >= 0) != 0); - if (unlikely(__pyx_t_4)) { - - /* "View.MemoryView":703 - * 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, 703, __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, 703, __pyx_L1_error) - - /* "View.MemoryView":702 - * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): - * for suboffset in suboffsets[:ndim]: - * if suboffset >= 0: # <<<<<<<<<<<<<< - * raise ValueError("Indirect dimensions not supported") - * - */ - } - } - - /* "View.MemoryView":700 - * return have_slices or nslices, tuple(result) - * - * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< - * for suboffset in suboffsets[:ndim]: - * if suboffset >= 0: - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("View.MemoryView.assert_direct_dimensions", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":710 - * - * @cname('__pyx_memview_slice') - * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< - * cdef int new_ndim = 0, suboffset_dim = -1, dim - * cdef bint negative_step - */ - -static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *__pyx_v_memview, PyObject *__pyx_v_indices) { - int __pyx_v_new_ndim; - int __pyx_v_suboffset_dim; - int __pyx_v_dim; - __Pyx_memviewslice __pyx_v_src; - __Pyx_memviewslice __pyx_v_dst; - __Pyx_memviewslice *__pyx_v_p_src; - struct __pyx_memoryviewslice_obj *__pyx_v_memviewsliceobj = 0; - __Pyx_memviewslice *__pyx_v_p_dst; - int *__pyx_v_p_suboffset_dim; - Py_ssize_t __pyx_v_start; - Py_ssize_t __pyx_v_stop; - Py_ssize_t __pyx_v_step; - int __pyx_v_have_start; - int __pyx_v_have_stop; - int __pyx_v_have_step; - PyObject *__pyx_v_index = NULL; - struct __pyx_memoryview_obj *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - struct __pyx_memoryview_obj *__pyx_t_4; - char *__pyx_t_5; - int __pyx_t_6; - Py_ssize_t __pyx_t_7; - PyObject *(*__pyx_t_8)(PyObject *); - PyObject *__pyx_t_9 = NULL; - Py_ssize_t __pyx_t_10; - int __pyx_t_11; - Py_ssize_t __pyx_t_12; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("memview_slice", 0); - - /* "View.MemoryView":711 - * @cname('__pyx_memview_slice') - * cdef memoryview memview_slice(memoryview memview, object indices): - * cdef int new_ndim = 0, suboffset_dim = -1, dim # <<<<<<<<<<<<<< - * cdef bint negative_step - * cdef __Pyx_memviewslice src, dst - */ - __pyx_v_new_ndim = 0; - __pyx_v_suboffset_dim = -1; - - /* "View.MemoryView":718 - * - * - * memset(&dst, 0, sizeof(dst)) # <<<<<<<<<<<<<< - * - * cdef _memoryviewslice memviewsliceobj - */ - (void)(memset((&__pyx_v_dst), 0, (sizeof(__pyx_v_dst)))); - - /* "View.MemoryView":722 - * cdef _memoryviewslice memviewsliceobj - * - * assert memview.view.ndim > 0 # <<<<<<<<<<<<<< - * - * if isinstance(memview, _memoryviewslice): - */ - #ifndef CYTHON_WITHOUT_ASSERTIONS - if (unlikely(!Py_OptimizeFlag)) { - if (unlikely(!((__pyx_v_memview->view.ndim > 0) != 0))) { - PyErr_SetNone(PyExc_AssertionError); - __PYX_ERR(1, 722, __pyx_L1_error) - } - } - #endif - - /* "View.MemoryView":724 - * assert memview.view.ndim > 0 - * - * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< - * memviewsliceobj = memview - * p_src = &memviewsliceobj.from_slice - */ - __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":725 - * - * 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, 725, __pyx_L1_error) - __pyx_t_3 = ((PyObject *)__pyx_v_memview); - __Pyx_INCREF(__pyx_t_3); - __pyx_v_memviewsliceobj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3); - __pyx_t_3 = 0; - - /* "View.MemoryView":726 - * if isinstance(memview, _memoryviewslice): - * memviewsliceobj = memview - * p_src = &memviewsliceobj.from_slice # <<<<<<<<<<<<<< - * else: - * slice_copy(memview, &src) - */ - __pyx_v_p_src = (&__pyx_v_memviewsliceobj->from_slice); - - /* "View.MemoryView":724 - * assert memview.view.ndim > 0 - * - * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< - * memviewsliceobj = memview - * p_src = &memviewsliceobj.from_slice - */ - goto __pyx_L3; - } - - /* "View.MemoryView":728 - * p_src = &memviewsliceobj.from_slice - * else: - * slice_copy(memview, &src) # <<<<<<<<<<<<<< - * p_src = &src - * - */ - /*else*/ { - __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_src)); - - /* "View.MemoryView":729 - * else: - * slice_copy(memview, &src) - * p_src = &src # <<<<<<<<<<<<<< - * - * - */ - __pyx_v_p_src = (&__pyx_v_src); - } - __pyx_L3:; - - /* "View.MemoryView":735 - * - * - * dst.memview = p_src.memview # <<<<<<<<<<<<<< - * dst.data = p_src.data - * - */ - __pyx_t_4 = __pyx_v_p_src->memview; - __pyx_v_dst.memview = __pyx_t_4; - - /* "View.MemoryView":736 - * - * dst.memview = p_src.memview - * dst.data = p_src.data # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_5 = __pyx_v_p_src->data; - __pyx_v_dst.data = __pyx_t_5; - - /* "View.MemoryView":741 - * - * - * cdef __Pyx_memviewslice *p_dst = &dst # <<<<<<<<<<<<<< - * cdef int *p_suboffset_dim = &suboffset_dim - * cdef Py_ssize_t start, stop, step - */ - __pyx_v_p_dst = (&__pyx_v_dst); - - /* "View.MemoryView":742 - * - * cdef __Pyx_memviewslice *p_dst = &dst - * cdef int *p_suboffset_dim = &suboffset_dim # <<<<<<<<<<<<<< - * cdef Py_ssize_t start, stop, step - * cdef bint have_start, have_stop, have_step - */ - __pyx_v_p_suboffset_dim = (&__pyx_v_suboffset_dim); - - /* "View.MemoryView":746 - * cdef bint have_start, have_stop, have_step - * - * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< - * if PyIndex_Check(index): - * slice_memviewslice( - */ - __pyx_t_6 = 0; - if (likely(PyList_CheckExact(__pyx_v_indices)) || PyTuple_CheckExact(__pyx_v_indices)) { - __pyx_t_3 = __pyx_v_indices; __Pyx_INCREF(__pyx_t_3); __pyx_t_7 = 0; - __pyx_t_8 = NULL; - } else { - __pyx_t_7 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_indices); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 746, __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, 746, __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, 746, __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, 746, __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, 746, __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, 746, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - #endif - } - } else { - __pyx_t_9 = __pyx_t_8(__pyx_t_3); - if (unlikely(!__pyx_t_9)) { - PyObject* exc_type = PyErr_Occurred(); - if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 746, __pyx_L1_error) - } - break; - } - __Pyx_GOTREF(__pyx_t_9); - } - __Pyx_XDECREF_SET(__pyx_v_index, __pyx_t_9); - __pyx_t_9 = 0; - __pyx_v_dim = __pyx_t_6; - __pyx_t_6 = (__pyx_t_6 + 1); - - /* "View.MemoryView":747 - * - * for dim, index in enumerate(indices): - * if PyIndex_Check(index): # <<<<<<<<<<<<<< - * slice_memviewslice( - * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], - */ - __pyx_t_2 = (PyIndex_Check(__pyx_v_index) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":751 - * 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, 751, __pyx_L1_error) - - /* "View.MemoryView":748 - * 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, 748, __pyx_L1_error) - - /* "View.MemoryView":747 - * - * for dim, index in enumerate(indices): - * if PyIndex_Check(index): # <<<<<<<<<<<<<< - * slice_memviewslice( - * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], - */ - goto __pyx_L6; - } - - /* "View.MemoryView":754 - * 0, 0, 0, # have_{start,stop,step} - * False) - * elif index is None: # <<<<<<<<<<<<<< - * p_dst.shape[new_ndim] = 1 - * p_dst.strides[new_ndim] = 0 - */ - __pyx_t_2 = (__pyx_v_index == Py_None); - __pyx_t_1 = (__pyx_t_2 != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":755 - * False) - * elif index is None: - * p_dst.shape[new_ndim] = 1 # <<<<<<<<<<<<<< - * p_dst.strides[new_ndim] = 0 - * p_dst.suboffsets[new_ndim] = -1 - */ - (__pyx_v_p_dst->shape[__pyx_v_new_ndim]) = 1; - - /* "View.MemoryView":756 - * elif index is None: - * p_dst.shape[new_ndim] = 1 - * p_dst.strides[new_ndim] = 0 # <<<<<<<<<<<<<< - * p_dst.suboffsets[new_ndim] = -1 - * new_ndim += 1 - */ - (__pyx_v_p_dst->strides[__pyx_v_new_ndim]) = 0; - - /* "View.MemoryView":757 - * p_dst.shape[new_ndim] = 1 - * p_dst.strides[new_ndim] = 0 - * p_dst.suboffsets[new_ndim] = -1 # <<<<<<<<<<<<<< - * new_ndim += 1 - * else: - */ - (__pyx_v_p_dst->suboffsets[__pyx_v_new_ndim]) = -1L; - - /* "View.MemoryView":758 - * p_dst.strides[new_ndim] = 0 - * p_dst.suboffsets[new_ndim] = -1 - * new_ndim += 1 # <<<<<<<<<<<<<< - * else: - * start = index.start or 0 - */ - __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); - - /* "View.MemoryView":754 - * 0, 0, 0, # have_{start,stop,step} - * False) - * elif index is None: # <<<<<<<<<<<<<< - * p_dst.shape[new_ndim] = 1 - * p_dst.strides[new_ndim] = 0 - */ - goto __pyx_L6; - } - - /* "View.MemoryView":760 - * new_ndim += 1 - * else: - * start = index.start or 0 # <<<<<<<<<<<<<< - * stop = index.stop or 0 - * step = index.step or 0 - */ - /*else*/ { - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 760, __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, 760, __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, 760, __pyx_L1_error) - __pyx_t_10 = __pyx_t_12; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - goto __pyx_L7_bool_binop_done; - } - __pyx_t_10 = 0; - __pyx_L7_bool_binop_done:; - __pyx_v_start = __pyx_t_10; - - /* "View.MemoryView":761 - * 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, 761, __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, 761, __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, 761, __pyx_L1_error) - __pyx_t_10 = __pyx_t_12; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - goto __pyx_L9_bool_binop_done; - } - __pyx_t_10 = 0; - __pyx_L9_bool_binop_done:; - __pyx_v_stop = __pyx_t_10; - - /* "View.MemoryView":762 - * 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, 762, __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, 762, __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, 762, __pyx_L1_error) - __pyx_t_10 = __pyx_t_12; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - goto __pyx_L11_bool_binop_done; - } - __pyx_t_10 = 0; - __pyx_L11_bool_binop_done:; - __pyx_v_step = __pyx_t_10; - - /* "View.MemoryView":764 - * 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, 764, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_1 = (__pyx_t_9 != Py_None); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_v_have_start = __pyx_t_1; - - /* "View.MemoryView":765 - * - * 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, 765, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_1 = (__pyx_t_9 != Py_None); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_v_have_stop = __pyx_t_1; - - /* "View.MemoryView":766 - * 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, 766, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_1 = (__pyx_t_9 != Py_None); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_v_have_step = __pyx_t_1; - - /* "View.MemoryView":768 - * 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, 768, __pyx_L1_error) - - /* "View.MemoryView":774 - * have_start, have_stop, have_step, - * True) - * new_ndim += 1 # <<<<<<<<<<<<<< - * - * if isinstance(memview, _memoryviewslice): - */ - __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); - } - __pyx_L6:; - - /* "View.MemoryView":746 - * cdef bint have_start, have_stop, have_step - * - * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< - * if PyIndex_Check(index): - * slice_memviewslice( - */ - } - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "View.MemoryView":776 - * new_ndim += 1 - * - * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< - * return memoryview_fromslice(dst, new_ndim, - * memviewsliceobj.to_object_func, - */ - __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":777 - * - * if isinstance(memview, _memoryviewslice): - * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< - * memviewsliceobj.to_object_func, - * memviewsliceobj.to_dtype_func, - */ - __Pyx_XDECREF(((PyObject *)__pyx_r)); - - /* "View.MemoryView":778 - * 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, 778, __pyx_L1_error) } - - /* "View.MemoryView":779 - * 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, 779, __pyx_L1_error) } - - /* "View.MemoryView":777 - * - * 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, 777, __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, 777, __pyx_L1_error) - __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); - __pyx_t_3 = 0; - goto __pyx_L0; - - /* "View.MemoryView":776 - * new_ndim += 1 - * - * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< - * return memoryview_fromslice(dst, new_ndim, - * memviewsliceobj.to_object_func, - */ - } - - /* "View.MemoryView":782 - * memview.dtype_is_object) - * else: - * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< - * memview.dtype_is_object) - * - */ - /*else*/ { - __Pyx_XDECREF(((PyObject *)__pyx_r)); - - /* "View.MemoryView":783 - * 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, 782, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - - /* "View.MemoryView":782 - * 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, 782, __pyx_L1_error) - __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); - __pyx_t_3 = 0; - goto __pyx_L0; - } - - /* "View.MemoryView":710 - * - * @cname('__pyx_memview_slice') - * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< - * cdef int new_ndim = 0, suboffset_dim = -1, dim - * cdef bint negative_step - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_9); - __Pyx_AddTraceback("View.MemoryView.memview_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_memviewsliceobj); - __Pyx_XDECREF(__pyx_v_index); - __Pyx_XGIVEREF((PyObject *)__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":807 - * - * @cname('__pyx_memoryview_slice_memviewslice') - * cdef int slice_memviewslice( # <<<<<<<<<<<<<< - * __Pyx_memviewslice *dst, - * Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, - */ - -static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, Py_ssize_t __pyx_v_shape, Py_ssize_t __pyx_v_stride, Py_ssize_t __pyx_v_suboffset, int __pyx_v_dim, int __pyx_v_new_ndim, int *__pyx_v_suboffset_dim, Py_ssize_t __pyx_v_start, Py_ssize_t __pyx_v_stop, Py_ssize_t __pyx_v_step, int __pyx_v_have_start, int __pyx_v_have_stop, int __pyx_v_have_step, int __pyx_v_is_slice) { - Py_ssize_t __pyx_v_new_shape; - int __pyx_v_negative_step; - int __pyx_r; - int __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - - /* "View.MemoryView":827 - * cdef bint negative_step - * - * if not is_slice: # <<<<<<<<<<<<<< - * - * if start < 0: - */ - __pyx_t_1 = ((!(__pyx_v_is_slice != 0)) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":829 - * if not is_slice: - * - * if start < 0: # <<<<<<<<<<<<<< - * start += shape - * if not 0 <= start < shape: - */ - __pyx_t_1 = ((__pyx_v_start < 0) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":830 - * - * if start < 0: - * start += shape # <<<<<<<<<<<<<< - * if not 0 <= start < shape: - * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) - */ - __pyx_v_start = (__pyx_v_start + __pyx_v_shape); - - /* "View.MemoryView":829 - * if not is_slice: - * - * if start < 0: # <<<<<<<<<<<<<< - * start += shape - * if not 0 <= start < shape: - */ - } - - /* "View.MemoryView":831 - * if start < 0: - * start += shape - * if not 0 <= start < shape: # <<<<<<<<<<<<<< - * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) - * else: - */ - __pyx_t_1 = (0 <= __pyx_v_start); - if (__pyx_t_1) { - __pyx_t_1 = (__pyx_v_start < __pyx_v_shape); - } - __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":832 - * 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, 832, __pyx_L1_error) - - /* "View.MemoryView":831 - * if start < 0: - * start += shape - * if not 0 <= start < shape: # <<<<<<<<<<<<<< - * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) - * else: - */ - } - - /* "View.MemoryView":827 - * cdef bint negative_step - * - * if not is_slice: # <<<<<<<<<<<<<< - * - * if start < 0: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":835 - * else: - * - * negative_step = have_step != 0 and step < 0 # <<<<<<<<<<<<<< - * - * if have_step and step == 0: - */ - /*else*/ { - __pyx_t_1 = ((__pyx_v_have_step != 0) != 0); - if (__pyx_t_1) { - } else { - __pyx_t_2 = __pyx_t_1; - goto __pyx_L6_bool_binop_done; - } - __pyx_t_1 = ((__pyx_v_step < 0) != 0); - __pyx_t_2 = __pyx_t_1; - __pyx_L6_bool_binop_done:; - __pyx_v_negative_step = __pyx_t_2; - - /* "View.MemoryView":837 - * negative_step = have_step != 0 and step < 0 - * - * if have_step and step == 0: # <<<<<<<<<<<<<< - * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) - * - */ - __pyx_t_1 = (__pyx_v_have_step != 0); - if (__pyx_t_1) { - } else { - __pyx_t_2 = __pyx_t_1; - goto __pyx_L9_bool_binop_done; - } - __pyx_t_1 = ((__pyx_v_step == 0) != 0); - __pyx_t_2 = __pyx_t_1; - __pyx_L9_bool_binop_done:; - if (__pyx_t_2) { - - /* "View.MemoryView":838 - * - * 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, 838, __pyx_L1_error) - - /* "View.MemoryView":837 - * negative_step = have_step != 0 and step < 0 - * - * if have_step and step == 0: # <<<<<<<<<<<<<< - * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) - * - */ - } - - /* "View.MemoryView":841 - * - * - * if have_start: # <<<<<<<<<<<<<< - * if start < 0: - * start += shape - */ - __pyx_t_2 = (__pyx_v_have_start != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":842 - * - * if have_start: - * if start < 0: # <<<<<<<<<<<<<< - * start += shape - * if start < 0: - */ - __pyx_t_2 = ((__pyx_v_start < 0) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":843 - * if have_start: - * if start < 0: - * start += shape # <<<<<<<<<<<<<< - * if start < 0: - * start = 0 - */ - __pyx_v_start = (__pyx_v_start + __pyx_v_shape); - - /* "View.MemoryView":844 - * if start < 0: - * start += shape - * if start < 0: # <<<<<<<<<<<<<< - * start = 0 - * elif start >= shape: - */ - __pyx_t_2 = ((__pyx_v_start < 0) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":845 - * start += shape - * if start < 0: - * start = 0 # <<<<<<<<<<<<<< - * elif start >= shape: - * if negative_step: - */ - __pyx_v_start = 0; - - /* "View.MemoryView":844 - * if start < 0: - * start += shape - * if start < 0: # <<<<<<<<<<<<<< - * start = 0 - * elif start >= shape: - */ - } - - /* "View.MemoryView":842 - * - * if have_start: - * if start < 0: # <<<<<<<<<<<<<< - * start += shape - * if start < 0: - */ - goto __pyx_L12; - } - - /* "View.MemoryView":846 - * if start < 0: - * start = 0 - * elif start >= shape: # <<<<<<<<<<<<<< - * if negative_step: - * start = shape - 1 - */ - __pyx_t_2 = ((__pyx_v_start >= __pyx_v_shape) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":847 - * start = 0 - * elif start >= shape: - * if negative_step: # <<<<<<<<<<<<<< - * start = shape - 1 - * else: - */ - __pyx_t_2 = (__pyx_v_negative_step != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":848 - * elif start >= shape: - * if negative_step: - * start = shape - 1 # <<<<<<<<<<<<<< - * else: - * start = shape - */ - __pyx_v_start = (__pyx_v_shape - 1); - - /* "View.MemoryView":847 - * start = 0 - * elif start >= shape: - * if negative_step: # <<<<<<<<<<<<<< - * start = shape - 1 - * else: - */ - goto __pyx_L14; - } - - /* "View.MemoryView":850 - * start = shape - 1 - * else: - * start = shape # <<<<<<<<<<<<<< - * else: - * if negative_step: - */ - /*else*/ { - __pyx_v_start = __pyx_v_shape; - } - __pyx_L14:; - - /* "View.MemoryView":846 - * if start < 0: - * start = 0 - * elif start >= shape: # <<<<<<<<<<<<<< - * if negative_step: - * start = shape - 1 - */ - } - __pyx_L12:; - - /* "View.MemoryView":841 - * - * - * if have_start: # <<<<<<<<<<<<<< - * if start < 0: - * start += shape - */ - goto __pyx_L11; - } - - /* "View.MemoryView":852 - * start = shape - * else: - * if negative_step: # <<<<<<<<<<<<<< - * start = shape - 1 - * else: - */ - /*else*/ { - __pyx_t_2 = (__pyx_v_negative_step != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":853 - * else: - * if negative_step: - * start = shape - 1 # <<<<<<<<<<<<<< - * else: - * start = 0 - */ - __pyx_v_start = (__pyx_v_shape - 1); - - /* "View.MemoryView":852 - * start = shape - * else: - * if negative_step: # <<<<<<<<<<<<<< - * start = shape - 1 - * else: - */ - goto __pyx_L15; - } - - /* "View.MemoryView":855 - * start = shape - 1 - * else: - * start = 0 # <<<<<<<<<<<<<< - * - * if have_stop: - */ - /*else*/ { - __pyx_v_start = 0; - } - __pyx_L15:; - } - __pyx_L11:; - - /* "View.MemoryView":857 - * start = 0 - * - * if have_stop: # <<<<<<<<<<<<<< - * if stop < 0: - * stop += shape - */ - __pyx_t_2 = (__pyx_v_have_stop != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":858 - * - * if have_stop: - * if stop < 0: # <<<<<<<<<<<<<< - * stop += shape - * if stop < 0: - */ - __pyx_t_2 = ((__pyx_v_stop < 0) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":859 - * if have_stop: - * if stop < 0: - * stop += shape # <<<<<<<<<<<<<< - * if stop < 0: - * stop = 0 - */ - __pyx_v_stop = (__pyx_v_stop + __pyx_v_shape); - - /* "View.MemoryView":860 - * if stop < 0: - * stop += shape - * if stop < 0: # <<<<<<<<<<<<<< - * stop = 0 - * elif stop > shape: - */ - __pyx_t_2 = ((__pyx_v_stop < 0) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":861 - * stop += shape - * if stop < 0: - * stop = 0 # <<<<<<<<<<<<<< - * elif stop > shape: - * stop = shape - */ - __pyx_v_stop = 0; - - /* "View.MemoryView":860 - * if stop < 0: - * stop += shape - * if stop < 0: # <<<<<<<<<<<<<< - * stop = 0 - * elif stop > shape: - */ - } - - /* "View.MemoryView":858 - * - * if have_stop: - * if stop < 0: # <<<<<<<<<<<<<< - * stop += shape - * if stop < 0: - */ - goto __pyx_L17; - } - - /* "View.MemoryView":862 - * if stop < 0: - * stop = 0 - * elif stop > shape: # <<<<<<<<<<<<<< - * stop = shape - * else: - */ - __pyx_t_2 = ((__pyx_v_stop > __pyx_v_shape) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":863 - * stop = 0 - * elif stop > shape: - * stop = shape # <<<<<<<<<<<<<< - * else: - * if negative_step: - */ - __pyx_v_stop = __pyx_v_shape; - - /* "View.MemoryView":862 - * if stop < 0: - * stop = 0 - * elif stop > shape: # <<<<<<<<<<<<<< - * stop = shape - * else: - */ - } - __pyx_L17:; - - /* "View.MemoryView":857 - * start = 0 - * - * if have_stop: # <<<<<<<<<<<<<< - * if stop < 0: - * stop += shape - */ - goto __pyx_L16; - } - - /* "View.MemoryView":865 - * stop = shape - * else: - * if negative_step: # <<<<<<<<<<<<<< - * stop = -1 - * else: - */ - /*else*/ { - __pyx_t_2 = (__pyx_v_negative_step != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":866 - * else: - * if negative_step: - * stop = -1 # <<<<<<<<<<<<<< - * else: - * stop = shape - */ - __pyx_v_stop = -1L; - - /* "View.MemoryView":865 - * stop = shape - * else: - * if negative_step: # <<<<<<<<<<<<<< - * stop = -1 - * else: - */ - goto __pyx_L19; - } - - /* "View.MemoryView":868 - * stop = -1 - * else: - * stop = shape # <<<<<<<<<<<<<< - * - * if not have_step: - */ - /*else*/ { - __pyx_v_stop = __pyx_v_shape; - } - __pyx_L19:; - } - __pyx_L16:; - - /* "View.MemoryView":870 - * stop = shape - * - * if not have_step: # <<<<<<<<<<<<<< - * step = 1 - * - */ - __pyx_t_2 = ((!(__pyx_v_have_step != 0)) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":871 - * - * if not have_step: - * step = 1 # <<<<<<<<<<<<<< - * - * - */ - __pyx_v_step = 1; - - /* "View.MemoryView":870 - * stop = shape - * - * if not have_step: # <<<<<<<<<<<<<< - * step = 1 - * - */ - } - - /* "View.MemoryView":875 - * - * with cython.cdivision(True): - * new_shape = (stop - start) // step # <<<<<<<<<<<<<< - * - * if (stop - start) - step * new_shape: - */ - __pyx_v_new_shape = ((__pyx_v_stop - __pyx_v_start) / __pyx_v_step); - - /* "View.MemoryView":877 - * new_shape = (stop - start) // step - * - * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< - * new_shape += 1 - * - */ - __pyx_t_2 = (((__pyx_v_stop - __pyx_v_start) - (__pyx_v_step * __pyx_v_new_shape)) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":878 - * - * if (stop - start) - step * new_shape: - * new_shape += 1 # <<<<<<<<<<<<<< - * - * if new_shape < 0: - */ - __pyx_v_new_shape = (__pyx_v_new_shape + 1); - - /* "View.MemoryView":877 - * new_shape = (stop - start) // step - * - * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< - * new_shape += 1 - * - */ - } - - /* "View.MemoryView":880 - * new_shape += 1 - * - * if new_shape < 0: # <<<<<<<<<<<<<< - * new_shape = 0 - * - */ - __pyx_t_2 = ((__pyx_v_new_shape < 0) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":881 - * - * if new_shape < 0: - * new_shape = 0 # <<<<<<<<<<<<<< - * - * - */ - __pyx_v_new_shape = 0; - - /* "View.MemoryView":880 - * new_shape += 1 - * - * if new_shape < 0: # <<<<<<<<<<<<<< - * new_shape = 0 - * - */ - } - - /* "View.MemoryView":884 - * - * - * dst.strides[new_ndim] = stride * step # <<<<<<<<<<<<<< - * dst.shape[new_ndim] = new_shape - * dst.suboffsets[new_ndim] = suboffset - */ - (__pyx_v_dst->strides[__pyx_v_new_ndim]) = (__pyx_v_stride * __pyx_v_step); - - /* "View.MemoryView":885 - * - * dst.strides[new_ndim] = stride * step - * dst.shape[new_ndim] = new_shape # <<<<<<<<<<<<<< - * dst.suboffsets[new_ndim] = suboffset - * - */ - (__pyx_v_dst->shape[__pyx_v_new_ndim]) = __pyx_v_new_shape; - - /* "View.MemoryView":886 - * dst.strides[new_ndim] = stride * step - * dst.shape[new_ndim] = new_shape - * dst.suboffsets[new_ndim] = suboffset # <<<<<<<<<<<<<< - * - * - */ - (__pyx_v_dst->suboffsets[__pyx_v_new_ndim]) = __pyx_v_suboffset; - } - __pyx_L3:; - - /* "View.MemoryView":889 - * - * - * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< - * dst.data += start * stride - * else: - */ - __pyx_t_2 = (((__pyx_v_suboffset_dim[0]) < 0) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":890 - * - * if suboffset_dim[0] < 0: - * dst.data += start * stride # <<<<<<<<<<<<<< - * else: - * dst.suboffsets[suboffset_dim[0]] += start * stride - */ - __pyx_v_dst->data = (__pyx_v_dst->data + (__pyx_v_start * __pyx_v_stride)); - - /* "View.MemoryView":889 - * - * - * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< - * dst.data += start * stride - * else: - */ - goto __pyx_L23; - } - - /* "View.MemoryView":892 - * dst.data += start * stride - * else: - * dst.suboffsets[suboffset_dim[0]] += start * stride # <<<<<<<<<<<<<< - * - * if suboffset >= 0: - */ - /*else*/ { - __pyx_t_3 = (__pyx_v_suboffset_dim[0]); - (__pyx_v_dst->suboffsets[__pyx_t_3]) = ((__pyx_v_dst->suboffsets[__pyx_t_3]) + (__pyx_v_start * __pyx_v_stride)); - } - __pyx_L23:; - - /* "View.MemoryView":894 - * dst.suboffsets[suboffset_dim[0]] += start * stride - * - * if suboffset >= 0: # <<<<<<<<<<<<<< - * if not is_slice: - * if new_ndim == 0: - */ - __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":895 - * - * if suboffset >= 0: - * if not is_slice: # <<<<<<<<<<<<<< - * if new_ndim == 0: - * dst.data = ( dst.data)[0] + suboffset - */ - __pyx_t_2 = ((!(__pyx_v_is_slice != 0)) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":896 - * if suboffset >= 0: - * if not is_slice: - * if new_ndim == 0: # <<<<<<<<<<<<<< - * dst.data = ( dst.data)[0] + suboffset - * else: - */ - __pyx_t_2 = ((__pyx_v_new_ndim == 0) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":897 - * if not is_slice: - * if new_ndim == 0: - * dst.data = ( dst.data)[0] + suboffset # <<<<<<<<<<<<<< - * else: - * _err_dim(IndexError, "All dimensions preceding dimension %d " - */ - __pyx_v_dst->data = ((((char **)__pyx_v_dst->data)[0]) + __pyx_v_suboffset); - - /* "View.MemoryView":896 - * if suboffset >= 0: - * if not is_slice: - * if new_ndim == 0: # <<<<<<<<<<<<<< - * dst.data = ( dst.data)[0] + suboffset - * else: - */ - goto __pyx_L26; - } - - /* "View.MemoryView":899 - * dst.data = ( dst.data)[0] + suboffset - * else: - * _err_dim(IndexError, "All dimensions preceding dimension %d " # <<<<<<<<<<<<<< - * "must be indexed and not sliced", dim) - * else: - */ - /*else*/ { - - /* "View.MemoryView":900 - * 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, 899, __pyx_L1_error) - } - __pyx_L26:; - - /* "View.MemoryView":895 - * - * if suboffset >= 0: - * if not is_slice: # <<<<<<<<<<<<<< - * if new_ndim == 0: - * dst.data = ( dst.data)[0] + suboffset - */ - goto __pyx_L25; - } - - /* "View.MemoryView":902 - * "must be indexed and not sliced", dim) - * else: - * suboffset_dim[0] = new_ndim # <<<<<<<<<<<<<< - * - * return 0 - */ - /*else*/ { - (__pyx_v_suboffset_dim[0]) = __pyx_v_new_ndim; - } - __pyx_L25:; - - /* "View.MemoryView":894 - * dst.suboffsets[suboffset_dim[0]] += start * stride - * - * if suboffset >= 0: # <<<<<<<<<<<<<< - * if not is_slice: - * if new_ndim == 0: - */ - } - - /* "View.MemoryView":904 - * suboffset_dim[0] = new_ndim - * - * return 0 # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = 0; - goto __pyx_L0; - - /* "View.MemoryView":807 - * - * @cname('__pyx_memoryview_slice_memviewslice') - * cdef int slice_memviewslice( # <<<<<<<<<<<<<< - * __Pyx_memviewslice *dst, - * Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, - */ - - /* function exit code */ - __pyx_L1_error:; - { - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_AddTraceback("View.MemoryView.slice_memviewslice", __pyx_clineno, __pyx_lineno, __pyx_filename); - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - } - __pyx_r = -1; - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":910 - * - * @cname('__pyx_pybuffer_index') - * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<< - * Py_ssize_t dim) except NULL: - * cdef Py_ssize_t shape, stride, suboffset = -1 - */ - -static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, Py_ssize_t __pyx_v_index, Py_ssize_t __pyx_v_dim) { - Py_ssize_t __pyx_v_shape; - Py_ssize_t __pyx_v_stride; - Py_ssize_t __pyx_v_suboffset; - Py_ssize_t __pyx_v_itemsize; - char *__pyx_v_resultp; - char *__pyx_r; - __Pyx_RefNannyDeclarations - Py_ssize_t __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("pybuffer_index", 0); - - /* "View.MemoryView":912 - * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, - * Py_ssize_t dim) except NULL: - * cdef Py_ssize_t shape, stride, suboffset = -1 # <<<<<<<<<<<<<< - * cdef Py_ssize_t itemsize = view.itemsize - * cdef char *resultp - */ - __pyx_v_suboffset = -1L; - - /* "View.MemoryView":913 - * Py_ssize_t dim) except NULL: - * cdef Py_ssize_t shape, stride, suboffset = -1 - * cdef Py_ssize_t itemsize = view.itemsize # <<<<<<<<<<<<<< - * cdef char *resultp - * - */ - __pyx_t_1 = __pyx_v_view->itemsize; - __pyx_v_itemsize = __pyx_t_1; - - /* "View.MemoryView":916 - * cdef char *resultp - * - * if view.ndim == 0: # <<<<<<<<<<<<<< - * shape = view.len / itemsize - * stride = itemsize - */ - __pyx_t_2 = ((__pyx_v_view->ndim == 0) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":917 - * - * if view.ndim == 0: - * shape = view.len / itemsize # <<<<<<<<<<<<<< - * stride = itemsize - * else: - */ - if (unlikely(__pyx_v_itemsize == 0)) { - PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); - __PYX_ERR(1, 917, __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, 917, __pyx_L1_error) - } - __pyx_v_shape = __Pyx_div_Py_ssize_t(__pyx_v_view->len, __pyx_v_itemsize); - - /* "View.MemoryView":918 - * if view.ndim == 0: - * shape = view.len / itemsize - * stride = itemsize # <<<<<<<<<<<<<< - * else: - * shape = view.shape[dim] - */ - __pyx_v_stride = __pyx_v_itemsize; - - /* "View.MemoryView":916 - * cdef char *resultp - * - * if view.ndim == 0: # <<<<<<<<<<<<<< - * shape = view.len / itemsize - * stride = itemsize - */ - goto __pyx_L3; - } - - /* "View.MemoryView":920 - * stride = itemsize - * else: - * shape = view.shape[dim] # <<<<<<<<<<<<<< - * stride = view.strides[dim] - * if view.suboffsets != NULL: - */ - /*else*/ { - __pyx_v_shape = (__pyx_v_view->shape[__pyx_v_dim]); - - /* "View.MemoryView":921 - * else: - * shape = view.shape[dim] - * stride = view.strides[dim] # <<<<<<<<<<<<<< - * if view.suboffsets != NULL: - * suboffset = view.suboffsets[dim] - */ - __pyx_v_stride = (__pyx_v_view->strides[__pyx_v_dim]); - - /* "View.MemoryView":922 - * shape = view.shape[dim] - * stride = view.strides[dim] - * if view.suboffsets != NULL: # <<<<<<<<<<<<<< - * suboffset = view.suboffsets[dim] - * - */ - __pyx_t_2 = ((__pyx_v_view->suboffsets != NULL) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":923 - * stride = view.strides[dim] - * if view.suboffsets != NULL: - * suboffset = view.suboffsets[dim] # <<<<<<<<<<<<<< - * - * if index < 0: - */ - __pyx_v_suboffset = (__pyx_v_view->suboffsets[__pyx_v_dim]); - - /* "View.MemoryView":922 - * shape = view.shape[dim] - * stride = view.strides[dim] - * if view.suboffsets != NULL: # <<<<<<<<<<<<<< - * suboffset = view.suboffsets[dim] - * - */ - } - } - __pyx_L3:; - - /* "View.MemoryView":925 - * suboffset = view.suboffsets[dim] - * - * if index < 0: # <<<<<<<<<<<<<< - * index += view.shape[dim] - * if index < 0: - */ - __pyx_t_2 = ((__pyx_v_index < 0) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":926 - * - * if index < 0: - * index += view.shape[dim] # <<<<<<<<<<<<<< - * if index < 0: - * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) - */ - __pyx_v_index = (__pyx_v_index + (__pyx_v_view->shape[__pyx_v_dim])); - - /* "View.MemoryView":927 - * if index < 0: - * index += view.shape[dim] - * if index < 0: # <<<<<<<<<<<<<< - * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) - * - */ - __pyx_t_2 = ((__pyx_v_index < 0) != 0); - if (unlikely(__pyx_t_2)) { - - /* "View.MemoryView":928 - * 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, 928, __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, 928, __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, 928, __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, 928, __pyx_L1_error) - - /* "View.MemoryView":927 - * if index < 0: - * index += view.shape[dim] - * if index < 0: # <<<<<<<<<<<<<< - * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) - * - */ - } - - /* "View.MemoryView":925 - * suboffset = view.suboffsets[dim] - * - * if index < 0: # <<<<<<<<<<<<<< - * index += view.shape[dim] - * if index < 0: - */ - } - - /* "View.MemoryView":930 - * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) - * - * if index >= shape: # <<<<<<<<<<<<<< - * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) - * - */ - __pyx_t_2 = ((__pyx_v_index >= __pyx_v_shape) != 0); - if (unlikely(__pyx_t_2)) { - - /* "View.MemoryView":931 - * - * 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, 931, __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, 931, __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, 931, __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, 931, __pyx_L1_error) - - /* "View.MemoryView":930 - * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) - * - * if index >= shape: # <<<<<<<<<<<<<< - * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) - * - */ - } - - /* "View.MemoryView":933 - * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) - * - * resultp = bufp + index * stride # <<<<<<<<<<<<<< - * if suboffset >= 0: - * resultp = ( resultp)[0] + suboffset - */ - __pyx_v_resultp = (__pyx_v_bufp + (__pyx_v_index * __pyx_v_stride)); - - /* "View.MemoryView":934 - * - * resultp = bufp + index * stride - * if suboffset >= 0: # <<<<<<<<<<<<<< - * resultp = ( resultp)[0] + suboffset - * - */ - __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":935 - * resultp = bufp + index * stride - * if suboffset >= 0: - * resultp = ( resultp)[0] + suboffset # <<<<<<<<<<<<<< - * - * return resultp - */ - __pyx_v_resultp = ((((char **)__pyx_v_resultp)[0]) + __pyx_v_suboffset); - - /* "View.MemoryView":934 - * - * resultp = bufp + index * stride - * if suboffset >= 0: # <<<<<<<<<<<<<< - * resultp = ( resultp)[0] + suboffset - * - */ - } - - /* "View.MemoryView":937 - * resultp = ( resultp)[0] + suboffset - * - * return resultp # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = __pyx_v_resultp; - goto __pyx_L0; - - /* "View.MemoryView":910 - * - * @cname('__pyx_pybuffer_index') - * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<< - * Py_ssize_t dim) except NULL: - * cdef Py_ssize_t shape, stride, suboffset = -1 - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("View.MemoryView.pybuffer_index", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":943 - * - * @cname('__pyx_memslice_transpose') - * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< - * cdef int ndim = memslice.memview.view.ndim - * - */ - -static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { - int __pyx_v_ndim; - Py_ssize_t *__pyx_v_shape; - Py_ssize_t *__pyx_v_strides; - int __pyx_v_i; - int __pyx_v_j; - int __pyx_r; - int __pyx_t_1; - Py_ssize_t *__pyx_t_2; - long __pyx_t_3; - long __pyx_t_4; - Py_ssize_t __pyx_t_5; - Py_ssize_t __pyx_t_6; - int __pyx_t_7; - int __pyx_t_8; - int __pyx_t_9; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - - /* "View.MemoryView":944 - * @cname('__pyx_memslice_transpose') - * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: - * cdef int ndim = memslice.memview.view.ndim # <<<<<<<<<<<<<< - * - * cdef Py_ssize_t *shape = memslice.shape - */ - __pyx_t_1 = __pyx_v_memslice->memview->view.ndim; - __pyx_v_ndim = __pyx_t_1; - - /* "View.MemoryView":946 - * cdef int ndim = memslice.memview.view.ndim - * - * cdef Py_ssize_t *shape = memslice.shape # <<<<<<<<<<<<<< - * cdef Py_ssize_t *strides = memslice.strides - * - */ - __pyx_t_2 = __pyx_v_memslice->shape; - __pyx_v_shape = __pyx_t_2; - - /* "View.MemoryView":947 - * - * cdef Py_ssize_t *shape = memslice.shape - * cdef Py_ssize_t *strides = memslice.strides # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_2 = __pyx_v_memslice->strides; - __pyx_v_strides = __pyx_t_2; - - /* "View.MemoryView":951 - * - * cdef int i, j - * for i in range(ndim / 2): # <<<<<<<<<<<<<< - * j = ndim - 1 - i - * strides[i], strides[j] = strides[j], strides[i] - */ - __pyx_t_3 = __Pyx_div_long(__pyx_v_ndim, 2); - __pyx_t_4 = __pyx_t_3; - for (__pyx_t_1 = 0; __pyx_t_1 < __pyx_t_4; __pyx_t_1+=1) { - __pyx_v_i = __pyx_t_1; - - /* "View.MemoryView":952 - * cdef int i, j - * for i in range(ndim / 2): - * j = ndim - 1 - i # <<<<<<<<<<<<<< - * strides[i], strides[j] = strides[j], strides[i] - * shape[i], shape[j] = shape[j], shape[i] - */ - __pyx_v_j = ((__pyx_v_ndim - 1) - __pyx_v_i); - - /* "View.MemoryView":953 - * for i in range(ndim / 2): - * j = ndim - 1 - i - * strides[i], strides[j] = strides[j], strides[i] # <<<<<<<<<<<<<< - * shape[i], shape[j] = shape[j], shape[i] - * - */ - __pyx_t_5 = (__pyx_v_strides[__pyx_v_j]); - __pyx_t_6 = (__pyx_v_strides[__pyx_v_i]); - (__pyx_v_strides[__pyx_v_i]) = __pyx_t_5; - (__pyx_v_strides[__pyx_v_j]) = __pyx_t_6; - - /* "View.MemoryView":954 - * j = ndim - 1 - i - * strides[i], strides[j] = strides[j], strides[i] - * shape[i], shape[j] = shape[j], shape[i] # <<<<<<<<<<<<<< - * - * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: - */ - __pyx_t_6 = (__pyx_v_shape[__pyx_v_j]); - __pyx_t_5 = (__pyx_v_shape[__pyx_v_i]); - (__pyx_v_shape[__pyx_v_i]) = __pyx_t_6; - (__pyx_v_shape[__pyx_v_j]) = __pyx_t_5; - - /* "View.MemoryView":956 - * shape[i], shape[j] = shape[j], shape[i] - * - * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< - * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") - * - */ - __pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_i]) >= 0) != 0); - if (!__pyx_t_8) { - } else { - __pyx_t_7 = __pyx_t_8; - goto __pyx_L6_bool_binop_done; - } - __pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_j]) >= 0) != 0); - __pyx_t_7 = __pyx_t_8; - __pyx_L6_bool_binop_done:; - if (__pyx_t_7) { - - /* "View.MemoryView":957 - * - * 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, 957, __pyx_L1_error) - - /* "View.MemoryView":956 - * shape[i], shape[j] = shape[j], shape[i] - * - * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< - * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") - * - */ - } - } - - /* "View.MemoryView":959 - * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") - * - * return 1 # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = 1; - goto __pyx_L0; - - /* "View.MemoryView":943 - * - * @cname('__pyx_memslice_transpose') - * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< - * cdef int ndim = memslice.memview.view.ndim - * - */ - - /* function exit code */ - __pyx_L1_error:; - { - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_AddTraceback("View.MemoryView.transpose_memslice", __pyx_clineno, __pyx_lineno, __pyx_filename); - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - } - __pyx_r = 0; - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":976 - * cdef int (*to_dtype_func)(char *, object) except 0 - * - * def __dealloc__(self): # <<<<<<<<<<<<<< - * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) - * - */ - -/* Python wrapper */ -static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self); /*proto*/ -static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); - __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__dealloc__", 0); - - /* "View.MemoryView":977 - * - * def __dealloc__(self): - * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) # <<<<<<<<<<<<<< - * - * cdef convert_item_to_object(self, char *itemp): - */ - __PYX_XDEC_MEMVIEW((&__pyx_v_self->from_slice), 1); - - /* "View.MemoryView":976 - * cdef int (*to_dtype_func)(char *, object) except 0 - * - * def __dealloc__(self): # <<<<<<<<<<<<<< - * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) - * - */ - - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -/* "View.MemoryView":979 - * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) - * - * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< - * if self.to_object_func != NULL: - * return self.to_object_func(itemp) - */ - -static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("convert_item_to_object", 0); - - /* "View.MemoryView":980 - * - * cdef convert_item_to_object(self, char *itemp): - * if self.to_object_func != NULL: # <<<<<<<<<<<<<< - * return self.to_object_func(itemp) - * else: - */ - __pyx_t_1 = ((__pyx_v_self->to_object_func != NULL) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":981 - * cdef convert_item_to_object(self, char *itemp): - * if self.to_object_func != NULL: - * return self.to_object_func(itemp) # <<<<<<<<<<<<<< - * else: - * return memoryview.convert_item_to_object(self, itemp) - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __pyx_v_self->to_object_func(__pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 981, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "View.MemoryView":980 - * - * cdef convert_item_to_object(self, char *itemp): - * if self.to_object_func != NULL: # <<<<<<<<<<<<<< - * return self.to_object_func(itemp) - * else: - */ - } - - /* "View.MemoryView":983 - * return self.to_object_func(itemp) - * else: - * return memoryview.convert_item_to_object(self, itemp) # <<<<<<<<<<<<<< - * - * cdef assign_item_from_object(self, char *itemp, object value): - */ - /*else*/ { - __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __pyx_memoryview_convert_item_to_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 983, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - } - - /* "View.MemoryView":979 - * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) - * - * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< - * if self.to_object_func != NULL: - * return self.to_object_func(itemp) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("View.MemoryView._memoryviewslice.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":985 - * return memoryview.convert_item_to_object(self, itemp) - * - * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< - * if self.to_dtype_func != NULL: - * self.to_dtype_func(itemp, value) - */ - -static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("assign_item_from_object", 0); - - /* "View.MemoryView":986 - * - * cdef assign_item_from_object(self, char *itemp, object value): - * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< - * self.to_dtype_func(itemp, value) - * else: - */ - __pyx_t_1 = ((__pyx_v_self->to_dtype_func != NULL) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":987 - * 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, 987, __pyx_L1_error) - - /* "View.MemoryView":986 - * - * cdef assign_item_from_object(self, char *itemp, object value): - * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< - * self.to_dtype_func(itemp, value) - * else: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":989 - * self.to_dtype_func(itemp, value) - * else: - * memoryview.assign_item_from_object(self, itemp, value) # <<<<<<<<<<<<<< - * - * @property - */ - /*else*/ { - __pyx_t_3 = __pyx_memoryview_assign_item_from_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 989, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } - __pyx_L3:; - - /* "View.MemoryView":985 - * return memoryview.convert_item_to_object(self, itemp) - * - * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< - * if self.to_dtype_func != NULL: - * self.to_dtype_func(itemp, value) - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView._memoryviewslice.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":992 - * - * @property - * def base(self): # <<<<<<<<<<<<<< - * return self.from_object - * - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_r = __pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(struct __pyx_memoryviewslice_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 0); - - /* "View.MemoryView":993 - * @property - * def base(self): - * return self.from_object # <<<<<<<<<<<<<< - * - * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->from_object); - __pyx_r = __pyx_v_self->from_object; - goto __pyx_L0; - - /* "View.MemoryView":992 - * - * @property - * def base(self): # <<<<<<<<<<<<<< - * return self.from_object - * - */ - - /* function exit code */ - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): - */ - -/* Python wrapper */ -static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf___pyx_memoryviewslice___reduce_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__reduce_cython__", 0); - - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(1, 2, __pyx_L1_error) - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - */ - -/* Python wrapper */ -static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf___pyx_memoryviewslice_2__setstate_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setstate_cython__", 0); - - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< - */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(1, 4, __pyx_L1_error) - - /* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":999 - * - * @cname('__pyx_memoryview_fromslice') - * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< - * int ndim, - * object (*to_object_func)(char *), - */ - -static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewslice, int __pyx_v_ndim, PyObject *(*__pyx_v_to_object_func)(char *), int (*__pyx_v_to_dtype_func)(char *, PyObject *), int __pyx_v_dtype_is_object) { - struct __pyx_memoryviewslice_obj *__pyx_v_result = 0; - Py_ssize_t __pyx_v_suboffset; - PyObject *__pyx_v_length = NULL; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - __Pyx_TypeInfo *__pyx_t_4; - Py_buffer __pyx_t_5; - Py_ssize_t *__pyx_t_6; - Py_ssize_t *__pyx_t_7; - Py_ssize_t *__pyx_t_8; - Py_ssize_t __pyx_t_9; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("memoryview_fromslice", 0); - - /* "View.MemoryView":1007 - * cdef _memoryviewslice result - * - * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< - * return None - * - */ - __pyx_t_1 = ((((PyObject *)__pyx_v_memviewslice.memview) == Py_None) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":1008 - * - * if memviewslice.memview == Py_None: - * return None # <<<<<<<<<<<<<< - * - * - */ - __Pyx_XDECREF(__pyx_r); - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - - /* "View.MemoryView":1007 - * cdef _memoryviewslice result - * - * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< - * return None - * - */ - } - - /* "View.MemoryView":1013 - * - * - * result = _memoryviewslice(None, 0, dtype_is_object) # <<<<<<<<<<<<<< - * - * result.from_slice = memviewslice - */ - __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1013, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1013, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(Py_None); - PyTuple_SET_ITEM(__pyx_t_3, 0, Py_None); - __Pyx_INCREF(__pyx_int_0); - __Pyx_GIVEREF(__pyx_int_0); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_0); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryviewslice_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1013, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); - __pyx_t_2 = 0; - - /* "View.MemoryView":1015 - * result = _memoryviewslice(None, 0, dtype_is_object) - * - * result.from_slice = memviewslice # <<<<<<<<<<<<<< - * __PYX_INC_MEMVIEW(&memviewslice, 1) - * - */ - __pyx_v_result->from_slice = __pyx_v_memviewslice; - - /* "View.MemoryView":1016 - * - * result.from_slice = memviewslice - * __PYX_INC_MEMVIEW(&memviewslice, 1) # <<<<<<<<<<<<<< - * - * result.from_object = ( memviewslice.memview).base - */ - __PYX_INC_MEMVIEW((&__pyx_v_memviewslice), 1); - - /* "View.MemoryView":1018 - * __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, 1018, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_v_result->from_object); - __Pyx_DECREF(__pyx_v_result->from_object); - __pyx_v_result->from_object = __pyx_t_2; - __pyx_t_2 = 0; - - /* "View.MemoryView":1019 - * - * result.from_object = ( memviewslice.memview).base - * result.typeinfo = memviewslice.memview.typeinfo # <<<<<<<<<<<<<< - * - * result.view = memviewslice.memview.view - */ - __pyx_t_4 = __pyx_v_memviewslice.memview->typeinfo; - __pyx_v_result->__pyx_base.typeinfo = __pyx_t_4; - - /* "View.MemoryView":1021 - * result.typeinfo = memviewslice.memview.typeinfo - * - * result.view = memviewslice.memview.view # <<<<<<<<<<<<<< - * result.view.buf = memviewslice.data - * result.view.ndim = ndim - */ - __pyx_t_5 = __pyx_v_memviewslice.memview->view; - __pyx_v_result->__pyx_base.view = __pyx_t_5; - - /* "View.MemoryView":1022 - * - * result.view = memviewslice.memview.view - * result.view.buf = memviewslice.data # <<<<<<<<<<<<<< - * result.view.ndim = ndim - * (<__pyx_buffer *> &result.view).obj = Py_None - */ - __pyx_v_result->__pyx_base.view.buf = ((void *)__pyx_v_memviewslice.data); - - /* "View.MemoryView":1023 - * result.view = memviewslice.memview.view - * result.view.buf = memviewslice.data - * result.view.ndim = ndim # <<<<<<<<<<<<<< - * (<__pyx_buffer *> &result.view).obj = Py_None - * Py_INCREF(Py_None) - */ - __pyx_v_result->__pyx_base.view.ndim = __pyx_v_ndim; - - /* "View.MemoryView":1024 - * result.view.buf = memviewslice.data - * result.view.ndim = ndim - * (<__pyx_buffer *> &result.view).obj = Py_None # <<<<<<<<<<<<<< - * Py_INCREF(Py_None) - * - */ - ((Py_buffer *)(&__pyx_v_result->__pyx_base.view))->obj = Py_None; - - /* "View.MemoryView":1025 - * result.view.ndim = ndim - * (<__pyx_buffer *> &result.view).obj = Py_None - * Py_INCREF(Py_None) # <<<<<<<<<<<<<< - * - * if (memviewslice.memview).flags & PyBUF_WRITABLE: - */ - Py_INCREF(Py_None); - - /* "View.MemoryView":1027 - * Py_INCREF(Py_None) - * - * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< - * result.flags = PyBUF_RECORDS - * else: - */ - __pyx_t_1 = ((((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->flags & PyBUF_WRITABLE) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":1028 - * - * if (memviewslice.memview).flags & PyBUF_WRITABLE: - * result.flags = PyBUF_RECORDS # <<<<<<<<<<<<<< - * else: - * result.flags = PyBUF_RECORDS_RO - */ - __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS; - - /* "View.MemoryView":1027 - * Py_INCREF(Py_None) - * - * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< - * result.flags = PyBUF_RECORDS - * else: - */ - goto __pyx_L4; - } - - /* "View.MemoryView":1030 - * result.flags = PyBUF_RECORDS - * else: - * result.flags = PyBUF_RECORDS_RO # <<<<<<<<<<<<<< - * - * result.view.shape = result.from_slice.shape - */ - /*else*/ { - __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS_RO; - } - __pyx_L4:; - - /* "View.MemoryView":1032 - * result.flags = PyBUF_RECORDS_RO - * - * result.view.shape = result.from_slice.shape # <<<<<<<<<<<<<< - * result.view.strides = result.from_slice.strides - * - */ - __pyx_v_result->__pyx_base.view.shape = ((Py_ssize_t *)__pyx_v_result->from_slice.shape); - - /* "View.MemoryView":1033 - * - * result.view.shape = result.from_slice.shape - * result.view.strides = result.from_slice.strides # <<<<<<<<<<<<<< - * - * - */ - __pyx_v_result->__pyx_base.view.strides = ((Py_ssize_t *)__pyx_v_result->from_slice.strides); - - /* "View.MemoryView":1036 - * - * - * result.view.suboffsets = NULL # <<<<<<<<<<<<<< - * for suboffset in result.from_slice.suboffsets[:ndim]: - * if suboffset >= 0: - */ - __pyx_v_result->__pyx_base.view.suboffsets = NULL; - - /* "View.MemoryView":1037 - * - * result.view.suboffsets = NULL - * for suboffset in result.from_slice.suboffsets[:ndim]: # <<<<<<<<<<<<<< - * if suboffset >= 0: - * result.view.suboffsets = result.from_slice.suboffsets - */ - __pyx_t_7 = (__pyx_v_result->from_slice.suboffsets + __pyx_v_ndim); - for (__pyx_t_8 = __pyx_v_result->from_slice.suboffsets; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) { - __pyx_t_6 = __pyx_t_8; - __pyx_v_suboffset = (__pyx_t_6[0]); - - /* "View.MemoryView":1038 - * result.view.suboffsets = NULL - * for suboffset in result.from_slice.suboffsets[:ndim]: - * if suboffset >= 0: # <<<<<<<<<<<<<< - * result.view.suboffsets = result.from_slice.suboffsets - * break - */ - __pyx_t_1 = ((__pyx_v_suboffset >= 0) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":1039 - * for suboffset in result.from_slice.suboffsets[:ndim]: - * if suboffset >= 0: - * result.view.suboffsets = result.from_slice.suboffsets # <<<<<<<<<<<<<< - * break - * - */ - __pyx_v_result->__pyx_base.view.suboffsets = ((Py_ssize_t *)__pyx_v_result->from_slice.suboffsets); - - /* "View.MemoryView":1040 - * if suboffset >= 0: - * result.view.suboffsets = result.from_slice.suboffsets - * break # <<<<<<<<<<<<<< - * - * result.view.len = result.view.itemsize - */ - goto __pyx_L6_break; - - /* "View.MemoryView":1038 - * result.view.suboffsets = NULL - * for suboffset in result.from_slice.suboffsets[:ndim]: - * if suboffset >= 0: # <<<<<<<<<<<<<< - * result.view.suboffsets = result.from_slice.suboffsets - * break - */ - } - } - __pyx_L6_break:; - - /* "View.MemoryView":1042 - * break - * - * result.view.len = result.view.itemsize # <<<<<<<<<<<<<< - * for length in result.view.shape[:ndim]: - * result.view.len *= length - */ - __pyx_t_9 = __pyx_v_result->__pyx_base.view.itemsize; - __pyx_v_result->__pyx_base.view.len = __pyx_t_9; - - /* "View.MemoryView":1043 - * - * result.view.len = result.view.itemsize - * for length in result.view.shape[:ndim]: # <<<<<<<<<<<<<< - * result.view.len *= length - * - */ - __pyx_t_7 = (__pyx_v_result->__pyx_base.view.shape + __pyx_v_ndim); - for (__pyx_t_8 = __pyx_v_result->__pyx_base.view.shape; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) { - __pyx_t_6 = __pyx_t_8; - __pyx_t_2 = PyInt_FromSsize_t((__pyx_t_6[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1043, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_2); - __pyx_t_2 = 0; - - /* "View.MemoryView":1044 - * result.view.len = result.view.itemsize - * for length in result.view.shape[:ndim]: - * result.view.len *= length # <<<<<<<<<<<<<< - * - * result.to_object_func = to_object_func - */ - __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_result->__pyx_base.view.len); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1044, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyNumber_InPlaceMultiply(__pyx_t_2, __pyx_v_length); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1044, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 1044, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_result->__pyx_base.view.len = __pyx_t_9; - } - - /* "View.MemoryView":1046 - * result.view.len *= length - * - * result.to_object_func = to_object_func # <<<<<<<<<<<<<< - * result.to_dtype_func = to_dtype_func - * - */ - __pyx_v_result->to_object_func = __pyx_v_to_object_func; - - /* "View.MemoryView":1047 - * - * result.to_object_func = to_object_func - * result.to_dtype_func = to_dtype_func # <<<<<<<<<<<<<< - * - * return result - */ - __pyx_v_result->to_dtype_func = __pyx_v_to_dtype_func; - - /* "View.MemoryView":1049 - * result.to_dtype_func = to_dtype_func - * - * return result # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_get_slice_from_memoryview') - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_result)); - __pyx_r = ((PyObject *)__pyx_v_result); - goto __pyx_L0; - - /* "View.MemoryView":999 - * - * @cname('__pyx_memoryview_fromslice') - * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< - * int ndim, - * object (*to_object_func)(char *), - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.memoryview_fromslice", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_result); - __Pyx_XDECREF(__pyx_v_length); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":1052 - * - * @cname('__pyx_memoryview_get_slice_from_memoryview') - * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< - * __Pyx_memviewslice *mslice) except NULL: - * cdef _memoryviewslice obj - */ - -static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_mslice) { - struct __pyx_memoryviewslice_obj *__pyx_v_obj = 0; - __Pyx_memviewslice *__pyx_r; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_slice_from_memview", 0); - - /* "View.MemoryView":1055 - * __Pyx_memviewslice *mslice) except NULL: - * cdef _memoryviewslice obj - * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< - * obj = memview - * return &obj.from_slice - */ - __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":1056 - * cdef _memoryviewslice obj - * if isinstance(memview, _memoryviewslice): - * obj = memview # <<<<<<<<<<<<<< - * return &obj.from_slice - * else: - */ - if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(1, 1056, __pyx_L1_error) - __pyx_t_3 = ((PyObject *)__pyx_v_memview); - __Pyx_INCREF(__pyx_t_3); - __pyx_v_obj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3); - __pyx_t_3 = 0; - - /* "View.MemoryView":1057 - * if isinstance(memview, _memoryviewslice): - * obj = memview - * return &obj.from_slice # <<<<<<<<<<<<<< - * else: - * slice_copy(memview, mslice) - */ - __pyx_r = (&__pyx_v_obj->from_slice); - goto __pyx_L0; - - /* "View.MemoryView":1055 - * __Pyx_memviewslice *mslice) except NULL: - * cdef _memoryviewslice obj - * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< - * obj = memview - * return &obj.from_slice - */ - } - - /* "View.MemoryView":1059 - * return &obj.from_slice - * else: - * slice_copy(memview, mslice) # <<<<<<<<<<<<<< - * return mslice - * - */ - /*else*/ { - __pyx_memoryview_slice_copy(__pyx_v_memview, __pyx_v_mslice); - - /* "View.MemoryView":1060 - * else: - * slice_copy(memview, mslice) - * return mslice # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_slice_copy') - */ - __pyx_r = __pyx_v_mslice; - goto __pyx_L0; - } - - /* "View.MemoryView":1052 - * - * @cname('__pyx_memoryview_get_slice_from_memoryview') - * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< - * __Pyx_memviewslice *mslice) except NULL: - * cdef _memoryviewslice obj - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("View.MemoryView.get_slice_from_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_obj); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":1063 - * - * @cname('__pyx_memoryview_slice_copy') - * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< - * cdef int dim - * cdef (Py_ssize_t*) shape, strides, suboffsets - */ - -static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_dst) { - int __pyx_v_dim; - Py_ssize_t *__pyx_v_shape; - Py_ssize_t *__pyx_v_strides; - Py_ssize_t *__pyx_v_suboffsets; - __Pyx_RefNannyDeclarations - Py_ssize_t *__pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - int __pyx_t_4; - Py_ssize_t __pyx_t_5; - __Pyx_RefNannySetupContext("slice_copy", 0); - - /* "View.MemoryView":1067 - * cdef (Py_ssize_t*) shape, strides, suboffsets - * - * shape = memview.view.shape # <<<<<<<<<<<<<< - * strides = memview.view.strides - * suboffsets = memview.view.suboffsets - */ - __pyx_t_1 = __pyx_v_memview->view.shape; - __pyx_v_shape = __pyx_t_1; - - /* "View.MemoryView":1068 - * - * shape = memview.view.shape - * strides = memview.view.strides # <<<<<<<<<<<<<< - * suboffsets = memview.view.suboffsets - * - */ - __pyx_t_1 = __pyx_v_memview->view.strides; - __pyx_v_strides = __pyx_t_1; - - /* "View.MemoryView":1069 - * shape = memview.view.shape - * strides = memview.view.strides - * suboffsets = memview.view.suboffsets # <<<<<<<<<<<<<< - * - * dst.memview = <__pyx_memoryview *> memview - */ - __pyx_t_1 = __pyx_v_memview->view.suboffsets; - __pyx_v_suboffsets = __pyx_t_1; - - /* "View.MemoryView":1071 - * suboffsets = memview.view.suboffsets - * - * dst.memview = <__pyx_memoryview *> memview # <<<<<<<<<<<<<< - * dst.data = memview.view.buf - * - */ - __pyx_v_dst->memview = ((struct __pyx_memoryview_obj *)__pyx_v_memview); - - /* "View.MemoryView":1072 - * - * dst.memview = <__pyx_memoryview *> memview - * dst.data = memview.view.buf # <<<<<<<<<<<<<< - * - * for dim in range(memview.view.ndim): - */ - __pyx_v_dst->data = ((char *)__pyx_v_memview->view.buf); - - /* "View.MemoryView":1074 - * dst.data = memview.view.buf - * - * for dim in range(memview.view.ndim): # <<<<<<<<<<<<<< - * dst.shape[dim] = shape[dim] - * dst.strides[dim] = strides[dim] - */ - __pyx_t_2 = __pyx_v_memview->view.ndim; - __pyx_t_3 = __pyx_t_2; - for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { - __pyx_v_dim = __pyx_t_4; - - /* "View.MemoryView":1075 - * - * for dim in range(memview.view.ndim): - * dst.shape[dim] = shape[dim] # <<<<<<<<<<<<<< - * dst.strides[dim] = strides[dim] - * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 - */ - (__pyx_v_dst->shape[__pyx_v_dim]) = (__pyx_v_shape[__pyx_v_dim]); - - /* "View.MemoryView":1076 - * for dim in range(memview.view.ndim): - * dst.shape[dim] = shape[dim] - * dst.strides[dim] = strides[dim] # <<<<<<<<<<<<<< - * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 - * - */ - (__pyx_v_dst->strides[__pyx_v_dim]) = (__pyx_v_strides[__pyx_v_dim]); - - /* "View.MemoryView":1077 - * dst.shape[dim] = shape[dim] - * dst.strides[dim] = strides[dim] - * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_copy_object') - */ - if ((__pyx_v_suboffsets != 0)) { - __pyx_t_5 = (__pyx_v_suboffsets[__pyx_v_dim]); - } else { - __pyx_t_5 = -1L; - } - (__pyx_v_dst->suboffsets[__pyx_v_dim]) = __pyx_t_5; - } - - /* "View.MemoryView":1063 - * - * @cname('__pyx_memoryview_slice_copy') - * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< - * cdef int dim - * cdef (Py_ssize_t*) shape, strides, suboffsets - */ - - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -/* "View.MemoryView":1080 - * - * @cname('__pyx_memoryview_copy_object') - * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< - * "Create a new memoryview object" - * cdef __Pyx_memviewslice memviewslice - */ - -static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx_v_memview) { - __Pyx_memviewslice __pyx_v_memviewslice; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("memoryview_copy", 0); - - /* "View.MemoryView":1083 - * "Create a new memoryview object" - * cdef __Pyx_memviewslice memviewslice - * slice_copy(memview, &memviewslice) # <<<<<<<<<<<<<< - * return memoryview_copy_from_slice(memview, &memviewslice) - * - */ - __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_memviewslice)); - - /* "View.MemoryView":1084 - * cdef __Pyx_memviewslice memviewslice - * slice_copy(memview, &memviewslice) - * return memoryview_copy_from_slice(memview, &memviewslice) # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_copy_object_from_slice') - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_memoryview_copy_object_from_slice(__pyx_v_memview, (&__pyx_v_memviewslice)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1084, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "View.MemoryView":1080 - * - * @cname('__pyx_memoryview_copy_object') - * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< - * "Create a new memoryview object" - * cdef __Pyx_memviewslice memviewslice - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("View.MemoryView.memoryview_copy", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":1087 - * - * @cname('__pyx_memoryview_copy_object_from_slice') - * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< - * """ - * Create a new memoryview object from a given memoryview object and slice. - */ - -static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_memviewslice) { - PyObject *(*__pyx_v_to_object_func)(char *); - int (*__pyx_v_to_dtype_func)(char *, PyObject *); - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - PyObject *(*__pyx_t_3)(char *); - int (*__pyx_t_4)(char *, PyObject *); - PyObject *__pyx_t_5 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("memoryview_copy_from_slice", 0); - - /* "View.MemoryView":1094 - * cdef int (*to_dtype_func)(char *, object) except 0 - * - * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< - * to_object_func = (<_memoryviewslice> memview).to_object_func - * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func - */ - __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":1095 - * - * if isinstance(memview, _memoryviewslice): - * to_object_func = (<_memoryviewslice> memview).to_object_func # <<<<<<<<<<<<<< - * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func - * else: - */ - __pyx_t_3 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_object_func; - __pyx_v_to_object_func = __pyx_t_3; - - /* "View.MemoryView":1096 - * if isinstance(memview, _memoryviewslice): - * to_object_func = (<_memoryviewslice> memview).to_object_func - * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func # <<<<<<<<<<<<<< - * else: - * to_object_func = NULL - */ - __pyx_t_4 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_dtype_func; - __pyx_v_to_dtype_func = __pyx_t_4; - - /* "View.MemoryView":1094 - * cdef int (*to_dtype_func)(char *, object) except 0 - * - * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< - * to_object_func = (<_memoryviewslice> memview).to_object_func - * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func - */ - goto __pyx_L3; - } - - /* "View.MemoryView":1098 - * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func - * else: - * to_object_func = NULL # <<<<<<<<<<<<<< - * to_dtype_func = NULL - * - */ - /*else*/ { - __pyx_v_to_object_func = NULL; - - /* "View.MemoryView":1099 - * else: - * to_object_func = NULL - * to_dtype_func = NULL # <<<<<<<<<<<<<< - * - * return memoryview_fromslice(memviewslice[0], memview.view.ndim, - */ - __pyx_v_to_dtype_func = NULL; - } - __pyx_L3:; - - /* "View.MemoryView":1101 - * to_dtype_func = NULL - * - * return memoryview_fromslice(memviewslice[0], memview.view.ndim, # <<<<<<<<<<<<<< - * to_object_func, to_dtype_func, - * memview.dtype_is_object) - */ - __Pyx_XDECREF(__pyx_r); - - /* "View.MemoryView":1103 - * return memoryview_fromslice(memviewslice[0], memview.view.ndim, - * to_object_func, to_dtype_func, - * memview.dtype_is_object) # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_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, 1101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; - goto __pyx_L0; - - /* "View.MemoryView":1087 - * - * @cname('__pyx_memoryview_copy_object_from_slice') - * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< - * """ - * Create a new memoryview object from a given memoryview object and slice. - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("View.MemoryView.memoryview_copy_from_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "View.MemoryView":1109 - * - * - * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< - * if arg < 0: - * return -arg - */ - -static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { - Py_ssize_t __pyx_r; - int __pyx_t_1; - - /* "View.MemoryView":1110 - * - * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: - * if arg < 0: # <<<<<<<<<<<<<< - * return -arg - * else: - */ - __pyx_t_1 = ((__pyx_v_arg < 0) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":1111 - * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: - * if arg < 0: - * return -arg # <<<<<<<<<<<<<< - * else: - * return arg - */ - __pyx_r = (-__pyx_v_arg); - goto __pyx_L0; - - /* "View.MemoryView":1110 - * - * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: - * if arg < 0: # <<<<<<<<<<<<<< - * return -arg - * else: - */ - } - - /* "View.MemoryView":1113 - * return -arg - * else: - * return arg # <<<<<<<<<<<<<< - * - * @cname('__pyx_get_best_slice_order') - */ - /*else*/ { - __pyx_r = __pyx_v_arg; - goto __pyx_L0; - } - - /* "View.MemoryView":1109 - * - * - * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< - * if arg < 0: - * return -arg - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":1116 - * - * @cname('__pyx_get_best_slice_order') - * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<< - * """ - * Figure out the best memory access order for a given slice. - */ - -static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim) { - int __pyx_v_i; - Py_ssize_t __pyx_v_c_stride; - Py_ssize_t __pyx_v_f_stride; - char __pyx_r; - int __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - int __pyx_t_4; - - /* "View.MemoryView":1121 - * """ - * cdef int i - * cdef Py_ssize_t c_stride = 0 # <<<<<<<<<<<<<< - * cdef Py_ssize_t f_stride = 0 - * - */ - __pyx_v_c_stride = 0; - - /* "View.MemoryView":1122 - * cdef int i - * cdef Py_ssize_t c_stride = 0 - * cdef Py_ssize_t f_stride = 0 # <<<<<<<<<<<<<< - * - * for i in range(ndim - 1, -1, -1): - */ - __pyx_v_f_stride = 0; - - /* "View.MemoryView":1124 - * cdef Py_ssize_t f_stride = 0 - * - * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< - * if mslice.shape[i] > 1: - * c_stride = mslice.strides[i] - */ - for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { - __pyx_v_i = __pyx_t_1; - - /* "View.MemoryView":1125 - * - * for i in range(ndim - 1, -1, -1): - * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< - * c_stride = mslice.strides[i] - * break - */ - __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":1126 - * for i in range(ndim - 1, -1, -1): - * if mslice.shape[i] > 1: - * c_stride = mslice.strides[i] # <<<<<<<<<<<<<< - * break - * - */ - __pyx_v_c_stride = (__pyx_v_mslice->strides[__pyx_v_i]); - - /* "View.MemoryView":1127 - * if mslice.shape[i] > 1: - * c_stride = mslice.strides[i] - * break # <<<<<<<<<<<<<< - * - * for i in range(ndim): - */ - goto __pyx_L4_break; - - /* "View.MemoryView":1125 - * - * for i in range(ndim - 1, -1, -1): - * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< - * c_stride = mslice.strides[i] - * break - */ - } - } - __pyx_L4_break:; - - /* "View.MemoryView":1129 - * break - * - * for i in range(ndim): # <<<<<<<<<<<<<< - * if mslice.shape[i] > 1: - * f_stride = mslice.strides[i] - */ - __pyx_t_1 = __pyx_v_ndim; - __pyx_t_3 = __pyx_t_1; - for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { - __pyx_v_i = __pyx_t_4; - - /* "View.MemoryView":1130 - * - * for i in range(ndim): - * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< - * f_stride = mslice.strides[i] - * break - */ - __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":1131 - * for i in range(ndim): - * if mslice.shape[i] > 1: - * f_stride = mslice.strides[i] # <<<<<<<<<<<<<< - * break - * - */ - __pyx_v_f_stride = (__pyx_v_mslice->strides[__pyx_v_i]); - - /* "View.MemoryView":1132 - * if mslice.shape[i] > 1: - * f_stride = mslice.strides[i] - * break # <<<<<<<<<<<<<< - * - * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): - */ - goto __pyx_L7_break; - - /* "View.MemoryView":1130 - * - * for i in range(ndim): - * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< - * f_stride = mslice.strides[i] - * break - */ - } - } - __pyx_L7_break:; - - /* "View.MemoryView":1134 - * break - * - * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< - * return 'C' - * else: - */ - __pyx_t_2 = ((abs_py_ssize_t(__pyx_v_c_stride) <= abs_py_ssize_t(__pyx_v_f_stride)) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":1135 - * - * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): - * return 'C' # <<<<<<<<<<<<<< - * else: - * return 'F' - */ - __pyx_r = 'C'; - goto __pyx_L0; - - /* "View.MemoryView":1134 - * break - * - * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< - * return 'C' - * else: - */ - } - - /* "View.MemoryView":1137 - * return 'C' - * else: - * return 'F' # <<<<<<<<<<<<<< - * - * @cython.cdivision(True) - */ - /*else*/ { - __pyx_r = 'F'; - goto __pyx_L0; - } - - /* "View.MemoryView":1116 - * - * @cname('__pyx_get_best_slice_order') - * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<< - * """ - * Figure out the best memory access order for a given slice. - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":1140 - * - * @cython.cdivision(True) - * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< - * char *dst_data, Py_ssize_t *dst_strides, - * Py_ssize_t *src_shape, Py_ssize_t *dst_shape, - */ - -static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v_src_strides, char *__pyx_v_dst_data, Py_ssize_t *__pyx_v_dst_strides, Py_ssize_t *__pyx_v_src_shape, Py_ssize_t *__pyx_v_dst_shape, int __pyx_v_ndim, size_t __pyx_v_itemsize) { - CYTHON_UNUSED Py_ssize_t __pyx_v_i; - CYTHON_UNUSED Py_ssize_t __pyx_v_src_extent; - Py_ssize_t __pyx_v_dst_extent; - Py_ssize_t __pyx_v_src_stride; - Py_ssize_t __pyx_v_dst_stride; - int __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - Py_ssize_t __pyx_t_4; - Py_ssize_t __pyx_t_5; - Py_ssize_t __pyx_t_6; - - /* "View.MemoryView":1147 - * - * cdef Py_ssize_t i - * cdef Py_ssize_t src_extent = src_shape[0] # <<<<<<<<<<<<<< - * cdef Py_ssize_t dst_extent = dst_shape[0] - * cdef Py_ssize_t src_stride = src_strides[0] - */ - __pyx_v_src_extent = (__pyx_v_src_shape[0]); - - /* "View.MemoryView":1148 - * cdef Py_ssize_t i - * cdef Py_ssize_t src_extent = src_shape[0] - * cdef Py_ssize_t dst_extent = dst_shape[0] # <<<<<<<<<<<<<< - * cdef Py_ssize_t src_stride = src_strides[0] - * cdef Py_ssize_t dst_stride = dst_strides[0] - */ - __pyx_v_dst_extent = (__pyx_v_dst_shape[0]); - - /* "View.MemoryView":1149 - * cdef Py_ssize_t src_extent = src_shape[0] - * cdef Py_ssize_t dst_extent = dst_shape[0] - * cdef Py_ssize_t src_stride = src_strides[0] # <<<<<<<<<<<<<< - * cdef Py_ssize_t dst_stride = dst_strides[0] - * - */ - __pyx_v_src_stride = (__pyx_v_src_strides[0]); - - /* "View.MemoryView":1150 - * cdef Py_ssize_t dst_extent = dst_shape[0] - * cdef Py_ssize_t src_stride = src_strides[0] - * cdef Py_ssize_t dst_stride = dst_strides[0] # <<<<<<<<<<<<<< - * - * if ndim == 1: - */ - __pyx_v_dst_stride = (__pyx_v_dst_strides[0]); - - /* "View.MemoryView":1152 - * cdef Py_ssize_t dst_stride = dst_strides[0] - * - * if ndim == 1: # <<<<<<<<<<<<<< - * if (src_stride > 0 and dst_stride > 0 and - * src_stride == itemsize == dst_stride): - */ - __pyx_t_1 = ((__pyx_v_ndim == 1) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":1153 - * - * if ndim == 1: - * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< - * src_stride == itemsize == dst_stride): - * memcpy(dst_data, src_data, itemsize * dst_extent) - */ - __pyx_t_2 = ((__pyx_v_src_stride > 0) != 0); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L5_bool_binop_done; - } - __pyx_t_2 = ((__pyx_v_dst_stride > 0) != 0); - if (__pyx_t_2) { - } else { - __pyx_t_1 = __pyx_t_2; - goto __pyx_L5_bool_binop_done; - } - - /* "View.MemoryView":1154 - * if ndim == 1: - * if (src_stride > 0 and dst_stride > 0 and - * src_stride == itemsize == dst_stride): # <<<<<<<<<<<<<< - * memcpy(dst_data, src_data, itemsize * dst_extent) - * else: - */ - __pyx_t_2 = (((size_t)__pyx_v_src_stride) == __pyx_v_itemsize); - if (__pyx_t_2) { - __pyx_t_2 = (__pyx_v_itemsize == ((size_t)__pyx_v_dst_stride)); - } - __pyx_t_3 = (__pyx_t_2 != 0); - __pyx_t_1 = __pyx_t_3; - __pyx_L5_bool_binop_done:; - - /* "View.MemoryView":1153 - * - * if ndim == 1: - * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< - * src_stride == itemsize == dst_stride): - * memcpy(dst_data, src_data, itemsize * dst_extent) - */ - if (__pyx_t_1) { - - /* "View.MemoryView":1155 - * if (src_stride > 0 and dst_stride > 0 and - * src_stride == itemsize == dst_stride): - * memcpy(dst_data, src_data, itemsize * dst_extent) # <<<<<<<<<<<<<< - * else: - * for i in range(dst_extent): - */ - (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, (__pyx_v_itemsize * __pyx_v_dst_extent))); - - /* "View.MemoryView":1153 - * - * if ndim == 1: - * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< - * src_stride == itemsize == dst_stride): - * memcpy(dst_data, src_data, itemsize * dst_extent) - */ - goto __pyx_L4; - } - - /* "View.MemoryView":1157 - * memcpy(dst_data, src_data, itemsize * dst_extent) - * else: - * for i in range(dst_extent): # <<<<<<<<<<<<<< - * memcpy(dst_data, src_data, itemsize) - * src_data += src_stride - */ - /*else*/ { - __pyx_t_4 = __pyx_v_dst_extent; - __pyx_t_5 = __pyx_t_4; - for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { - __pyx_v_i = __pyx_t_6; - - /* "View.MemoryView":1158 - * else: - * for i in range(dst_extent): - * memcpy(dst_data, src_data, itemsize) # <<<<<<<<<<<<<< - * src_data += src_stride - * dst_data += dst_stride - */ - (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, __pyx_v_itemsize)); - - /* "View.MemoryView":1159 - * for i in range(dst_extent): - * memcpy(dst_data, src_data, itemsize) - * src_data += src_stride # <<<<<<<<<<<<<< - * dst_data += dst_stride - * else: - */ - __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); - - /* "View.MemoryView":1160 - * memcpy(dst_data, src_data, itemsize) - * src_data += src_stride - * dst_data += dst_stride # <<<<<<<<<<<<<< - * else: - * for i in range(dst_extent): - */ - __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride); - } - } - __pyx_L4:; - - /* "View.MemoryView":1152 - * cdef Py_ssize_t dst_stride = dst_strides[0] - * - * if ndim == 1: # <<<<<<<<<<<<<< - * if (src_stride > 0 and dst_stride > 0 and - * src_stride == itemsize == dst_stride): - */ - goto __pyx_L3; - } - - /* "View.MemoryView":1162 - * dst_data += dst_stride - * else: - * for i in range(dst_extent): # <<<<<<<<<<<<<< - * _copy_strided_to_strided(src_data, src_strides + 1, - * dst_data, dst_strides + 1, - */ - /*else*/ { - __pyx_t_4 = __pyx_v_dst_extent; - __pyx_t_5 = __pyx_t_4; - for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { - __pyx_v_i = __pyx_t_6; - - /* "View.MemoryView":1163 - * else: - * for i in range(dst_extent): - * _copy_strided_to_strided(src_data, src_strides + 1, # <<<<<<<<<<<<<< - * dst_data, dst_strides + 1, - * src_shape + 1, dst_shape + 1, - */ - _copy_strided_to_strided(__pyx_v_src_data, (__pyx_v_src_strides + 1), __pyx_v_dst_data, (__pyx_v_dst_strides + 1), (__pyx_v_src_shape + 1), (__pyx_v_dst_shape + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize); - - /* "View.MemoryView":1167 - * src_shape + 1, dst_shape + 1, - * ndim - 1, itemsize) - * src_data += src_stride # <<<<<<<<<<<<<< - * dst_data += dst_stride - * - */ - __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); - - /* "View.MemoryView":1168 - * ndim - 1, itemsize) - * src_data += src_stride - * dst_data += dst_stride # <<<<<<<<<<<<<< - * - * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, - */ - __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride); - } - } - __pyx_L3:; - - /* "View.MemoryView":1140 - * - * @cython.cdivision(True) - * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< - * char *dst_data, Py_ssize_t *dst_strides, - * Py_ssize_t *src_shape, Py_ssize_t *dst_shape, - */ - - /* function exit code */ -} - -/* "View.MemoryView":1170 - * dst_data += dst_stride - * - * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< - * __Pyx_memviewslice *dst, - * int ndim, size_t itemsize) nogil: - */ - -static void copy_strided_to_strided(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize) { - - /* "View.MemoryView":1173 - * __Pyx_memviewslice *dst, - * int ndim, size_t itemsize) nogil: - * _copy_strided_to_strided(src.data, src.strides, dst.data, dst.strides, # <<<<<<<<<<<<<< - * src.shape, dst.shape, ndim, itemsize) - * - */ - _copy_strided_to_strided(__pyx_v_src->data, __pyx_v_src->strides, __pyx_v_dst->data, __pyx_v_dst->strides, __pyx_v_src->shape, __pyx_v_dst->shape, __pyx_v_ndim, __pyx_v_itemsize); - - /* "View.MemoryView":1170 - * dst_data += dst_stride - * - * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< - * __Pyx_memviewslice *dst, - * int ndim, size_t itemsize) nogil: - */ - - /* function exit code */ -} - -/* "View.MemoryView":1177 - * - * @cname('__pyx_memoryview_slice_get_size') - * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<< - * "Return the size of the memory occupied by the slice in number of bytes" - * cdef Py_ssize_t shape, size = src.memview.view.itemsize - */ - -static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_src, int __pyx_v_ndim) { - Py_ssize_t __pyx_v_shape; - Py_ssize_t __pyx_v_size; - Py_ssize_t __pyx_r; - Py_ssize_t __pyx_t_1; - Py_ssize_t *__pyx_t_2; - Py_ssize_t *__pyx_t_3; - Py_ssize_t *__pyx_t_4; - - /* "View.MemoryView":1179 - * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: - * "Return the size of the memory occupied by the slice in number of bytes" - * cdef Py_ssize_t shape, size = src.memview.view.itemsize # <<<<<<<<<<<<<< - * - * for shape in src.shape[:ndim]: - */ - __pyx_t_1 = __pyx_v_src->memview->view.itemsize; - __pyx_v_size = __pyx_t_1; - - /* "View.MemoryView":1181 - * cdef Py_ssize_t shape, size = src.memview.view.itemsize - * - * for shape in src.shape[:ndim]: # <<<<<<<<<<<<<< - * size *= shape - * - */ - __pyx_t_3 = (__pyx_v_src->shape + __pyx_v_ndim); - for (__pyx_t_4 = __pyx_v_src->shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { - __pyx_t_2 = __pyx_t_4; - __pyx_v_shape = (__pyx_t_2[0]); - - /* "View.MemoryView":1182 - * - * for shape in src.shape[:ndim]: - * size *= shape # <<<<<<<<<<<<<< - * - * return size - */ - __pyx_v_size = (__pyx_v_size * __pyx_v_shape); - } - - /* "View.MemoryView":1184 - * size *= shape - * - * return size # <<<<<<<<<<<<<< - * - * @cname('__pyx_fill_contig_strides_array') - */ - __pyx_r = __pyx_v_size; - goto __pyx_L0; - - /* "View.MemoryView":1177 - * - * @cname('__pyx_memoryview_slice_get_size') - * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<< - * "Return the size of the memory occupied by the slice in number of bytes" - * cdef Py_ssize_t shape, size = src.memview.view.itemsize - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":1187 - * - * @cname('__pyx_fill_contig_strides_array') - * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< - * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, - * int ndim, char order) nogil: - */ - -static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, Py_ssize_t __pyx_v_stride, int __pyx_v_ndim, char __pyx_v_order) { - int __pyx_v_idx; - Py_ssize_t __pyx_r; - int __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - int __pyx_t_4; - - /* "View.MemoryView":1196 - * cdef int idx - * - * if order == 'F': # <<<<<<<<<<<<<< - * for idx in range(ndim): - * strides[idx] = stride - */ - __pyx_t_1 = ((__pyx_v_order == 'F') != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":1197 - * - * if order == 'F': - * for idx in range(ndim): # <<<<<<<<<<<<<< - * strides[idx] = stride - * stride *= shape[idx] - */ - __pyx_t_2 = __pyx_v_ndim; - __pyx_t_3 = __pyx_t_2; - for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { - __pyx_v_idx = __pyx_t_4; - - /* "View.MemoryView":1198 - * if order == 'F': - * for idx in range(ndim): - * strides[idx] = stride # <<<<<<<<<<<<<< - * stride *= shape[idx] - * else: - */ - (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; - - /* "View.MemoryView":1199 - * for idx in range(ndim): - * strides[idx] = stride - * stride *= shape[idx] # <<<<<<<<<<<<<< - * else: - * for idx in range(ndim - 1, -1, -1): - */ - __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx])); - } - - /* "View.MemoryView":1196 - * cdef int idx - * - * if order == 'F': # <<<<<<<<<<<<<< - * for idx in range(ndim): - * strides[idx] = stride - */ - goto __pyx_L3; - } - - /* "View.MemoryView":1201 - * stride *= shape[idx] - * else: - * for idx in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< - * strides[idx] = stride - * stride *= shape[idx] - */ - /*else*/ { - for (__pyx_t_2 = (__pyx_v_ndim - 1); __pyx_t_2 > -1; __pyx_t_2-=1) { - __pyx_v_idx = __pyx_t_2; - - /* "View.MemoryView":1202 - * else: - * for idx in range(ndim - 1, -1, -1): - * strides[idx] = stride # <<<<<<<<<<<<<< - * stride *= shape[idx] - * - */ - (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; - - /* "View.MemoryView":1203 - * for idx in range(ndim - 1, -1, -1): - * strides[idx] = stride - * stride *= shape[idx] # <<<<<<<<<<<<<< - * - * return stride - */ - __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx])); - } - } - __pyx_L3:; - - /* "View.MemoryView":1205 - * stride *= shape[idx] - * - * return stride # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_copy_data_to_temp') - */ - __pyx_r = __pyx_v_stride; - goto __pyx_L0; - - /* "View.MemoryView":1187 - * - * @cname('__pyx_fill_contig_strides_array') - * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< - * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, - * int ndim, char order) nogil: - */ - - /* function exit code */ - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":1208 - * - * @cname('__pyx_memoryview_copy_data_to_temp') - * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< - * __Pyx_memviewslice *tmpslice, - * char order, - */ - -static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_tmpslice, char __pyx_v_order, int __pyx_v_ndim) { - int __pyx_v_i; - void *__pyx_v_result; - size_t __pyx_v_itemsize; - size_t __pyx_v_size; - void *__pyx_r; - Py_ssize_t __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - struct __pyx_memoryview_obj *__pyx_t_4; - int __pyx_t_5; - int __pyx_t_6; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - - /* "View.MemoryView":1219 - * cdef void *result - * - * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< - * cdef size_t size = slice_get_size(src, ndim) - * - */ - __pyx_t_1 = __pyx_v_src->memview->view.itemsize; - __pyx_v_itemsize = __pyx_t_1; - - /* "View.MemoryView":1220 - * - * cdef size_t itemsize = src.memview.view.itemsize - * cdef size_t size = slice_get_size(src, ndim) # <<<<<<<<<<<<<< - * - * result = malloc(size) - */ - __pyx_v_size = __pyx_memoryview_slice_get_size(__pyx_v_src, __pyx_v_ndim); - - /* "View.MemoryView":1222 - * cdef size_t size = slice_get_size(src, ndim) - * - * result = malloc(size) # <<<<<<<<<<<<<< - * if not result: - * _err(MemoryError, NULL) - */ - __pyx_v_result = malloc(__pyx_v_size); - - /* "View.MemoryView":1223 - * - * result = malloc(size) - * if not result: # <<<<<<<<<<<<<< - * _err(MemoryError, NULL) - * - */ - __pyx_t_2 = ((!(__pyx_v_result != 0)) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":1224 - * 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, 1224, __pyx_L1_error) - - /* "View.MemoryView":1223 - * - * result = malloc(size) - * if not result: # <<<<<<<<<<<<<< - * _err(MemoryError, NULL) - * - */ - } - - /* "View.MemoryView":1227 - * - * - * tmpslice.data = result # <<<<<<<<<<<<<< - * tmpslice.memview = src.memview - * for i in range(ndim): - */ - __pyx_v_tmpslice->data = ((char *)__pyx_v_result); - - /* "View.MemoryView":1228 - * - * tmpslice.data = result - * tmpslice.memview = src.memview # <<<<<<<<<<<<<< - * for i in range(ndim): - * tmpslice.shape[i] = src.shape[i] - */ - __pyx_t_4 = __pyx_v_src->memview; - __pyx_v_tmpslice->memview = __pyx_t_4; - - /* "View.MemoryView":1229 - * tmpslice.data = result - * tmpslice.memview = src.memview - * for i in range(ndim): # <<<<<<<<<<<<<< - * tmpslice.shape[i] = src.shape[i] - * tmpslice.suboffsets[i] = -1 - */ - __pyx_t_3 = __pyx_v_ndim; - __pyx_t_5 = __pyx_t_3; - for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { - __pyx_v_i = __pyx_t_6; - - /* "View.MemoryView":1230 - * tmpslice.memview = src.memview - * for i in range(ndim): - * tmpslice.shape[i] = src.shape[i] # <<<<<<<<<<<<<< - * tmpslice.suboffsets[i] = -1 - * - */ - (__pyx_v_tmpslice->shape[__pyx_v_i]) = (__pyx_v_src->shape[__pyx_v_i]); - - /* "View.MemoryView":1231 - * for i in range(ndim): - * tmpslice.shape[i] = src.shape[i] - * tmpslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< - * - * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, - */ - (__pyx_v_tmpslice->suboffsets[__pyx_v_i]) = -1L; - } - - /* "View.MemoryView":1233 - * tmpslice.suboffsets[i] = -1 - * - * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, # <<<<<<<<<<<<<< - * ndim, order) - * - */ - (void)(__pyx_fill_contig_strides_array((&(__pyx_v_tmpslice->shape[0])), (&(__pyx_v_tmpslice->strides[0])), __pyx_v_itemsize, __pyx_v_ndim, __pyx_v_order)); - - /* "View.MemoryView":1237 - * - * - * for i in range(ndim): # <<<<<<<<<<<<<< - * if tmpslice.shape[i] == 1: - * tmpslice.strides[i] = 0 - */ - __pyx_t_3 = __pyx_v_ndim; - __pyx_t_5 = __pyx_t_3; - for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { - __pyx_v_i = __pyx_t_6; - - /* "View.MemoryView":1238 - * - * for i in range(ndim): - * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< - * tmpslice.strides[i] = 0 - * - */ - __pyx_t_2 = (((__pyx_v_tmpslice->shape[__pyx_v_i]) == 1) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":1239 - * for i in range(ndim): - * if tmpslice.shape[i] == 1: - * tmpslice.strides[i] = 0 # <<<<<<<<<<<<<< - * - * if slice_is_contig(src[0], order, ndim): - */ - (__pyx_v_tmpslice->strides[__pyx_v_i]) = 0; - - /* "View.MemoryView":1238 - * - * for i in range(ndim): - * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< - * tmpslice.strides[i] = 0 - * - */ - } - } - - /* "View.MemoryView":1241 - * tmpslice.strides[i] = 0 - * - * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< - * memcpy(result, src.data, size) - * else: - */ - __pyx_t_2 = (__pyx_memviewslice_is_contig((__pyx_v_src[0]), __pyx_v_order, __pyx_v_ndim) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":1242 - * - * if slice_is_contig(src[0], order, ndim): - * memcpy(result, src.data, size) # <<<<<<<<<<<<<< - * else: - * copy_strided_to_strided(src, tmpslice, ndim, itemsize) - */ - (void)(memcpy(__pyx_v_result, __pyx_v_src->data, __pyx_v_size)); - - /* "View.MemoryView":1241 - * tmpslice.strides[i] = 0 - * - * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< - * memcpy(result, src.data, size) - * else: - */ - goto __pyx_L9; - } - - /* "View.MemoryView":1244 - * memcpy(result, src.data, size) - * else: - * copy_strided_to_strided(src, tmpslice, ndim, itemsize) # <<<<<<<<<<<<<< - * - * return result - */ - /*else*/ { - copy_strided_to_strided(__pyx_v_src, __pyx_v_tmpslice, __pyx_v_ndim, __pyx_v_itemsize); - } - __pyx_L9:; - - /* "View.MemoryView":1246 - * copy_strided_to_strided(src, tmpslice, ndim, itemsize) - * - * return result # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = __pyx_v_result; - goto __pyx_L0; - - /* "View.MemoryView":1208 - * - * @cname('__pyx_memoryview_copy_data_to_temp') - * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< - * __Pyx_memviewslice *tmpslice, - * char order, - */ - - /* function exit code */ - __pyx_L1_error:; - { - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_AddTraceback("View.MemoryView.copy_data_to_temp", __pyx_clineno, __pyx_lineno, __pyx_filename); - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - } - __pyx_r = NULL; - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":1251 - * - * @cname('__pyx_memoryview_err_extents') - * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< - * Py_ssize_t extent2) except -1 with gil: - * raise ValueError("got differing extents in dimension %d (got %d and %d)" % - */ - -static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent1, Py_ssize_t __pyx_v_extent2) { - int __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_RefNannySetupContext("_err_extents", 0); - - /* "View.MemoryView":1254 - * 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, 1254, __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, 1254, __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, 1254, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1254, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3); - __pyx_t_1 = 0; - __pyx_t_2 = 0; - __pyx_t_3 = 0; - - /* "View.MemoryView":1253 - * 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, 1253, __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, 1253, __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, 1253, __pyx_L1_error) - - /* "View.MemoryView":1251 - * - * @cname('__pyx_memoryview_err_extents') - * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< - * Py_ssize_t extent2) except -1 with gil: - * raise ValueError("got differing extents in dimension %d (got %d and %d)" % - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("View.MemoryView._err_extents", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __Pyx_RefNannyFinishContext(); - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - return __pyx_r; -} - -/* "View.MemoryView":1257 - * - * @cname('__pyx_memoryview_err_dim') - * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< - * raise error(msg.decode('ascii') % dim) - * - */ - -static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg, int __pyx_v_dim) { - int __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_RefNannySetupContext("_err_dim", 0); - __Pyx_INCREF(__pyx_v_error); - - /* "View.MemoryView":1258 - * @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, 1258, __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, 1258, __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, 1258, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_INCREF(__pyx_v_error); - __pyx_t_3 = __pyx_v_error; __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - } - } - __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, 1258, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(1, 1258, __pyx_L1_error) - - /* "View.MemoryView":1257 - * - * @cname('__pyx_memoryview_err_dim') - * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< - * raise error(msg.decode('ascii') % dim) - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("View.MemoryView._err_dim", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __Pyx_XDECREF(__pyx_v_error); - __Pyx_RefNannyFinishContext(); - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - return __pyx_r; -} - -/* "View.MemoryView":1261 - * - * @cname('__pyx_memoryview_err') - * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< - * if msg != NULL: - * raise error(msg.decode('ascii')) - */ - -static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { - int __pyx_r; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_RefNannySetupContext("_err", 0); - __Pyx_INCREF(__pyx_v_error); - - /* "View.MemoryView":1262 - * @cname('__pyx_memoryview_err') - * cdef int _err(object error, char *msg) except -1 with gil: - * if msg != NULL: # <<<<<<<<<<<<<< - * raise error(msg.decode('ascii')) - * else: - */ - __pyx_t_1 = ((__pyx_v_msg != NULL) != 0); - if (unlikely(__pyx_t_1)) { - - /* "View.MemoryView":1263 - * 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, 1263, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_v_error); - __pyx_t_4 = __pyx_v_error; __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - } - } - __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, 1263, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_Raise(__pyx_t_2, 0, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(1, 1263, __pyx_L1_error) - - /* "View.MemoryView":1262 - * @cname('__pyx_memoryview_err') - * cdef int _err(object error, char *msg) except -1 with gil: - * if msg != NULL: # <<<<<<<<<<<<<< - * raise error(msg.decode('ascii')) - * else: - */ - } - - /* "View.MemoryView":1265 - * raise error(msg.decode('ascii')) - * else: - * raise error # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_copy_contents') - */ - /*else*/ { - __Pyx_Raise(__pyx_v_error, 0, 0, 0); - __PYX_ERR(1, 1265, __pyx_L1_error) - } - - /* "View.MemoryView":1261 - * - * @cname('__pyx_memoryview_err') - * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< - * if msg != NULL: - * raise error(msg.decode('ascii')) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("View.MemoryView._err", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __Pyx_XDECREF(__pyx_v_error); - __Pyx_RefNannyFinishContext(); - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - return __pyx_r; -} - -/* "View.MemoryView":1268 - * - * @cname('__pyx_memoryview_copy_contents') - * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< - * __Pyx_memviewslice dst, - * int src_ndim, int dst_ndim, - */ - -static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_memviewslice __pyx_v_dst, int __pyx_v_src_ndim, int __pyx_v_dst_ndim, int __pyx_v_dtype_is_object) { - void *__pyx_v_tmpdata; - size_t __pyx_v_itemsize; - int __pyx_v_i; - char __pyx_v_order; - int __pyx_v_broadcasting; - int __pyx_v_direct_copy; - __Pyx_memviewslice __pyx_v_tmp; - int __pyx_v_ndim; - int __pyx_r; - Py_ssize_t __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - int __pyx_t_4; - int __pyx_t_5; - int __pyx_t_6; - void *__pyx_t_7; - int __pyx_t_8; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - - /* "View.MemoryView":1276 - * Check for overlapping memory and verify the shapes. - * """ - * cdef void *tmpdata = NULL # <<<<<<<<<<<<<< - * cdef size_t itemsize = src.memview.view.itemsize - * cdef int i - */ - __pyx_v_tmpdata = NULL; - - /* "View.MemoryView":1277 - * """ - * cdef void *tmpdata = NULL - * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< - * cdef int i - * cdef char order = get_best_order(&src, src_ndim) - */ - __pyx_t_1 = __pyx_v_src.memview->view.itemsize; - __pyx_v_itemsize = __pyx_t_1; - - /* "View.MemoryView":1279 - * cdef size_t itemsize = src.memview.view.itemsize - * cdef int i - * cdef char order = get_best_order(&src, src_ndim) # <<<<<<<<<<<<<< - * cdef bint broadcasting = False - * cdef bint direct_copy = False - */ - __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_src), __pyx_v_src_ndim); - - /* "View.MemoryView":1280 - * cdef int i - * cdef char order = get_best_order(&src, src_ndim) - * cdef bint broadcasting = False # <<<<<<<<<<<<<< - * cdef bint direct_copy = False - * cdef __Pyx_memviewslice tmp - */ - __pyx_v_broadcasting = 0; - - /* "View.MemoryView":1281 - * cdef char order = get_best_order(&src, src_ndim) - * cdef bint broadcasting = False - * cdef bint direct_copy = False # <<<<<<<<<<<<<< - * cdef __Pyx_memviewslice tmp - * - */ - __pyx_v_direct_copy = 0; - - /* "View.MemoryView":1284 - * cdef __Pyx_memviewslice tmp - * - * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< - * broadcast_leading(&src, src_ndim, dst_ndim) - * elif dst_ndim < src_ndim: - */ - __pyx_t_2 = ((__pyx_v_src_ndim < __pyx_v_dst_ndim) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":1285 - * - * if src_ndim < dst_ndim: - * broadcast_leading(&src, src_ndim, dst_ndim) # <<<<<<<<<<<<<< - * elif dst_ndim < src_ndim: - * broadcast_leading(&dst, dst_ndim, src_ndim) - */ - __pyx_memoryview_broadcast_leading((&__pyx_v_src), __pyx_v_src_ndim, __pyx_v_dst_ndim); - - /* "View.MemoryView":1284 - * cdef __Pyx_memviewslice tmp - * - * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< - * broadcast_leading(&src, src_ndim, dst_ndim) - * elif dst_ndim < src_ndim: - */ - goto __pyx_L3; - } - - /* "View.MemoryView":1286 - * if src_ndim < dst_ndim: - * broadcast_leading(&src, src_ndim, dst_ndim) - * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< - * broadcast_leading(&dst, dst_ndim, src_ndim) - * - */ - __pyx_t_2 = ((__pyx_v_dst_ndim < __pyx_v_src_ndim) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":1287 - * broadcast_leading(&src, src_ndim, dst_ndim) - * elif dst_ndim < src_ndim: - * broadcast_leading(&dst, dst_ndim, src_ndim) # <<<<<<<<<<<<<< - * - * cdef int ndim = max(src_ndim, dst_ndim) - */ - __pyx_memoryview_broadcast_leading((&__pyx_v_dst), __pyx_v_dst_ndim, __pyx_v_src_ndim); - - /* "View.MemoryView":1286 - * if src_ndim < dst_ndim: - * broadcast_leading(&src, src_ndim, dst_ndim) - * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< - * broadcast_leading(&dst, dst_ndim, src_ndim) - * - */ - } - __pyx_L3:; - - /* "View.MemoryView":1289 - * broadcast_leading(&dst, dst_ndim, src_ndim) - * - * cdef int ndim = max(src_ndim, dst_ndim) # <<<<<<<<<<<<<< - * - * for i in range(ndim): - */ - __pyx_t_3 = __pyx_v_dst_ndim; - __pyx_t_4 = __pyx_v_src_ndim; - if (((__pyx_t_3 > __pyx_t_4) != 0)) { - __pyx_t_5 = __pyx_t_3; - } else { - __pyx_t_5 = __pyx_t_4; - } - __pyx_v_ndim = __pyx_t_5; - - /* "View.MemoryView":1291 - * cdef int ndim = max(src_ndim, dst_ndim) - * - * for i in range(ndim): # <<<<<<<<<<<<<< - * if src.shape[i] != dst.shape[i]: - * if src.shape[i] == 1: - */ - __pyx_t_5 = __pyx_v_ndim; - __pyx_t_3 = __pyx_t_5; - for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { - __pyx_v_i = __pyx_t_4; - - /* "View.MemoryView":1292 - * - * for i in range(ndim): - * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< - * if src.shape[i] == 1: - * broadcasting = True - */ - __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) != (__pyx_v_dst.shape[__pyx_v_i])) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":1293 - * for i in range(ndim): - * if src.shape[i] != dst.shape[i]: - * if src.shape[i] == 1: # <<<<<<<<<<<<<< - * broadcasting = True - * src.strides[i] = 0 - */ - __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) == 1) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":1294 - * if src.shape[i] != dst.shape[i]: - * if src.shape[i] == 1: - * broadcasting = True # <<<<<<<<<<<<<< - * src.strides[i] = 0 - * else: - */ - __pyx_v_broadcasting = 1; - - /* "View.MemoryView":1295 - * if src.shape[i] == 1: - * broadcasting = True - * src.strides[i] = 0 # <<<<<<<<<<<<<< - * else: - * _err_extents(i, dst.shape[i], src.shape[i]) - */ - (__pyx_v_src.strides[__pyx_v_i]) = 0; - - /* "View.MemoryView":1293 - * for i in range(ndim): - * if src.shape[i] != dst.shape[i]: - * if src.shape[i] == 1: # <<<<<<<<<<<<<< - * broadcasting = True - * src.strides[i] = 0 - */ - goto __pyx_L7; - } - - /* "View.MemoryView":1297 - * src.strides[i] = 0 - * else: - * _err_extents(i, dst.shape[i], src.shape[i]) # <<<<<<<<<<<<<< - * - * if src.suboffsets[i] >= 0: - */ - /*else*/ { - __pyx_t_6 = __pyx_memoryview_err_extents(__pyx_v_i, (__pyx_v_dst.shape[__pyx_v_i]), (__pyx_v_src.shape[__pyx_v_i])); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1297, __pyx_L1_error) - } - __pyx_L7:; - - /* "View.MemoryView":1292 - * - * for i in range(ndim): - * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< - * if src.shape[i] == 1: - * broadcasting = True - */ - } - - /* "View.MemoryView":1299 - * _err_extents(i, dst.shape[i], src.shape[i]) - * - * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< - * _err_dim(ValueError, "Dimension %d is not direct", i) - * - */ - __pyx_t_2 = (((__pyx_v_src.suboffsets[__pyx_v_i]) >= 0) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":1300 - * - * 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, 1300, __pyx_L1_error) - - /* "View.MemoryView":1299 - * _err_extents(i, dst.shape[i], src.shape[i]) - * - * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< - * _err_dim(ValueError, "Dimension %d is not direct", i) - * - */ - } - } - - /* "View.MemoryView":1302 - * _err_dim(ValueError, "Dimension %d is not direct", i) - * - * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< - * - * if not slice_is_contig(src, order, ndim): - */ - __pyx_t_2 = (__pyx_slices_overlap((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":1304 - * if slices_overlap(&src, &dst, ndim, itemsize): - * - * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< - * order = get_best_order(&dst, ndim) - * - */ - __pyx_t_2 = ((!(__pyx_memviewslice_is_contig(__pyx_v_src, __pyx_v_order, __pyx_v_ndim) != 0)) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":1305 - * - * if not slice_is_contig(src, order, ndim): - * order = get_best_order(&dst, ndim) # <<<<<<<<<<<<<< - * - * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) - */ - __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim); - - /* "View.MemoryView":1304 - * if slices_overlap(&src, &dst, ndim, itemsize): - * - * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< - * order = get_best_order(&dst, ndim) - * - */ - } - - /* "View.MemoryView":1307 - * 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, 1307, __pyx_L1_error) - __pyx_v_tmpdata = __pyx_t_7; - - /* "View.MemoryView":1308 - * - * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) - * src = tmp # <<<<<<<<<<<<<< - * - * if not broadcasting: - */ - __pyx_v_src = __pyx_v_tmp; - - /* "View.MemoryView":1302 - * _err_dim(ValueError, "Dimension %d is not direct", i) - * - * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< - * - * if not slice_is_contig(src, order, ndim): - */ - } - - /* "View.MemoryView":1310 - * src = tmp - * - * if not broadcasting: # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_2 = ((!(__pyx_v_broadcasting != 0)) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":1313 - * - * - * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< - * direct_copy = slice_is_contig(dst, 'C', ndim) - * elif slice_is_contig(src, 'F', ndim): - */ - __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'C', __pyx_v_ndim) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":1314 - * - * if slice_is_contig(src, 'C', ndim): - * direct_copy = slice_is_contig(dst, 'C', ndim) # <<<<<<<<<<<<<< - * elif slice_is_contig(src, 'F', ndim): - * direct_copy = slice_is_contig(dst, 'F', ndim) - */ - __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'C', __pyx_v_ndim); - - /* "View.MemoryView":1313 - * - * - * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< - * direct_copy = slice_is_contig(dst, 'C', ndim) - * elif slice_is_contig(src, 'F', ndim): - */ - goto __pyx_L12; - } - - /* "View.MemoryView":1315 - * if slice_is_contig(src, 'C', ndim): - * direct_copy = slice_is_contig(dst, 'C', ndim) - * elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<< - * direct_copy = slice_is_contig(dst, 'F', ndim) - * - */ - __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'F', __pyx_v_ndim) != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":1316 - * direct_copy = slice_is_contig(dst, 'C', ndim) - * elif slice_is_contig(src, 'F', ndim): - * direct_copy = slice_is_contig(dst, 'F', ndim) # <<<<<<<<<<<<<< - * - * if direct_copy: - */ - __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'F', __pyx_v_ndim); - - /* "View.MemoryView":1315 - * if slice_is_contig(src, 'C', ndim): - * direct_copy = slice_is_contig(dst, 'C', ndim) - * elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<< - * direct_copy = slice_is_contig(dst, 'F', ndim) - * - */ - } - __pyx_L12:; - - /* "View.MemoryView":1318 - * direct_copy = slice_is_contig(dst, 'F', ndim) - * - * if direct_copy: # <<<<<<<<<<<<<< - * - * refcount_copying(&dst, dtype_is_object, ndim, False) - */ - __pyx_t_2 = (__pyx_v_direct_copy != 0); - if (__pyx_t_2) { - - /* "View.MemoryView":1320 - * if direct_copy: - * - * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< - * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) - * refcount_copying(&dst, dtype_is_object, ndim, True) - */ - __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); - - /* "View.MemoryView":1321 - * - * refcount_copying(&dst, dtype_is_object, ndim, False) - * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) # <<<<<<<<<<<<<< - * refcount_copying(&dst, dtype_is_object, ndim, True) - * free(tmpdata) - */ - (void)(memcpy(__pyx_v_dst.data, __pyx_v_src.data, __pyx_memoryview_slice_get_size((&__pyx_v_src), __pyx_v_ndim))); - - /* "View.MemoryView":1322 - * refcount_copying(&dst, dtype_is_object, ndim, False) - * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) - * refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< - * free(tmpdata) - * return 0 - */ - __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); - - /* "View.MemoryView":1323 - * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) - * refcount_copying(&dst, dtype_is_object, ndim, True) - * free(tmpdata) # <<<<<<<<<<<<<< - * return 0 - * - */ - free(__pyx_v_tmpdata); - - /* "View.MemoryView":1324 - * refcount_copying(&dst, dtype_is_object, ndim, True) - * free(tmpdata) - * return 0 # <<<<<<<<<<<<<< - * - * if order == 'F' == get_best_order(&dst, ndim): - */ - __pyx_r = 0; - goto __pyx_L0; - - /* "View.MemoryView":1318 - * direct_copy = slice_is_contig(dst, 'F', ndim) - * - * if direct_copy: # <<<<<<<<<<<<<< - * - * refcount_copying(&dst, dtype_is_object, ndim, False) - */ - } - - /* "View.MemoryView":1310 - * src = tmp - * - * if not broadcasting: # <<<<<<<<<<<<<< - * - * - */ - } - - /* "View.MemoryView":1326 - * return 0 - * - * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_2 = (__pyx_v_order == 'F'); - if (__pyx_t_2) { - __pyx_t_2 = ('F' == __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim)); - } - __pyx_t_8 = (__pyx_t_2 != 0); - if (__pyx_t_8) { - - /* "View.MemoryView":1329 - * - * - * 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, 1329, __pyx_L1_error) - - /* "View.MemoryView":1330 - * - * 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, 1330, __pyx_L1_error) - - /* "View.MemoryView":1326 - * return 0 - * - * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< - * - * - */ - } - - /* "View.MemoryView":1332 - * transpose_memslice(&dst) - * - * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< - * copy_strided_to_strided(&src, &dst, ndim, itemsize) - * refcount_copying(&dst, dtype_is_object, ndim, True) - */ - __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); - - /* "View.MemoryView":1333 - * - * refcount_copying(&dst, dtype_is_object, ndim, False) - * copy_strided_to_strided(&src, &dst, ndim, itemsize) # <<<<<<<<<<<<<< - * refcount_copying(&dst, dtype_is_object, ndim, True) - * - */ - copy_strided_to_strided((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize); - - /* "View.MemoryView":1334 - * refcount_copying(&dst, dtype_is_object, ndim, False) - * copy_strided_to_strided(&src, &dst, ndim, itemsize) - * refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< - * - * free(tmpdata) - */ - __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); - - /* "View.MemoryView":1336 - * refcount_copying(&dst, dtype_is_object, ndim, True) - * - * free(tmpdata) # <<<<<<<<<<<<<< - * return 0 - * - */ - free(__pyx_v_tmpdata); - - /* "View.MemoryView":1337 - * - * free(tmpdata) - * return 0 # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_broadcast_leading') - */ - __pyx_r = 0; - goto __pyx_L0; - - /* "View.MemoryView":1268 - * - * @cname('__pyx_memoryview_copy_contents') - * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< - * __Pyx_memviewslice dst, - * int src_ndim, int dst_ndim, - */ - - /* function exit code */ - __pyx_L1_error:; - { - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_AddTraceback("View.MemoryView.memoryview_copy_contents", __pyx_clineno, __pyx_lineno, __pyx_filename); - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif - } - __pyx_r = -1; - __pyx_L0:; - return __pyx_r; -} - -/* "View.MemoryView":1340 - * - * @cname('__pyx_memoryview_broadcast_leading') - * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< - * int ndim, - * int ndim_other) nogil: - */ - -static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim, int __pyx_v_ndim_other) { - int __pyx_v_i; - int __pyx_v_offset; - int __pyx_t_1; - int __pyx_t_2; - int __pyx_t_3; - - /* "View.MemoryView":1344 - * int ndim_other) nogil: - * cdef int i - * cdef int offset = ndim_other - ndim # <<<<<<<<<<<<<< - * - * for i in range(ndim - 1, -1, -1): - */ - __pyx_v_offset = (__pyx_v_ndim_other - __pyx_v_ndim); - - /* "View.MemoryView":1346 - * cdef int offset = ndim_other - ndim - * - * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< - * mslice.shape[i + offset] = mslice.shape[i] - * mslice.strides[i + offset] = mslice.strides[i] - */ - for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { - __pyx_v_i = __pyx_t_1; - - /* "View.MemoryView":1347 - * - * for i in range(ndim - 1, -1, -1): - * mslice.shape[i + offset] = mslice.shape[i] # <<<<<<<<<<<<<< - * mslice.strides[i + offset] = mslice.strides[i] - * mslice.suboffsets[i + offset] = mslice.suboffsets[i] - */ - (__pyx_v_mslice->shape[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->shape[__pyx_v_i]); - - /* "View.MemoryView":1348 - * for i in range(ndim - 1, -1, -1): - * mslice.shape[i + offset] = mslice.shape[i] - * mslice.strides[i + offset] = mslice.strides[i] # <<<<<<<<<<<<<< - * mslice.suboffsets[i + offset] = mslice.suboffsets[i] - * - */ - (__pyx_v_mslice->strides[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->strides[__pyx_v_i]); - - /* "View.MemoryView":1349 - * mslice.shape[i + offset] = mslice.shape[i] - * mslice.strides[i + offset] = mslice.strides[i] - * mslice.suboffsets[i + offset] = mslice.suboffsets[i] # <<<<<<<<<<<<<< - * - * for i in range(offset): - */ - (__pyx_v_mslice->suboffsets[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->suboffsets[__pyx_v_i]); - } - - /* "View.MemoryView":1351 - * mslice.suboffsets[i + offset] = mslice.suboffsets[i] - * - * for i in range(offset): # <<<<<<<<<<<<<< - * mslice.shape[i] = 1 - * mslice.strides[i] = mslice.strides[0] - */ - __pyx_t_1 = __pyx_v_offset; - __pyx_t_2 = __pyx_t_1; - for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { - __pyx_v_i = __pyx_t_3; - - /* "View.MemoryView":1352 - * - * for i in range(offset): - * mslice.shape[i] = 1 # <<<<<<<<<<<<<< - * mslice.strides[i] = mslice.strides[0] - * mslice.suboffsets[i] = -1 - */ - (__pyx_v_mslice->shape[__pyx_v_i]) = 1; - - /* "View.MemoryView":1353 - * for i in range(offset): - * mslice.shape[i] = 1 - * mslice.strides[i] = mslice.strides[0] # <<<<<<<<<<<<<< - * mslice.suboffsets[i] = -1 - * - */ - (__pyx_v_mslice->strides[__pyx_v_i]) = (__pyx_v_mslice->strides[0]); - - /* "View.MemoryView":1354 - * mslice.shape[i] = 1 - * mslice.strides[i] = mslice.strides[0] - * mslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< - * - * - */ - (__pyx_v_mslice->suboffsets[__pyx_v_i]) = -1L; - } - - /* "View.MemoryView":1340 - * - * @cname('__pyx_memoryview_broadcast_leading') - * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< - * int ndim, - * int ndim_other) nogil: - */ - - /* function exit code */ -} - -/* "View.MemoryView":1362 - * - * @cname('__pyx_memoryview_refcount_copying') - * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< - * int ndim, bint inc) nogil: - * - */ - -static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_dtype_is_object, int __pyx_v_ndim, int __pyx_v_inc) { - int __pyx_t_1; - - /* "View.MemoryView":1366 - * - * - * if dtype_is_object: # <<<<<<<<<<<<<< - * refcount_objects_in_slice_with_gil(dst.data, dst.shape, - * dst.strides, ndim, inc) - */ - __pyx_t_1 = (__pyx_v_dtype_is_object != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":1367 - * - * if dtype_is_object: - * refcount_objects_in_slice_with_gil(dst.data, dst.shape, # <<<<<<<<<<<<<< - * dst.strides, ndim, inc) - * - */ - __pyx_memoryview_refcount_objects_in_slice_with_gil(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_inc); - - /* "View.MemoryView":1366 - * - * - * if dtype_is_object: # <<<<<<<<<<<<<< - * refcount_objects_in_slice_with_gil(dst.data, dst.shape, - * dst.strides, ndim, inc) - */ - } - - /* "View.MemoryView":1362 - * - * @cname('__pyx_memoryview_refcount_copying') - * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< - * int ndim, bint inc) nogil: - * - */ - - /* function exit code */ -} - -/* "View.MemoryView":1371 - * - * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') - * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< - * Py_ssize_t *strides, int ndim, - * bint inc) with gil: - */ - -static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) { - __Pyx_RefNannyDeclarations - #ifdef WITH_THREAD - PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); - #endif - __Pyx_RefNannySetupContext("refcount_objects_in_slice_with_gil", 0); - - /* "View.MemoryView":1374 - * Py_ssize_t *strides, int ndim, - * bint inc) with gil: - * refcount_objects_in_slice(data, shape, strides, ndim, inc) # <<<<<<<<<<<<<< - * - * @cname('__pyx_memoryview_refcount_objects_in_slice') - */ - __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, __pyx_v_shape, __pyx_v_strides, __pyx_v_ndim, __pyx_v_inc); - - /* "View.MemoryView":1371 - * - * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') - * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< - * Py_ssize_t *strides, int ndim, - * bint inc) with gil: - */ - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - #ifdef WITH_THREAD - __Pyx_PyGILState_Release(__pyx_gilstate_save); - #endif -} - -/* "View.MemoryView":1377 - * - * @cname('__pyx_memoryview_refcount_objects_in_slice') - * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< - * Py_ssize_t *strides, int ndim, bint inc): - * cdef Py_ssize_t i - */ - -static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) { - CYTHON_UNUSED Py_ssize_t __pyx_v_i; - __Pyx_RefNannyDeclarations - Py_ssize_t __pyx_t_1; - Py_ssize_t __pyx_t_2; - Py_ssize_t __pyx_t_3; - int __pyx_t_4; - __Pyx_RefNannySetupContext("refcount_objects_in_slice", 0); - - /* "View.MemoryView":1381 - * cdef Py_ssize_t i - * - * for i in range(shape[0]): # <<<<<<<<<<<<<< - * if ndim == 1: - * if inc: - */ - __pyx_t_1 = (__pyx_v_shape[0]); - __pyx_t_2 = __pyx_t_1; - for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { - __pyx_v_i = __pyx_t_3; - - /* "View.MemoryView":1382 - * - * for i in range(shape[0]): - * if ndim == 1: # <<<<<<<<<<<<<< - * if inc: - * Py_INCREF(( data)[0]) - */ - __pyx_t_4 = ((__pyx_v_ndim == 1) != 0); - if (__pyx_t_4) { - - /* "View.MemoryView":1383 - * for i in range(shape[0]): - * if ndim == 1: - * if inc: # <<<<<<<<<<<<<< - * Py_INCREF(( data)[0]) - * else: - */ - __pyx_t_4 = (__pyx_v_inc != 0); - if (__pyx_t_4) { - - /* "View.MemoryView":1384 - * if ndim == 1: - * if inc: - * Py_INCREF(( data)[0]) # <<<<<<<<<<<<<< - * else: - * Py_DECREF(( data)[0]) - */ - Py_INCREF((((PyObject **)__pyx_v_data)[0])); - - /* "View.MemoryView":1383 - * for i in range(shape[0]): - * if ndim == 1: - * if inc: # <<<<<<<<<<<<<< - * Py_INCREF(( data)[0]) - * else: - */ - goto __pyx_L6; - } - - /* "View.MemoryView":1386 - * Py_INCREF(( data)[0]) - * else: - * Py_DECREF(( data)[0]) # <<<<<<<<<<<<<< - * else: - * refcount_objects_in_slice(data, shape + 1, strides + 1, - */ - /*else*/ { - Py_DECREF((((PyObject **)__pyx_v_data)[0])); - } - __pyx_L6:; - - /* "View.MemoryView":1382 - * - * for i in range(shape[0]): - * if ndim == 1: # <<<<<<<<<<<<<< - * if inc: - * Py_INCREF(( data)[0]) - */ - goto __pyx_L5; - } - - /* "View.MemoryView":1388 - * Py_DECREF(( data)[0]) - * else: - * refcount_objects_in_slice(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< - * ndim - 1, inc) - * - */ - /*else*/ { - - /* "View.MemoryView":1389 - * else: - * refcount_objects_in_slice(data, shape + 1, strides + 1, - * ndim - 1, inc) # <<<<<<<<<<<<<< - * - * data += strides[0] - */ - __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_inc); - } - __pyx_L5:; - - /* "View.MemoryView":1391 - * ndim - 1, inc) - * - * data += strides[0] # <<<<<<<<<<<<<< - * - * - */ - __pyx_v_data = (__pyx_v_data + (__pyx_v_strides[0])); - } - - /* "View.MemoryView":1377 - * - * @cname('__pyx_memoryview_refcount_objects_in_slice') - * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< - * Py_ssize_t *strides, int ndim, bint inc): - * cdef Py_ssize_t i - */ - - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -/* "View.MemoryView":1397 - * - * @cname('__pyx_memoryview_slice_assign_scalar') - * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< - * size_t itemsize, void *item, - * bint dtype_is_object) nogil: - */ - -static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item, int __pyx_v_dtype_is_object) { - - /* "View.MemoryView":1400 - * size_t itemsize, void *item, - * bint dtype_is_object) nogil: - * refcount_copying(dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< - * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, - * itemsize, item) - */ - __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 0); - - /* "View.MemoryView":1401 - * bint dtype_is_object) nogil: - * refcount_copying(dst, dtype_is_object, ndim, False) - * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, # <<<<<<<<<<<<<< - * itemsize, item) - * refcount_copying(dst, dtype_is_object, ndim, True) - */ - __pyx_memoryview__slice_assign_scalar(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_itemsize, __pyx_v_item); - - /* "View.MemoryView":1403 - * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, - * itemsize, item) - * refcount_copying(dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< - * - * - */ - __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 1); - - /* "View.MemoryView":1397 - * - * @cname('__pyx_memoryview_slice_assign_scalar') - * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< - * size_t itemsize, void *item, - * bint dtype_is_object) nogil: - */ - - /* function exit code */ -} - -/* "View.MemoryView":1407 - * - * @cname('__pyx_memoryview__slice_assign_scalar') - * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< - * Py_ssize_t *strides, int ndim, - * size_t itemsize, void *item) nogil: - */ - -static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item) { - CYTHON_UNUSED Py_ssize_t __pyx_v_i; - Py_ssize_t __pyx_v_stride; - Py_ssize_t __pyx_v_extent; - int __pyx_t_1; - Py_ssize_t __pyx_t_2; - Py_ssize_t __pyx_t_3; - Py_ssize_t __pyx_t_4; - - /* "View.MemoryView":1411 - * size_t itemsize, void *item) nogil: - * cdef Py_ssize_t i - * cdef Py_ssize_t stride = strides[0] # <<<<<<<<<<<<<< - * cdef Py_ssize_t extent = shape[0] - * - */ - __pyx_v_stride = (__pyx_v_strides[0]); - - /* "View.MemoryView":1412 - * cdef Py_ssize_t i - * cdef Py_ssize_t stride = strides[0] - * cdef Py_ssize_t extent = shape[0] # <<<<<<<<<<<<<< - * - * if ndim == 1: - */ - __pyx_v_extent = (__pyx_v_shape[0]); - - /* "View.MemoryView":1414 - * cdef Py_ssize_t extent = shape[0] - * - * if ndim == 1: # <<<<<<<<<<<<<< - * for i in range(extent): - * memcpy(data, item, itemsize) - */ - __pyx_t_1 = ((__pyx_v_ndim == 1) != 0); - if (__pyx_t_1) { - - /* "View.MemoryView":1415 - * - * if ndim == 1: - * for i in range(extent): # <<<<<<<<<<<<<< - * memcpy(data, item, itemsize) - * data += stride - */ - __pyx_t_2 = __pyx_v_extent; - __pyx_t_3 = __pyx_t_2; - for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { - __pyx_v_i = __pyx_t_4; - - /* "View.MemoryView":1416 - * if ndim == 1: - * for i in range(extent): - * memcpy(data, item, itemsize) # <<<<<<<<<<<<<< - * data += stride - * else: - */ - (void)(memcpy(__pyx_v_data, __pyx_v_item, __pyx_v_itemsize)); - - /* "View.MemoryView":1417 - * for i in range(extent): - * memcpy(data, item, itemsize) - * data += stride # <<<<<<<<<<<<<< - * else: - * for i in range(extent): - */ - __pyx_v_data = (__pyx_v_data + __pyx_v_stride); - } - - /* "View.MemoryView":1414 - * cdef Py_ssize_t extent = shape[0] - * - * if ndim == 1: # <<<<<<<<<<<<<< - * for i in range(extent): - * memcpy(data, item, itemsize) - */ - goto __pyx_L3; - } - - /* "View.MemoryView":1419 - * data += stride - * else: - * for i in range(extent): # <<<<<<<<<<<<<< - * _slice_assign_scalar(data, shape + 1, strides + 1, - * ndim - 1, itemsize, item) - */ - /*else*/ { - __pyx_t_2 = __pyx_v_extent; - __pyx_t_3 = __pyx_t_2; - for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { - __pyx_v_i = __pyx_t_4; - - /* "View.MemoryView":1420 - * else: - * for i in range(extent): - * _slice_assign_scalar(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< - * ndim - 1, itemsize, item) - * data += stride - */ - __pyx_memoryview__slice_assign_scalar(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize, __pyx_v_item); - - /* "View.MemoryView":1422 - * _slice_assign_scalar(data, shape + 1, strides + 1, - * ndim - 1, itemsize, item) - * data += stride # <<<<<<<<<<<<<< - * - * - */ - __pyx_v_data = (__pyx_v_data + __pyx_v_stride); - } - } - __pyx_L3:; - - /* "View.MemoryView":1407 - * - * @cname('__pyx_memoryview__slice_assign_scalar') - * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< - * Py_ssize_t *strides, int ndim, - * size_t itemsize, void *item) nogil: - */ - - /* function exit code */ -} - -/* "(tree fragment)":1 - * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ - -/* 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 PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v___pyx_type = 0; - long __pyx_v___pyx_checksum; - PyObject *__pyx_v___pyx_state = 0; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__pyx_unpickle_Enum (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; - PyObject* values[3] = {0,0,0}; - if (unlikely(__pyx_kwds)) { - Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { - case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--; - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_Enum") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) - } - } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - values[2] = PyTuple_GET_ITEM(__pyx_args, 2); - } - __pyx_v___pyx_type = values[0]; - __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) - __pyx_v___pyx_state = values[2]; - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_v___pyx_PickleError = 0; - PyObject *__pyx_v___pyx_result = 0; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - int __pyx_t_6; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_unpickle_Enum", 0); - - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * if __pyx_checksum != 0xb068931: # <<<<<<<<<<<<<< - * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum) - */ - __pyx_t_1 = ((__pyx_v___pyx_checksum != 0xb068931) != 0); - if (__pyx_t_1) { - - /* "(tree fragment)":5 - * cdef object __pyx_result - * 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_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_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_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 - * 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_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_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_INCREF(__pyx_v___pyx_PickleError); - __pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } - } - __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); - __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) - - /* "(tree fragment)":4 - * cdef object __pyx_PickleError - * cdef object __pyx_result - * 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 - * 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_GOTREF(__pyx_t_2); - __pyx_t_4 = 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)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_4); - __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); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v___pyx_result = __pyx_t_3; - __pyx_t_3 = 0; - - /* "(tree fragment)":8 - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum) - * __pyx_result = Enum.__new__(__pyx_type) - * if __pyx_state is not None: # <<<<<<<<<<<<<< - * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) - * return __pyx_result - */ - __pyx_t_1 = (__pyx_v___pyx_state != Py_None); - __pyx_t_6 = (__pyx_t_1 != 0); - if (__pyx_t_6) { - - /* "(tree fragment)":9 - * __pyx_result = Enum.__new__(__pyx_type) - * if __pyx_state is not None: - * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< - * return __pyx_result - * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): - */ - if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(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) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "(tree fragment)":8 - * raise __pyx_PickleError("Incompatible checksums (%s vs 0xb068931 = (name))" % __pyx_checksum) - * __pyx_result = Enum.__new__(__pyx_type) - * if __pyx_state is not None: # <<<<<<<<<<<<<< - * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) - * return __pyx_result - */ - } - - /* "(tree fragment)":10 - * if __pyx_state is not None: - * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) - * return __pyx_result # <<<<<<<<<<<<<< - * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): - * __pyx_result.name = __pyx_state[0] - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v___pyx_result); - __pyx_r = __pyx_v___pyx_result; - goto __pyx_L0; - - /* "(tree fragment)":1 - * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v___pyx_PickleError); - __Pyx_XDECREF(__pyx_v___pyx_result); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":11 - * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result.name = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - */ - -static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_t_2; - Py_ssize_t __pyx_t_3; - int __pyx_t_4; - int __pyx_t_5; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_unpickle_Enum__set_state", 0); - - /* "(tree fragment)":12 - * return __pyx_result - * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): - * __pyx_result.name = __pyx_state[0] # <<<<<<<<<<<<<< - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - * __pyx_result.__dict__.update(__pyx_state[1]) - */ - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 12, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v___pyx_result->name); - __Pyx_DECREF(__pyx_v___pyx_result->name); - __pyx_v___pyx_result->name = __pyx_t_1; - __pyx_t_1 = 0; - - /* "(tree fragment)":13 - * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): - * __pyx_result.name = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< - * __pyx_result.__dict__.update(__pyx_state[1]) - */ - if (unlikely(__pyx_v___pyx_state == Py_None)) { - PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(1, 13, __pyx_L1_error) - } - __pyx_t_3 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) - __pyx_t_4 = ((__pyx_t_3 > 1) != 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_5 = (__pyx_t_4 != 0); - __pyx_t_2 = __pyx_t_5; - __pyx_L4_bool_binop_done:; - if (__pyx_t_2) { - - /* "(tree fragment)":14 - * __pyx_result.name = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< - */ - __pyx_t_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_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_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_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); - } - } - __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); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "(tree fragment)":13 - * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): - * __pyx_result.name = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< - * __pyx_result.__dict__.update(__pyx_state[1]) - */ - } - - /* "(tree fragment)":11 - * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result.name = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} -static struct __pyx_vtabstruct_array __pyx_vtable_array; - -static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k) { - struct __pyx_array_obj *p; - PyObject *o; - if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { - o = (*t->tp_alloc)(t, 0); - } else { - o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); - } - if (unlikely(!o)) return 0; - p = ((struct __pyx_array_obj *)o); - p->__pyx_vtab = __pyx_vtabptr_array; - p->mode = ((PyObject*)Py_None); Py_INCREF(Py_None); - p->_format = ((PyObject*)Py_None); Py_INCREF(Py_None); - if (unlikely(__pyx_array___cinit__(o, a, k) < 0)) goto bad; - return o; - bad: - Py_DECREF(o); o = 0; - return NULL; -} - -static void __pyx_tp_dealloc_array(PyObject *o) { - struct __pyx_array_obj *p = (struct __pyx_array_obj *)o; - #if CYTHON_USE_TP_FINALIZE - if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { - if (PyObject_CallFinalizerFromDealloc(o)) return; - } - #endif - { - PyObject *etype, *eval, *etb; - PyErr_Fetch(&etype, &eval, &etb); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); - __pyx_array___dealloc__(o); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); - PyErr_Restore(etype, eval, etb); - } - Py_CLEAR(p->mode); - Py_CLEAR(p->_format); - (*Py_TYPE(o)->tp_free)(o); -} -static PyObject *__pyx_sq_item_array(PyObject *o, Py_ssize_t i) { - PyObject *r; - PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; - r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); - Py_DECREF(x); - return r; -} - -static int __pyx_mp_ass_subscript_array(PyObject *o, PyObject *i, PyObject *v) { - if (v) { - return __pyx_array___setitem__(o, i, v); - } - else { - PyErr_Format(PyExc_NotImplementedError, - "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); - return -1; - } -} - -static PyObject *__pyx_tp_getattro_array(PyObject *o, PyObject *n) { - PyObject *v = __Pyx_PyObject_GenericGetAttr(o, n); - if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) { - PyErr_Clear(); - v = __pyx_array___getattr__(o, n); - } - return v; -} - -static PyObject *__pyx_getprop___pyx_array_memview(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(o); -} - -static PyMethodDef __pyx_methods_array[] = { - {"__getattr__", (PyCFunction)__pyx_array___getattr__, METH_O|METH_COEXIST, 0}, - {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_array_1__reduce_cython__, METH_NOARGS, 0}, - {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_array_3__setstate_cython__, METH_O, 0}, - {0, 0, 0, 0} -}; - -static struct PyGetSetDef __pyx_getsets_array[] = { - {(char *)"memview", __pyx_getprop___pyx_array_memview, 0, (char *)0, 0}, - {0, 0, 0, 0, 0} -}; - -static PySequenceMethods __pyx_tp_as_sequence_array = { - __pyx_array___len__, /*sq_length*/ - 0, /*sq_concat*/ - 0, /*sq_repeat*/ - __pyx_sq_item_array, /*sq_item*/ - 0, /*sq_slice*/ - 0, /*sq_ass_item*/ - 0, /*sq_ass_slice*/ - 0, /*sq_contains*/ - 0, /*sq_inplace_concat*/ - 0, /*sq_inplace_repeat*/ -}; - -static PyMappingMethods __pyx_tp_as_mapping_array = { - __pyx_array___len__, /*mp_length*/ - __pyx_array___getitem__, /*mp_subscript*/ - __pyx_mp_ass_subscript_array, /*mp_ass_subscript*/ -}; - -static PyBufferProcs __pyx_tp_as_buffer_array = { - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getreadbuffer*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getwritebuffer*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getsegcount*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getcharbuffer*/ - #endif - __pyx_array_getbuffer, /*bf_getbuffer*/ - 0, /*bf_releasebuffer*/ -}; - -static PyTypeObject __pyx_type___pyx_array = { - PyVarObject_HEAD_INIT(0, 0) - "core.array", /*tp_name*/ - sizeof(struct __pyx_array_obj), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_array, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - &__pyx_tp_as_sequence_array, /*tp_as_sequence*/ - &__pyx_tp_as_mapping_array, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - __pyx_tp_getattro_array, /*tp_getattro*/ - 0, /*tp_setattro*/ - &__pyx_tp_as_buffer_array, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ - 0, /*tp_doc*/ - 0, /*tp_traverse*/ - 0, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods_array, /*tp_methods*/ - 0, /*tp_members*/ - __pyx_getsets_array, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - 0, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_array, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - 0, /*tp_finalize*/ - #endif - #if PY_VERSION_HEX >= 0x030800b1 - 0, /*tp_vectorcall*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif -}; - -static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - struct __pyx_MemviewEnum_obj *p; - PyObject *o; - if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { - o = (*t->tp_alloc)(t, 0); - } else { - o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); - } - if (unlikely(!o)) return 0; - p = ((struct __pyx_MemviewEnum_obj *)o); - p->name = Py_None; Py_INCREF(Py_None); - return o; -} - -static void __pyx_tp_dealloc_Enum(PyObject *o) { - struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; - #if CYTHON_USE_TP_FINALIZE - if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { - if (PyObject_CallFinalizerFromDealloc(o)) return; - } - #endif - PyObject_GC_UnTrack(o); - Py_CLEAR(p->name); - (*Py_TYPE(o)->tp_free)(o); -} - -static int __pyx_tp_traverse_Enum(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; - if (p->name) { - e = (*v)(p->name, a); if (e) return e; - } - return 0; -} - -static int __pyx_tp_clear_Enum(PyObject *o) { - PyObject* tmp; - struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; - tmp = ((PyObject*)p->name); - p->name = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - return 0; -} - -static PyMethodDef __pyx_methods_Enum[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_1__reduce_cython__, METH_NOARGS, 0}, - {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_3__setstate_cython__, METH_O, 0}, - {0, 0, 0, 0} -}; - -static PyTypeObject __pyx_type___pyx_MemviewEnum = { - PyVarObject_HEAD_INIT(0, 0) - "core.Enum", /*tp_name*/ - sizeof(struct __pyx_MemviewEnum_obj), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_Enum, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - __pyx_MemviewEnum___repr__, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - 0, /*tp_doc*/ - __pyx_tp_traverse_Enum, /*tp_traverse*/ - __pyx_tp_clear_Enum, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods_Enum, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - __pyx_MemviewEnum___init__, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_Enum, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - 0, /*tp_finalize*/ - #endif - #if PY_VERSION_HEX >= 0x030800b1 - 0, /*tp_vectorcall*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif -}; -static struct __pyx_vtabstruct_memoryview __pyx_vtable_memoryview; - -static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k) { - struct __pyx_memoryview_obj *p; - PyObject *o; - if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { - o = (*t->tp_alloc)(t, 0); - } else { - o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); - } - if (unlikely(!o)) return 0; - p = ((struct __pyx_memoryview_obj *)o); - p->__pyx_vtab = __pyx_vtabptr_memoryview; - p->obj = Py_None; Py_INCREF(Py_None); - p->_size = Py_None; Py_INCREF(Py_None); - p->_array_interface = Py_None; Py_INCREF(Py_None); - p->view.obj = NULL; - if (unlikely(__pyx_memoryview___cinit__(o, a, k) < 0)) goto bad; - return o; - bad: - Py_DECREF(o); o = 0; - return NULL; -} - -static void __pyx_tp_dealloc_memoryview(PyObject *o) { - struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; - #if CYTHON_USE_TP_FINALIZE - if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { - if (PyObject_CallFinalizerFromDealloc(o)) return; - } - #endif - PyObject_GC_UnTrack(o); - { - PyObject *etype, *eval, *etb; - PyErr_Fetch(&etype, &eval, &etb); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); - __pyx_memoryview___dealloc__(o); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); - PyErr_Restore(etype, eval, etb); - } - Py_CLEAR(p->obj); - Py_CLEAR(p->_size); - Py_CLEAR(p->_array_interface); - (*Py_TYPE(o)->tp_free)(o); -} - -static int __pyx_tp_traverse_memoryview(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; - if (p->obj) { - e = (*v)(p->obj, a); if (e) return e; - } - if (p->_size) { - e = (*v)(p->_size, a); if (e) return e; - } - if (p->_array_interface) { - e = (*v)(p->_array_interface, a); if (e) return e; - } - if (p->view.obj) { - e = (*v)(p->view.obj, a); if (e) return e; - } - return 0; -} - -static int __pyx_tp_clear_memoryview(PyObject *o) { - PyObject* tmp; - struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; - tmp = ((PyObject*)p->obj); - p->obj = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->_size); - p->_size = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->_array_interface); - p->_array_interface = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - Py_CLEAR(p->view.obj); - return 0; -} -static PyObject *__pyx_sq_item_memoryview(PyObject *o, Py_ssize_t i) { - PyObject *r; - PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; - r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); - Py_DECREF(x); - return r; -} - -static int __pyx_mp_ass_subscript_memoryview(PyObject *o, PyObject *i, PyObject *v) { - if (v) { - return __pyx_memoryview___setitem__(o, i, v); - } - else { - PyErr_Format(PyExc_NotImplementedError, - "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); - return -1; - } -} - -static PyObject *__pyx_getprop___pyx_memoryview_T(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(o); -} - -static PyObject *__pyx_getprop___pyx_memoryview_base(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(o); -} - -static PyObject *__pyx_getprop___pyx_memoryview_shape(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(o); -} - -static PyObject *__pyx_getprop___pyx_memoryview_strides(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(o); -} - -static PyObject *__pyx_getprop___pyx_memoryview_suboffsets(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(o); -} - -static PyObject *__pyx_getprop___pyx_memoryview_ndim(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(o); -} - -static PyObject *__pyx_getprop___pyx_memoryview_itemsize(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(o); -} - -static PyObject *__pyx_getprop___pyx_memoryview_nbytes(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(o); -} - -static PyObject *__pyx_getprop___pyx_memoryview_size(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(o); -} - -static PyMethodDef __pyx_methods_memoryview[] = { - {"is_c_contig", (PyCFunction)__pyx_memoryview_is_c_contig, METH_NOARGS, 0}, - {"is_f_contig", (PyCFunction)__pyx_memoryview_is_f_contig, METH_NOARGS, 0}, - {"copy", (PyCFunction)__pyx_memoryview_copy, METH_NOARGS, 0}, - {"copy_fortran", (PyCFunction)__pyx_memoryview_copy_fortran, METH_NOARGS, 0}, - {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_1__reduce_cython__, METH_NOARGS, 0}, - {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_3__setstate_cython__, METH_O, 0}, - {0, 0, 0, 0} -}; - -static struct PyGetSetDef __pyx_getsets_memoryview[] = { - {(char *)"T", __pyx_getprop___pyx_memoryview_T, 0, (char *)0, 0}, - {(char *)"base", __pyx_getprop___pyx_memoryview_base, 0, (char *)0, 0}, - {(char *)"shape", __pyx_getprop___pyx_memoryview_shape, 0, (char *)0, 0}, - {(char *)"strides", __pyx_getprop___pyx_memoryview_strides, 0, (char *)0, 0}, - {(char *)"suboffsets", __pyx_getprop___pyx_memoryview_suboffsets, 0, (char *)0, 0}, - {(char *)"ndim", __pyx_getprop___pyx_memoryview_ndim, 0, (char *)0, 0}, - {(char *)"itemsize", __pyx_getprop___pyx_memoryview_itemsize, 0, (char *)0, 0}, - {(char *)"nbytes", __pyx_getprop___pyx_memoryview_nbytes, 0, (char *)0, 0}, - {(char *)"size", __pyx_getprop___pyx_memoryview_size, 0, (char *)0, 0}, - {0, 0, 0, 0, 0} -}; - -static PySequenceMethods __pyx_tp_as_sequence_memoryview = { - __pyx_memoryview___len__, /*sq_length*/ - 0, /*sq_concat*/ - 0, /*sq_repeat*/ - __pyx_sq_item_memoryview, /*sq_item*/ - 0, /*sq_slice*/ - 0, /*sq_ass_item*/ - 0, /*sq_ass_slice*/ - 0, /*sq_contains*/ - 0, /*sq_inplace_concat*/ - 0, /*sq_inplace_repeat*/ -}; - -static PyMappingMethods __pyx_tp_as_mapping_memoryview = { - __pyx_memoryview___len__, /*mp_length*/ - __pyx_memoryview___getitem__, /*mp_subscript*/ - __pyx_mp_ass_subscript_memoryview, /*mp_ass_subscript*/ -}; - -static PyBufferProcs __pyx_tp_as_buffer_memoryview = { - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getreadbuffer*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getwritebuffer*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getsegcount*/ - #endif - #if PY_MAJOR_VERSION < 3 - 0, /*bf_getcharbuffer*/ - #endif - __pyx_memoryview_getbuffer, /*bf_getbuffer*/ - 0, /*bf_releasebuffer*/ -}; - -static PyTypeObject __pyx_type___pyx_memoryview = { - PyVarObject_HEAD_INIT(0, 0) - "core.memoryview", /*tp_name*/ - sizeof(struct __pyx_memoryview_obj), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_memoryview, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - __pyx_memoryview___repr__, /*tp_repr*/ - 0, /*tp_as_number*/ - &__pyx_tp_as_sequence_memoryview, /*tp_as_sequence*/ - &__pyx_tp_as_mapping_memoryview, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - __pyx_memoryview___str__, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - &__pyx_tp_as_buffer_memoryview, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - 0, /*tp_doc*/ - __pyx_tp_traverse_memoryview, /*tp_traverse*/ - __pyx_tp_clear_memoryview, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods_memoryview, /*tp_methods*/ - 0, /*tp_members*/ - __pyx_getsets_memoryview, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - 0, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_memoryview, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - 0, /*tp_finalize*/ - #endif - #if PY_VERSION_HEX >= 0x030800b1 - 0, /*tp_vectorcall*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif -}; -static struct __pyx_vtabstruct__memoryviewslice __pyx_vtable__memoryviewslice; - -static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k) { - struct __pyx_memoryviewslice_obj *p; - PyObject *o = __pyx_tp_new_memoryview(t, a, k); - if (unlikely(!o)) return 0; - p = ((struct __pyx_memoryviewslice_obj *)o); - p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_memoryview*)__pyx_vtabptr__memoryviewslice; - p->from_object = Py_None; Py_INCREF(Py_None); - p->from_slice.memview = NULL; - return o; -} - -static void __pyx_tp_dealloc__memoryviewslice(PyObject *o) { - struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; - #if CYTHON_USE_TP_FINALIZE - if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { - if (PyObject_CallFinalizerFromDealloc(o)) return; - } - #endif - PyObject_GC_UnTrack(o); - { - PyObject *etype, *eval, *etb; - PyErr_Fetch(&etype, &eval, &etb); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); - __pyx_memoryviewslice___dealloc__(o); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); - PyErr_Restore(etype, eval, etb); - } - Py_CLEAR(p->from_object); - PyObject_GC_Track(o); - __pyx_tp_dealloc_memoryview(o); -} - -static int __pyx_tp_traverse__memoryviewslice(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; - e = __pyx_tp_traverse_memoryview(o, v, a); if (e) return e; - if (p->from_object) { - e = (*v)(p->from_object, a); if (e) return e; - } - return 0; -} - -static int __pyx_tp_clear__memoryviewslice(PyObject *o) { - PyObject* tmp; - struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; - __pyx_tp_clear_memoryview(o); - tmp = ((PyObject*)p->from_object); - p->from_object = Py_None; Py_INCREF(Py_None); - Py_XDECREF(tmp); - __PYX_XDEC_MEMVIEW(&p->from_slice, 1); - return 0; -} - -static PyObject *__pyx_getprop___pyx_memoryviewslice_base(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(o); -} - -static PyMethodDef __pyx_methods__memoryviewslice[] = { - {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_1__reduce_cython__, METH_NOARGS, 0}, - {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_3__setstate_cython__, METH_O, 0}, - {0, 0, 0, 0} -}; - -static struct PyGetSetDef __pyx_getsets__memoryviewslice[] = { - {(char *)"base", __pyx_getprop___pyx_memoryviewslice_base, 0, (char *)0, 0}, - {0, 0, 0, 0, 0} -}; - -static PyTypeObject __pyx_type___pyx_memoryviewslice = { - PyVarObject_HEAD_INIT(0, 0) - "core._memoryviewslice", /*tp_name*/ - sizeof(struct __pyx_memoryviewslice_obj), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc__memoryviewslice, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - #if CYTHON_COMPILING_IN_PYPY - __pyx_memoryview___repr__, /*tp_repr*/ - #else - 0, /*tp_repr*/ - #endif - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - #if CYTHON_COMPILING_IN_PYPY - __pyx_memoryview___str__, /*tp_str*/ - #else - 0, /*tp_str*/ - #endif - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - "Internal class for passing memoryview slices to Python", /*tp_doc*/ - __pyx_tp_traverse__memoryviewslice, /*tp_traverse*/ - __pyx_tp_clear__memoryviewslice, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods__memoryviewslice, /*tp_methods*/ - 0, /*tp_members*/ - __pyx_getsets__memoryviewslice, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - 0, /*tp_dictoffset*/ - 0, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new__memoryviewslice, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - 0, /*tp_finalize*/ - #endif - #if PY_VERSION_HEX >= 0x030800b1 - 0, /*tp_vectorcall*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 - 0, /*tp_print*/ - #endif -}; - -static PyMethodDef __pyx_methods[] = { - {0, 0, 0, 0} -}; - -#if PY_MAJOR_VERSION >= 3 -#if CYTHON_PEP489_MULTI_PHASE_INIT -static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ -static int __pyx_pymod_exec_core(PyObject* module); /*proto*/ -static PyModuleDef_Slot __pyx_moduledef_slots[] = { - {Py_mod_create, (void*)__pyx_pymod_create}, - {Py_mod_exec, (void*)__pyx_pymod_exec_core}, - {0, NULL} -}; -#endif - -static struct PyModuleDef __pyx_moduledef = { - PyModuleDef_HEAD_INIT, - "core", - 0, /* m_doc */ - #if CYTHON_PEP489_MULTI_PHASE_INIT - 0, /* m_size */ - #else - -1, /* m_size */ - #endif - __pyx_methods /* m_methods */, - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_moduledef_slots, /* m_slots */ - #else - NULL, /* m_reload */ - #endif - NULL, /* m_traverse */ - NULL, /* m_clear */ - NULL /* m_free */ -}; -#endif -#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}, - {&__pyx_kp_s_Buffer_view_does_not_expose_stri, __pyx_k_Buffer_view_does_not_expose_stri, sizeof(__pyx_k_Buffer_view_does_not_expose_stri), 0, 0, 1, 0}, - {&__pyx_kp_s_Can_only_create_a_buffer_that_is, __pyx_k_Can_only_create_a_buffer_that_is, sizeof(__pyx_k_Can_only_create_a_buffer_that_is), 0, 0, 1, 0}, - {&__pyx_kp_s_Cannot_assign_to_read_only_memor, __pyx_k_Cannot_assign_to_read_only_memor, sizeof(__pyx_k_Cannot_assign_to_read_only_memor), 0, 0, 1, 0}, - {&__pyx_kp_s_Cannot_create_writable_memory_vi, __pyx_k_Cannot_create_writable_memory_vi, sizeof(__pyx_k_Cannot_create_writable_memory_vi), 0, 0, 1, 0}, - {&__pyx_kp_s_Cannot_index_with_type_s, __pyx_k_Cannot_index_with_type_s, sizeof(__pyx_k_Cannot_index_with_type_s), 0, 0, 1, 0}, - {&__pyx_n_s_Ellipsis, __pyx_k_Ellipsis, sizeof(__pyx_k_Ellipsis), 0, 0, 1, 1}, - {&__pyx_kp_s_Empty_shape_tuple_for_cython_arr, __pyx_k_Empty_shape_tuple_for_cython_arr, sizeof(__pyx_k_Empty_shape_tuple_for_cython_arr), 0, 0, 1, 0}, - {&__pyx_kp_s_Incompatible_checksums_s_vs_0xb0, __pyx_k_Incompatible_checksums_s_vs_0xb0, sizeof(__pyx_k_Incompatible_checksums_s_vs_0xb0), 0, 0, 1, 0}, - {&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1}, - {&__pyx_kp_s_Indirect_dimensions_not_supporte, __pyx_k_Indirect_dimensions_not_supporte, sizeof(__pyx_k_Indirect_dimensions_not_supporte), 0, 0, 1, 0}, - {&__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_k_Invalid_mode_expected_c_or_fortr, sizeof(__pyx_k_Invalid_mode_expected_c_or_fortr), 0, 0, 1, 0}, - {&__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_k_Invalid_shape_in_axis_d_d, sizeof(__pyx_k_Invalid_shape_in_axis_d_d), 0, 0, 1, 0}, - {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, - {&__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_k_MemoryView_of_r_at_0x_x, sizeof(__pyx_k_MemoryView_of_r_at_0x_x), 0, 0, 1, 0}, - {&__pyx_kp_s_MemoryView_of_r_object, __pyx_k_MemoryView_of_r_object, sizeof(__pyx_k_MemoryView_of_r_object), 0, 0, 1, 0}, - {&__pyx_n_b_O, __pyx_k_O, sizeof(__pyx_k_O), 0, 0, 0, 1}, - {&__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_k_Out_of_bounds_on_buffer_access_a, sizeof(__pyx_k_Out_of_bounds_on_buffer_access_a), 0, 0, 1, 0}, - {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, - {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, - {&__pyx_kp_s_Unable_to_convert_item_to_object, __pyx_k_Unable_to_convert_item_to_object, sizeof(__pyx_k_Unable_to_convert_item_to_object), 0, 0, 1, 0}, - {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, - {&__pyx_n_s_View_MemoryView, __pyx_k_View_MemoryView, sizeof(__pyx_k_View_MemoryView), 0, 0, 1, 1}, - {&__pyx_n_s_X, __pyx_k_X, sizeof(__pyx_k_X), 0, 0, 1, 1}, - {&__pyx_n_s_accum_n, __pyx_k_accum_n, sizeof(__pyx_k_accum_n), 0, 0, 1, 1}, - {&__pyx_n_s_accum_w, __pyx_k_accum_w, sizeof(__pyx_k_accum_w), 0, 0, 1, 1}, - {&__pyx_n_s_activation, __pyx_k_activation, sizeof(__pyx_k_activation), 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_alp, __pyx_k_alp, sizeof(__pyx_k_alp), 0, 0, 1, 1}, - {&__pyx_n_s_alpha, __pyx_k_alpha, sizeof(__pyx_k_alpha), 0, 0, 1, 1}, - {&__pyx_n_s_an, __pyx_k_an, sizeof(__pyx_k_an), 0, 0, 1, 1}, - {&__pyx_n_s_base, __pyx_k_base, sizeof(__pyx_k_base), 0, 0, 1, 1}, - {&__pyx_n_s_best, __pyx_k_best, sizeof(__pyx_k_best), 0, 0, 1, 1}, - {&__pyx_n_s_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 0, 1, 1}, - {&__pyx_n_u_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 1, 0, 1}, - {&__pyx_n_s_class, __pyx_k_class, sizeof(__pyx_k_class), 0, 0, 1, 1}, - {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, - {&__pyx_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_core, __pyx_k_core, sizeof(__pyx_k_core), 0, 0, 1, 1}, - {&__pyx_n_s_count_modified_cells, __pyx_k_count_modified_cells, sizeof(__pyx_k_count_modified_cells), 0, 0, 1, 1}, - {&__pyx_n_s_create_map_batch, __pyx_k_create_map_batch, sizeof(__pyx_k_create_map_batch), 0, 0, 1, 1}, - {&__pyx_n_s_create_map_online, __pyx_k_create_map_online, sizeof(__pyx_k_create_map_online), 0, 0, 1, 1}, - {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, - {&__pyx_n_s_dist_lib, __pyx_k_dist_lib, sizeof(__pyx_k_dist_lib), 0, 0, 1, 1}, - {&__pyx_n_s_dtype_is_object, __pyx_k_dtype_is_object, sizeof(__pyx_k_dtype_is_object), 0, 0, 1, 1}, - {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1}, - {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1}, - {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1}, - {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1}, - {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1}, - {&__pyx_n_s_fortran, __pyx_k_fortran, sizeof(__pyx_k_fortran), 0, 0, 1, 1}, - {&__pyx_n_u_fortran, __pyx_k_fortran, sizeof(__pyx_k_fortran), 0, 1, 0, 1}, - {&__pyx_n_s_get_best_cell, __pyx_k_get_best_cell, sizeof(__pyx_k_get_best_cell), 0, 0, 1, 1}, - {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, - {&__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_k_got_differing_extents_in_dimensi, sizeof(__pyx_k_got_differing_extents_in_dimensi), 0, 0, 1, 0}, - {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, - {&__pyx_n_s_id, __pyx_k_id, sizeof(__pyx_k_id), 0, 0, 1, 1}, - {&__pyx_n_s_imp, __pyx_k_imp, sizeof(__pyx_k_imp), 0, 0, 1, 1}, - {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, - {&__pyx_n_s_importance, __pyx_k_importance, sizeof(__pyx_k_importance), 0, 0, 1, 1}, - {&__pyx_n_s_inputs, __pyx_k_inputs, sizeof(__pyx_k_inputs), 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_j, __pyx_k_j, sizeof(__pyx_k_j), 0, 0, 1, 1}, - {&__pyx_n_s_k, __pyx_k_k, sizeof(__pyx_k_k), 0, 0, 1, 1}, - {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, - {&__pyx_n_s_memview, __pyx_k_memview, sizeof(__pyx_k_memview), 0, 0, 1, 1}, - {&__pyx_n_s_mode, __pyx_k_mode, sizeof(__pyx_k_mode), 0, 0, 1, 1}, - {&__pyx_n_s_n_col, __pyx_k_n_col, sizeof(__pyx_k_n_col), 0, 0, 1, 1}, - {&__pyx_n_s_n_pix, __pyx_k_n_pix, sizeof(__pyx_k_n_pix), 0, 0, 1, 1}, - {&__pyx_n_s_n_row, __pyx_k_n_row, sizeof(__pyx_k_n_row), 0, 0, 1, 1}, - {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, - {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, - {&__pyx_n_s_nc, __pyx_k_nc, sizeof(__pyx_k_nc), 0, 0, 1, 1}, - {&__pyx_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 0, 0, 1, 1}, - {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, - {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, - {&__pyx_n_s_npix, __pyx_k_npix, sizeof(__pyx_k_npix), 0, 0, 1, 1}, - {&__pyx_n_s_nr, __pyx_k_nr, sizeof(__pyx_k_nr), 0, 0, 1, 1}, - {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, - {&__pyx_n_s_obj, __pyx_k_obj, sizeof(__pyx_k_obj), 0, 0, 1, 1}, - {&__pyx_n_s_pack, __pyx_k_pack, sizeof(__pyx_k_pack), 0, 0, 1, 1}, - {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_PickleError, __pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_checksum, __pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_getbuffer, __pyx_k_pyx_getbuffer, sizeof(__pyx_k_pyx_getbuffer), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_result, __pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_type, __pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_unpickle_Enum, __pyx_k_pyx_unpickle_Enum, sizeof(__pyx_k_pyx_unpickle_Enum), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, - {&__pyx_n_s_random_indices, __pyx_k_random_indices, sizeof(__pyx_k_random_indices), 0, 0, 1, 1}, - {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, - {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, - {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, - {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, - {&__pyx_n_s_shape, __pyx_k_shape, sizeof(__pyx_k_shape), 0, 0, 1, 1}, - {&__pyx_n_s_sig, __pyx_k_sig, sizeof(__pyx_k_sig), 0, 0, 1, 1}, - {&__pyx_n_s_sigma, __pyx_k_sigma, sizeof(__pyx_k_sigma), 0, 0, 1, 1}, - {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1}, - {&__pyx_kp_s_somsphere_cython_core_pyx, __pyx_k_somsphere_cython_core_pyx, sizeof(__pyx_k_somsphere_cython_core_pyx), 0, 0, 1, 0}, - {&__pyx_n_s_somsphere_utils, __pyx_k_somsphere_utils, sizeof(__pyx_k_somsphere_utils), 0, 0, 1, 1}, - {&__pyx_n_s_start, __pyx_k_start, sizeof(__pyx_k_start), 0, 0, 1, 1}, - {&__pyx_n_s_step, __pyx_k_step, sizeof(__pyx_k_step), 0, 0, 1, 1}, - {&__pyx_n_s_stop, __pyx_k_stop, sizeof(__pyx_k_stop), 0, 0, 1, 1}, - {&__pyx_kp_s_strided_and_direct, __pyx_k_strided_and_direct, sizeof(__pyx_k_strided_and_direct), 0, 0, 1, 0}, - {&__pyx_kp_s_strided_and_direct_or_indirect, __pyx_k_strided_and_direct_or_indirect, sizeof(__pyx_k_strided_and_direct_or_indirect), 0, 0, 1, 0}, - {&__pyx_kp_s_strided_and_indirect, __pyx_k_strided_and_indirect, sizeof(__pyx_k_strided_and_indirect), 0, 0, 1, 0}, - {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, - {&__pyx_n_s_struct, __pyx_k_struct, sizeof(__pyx_k_struct), 0, 0, 1, 1}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {&__pyx_n_s_timeit, __pyx_k_timeit, sizeof(__pyx_k_timeit), 0, 0, 1, 1}, - {&__pyx_n_s_transpose, __pyx_k_transpose, sizeof(__pyx_k_transpose), 0, 0, 1, 1}, - {&__pyx_kp_s_unable_to_allocate_array_data, __pyx_k_unable_to_allocate_array_data, sizeof(__pyx_k_unable_to_allocate_array_data), 0, 0, 1, 0}, - {&__pyx_kp_s_unable_to_allocate_shape_and_str, __pyx_k_unable_to_allocate_shape_and_str, sizeof(__pyx_k_unable_to_allocate_shape_and_str), 0, 0, 1, 0}, - {&__pyx_n_s_unpack, __pyx_k_unpack, sizeof(__pyx_k_unpack), 0, 0, 1, 1}, - {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, - {&__pyx_n_s_weights, __pyx_k_weights, sizeof(__pyx_k_weights), 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, 14, __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) - __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, 404, __pyx_L1_error) - __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(1, 613, __pyx_L1_error) - __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(1, 832, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; -} - -static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - - /* "core.pyx":19 - * weights=weights, n_pix=npix) - * for j in range(nc): - * accum_w[j, :] += count_modified_cells(best, dist_lib, sig) * inputs[j] # <<<<<<<<<<<<<< - * an += count_modified_cells(best, dist_lib, sig) - * - */ - __pyx_slice_ = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice_)) __PYX_ERR(0, 19, __pyx_L1_error) - __Pyx_GOTREF(__pyx_slice_); - __Pyx_GIVEREF(__pyx_slice_); - - /* "View.MemoryView":133 - * - * if not self.ndim: - * raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<< - * - * if itemsize <= 0: - */ - __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_Empty_shape_tuple_for_cython_arr); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 133, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__2); - __Pyx_GIVEREF(__pyx_tuple__2); - - /* "View.MemoryView":136 - * - * if itemsize <= 0: - * raise ValueError("itemsize <= 0 for cython.array") # <<<<<<<<<<<<<< - * - * if not isinstance(format, bytes): - */ - __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s_itemsize_0_for_cython_array); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 136, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__3); - __Pyx_GIVEREF(__pyx_tuple__3); - - /* "View.MemoryView":148 - * - * if not self._shape: - * raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<< - * - * - */ - __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_shape_and_str); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__4); - __Pyx_GIVEREF(__pyx_tuple__4); - - /* "View.MemoryView":176 - * self.data = malloc(self.len) - * if not self.data: - * raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<< - * - * if self.dtype_is_object: - */ - __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_array_data); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 176, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__5); - __Pyx_GIVEREF(__pyx_tuple__5); - - /* "View.MemoryView":192 - * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS - * if not (flags & bufmode): - * raise ValueError("Can only create a buffer that is contiguous in memory.") # <<<<<<<<<<<<<< - * info.buf = self.data - * info.len = self.len - */ - __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_Can_only_create_a_buffer_that_is); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 192, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__6); - __Pyx_GIVEREF(__pyx_tuple__6); - - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - */ - __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__7); - __Pyx_GIVEREF(__pyx_tuple__7); - - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< - */ - __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__8); - __Pyx_GIVEREF(__pyx_tuple__8); - - /* "View.MemoryView":418 - * def __setitem__(memoryview self, object index, object value): - * if self.view.readonly: - * raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<< - * - * have_slices, index = _unellipsify(index, self.view.ndim) - */ - __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_Cannot_assign_to_read_only_memor); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 418, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__9); - __Pyx_GIVEREF(__pyx_tuple__9); - - /* "View.MemoryView":495 - * result = struct.unpack(self.view.format, bytesitem) - * except struct.error: - * raise ValueError("Unable to convert item to object") # <<<<<<<<<<<<<< - * else: - * if len(self.view.format) == 1: - */ - __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_Unable_to_convert_item_to_object); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 495, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__10); - __Pyx_GIVEREF(__pyx_tuple__10); - - /* "View.MemoryView":520 - * def __getbuffer__(self, Py_buffer *info, int flags): - * if flags & PyBUF_WRITABLE and self.view.readonly: - * raise ValueError("Cannot create writable memory view from read-only memoryview") # <<<<<<<<<<<<<< - * - * if flags & PyBUF_ND: - */ - __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_Cannot_create_writable_memory_vi); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 520, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__11); - __Pyx_GIVEREF(__pyx_tuple__11); - - /* "View.MemoryView":570 - * if self.view.strides == NULL: - * - * raise ValueError("Buffer view does not expose strides") # <<<<<<<<<<<<<< - * - * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) - */ - __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_s_Buffer_view_does_not_expose_stri); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 570, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__12); - __Pyx_GIVEREF(__pyx_tuple__12); - - /* "View.MemoryView":577 - * def suboffsets(self): - * if self.view.suboffsets == NULL: - * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< - * - * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) - */ - __pyx_tuple__13 = PyTuple_New(1); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 577, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__13); - __Pyx_INCREF(__pyx_int_neg_1); - __Pyx_GIVEREF(__pyx_int_neg_1); - PyTuple_SET_ITEM(__pyx_tuple__13, 0, __pyx_int_neg_1); - __Pyx_GIVEREF(__pyx_tuple__13); - - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - */ - __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__14); - __Pyx_GIVEREF(__pyx_tuple__14); - - /* "(tree fragment)":4 - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< - */ - __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__15); - __Pyx_GIVEREF(__pyx_tuple__15); - - /* "View.MemoryView":703 - * 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, 703, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__16); - __Pyx_GIVEREF(__pyx_tuple__16); - - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("no default __reduce__ due to non-trivial __cinit__") - */ - __pyx_tuple__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); - - /* "(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); - - /* "core.pyx":6 - * from somsphere.utils import get_best_cell, count_modified_cells, timeit - * - * def create_map_batch(X, n_row, n_col, accum_w, accum_n, sigma, importance, n_pix, dist_lib, weights): # <<<<<<<<<<<<<< - * cdef int i, j, k - * cdef int nr = n_row - */ - __pyx_tuple__19 = PyTuple_Pack(22, __pyx_n_s_X, __pyx_n_s_n_row, __pyx_n_s_n_col, __pyx_n_s_accum_w, __pyx_n_s_accum_n, __pyx_n_s_sigma, __pyx_n_s_importance, __pyx_n_s_n_pix, __pyx_n_s_dist_lib, __pyx_n_s_weights, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_k, __pyx_n_s_nr, __pyx_n_s_nc, __pyx_n_s_npix, __pyx_n_s_sig, __pyx_n_s_imp, __pyx_n_s_an, __pyx_n_s_inputs, __pyx_n_s_best, __pyx_n_s_activation); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__19); - __Pyx_GIVEREF(__pyx_tuple__19); - __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(10, 0, 22, 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_somsphere_cython_core_pyx, __pyx_n_s_create_map_batch, 6, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(0, 6, __pyx_L1_error) - - /* "core.pyx":25 - * weights[k] = accum_w[k] / an - * - * def create_map_online(X, n_row, alpha, sigma, random_indices, importance, n_pix, dist_lib, weights): # <<<<<<<<<<<<<< - * cdef int i - * cdef int nr = n_row - */ - __pyx_tuple__21 = PyTuple_Pack(18, __pyx_n_s_X, __pyx_n_s_n_row, __pyx_n_s_alpha, __pyx_n_s_sigma, __pyx_n_s_random_indices, __pyx_n_s_importance, __pyx_n_s_n_pix, __pyx_n_s_dist_lib, __pyx_n_s_weights, __pyx_n_s_i, __pyx_n_s_nr, __pyx_n_s_npix, __pyx_n_s_alp, __pyx_n_s_sig, __pyx_n_s_imp, __pyx_n_s_inputs, __pyx_n_s_best, __pyx_n_s_activation); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 25, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__21); - __Pyx_GIVEREF(__pyx_tuple__21); - __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(9, 0, 18, 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_somsphere_cython_core_pyx, __pyx_n_s_create_map_online, 25, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 25, __pyx_L1_error) - - /* "View.MemoryView":286 - * 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); - - /* "View.MemoryView":287 - * - * 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); - - /* "View.MemoryView":288 - * 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); - - /* "View.MemoryView":291 - * - * - * 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); - - /* "View.MemoryView":292 - * - * 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); - - /* "(tree fragment)":1 - * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result - */ - __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_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} - -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); - __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_184977713 = PyInt_FromLong(184977713L); if (unlikely(!__pyx_int_184977713)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; -} - -static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ - -static int __Pyx_modinit_global_init_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); - /*--- Global init code ---*/ - generic = Py_None; Py_INCREF(Py_None); - strided = Py_None; Py_INCREF(Py_None); - indirect = Py_None; Py_INCREF(Py_None); - contiguous = Py_None; Py_INCREF(Py_None); - indirect_contiguous = Py_None; Py_INCREF(Py_None); - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_variable_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); - /*--- Variable export code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_function_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); - /*--- Function export code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_type_init_code(void) { - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); - /*--- Type init code ---*/ - __pyx_vtabptr_array = &__pyx_vtable_array; - __pyx_vtable_array.get_memview = (PyObject *(*)(struct __pyx_array_obj *))__pyx_array_get_memview; - if (PyType_Ready(&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 105, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type___pyx_array.tp_print = 0; - #endif - 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) - __pyx_array_type = &__pyx_type___pyx_array; - if (PyType_Ready(&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(1, 279, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type___pyx_MemviewEnum.tp_print = 0; - #endif - 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) - __pyx_MemviewEnum_type = &__pyx_type___pyx_MemviewEnum; - __pyx_vtabptr_memoryview = &__pyx_vtable_memoryview; - __pyx_vtable_memoryview.get_item_pointer = (char *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_get_item_pointer; - __pyx_vtable_memoryview.is_slice = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_is_slice; - __pyx_vtable_memoryview.setitem_slice_assignment = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_slice_assignment; - __pyx_vtable_memoryview.setitem_slice_assign_scalar = (PyObject *(*)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_setitem_slice_assign_scalar; - __pyx_vtable_memoryview.setitem_indexed = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_indexed; - __pyx_vtable_memoryview.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryview_convert_item_to_object; - __pyx_vtable_memoryview.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryview_assign_item_from_object; - if (PyType_Ready(&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 330, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type___pyx_memoryview.tp_print = 0; - #endif - 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) - __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, 965, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type___pyx_memoryviewslice.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryviewslice.tp_dictoffset && __pyx_type___pyx_memoryviewslice.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type___pyx_memoryviewslice.tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - if (__Pyx_SetVtable(__pyx_type___pyx_memoryviewslice.tp_dict, __pyx_vtabptr__memoryviewslice) < 0) __PYX_ERR(1, 965, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 965, __pyx_L1_error) - __pyx_memoryviewslice_type = &__pyx_type___pyx_memoryviewslice; - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} - -static int __Pyx_modinit_type_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); - /*--- Type import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_variable_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); - /*--- Variable import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_function_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); - /*--- Function import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - - -#ifndef CYTHON_NO_PYINIT_EXPORT -#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC -#elif PY_MAJOR_VERSION < 3 -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" void -#else -#define __Pyx_PyMODINIT_FUNC void -#endif -#else -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * -#else -#define __Pyx_PyMODINIT_FUNC PyObject * -#endif -#endif - - -#if PY_MAJOR_VERSION < 3 -__Pyx_PyMODINIT_FUNC initcore(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC initcore(void) -#else -__Pyx_PyMODINIT_FUNC PyInit_core(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC PyInit_core(void) -#if CYTHON_PEP489_MULTI_PHASE_INIT -{ - return PyModuleDef_Init(&__pyx_moduledef); -} -static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { - #if PY_VERSION_HEX >= 0x030700A1 - static PY_INT64_T main_interpreter_id = -1; - PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); - if (main_interpreter_id == -1) { - main_interpreter_id = current_id; - return (unlikely(current_id == -1)) ? -1 : 0; - } else if (unlikely(main_interpreter_id != current_id)) - #else - static PyInterpreterState *main_interpreter = NULL; - PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; - if (!main_interpreter) { - main_interpreter = current_interpreter; - } else if (unlikely(main_interpreter != current_interpreter)) - #endif - { - PyErr_SetString( - PyExc_ImportError, - "Interpreter change detected - this module can only be loaded into one interpreter per process."); - return -1; - } - return 0; -} -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) { - 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); - } - Py_DECREF(value); - } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { - PyErr_Clear(); - } else { - result = -1; - } - return result; -} -static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, 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"); - if (unlikely(!modname)) goto bad; - module = PyModule_NewObject(modname); - Py_DECREF(modname); - if (unlikely(!module)) goto bad; - moddict = PyModule_GetDict(module); - if (unlikely(!moddict)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; - return module; -bad: - Py_XDECREF(module); - return NULL; -} - - -static CYTHON_SMALL_CODE int __pyx_pymod_exec_core(PyObject *__pyx_pyinit_module) -#endif -#endif -{ - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - static PyThread_type_lock __pyx_t_3[8]; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannyDeclarations - #if CYTHON_PEP489_MULTI_PHASE_INIT - if (__pyx_m) { - if (__pyx_m == __pyx_pyinit_module) return 0; - PyErr_SetString(PyExc_RuntimeError, "Module 'core' has already been imported. Re-initialisation is not supported."); - return -1; - } - #elif PY_MAJOR_VERSION >= 3 - if (__pyx_m) return __Pyx_NewRef(__pyx_m); - #endif - #if CYTHON_REFNANNY -__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); -if (!__Pyx_RefNanny) { - PyErr_Clear(); - __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); - if (!__Pyx_RefNanny) - Py_FatalError("failed to import 'refnanny' module"); -} -#endif - __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_core(void)", 0); - if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pxy_PyFrame_Initialize_Offsets - __Pxy_PyFrame_Initialize_Offsets(); - #endif - __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pyx_CyFunction_USED - if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_FusedFunction_USED - if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Coroutine_USED - if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Generator_USED - if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_AsyncGen_USED - if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_StopAsyncIteration_USED - if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - /*--- Library function declarations ---*/ - /*--- Threads initialization code ---*/ - #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS - #ifdef WITH_THREAD /* Python build with threading support? */ - PyEval_InitThreads(); - #endif - #endif - /*--- Module creation code ---*/ - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_m = __pyx_pyinit_module; - Py_INCREF(__pyx_m); - #else - #if PY_MAJOR_VERSION < 3 - __pyx_m = Py_InitModule4("core", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); - #else - __pyx_m = PyModule_Create(&__pyx_moduledef); - #endif - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_d); - __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_b); - __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_cython_runtime); - if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); - /*--- Initialize various global constants etc. ---*/ - if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) - if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - if (__pyx_module_is_main_core) { - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - } - #if PY_MAJOR_VERSION >= 3 - { - PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) - if (!PyDict_GetItemString(modules, "core")) { - if (unlikely(PyDict_SetItemString(modules, "core", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) - } - } - #endif - /*--- Builtin init code ---*/ - if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Constants init code ---*/ - if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Global type/function init code ---*/ - (void)__Pyx_modinit_global_init_code(); - (void)__Pyx_modinit_variable_export_code(); - (void)__Pyx_modinit_function_export_code(); - if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) - (void)__Pyx_modinit_type_import_code(); - (void)__Pyx_modinit_variable_import_code(); - (void)__Pyx_modinit_function_import_code(); - /*--- Execution code ---*/ - #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) - if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - - /* "core.pyx":2 - * #cython: language_level=3 - * import numpy # <<<<<<<<<<<<<< - * - * from somsphere.utils import get_best_cell, count_modified_cells, timeit - */ - __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_numpy, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "core.pyx":4 - * import numpy - * - * from somsphere.utils import get_best_cell, count_modified_cells, timeit # <<<<<<<<<<<<<< - * - * def create_map_batch(X, n_row, n_col, accum_w, accum_n, sigma, importance, n_pix, dist_lib, weights): - */ - __pyx_t_1 = PyList_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_n_s_get_best_cell); - __Pyx_GIVEREF(__pyx_n_s_get_best_cell); - PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_get_best_cell); - __Pyx_INCREF(__pyx_n_s_count_modified_cells); - __Pyx_GIVEREF(__pyx_n_s_count_modified_cells); - PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_count_modified_cells); - __Pyx_INCREF(__pyx_n_s_timeit); - __Pyx_GIVEREF(__pyx_n_s_timeit); - PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_timeit); - __pyx_t_2 = __Pyx_Import(__pyx_n_s_somsphere_utils, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_get_best_cell); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_best_cell, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_count_modified_cells); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_count_modified_cells, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_timeit); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_timeit, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "core.pyx":6 - * from somsphere.utils import get_best_cell, count_modified_cells, timeit - * - * def create_map_batch(X, n_row, n_col, accum_w, accum_n, sigma, importance, n_pix, dist_lib, weights): # <<<<<<<<<<<<<< - * cdef int i, j, k - * cdef int nr = n_row - */ - __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_4core_1create_map_batch, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_create_map_batch, __pyx_t_2) < 0) __PYX_ERR(0, 6, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "core.pyx":25 - * weights[k] = accum_w[k] / an - * - * def create_map_online(X, n_row, alpha, sigma, random_indices, importance, n_pix, dist_lib, weights): # <<<<<<<<<<<<<< - * cdef int i - * cdef int nr = n_row - */ - __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_4core_3create_map_online, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 25, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_create_map_online, __pyx_t_2) < 0) __PYX_ERR(0, 25, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "core.pyx":1 - * #cython: language_level=3 # <<<<<<<<<<<<<< - * import numpy - * - */ - __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "View.MemoryView":209 - * info.obj = self - * - * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< - * - * def __dealloc__(array self): - */ - __pyx_t_2 = __pyx_capsule_create(((void *)(&__pyx_array_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 209, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem((PyObject *)__pyx_array_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_2) < 0) __PYX_ERR(1, 209, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - PyType_Modified(__pyx_array_type); - - /* "View.MemoryView":286 - * return self.name - * - * cdef generic = Enum("") # <<<<<<<<<<<<<< - * cdef strided = Enum("") # default - * cdef indirect = Enum("") - */ - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 286, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_XGOTREF(generic); - __Pyx_DECREF_SET(generic, __pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __pyx_t_2 = 0; - - /* "View.MemoryView":287 - * - * cdef generic = Enum("") - * cdef strided = Enum("") # default # <<<<<<<<<<<<<< - * cdef indirect = Enum("") - * - */ - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 287, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_XGOTREF(strided); - __Pyx_DECREF_SET(strided, __pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __pyx_t_2 = 0; - - /* "View.MemoryView":288 - * cdef generic = Enum("") - * cdef strided = Enum("") # default - * cdef indirect = Enum("") # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 288, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_XGOTREF(indirect); - __Pyx_DECREF_SET(indirect, __pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __pyx_t_2 = 0; - - /* "View.MemoryView":291 - * - * - * cdef contiguous = Enum("") # <<<<<<<<<<<<<< - * cdef indirect_contiguous = Enum("") - * - */ - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 291, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_XGOTREF(contiguous); - __Pyx_DECREF_SET(contiguous, __pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __pyx_t_2 = 0; - - /* "View.MemoryView":292 - * - * cdef contiguous = Enum("") - * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__27, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 292, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_XGOTREF(indirect_contiguous); - __Pyx_DECREF_SET(indirect_contiguous, __pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - __pyx_t_2 = 0; - - /* "View.MemoryView":316 - * - * DEF THREAD_LOCKS_PREALLOCATED = 8 - * cdef int __pyx_memoryview_thread_locks_used = 0 # <<<<<<<<<<<<<< - * cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [ - * PyThread_allocate_lock(), - */ - __pyx_memoryview_thread_locks_used = 0; - - /* "View.MemoryView":317 - * DEF THREAD_LOCKS_PREALLOCATED = 8 - * cdef int __pyx_memoryview_thread_locks_used = 0 - * cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [ # <<<<<<<<<<<<<< - * PyThread_allocate_lock(), - * PyThread_allocate_lock(), - */ - __pyx_t_3[0] = PyThread_allocate_lock(); - __pyx_t_3[1] = PyThread_allocate_lock(); - __pyx_t_3[2] = PyThread_allocate_lock(); - __pyx_t_3[3] = PyThread_allocate_lock(); - __pyx_t_3[4] = PyThread_allocate_lock(); - __pyx_t_3[5] = PyThread_allocate_lock(); - __pyx_t_3[6] = PyThread_allocate_lock(); - __pyx_t_3[7] = PyThread_allocate_lock(); - memcpy(&(__pyx_memoryview_thread_locks[0]), __pyx_t_3, sizeof(__pyx_memoryview_thread_locks[0]) * (8)); - - /* "View.MemoryView":549 - * info.obj = self - * - * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_2 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 549, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem((PyObject *)__pyx_memoryview_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_2) < 0) __PYX_ERR(1, 549, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - PyType_Modified(__pyx_memoryview_type); - - /* "View.MemoryView":995 - * return self.from_object - * - * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_2 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 995, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem((PyObject *)__pyx_memoryviewslice_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_2) < 0) __PYX_ERR(1, 995, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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 - */ - __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum, NULL, __pyx_n_s_View_MemoryView); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Enum, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "(tree fragment)":11 - * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) - * return __pyx_result - * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< - * __pyx_result.name = __pyx_state[0] - * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): - */ - - /*--- Wrapped vars code ---*/ - - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - if (__pyx_m) { - if (__pyx_d) { - __Pyx_AddTraceback("init core", __pyx_clineno, __pyx_lineno, __pyx_filename); - } - Py_CLEAR(__pyx_m); - } else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_ImportError, "init core"); - } - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - #if CYTHON_PEP489_MULTI_PHASE_INIT - return (__pyx_m != NULL) ? 0 : -1; - #elif PY_MAJOR_VERSION >= 3 - return __pyx_m; - #else - return; - #endif -} - -/* --- Runtime support code --- */ -/* Refnanny */ -#if CYTHON_REFNANNY -static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { - PyObject *m = NULL, *p = NULL; - void *r = NULL; - m = PyImport_ImportModule(modname); - if (!m) goto end; - p = PyObject_GetAttrString(m, "RefNannyAPI"); - if (!p) goto end; - r = PyLong_AsVoidPtr(p); -end: - Py_XDECREF(p); - Py_XDECREF(m); - return (__Pyx_RefNannyAPIStruct *)r; -} -#endif +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule(modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, "RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif /* PyObjectGetAttrStr */ #if CYTHON_USE_TYPE_SLOTS @@ -18210,93 +6394,6 @@ static int __Pyx_ParseOptionalKeywords( return -1; } -/* GetItemInt */ -static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { - PyObject *r; - if (!j) return NULL; - r = PyObject_GetItem(o, j); - Py_DECREF(j); - return r; -} -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - Py_ssize_t wrapped_i = i; - if (wraparound & unlikely(i < 0)) { - wrapped_i += PyList_GET_SIZE(o); - } - if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { - PyObject *r = PyList_GET_ITEM(o, wrapped_i); - Py_INCREF(r); - return r; - } - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); -#else - return PySequence_GetItem(o, i); -#endif -} -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - Py_ssize_t wrapped_i = i; - if (wraparound & unlikely(i < 0)) { - wrapped_i += PyTuple_GET_SIZE(o); - } - if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { - PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); - Py_INCREF(r); - return r; - } - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); -#else - return PySequence_GetItem(o, i); -#endif -} -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS - if (is_list || PyList_CheckExact(o)) { - Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); - if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { - PyObject *r = PyList_GET_ITEM(o, n); - Py_INCREF(r); - return r; - } - } - else if (PyTuple_CheckExact(o)) { - Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); - if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { - PyObject *r = PyTuple_GET_ITEM(o, n); - Py_INCREF(r); - return r; - } - } else { - PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; - if (likely(m && m->sq_item)) { - if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { - Py_ssize_t l = m->sq_length(o); - if (likely(l >= 0)) { - i += l; - } else { - if (!PyErr_ExceptionMatches(PyExc_OverflowError)) - return NULL; - PyErr_Clear(); - } - } - return m->sq_item(o, i); - } - } -#else - if (is_list || PySequence_Check(o)) { - return PySequence_GetItem(o, i); - } -#endif - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); -} - /* PyDictVersioning */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { @@ -18318,154 +6415,45 @@ static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { PyObject *dict = Py_TYPE(obj)->tp_dict; if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) - return 0; - return obj_dict_version == __Pyx_get_object_dict_version(obj); -} -#endif - -/* GetModuleGlobalName */ -#if CYTHON_USE_DICT_VERSIONS -static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) -#else -static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) -#endif -{ - PyObject *result; -#if !CYTHON_AVOID_BORROWED_REFS -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 - result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } else if (unlikely(PyErr_Occurred())) { - return NULL; - } -#else - result = PyDict_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } -#endif -#else - result = PyObject_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } - PyErr_Clear(); -#endif - return __Pyx_GetBuiltinName(name); -} - -/* PyObjectCall */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { - PyObject *result; - ternaryfunc call = func->ob_type->tp_call; - if (unlikely(!call)) - return PyObject_Call(func, arg, kw); - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - result = (*call)(func, arg, kw); - Py_LeaveRecursiveCall(); - if (unlikely(!result) && unlikely(!PyErr_Occurred())) { - PyErr_SetString( - PyExc_SystemError, - "NULL result without error in PyObject_Call"); - } - return result; -} -#endif - -/* RaiseTooManyValuesToUnpack */ -static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { - PyErr_Format(PyExc_ValueError, - "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); -} - -/* RaiseNeedMoreValuesToUnpack */ -static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { - PyErr_Format(PyExc_ValueError, - "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", - index, (index == 1) ? "" : "s"); -} - -/* IterFinish */ -static CYTHON_INLINE int __Pyx_IterFinish(void) { -#if CYTHON_FAST_THREAD_STATE - PyThreadState *tstate = __Pyx_PyThreadState_Current; - PyObject* exc_type = tstate->curexc_type; - if (unlikely(exc_type)) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) { - PyObject *exc_value, *exc_tb; - exc_value = tstate->curexc_value; - exc_tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; - Py_DECREF(exc_type); - Py_XDECREF(exc_value); - Py_XDECREF(exc_tb); - return 0; - } else { - return -1; - } - } - return 0; -#else - if (unlikely(PyErr_Occurred())) { - if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { - PyErr_Clear(); - return 0; - } else { - return -1; - } - } - return 0; -#endif -} - -/* UnpackItemEndCheck */ -static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { - if (unlikely(retval)) { - Py_DECREF(retval); - __Pyx_RaiseTooManyValuesError(expected); - return -1; - } else { - return __Pyx_IterFinish(); - } - return 0; -} - -/* ObjectGetItem */ -#if CYTHON_USE_TYPE_SLOTS -static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) { - PyObject *runerr; - Py_ssize_t key_value; - PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence; - if (unlikely(!(m && m->sq_item))) { - PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name); + return 0; + return obj_dict_version == __Pyx_get_object_dict_version(obj); +} +#endif + +/* GetModuleGlobalName */ +#if CYTHON_USE_DICT_VERSIONS +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) +#else +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) +#endif +{ + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 + result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } else if (unlikely(PyErr_Occurred())) { return NULL; } - key_value = __Pyx_PyIndex_AsSsize_t(index); - if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { - return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); - } - if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { - PyErr_Clear(); - PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name); +#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); } - return NULL; -} -static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) { - PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping; - if (likely(m && m->mp_subscript)) { - return m->mp_subscript(obj, key); +#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); } - return __Pyx_PyObject_GetIndex(obj, key); -} + PyErr_Clear(); #endif + return __Pyx_GetBuiltinName(name); +} /* PyFunctionFastCall */ #if CYTHON_FAST_PYCALL @@ -18609,185 +6597,58 @@ static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, P } #endif -/* MemviewSliceInit */ -static int -__Pyx_init_memviewslice(struct __pyx_memoryview_obj *memview, - int ndim, - __Pyx_memviewslice *memviewslice, - int memview_is_new_reference) -{ - __Pyx_RefNannyDeclarations - int i, retval=-1; - Py_buffer *buf = &memview->view; - __Pyx_RefNannySetupContext("init_memviewslice", 0); - if (unlikely(memviewslice->memview || memviewslice->data)) { - PyErr_SetString(PyExc_ValueError, - "memviewslice is already initialized!"); - goto fail; - } - if (buf->strides) { - for (i = 0; i < ndim; i++) { - memviewslice->strides[i] = buf->strides[i]; - } - } else { - Py_ssize_t stride = buf->itemsize; - for (i = ndim - 1; i >= 0; i--) { - memviewslice->strides[i] = stride; - stride *= buf->shape[i]; - } - } - for (i = 0; i < ndim; i++) { - memviewslice->shape[i] = buf->shape[i]; - if (buf->suboffsets) { - memviewslice->suboffsets[i] = buf->suboffsets[i]; - } else { - memviewslice->suboffsets[i] = -1; - } - } - memviewslice->memview = memview; - memviewslice->data = (char *)buf->buf; - if (__pyx_add_acquisition_count(memview) == 0 && !memview_is_new_reference) { - Py_INCREF(memview); +/* PyObjectCall */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); } - retval = 0; - goto no_fail; -fail: - memviewslice->memview = 0; - memviewslice->data = 0; - retval = -1; -no_fail: - __Pyx_RefNannyFinishContext(); - return retval; -} -#ifndef Py_NO_RETURN -#define Py_NO_RETURN -#endif -static void __pyx_fatalerror(const char *fmt, ...) Py_NO_RETURN { - va_list vargs; - char msg[200]; -#ifdef HAVE_STDARG_PROTOTYPES - va_start(vargs, fmt); -#else - va_start(vargs); -#endif - vsnprintf(msg, 200, fmt, vargs); - va_end(vargs); - Py_FatalError(msg); -} -static CYTHON_INLINE int -__pyx_add_acquisition_count_locked(__pyx_atomic_int *acquisition_count, - PyThread_type_lock lock) -{ - int result; - PyThread_acquire_lock(lock, 1); - result = (*acquisition_count)++; - PyThread_release_lock(lock); return result; } -static CYTHON_INLINE int -__pyx_sub_acquisition_count_locked(__pyx_atomic_int *acquisition_count, - PyThread_type_lock lock) -{ - int result; - PyThread_acquire_lock(lock, 1); - result = (*acquisition_count)--; - PyThread_release_lock(lock); - return result; -} -static CYTHON_INLINE void -__Pyx_INC_MEMVIEW(__Pyx_memviewslice *memslice, int have_gil, int lineno) +#endif + +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) { - int first_time; - struct __pyx_memoryview_obj *memview = memslice->memview; - if (unlikely(!memview || (PyObject *) memview == Py_None)) - return; - if (unlikely(__pyx_get_slice_count(memview) < 0)) - __pyx_fatalerror("Acquisition count is %d (line %d)", - __pyx_get_slice_count(memview), lineno); - first_time = __pyx_add_acquisition_count(memview) == 0; - if (unlikely(first_time)) { - if (have_gil) { - Py_INCREF((PyObject *) memview); - } else { - PyGILState_STATE _gilstate = PyGILState_Ensure(); - Py_INCREF((PyObject *) memview); - PyGILState_Release(_gilstate); - } + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; } -} -static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW(__Pyx_memviewslice *memslice, - int have_gil, int lineno) { - int last_time; - struct __pyx_memoryview_obj *memview = memslice->memview; - if (unlikely(!memview || (PyObject *) memview == Py_None)) { - memslice->memview = NULL; - return; + else if (exact) { + #if PY_MAJOR_VERSION == 2 + if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif } - if (unlikely(__pyx_get_slice_count(memview) <= 0)) - __pyx_fatalerror("Acquisition count is %d (line %d)", - __pyx_get_slice_count(memview), lineno); - last_time = __pyx_sub_acquisition_count(memview) == 1; - memslice->data = NULL; - if (unlikely(last_time)) { - if (have_gil) { - Py_CLEAR(memslice->memview); - } else { - PyGILState_STATE _gilstate = PyGILState_Ensure(); - Py_CLEAR(memslice->memview); - PyGILState_Release(_gilstate); - } - } else { - memslice->memview = NULL; + else { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; } + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); + return 0; } -/* SetItemInt */ -static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { - int r; - if (!j) return -1; - r = PyObject_SetItem(o, j, v); - Py_DECREF(j); - return r; -} -static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list, - CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS - if (is_list || PyList_CheckExact(o)) { - Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o)); - if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o)))) { - PyObject* old = PyList_GET_ITEM(o, n); - Py_INCREF(v); - PyList_SET_ITEM(o, n, v); - Py_DECREF(old); - return 1; - } - } else { - PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; - if (likely(m && m->sq_ass_item)) { - if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { - Py_ssize_t l = m->sq_length(o); - if (likely(l >= 0)) { - i += l; - } else { - if (!PyErr_ExceptionMatches(PyExc_OverflowError)) - return -1; - PyErr_Clear(); - } - } - return m->sq_ass_item(o, i, v); - } - } -#else -#if CYTHON_COMPILING_IN_PYPY - if (is_list || (PySequence_Check(o) && !PyDict_Check(o))) -#else - if (is_list || PySequence_Check(o)) -#endif - { - return PySequence_SetItem(o, i, v); +/* ExtTypeTest */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; } -#endif - return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v); + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; } /* PyObjectCall2Args */ @@ -18831,808 +6692,621 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { - PyErr_SetString( - PyExc_SystemError, - "NULL result without error in PyObject_Call"); - } - return result; -} -#endif - -/* PyObjectCallOneArg */ -#if CYTHON_COMPILING_IN_CPYTHON -static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *result; - PyObject *args = PyTuple_New(1); - if (unlikely(!args)) return NULL; - Py_INCREF(arg); - PyTuple_SET_ITEM(args, 0, arg); - result = __Pyx_PyObject_Call(func, args, NULL); - Py_DECREF(args); - return result; -} -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { -#if CYTHON_FAST_PYCALL - if (PyFunction_Check(func)) { - return __Pyx_PyFunction_FastCall(func, &arg, 1); - } -#endif - if (likely(PyCFunction_Check(func))) { - if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { - return __Pyx_PyObject_CallMethO(func, arg); -#if CYTHON_FAST_PYCCALL - } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { - return __Pyx_PyCFunction_FastCall(func, &arg, 1); -#endif - } - } - return __Pyx__PyObject_CallOneArg(func, arg); -} -#else -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *result; - PyObject *args = PyTuple_Pack(1, arg); - if (unlikely(!args)) return NULL; - result = __Pyx_PyObject_Call(func, args, NULL); - Py_DECREF(args); - return result; -} -#endif - -/* ArgTypeTest */ -static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) -{ - if (unlikely(!type)) { - PyErr_SetString(PyExc_SystemError, "Missing type object"); - return 0; - } - else if (exact) { - #if PY_MAJOR_VERSION == 2 - if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; - #endif - } - else { - if (likely(__Pyx_TypeCheck(obj, type))) return 1; - } - PyErr_Format(PyExc_TypeError, - "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", - name, type->tp_name, Py_TYPE(obj)->tp_name); - return 0; -} - -/* PyErrFetchRestore */ -#if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - tmp_type = tstate->curexc_type; - tmp_value = tstate->curexc_value; - tmp_tb = tstate->curexc_traceback; - tstate->curexc_type = type; - tstate->curexc_value = value; - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); -} -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - *type = tstate->curexc_type; - *value = tstate->curexc_value; - *tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; -} -#endif - -/* RaiseException */ -#if PY_MAJOR_VERSION < 3 -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, - CYTHON_UNUSED PyObject *cause) { - __Pyx_PyThreadState_declare - Py_XINCREF(type); - if (!value || value == Py_None) - value = NULL; - else - Py_INCREF(value); - if (!tb || tb == Py_None) - tb = NULL; - else { - Py_INCREF(tb); - if (!PyTraceBack_Check(tb)) { - PyErr_SetString(PyExc_TypeError, - "raise: arg 3 must be a traceback or None"); - goto raise_error; - } + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); } - if (PyType_Check(type)) { -#if CYTHON_COMPILING_IN_PYPY - if (!value) { - Py_INCREF(Py_None); - value = Py_None; - } + return result; +} +#endif + +/* PyObjectCallOneArg */ +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, &arg, 1); + } +#endif + if (likely(PyCFunction_Check(func))) { + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); +#if CYTHON_FAST_PYCCALL + } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); #endif - PyErr_NormalizeException(&type, &value, &tb); - } else { - if (value) { - PyErr_SetString(PyExc_TypeError, - "instance exception may not have a separate value"); - goto raise_error; - } - value = type; - type = (PyObject*) Py_TYPE(type); - Py_INCREF(type); - if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { - PyErr_SetString(PyExc_TypeError, - "raise: exception class must be a subclass of BaseException"); - goto raise_error; } } - __Pyx_PyThreadState_assign - __Pyx_ErrRestore(type, value, tb); - return; -raise_error: - Py_XDECREF(value); - Py_XDECREF(type); - Py_XDECREF(tb); - return; + return __Pyx__PyObject_CallOneArg(func, arg); } #else -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { - PyObject* owned_instance = NULL; - if (tb == Py_None) { - tb = 0; - } else if (tb && !PyTraceBack_Check(tb)) { - PyErr_SetString(PyExc_TypeError, - "raise: arg 3 must be a traceback or None"); - goto bad; - } - if (value == Py_None) - value = 0; - if (PyExceptionInstance_Check(type)) { - if (value) { - PyErr_SetString(PyExc_TypeError, - "instance exception may not have a separate value"); - goto bad; - } - value = type; - type = (PyObject*) Py_TYPE(value); - } else if (PyExceptionClass_Check(type)) { - PyObject *instance_class = NULL; - if (value && PyExceptionInstance_Check(value)) { - instance_class = (PyObject*) Py_TYPE(value); - if (instance_class != type) { - int is_subclass = PyObject_IsSubclass(instance_class, type); - if (!is_subclass) { - instance_class = NULL; - } else if (unlikely(is_subclass == -1)) { - goto bad; - } else { - type = instance_class; - } - } +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +/* SliceObject */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj, + Py_ssize_t cstart, Py_ssize_t cstop, + PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice, + int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) { +#if CYTHON_USE_TYPE_SLOTS + PyMappingMethods* mp; +#if PY_MAJOR_VERSION < 3 + PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence; + if (likely(ms && ms->sq_slice)) { + if (!has_cstart) { + if (_py_start && (*_py_start != Py_None)) { + cstart = __Pyx_PyIndex_AsSsize_t(*_py_start); + if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; + } else + cstart = 0; } - if (!instance_class) { - PyObject *args; - if (!value) - args = PyTuple_New(0); - else if (PyTuple_Check(value)) { - Py_INCREF(value); - args = value; + if (!has_cstop) { + if (_py_stop && (*_py_stop != Py_None)) { + cstop = __Pyx_PyIndex_AsSsize_t(*_py_stop); + if ((cstop == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; } else - args = PyTuple_Pack(1, value); - if (!args) - goto bad; - owned_instance = PyObject_Call(type, args, NULL); - Py_DECREF(args); - if (!owned_instance) - goto bad; - value = owned_instance; - if (!PyExceptionInstance_Check(value)) { - PyErr_Format(PyExc_TypeError, - "calling %R should have returned an instance of " - "BaseException, not %R", - type, Py_TYPE(value)); - goto bad; + cstop = PY_SSIZE_T_MAX; + } + if (wraparound && unlikely((cstart < 0) | (cstop < 0)) && likely(ms->sq_length)) { + Py_ssize_t l = ms->sq_length(obj); + if (likely(l >= 0)) { + if (cstop < 0) { + cstop += l; + if (cstop < 0) cstop = 0; + } + if (cstart < 0) { + cstart += l; + if (cstart < 0) cstart = 0; + } + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + goto bad; + PyErr_Clear(); } } - } else { - PyErr_SetString(PyExc_TypeError, - "raise: exception class must be a subclass of BaseException"); - goto bad; - } - if (cause) { - PyObject *fixed_cause; - if (cause == Py_None) { - fixed_cause = NULL; - } else if (PyExceptionClass_Check(cause)) { - fixed_cause = PyObject_CallObject(cause, NULL); - if (fixed_cause == NULL) - goto bad; - } else if (PyExceptionInstance_Check(cause)) { - fixed_cause = cause; - Py_INCREF(fixed_cause); - } else { - PyErr_SetString(PyExc_TypeError, - "exception causes must derive from " - "BaseException"); - goto bad; - } - PyException_SetCause(value, fixed_cause); + return ms->sq_slice(obj, cstart, cstop); } - PyErr_SetObject(type, value); - if (tb) { -#if CYTHON_COMPILING_IN_PYPY - PyObject *tmp_type, *tmp_value, *tmp_tb; - PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); - Py_INCREF(tb); - PyErr_Restore(tmp_type, tmp_value, tb); - Py_XDECREF(tmp_tb); -#else - PyThreadState *tstate = __Pyx_PyThreadState_Current; - PyObject* tmp_tb = tstate->curexc_traceback; - if (tb != tmp_tb) { - Py_INCREF(tb); - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_tb); - } #endif - } -bad: - Py_XDECREF(owned_instance); - return; -} + mp = Py_TYPE(obj)->tp_as_mapping; + if (likely(mp && mp->mp_subscript)) #endif - -/* BytesEquals */ -static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { -#if CYTHON_COMPILING_IN_PYPY - return PyObject_RichCompareBool(s1, s2, equals); -#else - if (s1 == s2) { - return (equals == Py_EQ); - } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { - const char *ps1, *ps2; - Py_ssize_t length = PyBytes_GET_SIZE(s1); - if (length != PyBytes_GET_SIZE(s2)) - return (equals == Py_NE); - ps1 = PyBytes_AS_STRING(s1); - ps2 = PyBytes_AS_STRING(s2); - if (ps1[0] != ps2[0]) { - return (equals == Py_NE); - } else if (length == 1) { - return (equals == Py_EQ); + { + PyObject* result; + PyObject *py_slice, *py_start, *py_stop; + if (_py_slice) { + py_slice = *_py_slice; } else { - int result; -#if CYTHON_USE_UNICODE_INTERNALS - Py_hash_t hash1, hash2; - hash1 = ((PyBytesObject*)s1)->ob_shash; - hash2 = ((PyBytesObject*)s2)->ob_shash; - if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { - return (equals == Py_NE); + PyObject* owned_start = NULL; + PyObject* owned_stop = NULL; + if (_py_start) { + py_start = *_py_start; + } else { + if (has_cstart) { + owned_start = py_start = PyInt_FromSsize_t(cstart); + if (unlikely(!py_start)) goto bad; + } else + py_start = Py_None; + } + if (_py_stop) { + py_stop = *_py_stop; + } else { + if (has_cstop) { + owned_stop = py_stop = PyInt_FromSsize_t(cstop); + if (unlikely(!py_stop)) { + Py_XDECREF(owned_start); + goto bad; + } + } else + py_stop = Py_None; } + py_slice = PySlice_New(py_start, py_stop, Py_None); + Py_XDECREF(owned_start); + Py_XDECREF(owned_stop); + if (unlikely(!py_slice)) goto bad; + } +#if CYTHON_USE_TYPE_SLOTS + result = mp->mp_subscript(obj, py_slice); +#else + result = PyObject_GetItem(obj, py_slice); #endif - result = memcmp(ps1, ps2, (size_t)length); - return (equals == Py_EQ) ? (result == 0) : (result != 0); + if (!_py_slice) { + Py_DECREF(py_slice); } - } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { - return (equals == Py_NE); - } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { - return (equals == Py_NE); - } else { - int result; - PyObject* py_result = PyObject_RichCompare(s1, s2, equals); - if (!py_result) - return -1; - result = __Pyx_PyObject_IsTrue(py_result); - Py_DECREF(py_result); return result; } -#endif + PyErr_Format(PyExc_TypeError, + "'%.200s' object is unsliceable", Py_TYPE(obj)->tp_name); +bad: + return NULL; } -/* UnicodeEquals */ -static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { -#if CYTHON_COMPILING_IN_PYPY - return PyObject_RichCompareBool(s1, s2, equals); -#else -#if PY_MAJOR_VERSION < 3 - PyObject* owned_ref = NULL; -#endif - int s1_is_unicode, s2_is_unicode; - if (s1 == s2) { - goto return_eq; - } - s1_is_unicode = PyUnicode_CheckExact(s1); - s2_is_unicode = PyUnicode_CheckExact(s2); -#if PY_MAJOR_VERSION < 3 - if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { - owned_ref = PyUnicode_FromObject(s2); - if (unlikely(!owned_ref)) - return -1; - s2 = owned_ref; - s2_is_unicode = 1; - } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { - owned_ref = PyUnicode_FromObject(s1); - if (unlikely(!owned_ref)) - return -1; - s1 = owned_ref; - s1_is_unicode = 1; - } else if (((!s2_is_unicode) & (!s1_is_unicode))) { - return __Pyx_PyBytes_Equals(s1, s2, equals); +/* GetItemInt */ +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (!j) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyList_GET_SIZE(o); } -#endif - if (s1_is_unicode & s2_is_unicode) { - Py_ssize_t length; - int kind; - void *data1, *data2; - if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) - return -1; - length = __Pyx_PyUnicode_GET_LENGTH(s1); - if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { - goto return_ne; - } -#if CYTHON_USE_UNICODE_INTERNALS - { - Py_hash_t hash1, hash2; - #if CYTHON_PEP393_ENABLED - hash1 = ((PyASCIIObject*)s1)->hash; - hash2 = ((PyASCIIObject*)s2)->hash; - #else - hash1 = ((PyUnicodeObject*)s1)->hash; - hash2 = ((PyUnicodeObject*)s2)->hash; - #endif - if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { - goto return_ne; - } - } -#endif - kind = __Pyx_PyUnicode_KIND(s1); - if (kind != __Pyx_PyUnicode_KIND(s2)) { - goto return_ne; - } - data1 = __Pyx_PyUnicode_DATA(s1); - data2 = __Pyx_PyUnicode_DATA(s2); - if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { - goto return_ne; - } else if (length == 1) { - goto return_eq; - } else { - int result = memcmp(data1, data2, (size_t)(length * kind)); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - return (equals == Py_EQ) ? (result == 0) : (result != 0); - } - } else if ((s1 == Py_None) & s2_is_unicode) { - goto return_ne; - } else if ((s2 == Py_None) & s1_is_unicode) { - goto return_ne; - } else { - int result; - PyObject* py_result = PyObject_RichCompare(s1, s2, equals); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - if (!py_result) - return -1; - result = __Pyx_PyObject_IsTrue(py_result); - Py_DECREF(py_result); - return result; + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; } -return_eq: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - return (equals == Py_EQ); -return_ne: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - return (equals == Py_NE); + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); #endif } - -/* None */ -static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t a, Py_ssize_t b) { - Py_ssize_t q = a / b; - Py_ssize_t r = a - q*b; - q -= ((r != 0) & ((r ^ b) < 0)); - return q; -} - -/* GetAttr */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { -#if CYTHON_USE_TYPE_SLOTS -#if PY_MAJOR_VERSION >= 3 - if (likely(PyUnicode_Check(n))) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyTuple_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else - if (likely(PyString_Check(n))) -#endif - return __Pyx_PyObject_GetAttrStr(o, n); + return PySequence_GetItem(o, i); #endif - return PyObject_GetAttr(o, n); } - -/* decode_c_string */ -static CYTHON_INLINE PyObject* __Pyx_decode_c_string( - const char* cstring, Py_ssize_t start, Py_ssize_t stop, - const char* encoding, const char* errors, - PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { - Py_ssize_t length; - if (unlikely((start < 0) | (stop < 0))) { - size_t slen = strlen(cstring); - if (unlikely(slen > (size_t) PY_SSIZE_T_MAX)) { - PyErr_SetString(PyExc_OverflowError, - "c-string too long to convert to Python"); - return NULL; - } - length = (Py_ssize_t) slen; - if (start < 0) { - start += length; - if (start < 0) - start = 0; +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { + PyObject *r = PyList_GET_ITEM(o, n); + Py_INCREF(r); + return r; } - if (stop < 0) - stop += length; } - if (unlikely(stop <= start)) - return __Pyx_NewRef(__pyx_empty_unicode); - length = stop - start; - cstring += start; - if (decode_func) { - return decode_func(cstring, length, errors); + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } } else { - return PyUnicode_Decode(cstring, length, encoding, errors); + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return m->sq_item(o, i); + } + } +#else + if (is_list || PySequence_Check(o)) { + return PySequence_GetItem(o, i); } +#endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); } -/* PyErrExceptionMatches */ -#if CYTHON_FAST_THREAD_STATE -static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(tuple); -#if PY_MAJOR_VERSION >= 3 - for (i=0; icurexc_type; - if (exc_type == err) return 1; - if (unlikely(!exc_type)) return 0; - if (unlikely(PyTuple_Check(err))) - return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); - return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); } #endif -/* GetAttr3 */ -static PyObject *__Pyx_GetAttr3Default(PyObject *d) { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) +/* ObjectGetItem */ +#if CYTHON_USE_TYPE_SLOTS +static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) { + PyObject *runerr; + Py_ssize_t key_value; + PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence; + if (unlikely(!(m && m->sq_item))) { + PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name); return NULL; - __Pyx_PyErr_Clear(); - Py_INCREF(d); - return d; -} -static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { - PyObject *r = __Pyx_GetAttr(o, n); - return (likely(r)) ? r : __Pyx_GetAttr3Default(d); -} - -/* RaiseNoneIterError */ -static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); -} - -/* ExtTypeTest */ -static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { - if (unlikely(!type)) { - PyErr_SetString(PyExc_SystemError, "Missing type object"); - return 0; } - if (likely(__Pyx_TypeCheck(obj, type))) - return 1; - PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", - Py_TYPE(obj)->tp_name, type->tp_name); - return 0; + key_value = __Pyx_PyIndex_AsSsize_t(index); + if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { + return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); + } + if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { + PyErr_Clear(); + PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name); + } + return NULL; } - -/* 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; +static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) { + PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping; + if (likely(m && m->mp_subscript)) { + return m->mp_subscript(obj, key); } - return exc_info; + return __Pyx_PyObject_GetIndex(obj, key); } #endif -/* SaveResetException */ -#if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - #if CYTHON_USE_EXC_INFO_STACK - _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); - *type = exc_info->exc_type; - *value = exc_info->exc_value; - *tb = exc_info->exc_traceback; - #else - *type = tstate->exc_type; - *value = tstate->exc_value; - *tb = tstate->exc_traceback; - #endif - Py_XINCREF(*type); - Py_XINCREF(*value); - Py_XINCREF(*tb); +/* RaiseTooManyValuesToUnpack */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); } -static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - #if CYTHON_USE_EXC_INFO_STACK - _PyErr_StackItem *exc_info = tstate->exc_info; - tmp_type = exc_info->exc_type; - tmp_value = exc_info->exc_value; - tmp_tb = exc_info->exc_traceback; - exc_info->exc_type = type; - exc_info->exc_value = value; - exc_info->exc_traceback = tb; - #else - tmp_type = tstate->exc_type; - tmp_value = tstate->exc_value; - tmp_tb = tstate->exc_traceback; - tstate->exc_type = type; - tstate->exc_value = value; - tstate->exc_traceback = tb; - #endif - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); + +/* RaiseNeedMoreValuesToUnpack */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); } -#endif -/* GetException */ -#if CYTHON_FAST_THREAD_STATE -static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) -#else -static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) -#endif -{ - PyObject *local_type, *local_value, *local_tb; -#if CYTHON_FAST_THREAD_STATE - PyObject *tmp_type, *tmp_value, *tmp_tb; - local_type = tstate->curexc_type; - local_value = tstate->curexc_value; - local_tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; -#else - PyErr_Fetch(&local_type, &local_value, &local_tb); -#endif - PyErr_NormalizeException(&local_type, &local_value, &local_tb); -#if CYTHON_FAST_THREAD_STATE - if (unlikely(tstate->curexc_type)) -#else - if (unlikely(PyErr_Occurred())) -#endif - goto bad; - #if PY_MAJOR_VERSION >= 3 - if (local_tb) { - if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) - goto bad; - } - #endif - Py_XINCREF(local_tb); - Py_XINCREF(local_type); - Py_XINCREF(local_value); - *type = local_type; - *value = local_value; - *tb = local_tb; +/* IterFinish */ +static CYTHON_INLINE int __Pyx_IterFinish(void) { #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; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* exc_type = tstate->curexc_type; + if (unlikely(exc_type)) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) { + PyObject *exc_value, *exc_tb; + exc_value = tstate->curexc_value; + exc_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; + Py_DECREF(exc_type); + Py_XDECREF(exc_value); + Py_XDECREF(exc_tb); + return 0; + } else { + return -1; + } } - #else - tmp_type = tstate->exc_type; - tmp_value = tstate->exc_value; - tmp_tb = tstate->exc_traceback; - tstate->exc_type = local_type; - tstate->exc_value = local_value; - tstate->exc_traceback = local_tb; - #endif - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); + return 0; #else - PyErr_SetExcInfo(local_type, local_value, local_tb); + if (unlikely(PyErr_Occurred())) { + if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { + PyErr_Clear(); + return 0; + } else { + return -1; + } + } + return 0; #endif +} + +/* UnpackItemEndCheck */ +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { + if (unlikely(retval)) { + Py_DECREF(retval); + __Pyx_RaiseTooManyValuesError(expected); + return -1; + } else { + return __Pyx_IterFinish(); + } return 0; -bad: - *type = 0; - *value = 0; - *tb = 0; - Py_XDECREF(local_type); - Py_XDECREF(local_value); - Py_XDECREF(local_tb); - return -1; } -/* SwapException */ +/* DictGetItem */ +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (!PyErr_Occurred()) { + if (unlikely(PyTuple_Check(key))) { + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) { + PyErr_SetObject(PyExc_KeyError, args); + Py_DECREF(args); + } + } else { + PyErr_SetObject(PyExc_KeyError, key); + } + } + return NULL; + } + Py_INCREF(value); + return value; +} +#endif + +/* RaiseNoneIterError */ +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +} + +/* PyErrFetchRestore */ #if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; - #if CYTHON_USE_EXC_INFO_STACK - _PyErr_StackItem *exc_info = tstate->exc_info; - tmp_type = exc_info->exc_type; - tmp_value = exc_info->exc_value; - tmp_tb = exc_info->exc_traceback; - exc_info->exc_type = *type; - exc_info->exc_value = *value; - exc_info->exc_traceback = *tb; - #else - tmp_type = tstate->exc_type; - tmp_value = tstate->exc_value; - tmp_tb = tstate->exc_traceback; - tstate->exc_type = *type; - tstate->exc_value = *value; - tstate->exc_traceback = *tb; - #endif - *type = tmp_type; - *value = tmp_value; - *tb = tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); } -#else -static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); - PyErr_SetExcInfo(*type, *value, *tb); - *type = tmp_type; - *value = tmp_value; - *tb = tmp_tb; +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; } #endif -/* Import */ -static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { - PyObject *empty_list = 0; - PyObject *module = 0; - PyObject *global_dict = 0; - PyObject *empty_dict = 0; - PyObject *list; - #if PY_MAJOR_VERSION < 3 - PyObject *py_import; - py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); - if (!py_import) - goto bad; - #endif - if (from_list) - list = from_list; +/* RaiseException */ +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + __Pyx_PyThreadState_declare + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; else { - empty_list = PyList_New(0); - if (!empty_list) - goto bad; - list = empty_list; + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } } - global_dict = PyModule_GetDict(__pyx_m); - if (!global_dict) - goto bad; - empty_dict = PyDict_New(); - if (!empty_dict) + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); goto bad; - { - #if PY_MAJOR_VERSION >= 3 - if (level == -1) { - if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { - module = PyImport_ImportModuleLevelObject( - name, global_dict, empty_dict, list, 1); - if (!module) { - if (!PyErr_ExceptionMatches(PyExc_ImportError)) - goto bad; - PyErr_Clear(); + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; } } - level = 0; } - #endif - if (!module) { - #if PY_MAJOR_VERSION < 3 - PyObject *py_level = PyInt_FromLong(level); - if (!py_level) + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) goto bad; - module = PyObject_CallFunctionObjArgs(py_import, - name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); - Py_DECREF(py_level); - #else - module = PyImport_ImportModuleLevelObject( - name, global_dict, empty_dict, list, level); - #endif + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); } +#endif } bad: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(py_import); - #endif - Py_XDECREF(empty_list); - Py_XDECREF(empty_dict); - return module; + Py_XDECREF(owned_instance); + return; } +#endif -/* FastTypeChecks */ -#if CYTHON_COMPILING_IN_CPYTHON -static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { - while (a) { - a = a->tp_base; - if (a == b) - return 1; - } - return b == &PyBaseObject_Type; -} -static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { - PyObject *mro; - if (a == b) return 1; - mro = a->tp_mro; - if (likely(mro)) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(mro); - for (i = 0; i < n; i++) { - if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) - return 1; - } - return 0; +/* 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 __Pyx_InBases(a, b); + return exc_info; } -#if PY_MAJOR_VERSION == 2 -static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { - PyObject *exception, *value, *tb; - int res; - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ErrFetch(&exception, &value, &tb); - res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; - if (unlikely(res == -1)) { - PyErr_WriteUnraisable(err); - res = 0; - } - if (!res) { - res = PyObject_IsSubclass(err, exc_type2); - if (unlikely(res == -1)) { - PyErr_WriteUnraisable(err); - res = 0; - } - } - __Pyx_ErrRestore(exception, value, tb); - return res; +#endif + +/* SaveResetException */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + *type = exc_info->exc_type; + *value = exc_info->exc_value; + *tb = exc_info->exc_traceback; + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + #endif + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); } -#else -static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { - int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; - if (!res) { - res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); - } - return res; +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = type; + exc_info->exc_value = value; + exc_info->exc_traceback = tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); } #endif -static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + +/* PyErrExceptionMatches */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; - assert(PyExceptionClass_Check(exc_type)); n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; icurexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; + if (unlikely(PyTuple_Check(err))) + return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } #endif -/* PyIntBinop */ -#if !CYTHON_COMPILING_IN_PYPY -static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) { - (void)inplace; - (void)zerodivision_check; - #if PY_MAJOR_VERSION < 3 - if (likely(PyInt_CheckExact(op1))) { - const long b = intval; - long x; - long a = PyInt_AS_LONG(op1); - x = (long)((unsigned long)a + b); - if (likely((x^a) >= 0 || (x^b) >= 0)) - return PyInt_FromLong(x); - return PyLong_Type.tp_as_number->nb_add(op1, op2); - } - #endif - #if CYTHON_USE_PYLONG_INTERNALS - if (likely(PyLong_CheckExact(op1))) { - const long b = intval; - long a, x; -#ifdef HAVE_LONG_LONG - const PY_LONG_LONG llb = intval; - PY_LONG_LONG lla, llx; -#endif - const digit* digits = ((PyLongObject*)op1)->ob_digit; - const Py_ssize_t size = Py_SIZE(op1); - if (likely(__Pyx_sst_abs(size) <= 1)) { - a = likely(size) ? digits[0] : 0; - if (size == -1) a = -a; - } else { - switch (size) { - case -2: - if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { - lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; -#endif - } - CYTHON_FALLTHROUGH; - case 2: - if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { - lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; -#endif - } - CYTHON_FALLTHROUGH; - case -3: - if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { - lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; -#endif - } - CYTHON_FALLTHROUGH; - case 3: - if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { - lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; -#endif - } - CYTHON_FALLTHROUGH; - case -4: - if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { - lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; -#endif - } - CYTHON_FALLTHROUGH; - case 4: - if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); - break; -#ifdef HAVE_LONG_LONG - } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { - lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); - goto long_long; -#endif - } - CYTHON_FALLTHROUGH; - default: return PyLong_Type.tp_as_number->nb_add(op1, op2); - } - } - x = a + b; - return PyLong_FromLong(x); -#ifdef HAVE_LONG_LONG - long_long: - llx = lla + llb; - return PyLong_FromLongLong(llx); +/* GetException */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #endif - - - } - #endif - if (PyFloat_CheckExact(op1)) { - const long b = intval; - double a = PyFloat_AS_DOUBLE(op1); - double result; - PyFPE_START_PROTECT("add", return NULL) - result = ((double)a) + (double)b; - PyFPE_END_PROTECT(result) - return PyFloat_FromDouble(result); - } - return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); -} +{ + PyObject *local_type, *local_value, *local_tb; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); #endif - -/* None */ -static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { - PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); -} - -/* None */ -static CYTHON_INLINE long __Pyx_div_long(long a, long b) { - long q = a / b; - long r = a - q*b; - q -= ((r != 0) & ((r ^ b) < 0)); - return q; -} - -/* ImportFrom */ -static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { - PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); - if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { - PyErr_Format(PyExc_ImportError, - #if PY_MAJOR_VERSION < 3 - "cannot import name %.230s", PyString_AS_STRING(name)); - #else - "cannot import name %S", name); - #endif - } - return value; -} - -/* HasAttr */ -static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { - PyObject *r; - if (unlikely(!__Pyx_PyBaseString_Check(n))) { - PyErr_SetString(PyExc_TypeError, - "hasattr(): attribute name must be string"); - return -1; - } - r = __Pyx_GetAttr(o, n); - if (unlikely(!r)) { - PyErr_Clear(); - return 0; - } else { - Py_DECREF(r); - return 1; - } -} - -/* PyObject_GenericGetAttrNoDict */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { - PyErr_Format(PyExc_AttributeError, -#if PY_MAJOR_VERSION >= 3 - "'%.50s' object has no attribute '%U'", - tp->tp_name, attr_name); + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) #else - "'%.50s' object has no attribute '%.400s'", - tp->tp_name, PyString_AS_STRING(attr_name)); + if (unlikely(PyErr_Occurred())) #endif - return NULL; -} -static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { - PyObject *descr; - PyTypeObject *tp = Py_TYPE(obj); - if (unlikely(!PyString_Check(attr_name))) { - return PyObject_GenericGetAttr(obj, attr_name); - } - assert(!tp->tp_dictoffset); - descr = _PyType_Lookup(tp, attr_name); - if (unlikely(!descr)) { - return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); + goto bad; + #if PY_MAJOR_VERSION >= 3 + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; } - Py_INCREF(descr); - #if PY_MAJOR_VERSION < 3 - if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) #endif + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if CYTHON_USE_EXC_INFO_STACK { - descrgetfunc f = Py_TYPE(descr)->tp_descr_get; - if (unlikely(f)) { - PyObject *res = f(descr, obj, (PyObject *)tp); - Py_DECREF(descr); - return res; - } - } - return descr; -} -#endif - -/* PyObject_GenericGetAttr */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { - if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { - return PyObject_GenericGetAttr(obj, attr_name); + _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; } - return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); -} -#endif - -/* SetVTable */ -static int __Pyx_SetVtable(PyObject *dict, void *vtable) { -#if PY_VERSION_HEX >= 0x02070000 - PyObject *ob = PyCapsule_New(vtable, 0, 0); + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); #else - PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); + PyErr_SetExcInfo(local_type, local_value, local_tb); #endif - if (!ob) - goto bad; - if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) - goto bad; - Py_DECREF(ob); return 0; bad: - Py_XDECREF(ob); + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); return -1; } -/* PyObjectGetAttrStrNoError */ -static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) - __Pyx_PyErr_Clear(); -} -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { - PyObject *result; -#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 - PyTypeObject* tp = Py_TYPE(obj); - if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { - return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); +/* TypeImport */ +#ifndef __PYX_HAVE_RT_ImportType +#define __PYX_HAVE_RT_ImportType +static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, + size_t size, enum __Pyx_ImportType_CheckSize check_size) +{ + PyObject *result = 0; + char warning[200]; + Py_ssize_t basicsize; +#ifdef Py_LIMITED_API + PyObject *py_basicsize; +#endif + result = PyObject_GetAttrString(module, class_name); + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; } +#ifndef Py_LIMITED_API + basicsize = ((PyTypeObject *)result)->tp_basicsize; +#else + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; #endif - result = __Pyx_PyObject_GetAttrStr(obj, attr_name); - if (unlikely(!result)) { - __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + if ((size_t)basicsize < size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + goto bad; } - return result; -} - -/* SetupReduce */ -static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { - int ret; - PyObject *name_attr; - name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name_2); - if (likely(name_attr)) { - ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); - } else { - ret = -1; - } - if (unlikely(ret < 0)) { - PyErr_Clear(); - ret = 0; - } - Py_XDECREF(name_attr); - return ret; + if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + goto bad; + } + else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { + PyOS_snprintf(warning, sizeof(warning), + "%s.%s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + } + return (PyTypeObject *)result; +bad: + Py_XDECREF(result); + return NULL; } -static int __Pyx_setup_reduce(PyObject* type_obj) { - int ret = 0; - PyObject *object_reduce = NULL; - PyObject *object_reduce_ex = NULL; - PyObject *reduce = NULL; - PyObject *reduce_ex = NULL; - PyObject *reduce_cython = NULL; - PyObject *setstate = NULL; - PyObject *setstate_cython = NULL; -#if CYTHON_USE_PYTYPE_LOOKUP - if (_PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD; -#else - if (PyObject_HasAttr(type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD; -#endif -#if CYTHON_USE_PYTYPE_LOOKUP - object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; -#else - object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; -#endif - reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; - if (reduce_ex == object_reduce_ex) { -#if CYTHON_USE_PYTYPE_LOOKUP - object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; -#else - object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; #endif - reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; - if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { - reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); - if (likely(reduce_cython)) { - ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - } else if (reduce == object_reduce || PyErr_Occurred()) { - goto __PYX_BAD; - } - setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); - if (!setstate) PyErr_Clear(); - if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { - setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); - if (likely(setstate_cython)) { - ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - } else if (!setstate || PyErr_Occurred()) { - goto __PYX_BAD; + +/* Import */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_MAJOR_VERSION < 3 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); } } - PyType_Modified((PyTypeObject*)type_obj); + level = 0; + } + #endif + if (!module) { + #if PY_MAJOR_VERSION < 3 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif } } - goto __PYX_GOOD; -__PYX_BAD: - if (!PyErr_Occurred()) - PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); - ret = -1; -__PYX_GOOD: -#if !CYTHON_USE_PYTYPE_LOOKUP - Py_XDECREF(object_reduce); - Py_XDECREF(object_reduce_ex); -#endif - Py_XDECREF(reduce); - Py_XDECREF(reduce_ex); - Py_XDECREF(reduce_cython); - Py_XDECREF(setstate); - Py_XDECREF(setstate_cython); - return ret; +bad: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +/* ImportFrom */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Format(PyExc_ImportError, + #if PY_MAJOR_VERSION < 3 + "cannot import name %.230s", PyString_AS_STRING(name)); + #else + "cannot import name %S", name); + #endif + } + return value; } /* CLineInTraceback */ @@ -20224,99 +7749,6 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, Py_XDECREF(py_frame); } -#if PY_MAJOR_VERSION < 3 -static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { - if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); - if (__Pyx_TypeCheck(obj, __pyx_array_type)) return __pyx_array_getbuffer(obj, view, flags); - if (__Pyx_TypeCheck(obj, __pyx_memoryview_type)) return __pyx_memoryview_getbuffer(obj, view, flags); - PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); - return -1; -} -static void __Pyx_ReleaseBuffer(Py_buffer *view) { - PyObject *obj = view->obj; - if (!obj) return; - if (PyObject_CheckBuffer(obj)) { - PyBuffer_Release(view); - return; - } - if ((0)) {} - view->obj = NULL; - Py_DECREF(obj); -} -#endif - - -/* MemviewSliceIsContig */ -static int -__pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim) -{ - int i, index, step, start; - Py_ssize_t itemsize = mvs.memview->view.itemsize; - if (order == 'F') { - step = 1; - start = 0; - } else { - step = -1; - start = ndim - 1; - } - for (i = 0; i < ndim; i++) { - index = start + step * i; - if (mvs.suboffsets[index] >= 0 || mvs.strides[index] != itemsize) - return 0; - itemsize *= mvs.shape[index]; - } - return 1; -} - -/* OverlappingSlices */ -static void -__pyx_get_array_memory_extents(__Pyx_memviewslice *slice, - void **out_start, void **out_end, - int ndim, size_t itemsize) -{ - char *start, *end; - int i; - start = end = slice->data; - for (i = 0; i < ndim; i++) { - Py_ssize_t stride = slice->strides[i]; - Py_ssize_t extent = slice->shape[i]; - if (extent == 0) { - *out_start = *out_end = start; - return; - } else { - if (stride > 0) - end += stride * (extent - 1); - else - start += stride * (extent - 1); - } - } - *out_start = start; - *out_end = end + itemsize; -} -static int -__pyx_slices_overlap(__Pyx_memviewslice *slice1, - __Pyx_memviewslice *slice2, - int ndim, size_t itemsize) -{ - void *start1, *end1, *start2, *end2; - __pyx_get_array_memory_extents(slice1, &start1, &end1, ndim, itemsize); - __pyx_get_array_memory_extents(slice2, &start2, &end2, ndim, itemsize); - return (start1 < end2) && (start2 < end1); -} - -/* Capsule */ -static CYTHON_INLINE PyObject * -__pyx_capsule_create(void *p, CYTHON_UNUSED const char *sig) -{ - PyObject *cobj; -#if PY_VERSION_HEX >= 0x02070000 - cobj = PyCapsule_New(p, sig, NULL); -#else - cobj = PyCObject_FromVoidPtr(p, NULL); -#endif - return cobj; -} - /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) @@ -20340,24 +7772,363 @@ __pyx_capsule_create(void *p, CYTHON_UNUSED const char *sig) } /* 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) ((int) 0 - (int) 1), const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +/* Declarations */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return ::std::complex< float >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return x + y*(__pyx_t_float_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + __pyx_t_float_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +/* Arithmetic */ +#if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + #if 1 + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + if (b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); + } else if (fabsf(b.real) >= fabsf(b.imag)) { + if (b.real == 0 && b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag); + } else { + float r = b.imag / b.real; + float s = (float)(1.0) / (b.real + b.imag * r); + return __pyx_t_float_complex_from_parts( + (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); + } + } else { + float r = b.real / b.imag; + float s = (float)(1.0) / (b.imag + b.real * r); + return __pyx_t_float_complex_from_parts( + (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); + } + } + #else + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + if (b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); + } else { + float denom = b.real * b.real + b.imag * b.imag; + return __pyx_t_float_complex_from_parts( + (a.real * b.real + a.imag * b.imag) / denom, + (a.imag * b.real - a.real * b.imag) / denom); + } + } + #endif + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrtf(z.real*z.real + z.imag*z.imag); + #else + return hypotf(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + float denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + return __Pyx_c_prod_float(a, a); + case 3: + z = __Pyx_c_prod_float(a, a); + return __Pyx_c_prod_float(z, a); + case 4: + z = __Pyx_c_prod_float(a, a); + return __Pyx_c_prod_float(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } else if (b.imag == 0) { + z.real = powf(a.real, b.real); + z.imag = 0; + return z; + } else if (a.real > 0) { + r = a.real; + theta = 0; + } else { + r = -a.real; + theta = atan2f(0.0, -1.0); + } + } else { + r = __Pyx_c_abs_float(a); + theta = atan2f(a.imag, a.real); + } + lnr = logf(r); + z_r = expf(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cosf(z_theta); + z.imag = z_r * sinf(z_theta); + return z; + } + #endif +#endif + +/* Declarations */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return ::std::complex< double >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return x + y*(__pyx_t_double_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + __pyx_t_double_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +/* Arithmetic */ +#if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + #if 1 + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + if (b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else if (fabs(b.real) >= fabs(b.imag)) { + if (b.real == 0 && b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag); + } else { + double r = b.imag / b.real; + double s = (double)(1.0) / (b.real + b.imag * r); + return __pyx_t_double_complex_from_parts( + (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); + } + } else { + double r = b.real / b.imag; + double s = (double)(1.0) / (b.imag + b.real * r); + return __pyx_t_double_complex_from_parts( + (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); + } + } + #else + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + if (b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else { + double denom = b.real * b.real + b.imag * b.imag; + return __pyx_t_double_complex_from_parts( + (a.real * b.real + a.imag * b.imag) / denom, + (a.imag * b.real - a.real * b.imag) / denom); + } + } + #endif + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrt(z.real*z.real + z.imag*z.imag); + #else + return hypot(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + double denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + return __Pyx_c_prod_double(a, a); + case 3: + z = __Pyx_c_prod_double(a, a); + return __Pyx_c_prod_double(z, a); + case 4: + z = __Pyx_c_prod_double(a, a); + return __Pyx_c_prod_double(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } else if (b.imag == 0) { + z.real = pow(a.real, b.real); + z.imag = 0; + return z; + } else if (a.real > 0) { + r = a.real; + theta = 0; + } else { + r = -a.real; + theta = atan2(0.0, -1.0); + } + } else { + r = __Pyx_c_abs_double(a); + theta = atan2(a.imag, a.real); + } + lnr = log(r); + z_r = exp(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cos(z_theta); + z.imag = z_r * sin(z_theta); + return z; + } + #endif +#endif + +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) { + const enum NPY_TYPES neg_one = (enum NPY_TYPES) ((enum NPY_TYPES) 0 - (enum NPY_TYPES) 1), const_zero = (enum NPY_TYPES) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { - if (sizeof(int) < sizeof(long)) { + if (sizeof(enum NPY_TYPES) < sizeof(long)) { return PyInt_FromLong((long) value); - } else if (sizeof(int) <= sizeof(unsigned long)) { + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { - if (sizeof(int) <= sizeof(long)) { + if (sizeof(enum NPY_TYPES) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } @@ -20365,90 +8136,11 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; - return _PyLong_FromByteArray(bytes, sizeof(int), + return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES), little, !is_unsigned); } } -/* MemviewDtypeToObject */ -static CYTHON_INLINE PyObject *__pyx_memview_get_double(const char *itemp) { - return (PyObject *) PyFloat_FromDouble(*(double *) itemp); -} -static CYTHON_INLINE int __pyx_memview_set_double(const char *itemp, PyObject *obj) { - double value = __pyx_PyFloat_AsDouble(obj); - if ((value == (double)-1) && PyErr_Occurred()) - return 0; - *(double *) itemp = value; - return 1; -} - -/* MemviewSliceCopyTemplate */ -static __Pyx_memviewslice -__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, - const char *mode, int ndim, - size_t sizeof_dtype, int contig_flag, - int dtype_is_object) -{ - __Pyx_RefNannyDeclarations - int i; - __Pyx_memviewslice new_mvs = { 0, 0, { 0 }, { 0 }, { 0 } }; - struct __pyx_memoryview_obj *from_memview = from_mvs->memview; - Py_buffer *buf = &from_memview->view; - PyObject *shape_tuple = NULL; - PyObject *temp_int = NULL; - struct __pyx_array_obj *array_obj = NULL; - struct __pyx_memoryview_obj *memview_obj = NULL; - __Pyx_RefNannySetupContext("__pyx_memoryview_copy_new_contig", 0); - for (i = 0; i < ndim; i++) { - if (unlikely(from_mvs->suboffsets[i] >= 0)) { - PyErr_Format(PyExc_ValueError, "Cannot copy memoryview slice with " - "indirect dimensions (axis %d)", i); - goto fail; - } - } - shape_tuple = PyTuple_New(ndim); - if (unlikely(!shape_tuple)) { - goto fail; - } - __Pyx_GOTREF(shape_tuple); - for(i = 0; i < ndim; i++) { - temp_int = PyInt_FromSsize_t(from_mvs->shape[i]); - if(unlikely(!temp_int)) { - goto fail; - } else { - PyTuple_SET_ITEM(shape_tuple, i, temp_int); - temp_int = NULL; - } - } - array_obj = __pyx_array_new(shape_tuple, sizeof_dtype, buf->format, (char *) mode, NULL); - if (unlikely(!array_obj)) { - goto fail; - } - __Pyx_GOTREF(array_obj); - memview_obj = (struct __pyx_memoryview_obj *) __pyx_memoryview_new( - (PyObject *) array_obj, contig_flag, - dtype_is_object, - from_mvs->memview->typeinfo); - if (unlikely(!memview_obj)) - goto fail; - if (unlikely(__Pyx_init_memviewslice(memview_obj, ndim, &new_mvs, 1) < 0)) - goto fail; - if (unlikely(__pyx_memoryview_copy_contents(*from_mvs, new_mvs, ndim, ndim, - dtype_is_object) < 0)) - goto fail; - goto no_fail; -fail: - __Pyx_XDECREF(new_mvs.memview); - new_mvs.memview = NULL; - new_mvs.data = NULL; -no_fail: - __Pyx_XDECREF(shape_tuple); - __Pyx_XDECREF(temp_int); - __Pyx_XDECREF(array_obj); - __Pyx_RefNannyFinishContext(); - return new_mvs; -} - /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; @@ -20638,195 +8330,6 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { return (int) -1; } -/* CIntFromPy */ -static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { - const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; - const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if (sizeof(long) < sizeof(long)) { - __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (long) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { -#if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { - return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); - } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { - return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); - } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { - return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); - } - } - break; - } -#endif -#if CYTHON_COMPILING_IN_CPYTHON - if (unlikely(Py_SIZE(x) < 0)) { - goto raise_neg_overflow; - } -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (long) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#endif - if (sizeof(long) <= sizeof(unsigned long)) { - __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { - __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif - } - } else { -#if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) - case -2: - if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case -3: - if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case -4: - if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - } -#endif - if (sizeof(long) <= sizeof(long)) { - __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { - __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif - } - } - { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else - long val; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } - #endif - if (likely(v)) { - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); - Py_DECREF(v); - if (likely(!ret)) - return val; - } -#endif - return (long) -1; - } - } else { - long val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (long) -1; - val = __Pyx_PyInt_As_long(tmp); - Py_DECREF(tmp); - return val; - } -raise_overflow: - PyErr_SetString(PyExc_OverflowError, - "value too large to convert to long"); - return (long) -1; -raise_neg_overflow: - PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to long"); - return (long) -1; -} - /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; @@ -20859,19 +8362,19 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { } /* 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 long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(char) < sizeof(long)) { - __PYX_VERIFY_RETURN_INT(char, long, PyInt_AS_LONG(x)) + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } - return (char) val; + return (long) val; } } else #endif @@ -20880,32 +8383,32 @@ static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { - case 0: return (char) 0; - case 1: __PYX_VERIFY_RETURN_INT(char, digit, digits[0]) + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) case 2: - if (8 * sizeof(char) > 1 * PyLong_SHIFT) { + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(char) >= 2 * PyLong_SHIFT) { - return (char) (((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 3: - if (8 * sizeof(char) > 2 * PyLong_SHIFT) { + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(char) >= 3 * PyLong_SHIFT) { - return (char) (((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 4: - if (8 * sizeof(char) > 3 * PyLong_SHIFT) { + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(char) >= 4 * PyLong_SHIFT) { - return (char) (((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; @@ -20919,86 +8422,86 @@ static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) { { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) - return (char) -1; + return (long) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif - if (sizeof(char) <= sizeof(unsigned long)) { - __PYX_VERIFY_RETURN_INT_EXC(char, unsigned long, PyLong_AsUnsignedLong(x)) + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(char) <= sizeof(unsigned PY_LONG_LONG)) { - __PYX_VERIFY_RETURN_INT_EXC(char, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { - case 0: return (char) 0; - case -1: __PYX_VERIFY_RETURN_INT(char, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(char, digit, +digits[0]) + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) case -2: - if (8 * sizeof(char) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { - return (char) (((char)-1)*(((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 2: - if (8 * sizeof(char) > 1 * PyLong_SHIFT) { + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { - return (char) ((((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -3: - if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { - return (char) (((char)-1)*(((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 3: - if (8 * sizeof(char) > 2 * PyLong_SHIFT) { + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { - return (char) ((((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -4: - if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) { - return (char) (((char)-1)*(((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 4: - if (8 * sizeof(char) > 3 * PyLong_SHIFT) { + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) { - return (char) ((((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; } #endif - if (sizeof(char) <= sizeof(long)) { - __PYX_VERIFY_RETURN_INT_EXC(char, long, PyLong_AsLong(x)) + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(char) <= sizeof(PY_LONG_LONG)) { - __PYX_VERIFY_RETURN_INT_EXC(char, PY_LONG_LONG, PyLong_AsLongLong(x)) + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } @@ -21007,7 +8510,7 @@ static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) { PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else - char val; + long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { @@ -21027,786 +8530,128 @@ static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) { return val; } #endif - return (char) -1; + return (long) -1; } } else { - char val; + long val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (char) -1; - val = __Pyx_PyInt_As_char(tmp); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, - "value too large to convert to char"); - return (char) -1; + "value too large to convert to long"); + return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to char"); - return (char) -1; -} - -/* IsLittleEndian */ -static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) -{ - union { - uint32_t u32; - uint8_t u8[4]; - } S; - S.u32 = 0x01020304; - return S.u8[0] == 4; + "can't convert negative value to long"); + return (long) -1; } -/* BufferFormatCheck */ -static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, - __Pyx_BufFmt_StackElem* stack, - __Pyx_TypeInfo* type) { - stack[0].field = &ctx->root; - stack[0].parent_offset = 0; - ctx->root.type = type; - ctx->root.name = "buffer dtype"; - ctx->root.offset = 0; - ctx->head = stack; - ctx->head->field = &ctx->root; - ctx->fmt_offset = 0; - ctx->head->parent_offset = 0; - ctx->new_packmode = '@'; - ctx->enc_packmode = '@'; - ctx->new_count = 1; - ctx->enc_count = 0; - ctx->enc_type = 0; - ctx->is_complex = 0; - ctx->is_valid_array = 0; - ctx->struct_alignment = 0; - while (type->typegroup == 'S') { - ++ctx->head; - ctx->head->field = type->fields; - ctx->head->parent_offset = 0; - type = type->fields->type; - } +/* FastTypeChecks */ +#if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = a->tp_base; + if (a == b) + return 1; + } + return b == &PyBaseObject_Type; } -static int __Pyx_BufFmt_ParseNumber(const char** ts) { - int count; - const char* t = *ts; - if (*t < '0' || *t > '9') { - return -1; - } else { - count = *t++ - '0'; - while (*t >= '0' && *t <= '9') { - count *= 10; - count += *t++ - '0'; +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (a == b) return 1; + mro = a->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) + return 1; } + return 0; } - *ts = t; - return count; -} -static int __Pyx_BufFmt_ExpectNumber(const char **ts) { - int number = __Pyx_BufFmt_ParseNumber(ts); - if (number == -1) - PyErr_Format(PyExc_ValueError,\ - "Does not understand character buffer dtype format string ('%c')", **ts); - return number; -} -static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { - PyErr_Format(PyExc_ValueError, - "Unexpected format string character: '%c'", ch); -} -static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { - switch (ch) { - case '?': return "'bool'"; - case 'c': return "'char'"; - case 'b': return "'signed char'"; - case 'B': return "'unsigned char'"; - case 'h': return "'short'"; - case 'H': return "'unsigned short'"; - case 'i': return "'int'"; - case 'I': return "'unsigned int'"; - case 'l': return "'long'"; - case 'L': return "'unsigned long'"; - case 'q': return "'long long'"; - case 'Q': return "'unsigned long long'"; - case 'f': return (is_complex ? "'complex float'" : "'float'"); - case 'd': return (is_complex ? "'complex double'" : "'double'"); - case 'g': return (is_complex ? "'complex long double'" : "'long double'"); - case 'T': return "a struct"; - case 'O': return "Python object"; - case 'P': return "a pointer"; - case 's': case 'p': return "a string"; - case 0: return "end"; - default: return "unparseable format string"; - } + return __Pyx_InBases(a, b); } -static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { - switch (ch) { - case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; - case 'h': case 'H': return 2; - case 'i': case 'I': case 'l': case 'L': return 4; - case 'q': case 'Q': return 8; - case 'f': return (is_complex ? 8 : 4); - case 'd': return (is_complex ? 16 : 8); - case 'g': { - PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); - return 0; +#if PY_MAJOR_VERSION == 2 +static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { + PyObject *exception, *value, *tb; + int res; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&exception, &value, &tb); + res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; } - case 'O': case 'P': return sizeof(void*); - default: - __Pyx_BufFmt_RaiseUnexpectedChar(ch); - return 0; + if (!res) { + res = PyObject_IsSubclass(err, exc_type2); + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } } + __Pyx_ErrRestore(exception, value, tb); + return res; } -static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { - switch (ch) { - case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; - case 'h': case 'H': return sizeof(short); - case 'i': case 'I': return sizeof(int); - case 'l': case 'L': return sizeof(long); - #ifdef HAVE_LONG_LONG - case 'q': case 'Q': return sizeof(PY_LONG_LONG); - #endif - case 'f': return sizeof(float) * (is_complex ? 2 : 1); - case 'd': return sizeof(double) * (is_complex ? 2 : 1); - case 'g': return sizeof(long double) * (is_complex ? 2 : 1); - case 'O': case 'P': return sizeof(void*); - default: { - __Pyx_BufFmt_RaiseUnexpectedChar(ch); - return 0; +#else +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { + int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; + if (!res) { + res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } - } + return res; } -typedef struct { char c; short x; } __Pyx_st_short; -typedef struct { char c; int x; } __Pyx_st_int; -typedef struct { char c; long x; } __Pyx_st_long; -typedef struct { char c; float x; } __Pyx_st_float; -typedef struct { char c; double x; } __Pyx_st_double; -typedef struct { char c; long double x; } __Pyx_st_longdouble; -typedef struct { char c; void *x; } __Pyx_st_void_p; -#ifdef HAVE_LONG_LONG -typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; #endif -static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { - switch (ch) { - case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; - case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); - case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); - case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); -#ifdef HAVE_LONG_LONG - case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); -#endif - case 'f': return sizeof(__Pyx_st_float) - sizeof(float); - case 'd': return sizeof(__Pyx_st_double) - sizeof(double); - case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); - case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); - default: - __Pyx_BufFmt_RaiseUnexpectedChar(ch); - return 0; +static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + assert(PyExceptionClass_Check(exc_type)); + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; ihead == NULL || ctx->head->field == &ctx->root) { - const char* expected; - const char* quote; - if (ctx->head == NULL) { - expected = "end"; - quote = ""; - } else { - expected = ctx->head->field->type->name; - quote = "'"; - } - PyErr_Format(PyExc_ValueError, - "Buffer dtype mismatch, expected %s%s%s but got %s", - quote, expected, quote, - __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); - } else { - __Pyx_StructField* field = ctx->head->field; - __Pyx_StructField* parent = (ctx->head - 1)->field; - PyErr_Format(PyExc_ValueError, - "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", - field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), - parent->type->name, field->name); - } -} -static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { - char group; - size_t size, offset, arraysize = 1; - if (ctx->enc_type == 0) return 0; - if (ctx->head->field->type->arraysize[0]) { - int i, ndim = 0; - if (ctx->enc_type == 's' || ctx->enc_type == 'p') { - ctx->is_valid_array = ctx->head->field->type->ndim == 1; - ndim = 1; - if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { - PyErr_Format(PyExc_ValueError, - "Expected a dimension of size %zu, got %zu", - ctx->head->field->type->arraysize[0], ctx->enc_count); - return -1; - } - } - if (!ctx->is_valid_array) { - PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", - ctx->head->field->type->ndim, ndim); - return -1; - } - for (i = 0; i < ctx->head->field->type->ndim; i++) { - arraysize *= ctx->head->field->type->arraysize[i]; - } - ctx->is_valid_array = 0; - ctx->enc_count = 1; - } - group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); - do { - __Pyx_StructField* field = ctx->head->field; - __Pyx_TypeInfo* type = field->type; - if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { - size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); - } else { - size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); - } - if (ctx->enc_packmode == '@') { - size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); - size_t align_mod_offset; - if (align_at == 0) return -1; - align_mod_offset = ctx->fmt_offset % align_at; - if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; - if (ctx->struct_alignment == 0) - ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, - ctx->is_complex); - } - if (type->size != size || type->typegroup != group) { - if (type->typegroup == 'C' && type->fields != NULL) { - size_t parent_offset = ctx->head->parent_offset + field->offset; - ++ctx->head; - ctx->head->field = type->fields; - ctx->head->parent_offset = parent_offset; - continue; - } - if ((type->typegroup == 'H' || group == 'H') && type->size == size) { - } else { - __Pyx_BufFmt_RaiseExpected(ctx); - return -1; - } - } - offset = ctx->head->parent_offset + field->offset; - if (ctx->fmt_offset != offset) { - PyErr_Format(PyExc_ValueError, - "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", - (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); - return -1; - } - ctx->fmt_offset += size; - if (arraysize) - ctx->fmt_offset += (arraysize - 1) * size; - --ctx->enc_count; - while (1) { - if (field == &ctx->root) { - ctx->head = NULL; - if (ctx->enc_count != 0) { - __Pyx_BufFmt_RaiseExpected(ctx); - return -1; - } - break; - } - ctx->head->field = ++field; - if (field->type == NULL) { - --ctx->head; - field = ctx->head->field; - continue; - } else if (field->type->typegroup == 'S') { - size_t parent_offset = ctx->head->parent_offset + field->offset; - if (field->type->fields->type == NULL) continue; - field = field->type->fields; - ++ctx->head; - ctx->head->field = field; - ctx->head->parent_offset = parent_offset; - break; - } else { - break; - } - } - } while (ctx->enc_count); - ctx->enc_type = 0; - ctx->is_complex = 0; - return 0; -} -static PyObject * -__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) -{ - const char *ts = *tsp; - int i = 0, number, ndim; - ++ts; - if (ctx->new_count != 1) { - PyErr_SetString(PyExc_ValueError, - "Cannot handle repeated arrays in format string"); - return NULL; - } - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; - ndim = ctx->head->field->type->ndim; - while (*ts && *ts != ')') { - switch (*ts) { - case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; - default: break; - } - number = __Pyx_BufFmt_ExpectNumber(&ts); - if (number == -1) return NULL; - if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) - return PyErr_Format(PyExc_ValueError, - "Expected a dimension of size %zu, got %d", - ctx->head->field->type->arraysize[i], number); - if (*ts != ',' && *ts != ')') - return PyErr_Format(PyExc_ValueError, - "Expected a comma in format string, got '%c'", *ts); - if (*ts == ',') ts++; - i++; - } - if (i != ndim) - return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", - ctx->head->field->type->ndim, i); - if (!*ts) { - PyErr_SetString(PyExc_ValueError, - "Unexpected end of format string, expected ')'"); - return NULL; - } - ctx->is_valid_array = 1; - ctx->new_count = 1; - *tsp = ++ts; - return Py_None; -} -static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { - int got_Z = 0; - while (1) { - switch(*ts) { - case 0: - if (ctx->enc_type != 0 && ctx->head == NULL) { - __Pyx_BufFmt_RaiseExpected(ctx); - return NULL; - } - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; - if (ctx->head != NULL) { - __Pyx_BufFmt_RaiseExpected(ctx); - return NULL; - } - return ts; - case ' ': - case '\r': - case '\n': - ++ts; - break; - case '<': - if (!__Pyx_Is_Little_Endian()) { - PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); - return NULL; - } - ctx->new_packmode = '='; - ++ts; - break; - case '>': - case '!': - if (__Pyx_Is_Little_Endian()) { - PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); - return NULL; - } - ctx->new_packmode = '='; - ++ts; - break; - case '=': - case '@': - case '^': - ctx->new_packmode = *ts++; - break; - case 'T': - { - const char* ts_after_sub; - size_t i, struct_count = ctx->new_count; - size_t struct_alignment = ctx->struct_alignment; - ctx->new_count = 1; - ++ts; - if (*ts != '{') { - PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); - return NULL; - } - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; - ctx->enc_type = 0; - ctx->enc_count = 0; - ctx->struct_alignment = 0; - ++ts; - ts_after_sub = ts; - for (i = 0; i != struct_count; ++i) { - ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); - if (!ts_after_sub) return NULL; - } - ts = ts_after_sub; - if (struct_alignment) ctx->struct_alignment = struct_alignment; - } - break; - case '}': - { - size_t alignment = ctx->struct_alignment; - ++ts; - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; - ctx->enc_type = 0; - if (alignment && ctx->fmt_offset % alignment) { - ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); - } - } - return ts; - case 'x': - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; - ctx->fmt_offset += ctx->new_count; - ctx->new_count = 1; - ctx->enc_count = 0; - ctx->enc_type = 0; - ctx->enc_packmode = ctx->new_packmode; - ++ts; - break; - case 'Z': - got_Z = 1; - ++ts; - if (*ts != 'f' && *ts != 'd' && *ts != 'g') { - __Pyx_BufFmt_RaiseUnexpectedChar('Z'); - return NULL; - } - CYTHON_FALLTHROUGH; - case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': - case 'l': case 'L': case 'q': case 'Q': - case 'f': case 'd': case 'g': - case 'O': case 'p': - if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) && - (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) { - ctx->enc_count += ctx->new_count; - ctx->new_count = 1; - got_Z = 0; - ++ts; - break; - } - CYTHON_FALLTHROUGH; - case 's': - if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; - ctx->enc_count = ctx->new_count; - ctx->enc_packmode = ctx->new_packmode; - ctx->enc_type = *ts; - ctx->is_complex = got_Z; - ++ts; - ctx->new_count = 1; - got_Z = 0; - break; - case ':': - ++ts; - while(*ts != ':') ++ts; - ++ts; - break; - case '(': - if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; - break; - default: - { - int number = __Pyx_BufFmt_ExpectNumber(&ts); - if (number == -1) return NULL; - ctx->new_count = (size_t)number; - } - } - } -} - -/* TypeInfoCompare */ - static int -__pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b) -{ - int i; - if (!a || !b) - return 0; - if (a == b) - return 1; - if (a->size != b->size || a->typegroup != b->typegroup || - a->is_unsigned != b->is_unsigned || a->ndim != b->ndim) { - if (a->typegroup == 'H' || b->typegroup == 'H') { - return a->size == b->size; + for (i=0; indim) { - for (i = 0; i < a->ndim; i++) - if (a->arraysize[i] != b->arraysize[i]) - return 0; - } - if (a->typegroup == 'S') { - if (a->flags != b->flags) - return 0; - if (a->fields || b->fields) { - if (!(a->fields && b->fields)) - return 0; - for (i = 0; a->fields[i].type && b->fields[i].type; i++) { - __Pyx_StructField *field_a = a->fields + i; - __Pyx_StructField *field_b = b->fields + i; - if (field_a->offset != field_b->offset || - !__pyx_typeinfo_cmp(field_a->type, field_b->type)) - return 0; - } - return !a->fields[i].type && !b->fields[i].type; - } - } - return 1; -} - -/* MemviewSliceValidateAndInit */ - static int -__pyx_check_strides(Py_buffer *buf, int dim, int ndim, int spec) -{ - if (buf->shape[dim] <= 1) - return 1; - if (buf->strides) { - if (spec & __Pyx_MEMVIEW_CONTIG) { - if (spec & (__Pyx_MEMVIEW_PTR|__Pyx_MEMVIEW_FULL)) { - if (unlikely(buf->strides[dim] != sizeof(void *))) { - PyErr_Format(PyExc_ValueError, - "Buffer is not indirectly contiguous " - "in dimension %d.", dim); - goto fail; - } - } else if (unlikely(buf->strides[dim] != buf->itemsize)) { - PyErr_SetString(PyExc_ValueError, - "Buffer and memoryview are not contiguous " - "in the same dimension."); - goto fail; - } - } - if (spec & __Pyx_MEMVIEW_FOLLOW) { - Py_ssize_t stride = buf->strides[dim]; - if (stride < 0) - stride = -stride; - if (unlikely(stride < buf->itemsize)) { - PyErr_SetString(PyExc_ValueError, - "Buffer and memoryview are not contiguous " - "in the same dimension."); - goto fail; - } - } - } else { - if (unlikely(spec & __Pyx_MEMVIEW_CONTIG && dim != ndim - 1)) { - PyErr_Format(PyExc_ValueError, - "C-contiguous buffer is not contiguous in " - "dimension %d", dim); - goto fail; - } else if (unlikely(spec & (__Pyx_MEMVIEW_PTR))) { - PyErr_Format(PyExc_ValueError, - "C-contiguous buffer is not indirect in " - "dimension %d", dim); - goto fail; - } else if (unlikely(buf->suboffsets)) { - PyErr_SetString(PyExc_ValueError, - "Buffer exposes suboffsets but no strides"); - goto fail; - } - } - return 1; -fail: - return 0; -} -static int -__pyx_check_suboffsets(Py_buffer *buf, int dim, CYTHON_UNUSED int ndim, int spec) -{ - if (spec & __Pyx_MEMVIEW_DIRECT) { - if (unlikely(buf->suboffsets && buf->suboffsets[dim] >= 0)) { - PyErr_Format(PyExc_ValueError, - "Buffer not compatible with direct access " - "in dimension %d.", dim); - goto fail; - } - } - if (spec & __Pyx_MEMVIEW_PTR) { - if (unlikely(!buf->suboffsets || (buf->suboffsets[dim] < 0))) { - PyErr_Format(PyExc_ValueError, - "Buffer is not indirectly accessible " - "in dimension %d.", dim); - goto fail; - } - } - return 1; -fail: - return 0; -} -static int -__pyx_verify_contig(Py_buffer *buf, int ndim, int c_or_f_flag) -{ - int i; - if (c_or_f_flag & __Pyx_IS_F_CONTIG) { - Py_ssize_t stride = 1; - for (i = 0; i < ndim; i++) { - if (unlikely(stride * buf->itemsize != buf->strides[i] && buf->shape[i] > 1)) { - PyErr_SetString(PyExc_ValueError, - "Buffer not fortran contiguous."); - goto fail; - } - stride = stride * buf->shape[i]; - } - } else if (c_or_f_flag & __Pyx_IS_C_CONTIG) { - Py_ssize_t stride = 1; - for (i = ndim - 1; i >- 1; i--) { - if (unlikely(stride * buf->itemsize != buf->strides[i] && buf->shape[i] > 1)) { - PyErr_SetString(PyExc_ValueError, - "Buffer not C contiguous."); - goto fail; - } - stride = stride * buf->shape[i]; } } - return 1; -fail: return 0; } -static int __Pyx_ValidateAndInit_memviewslice( - int *axes_specs, - int c_or_f_flag, - int buf_flags, - int ndim, - __Pyx_TypeInfo *dtype, - __Pyx_BufFmt_StackElem stack[], - __Pyx_memviewslice *memviewslice, - PyObject *original_obj) -{ - struct __pyx_memoryview_obj *memview, *new_memview; - __Pyx_RefNannyDeclarations - Py_buffer *buf; - int i, spec = 0, retval = -1; - __Pyx_BufFmt_Context ctx; - int from_memoryview = __pyx_memoryview_check(original_obj); - __Pyx_RefNannySetupContext("ValidateAndInit_memviewslice", 0); - if (from_memoryview && __pyx_typeinfo_cmp(dtype, ((struct __pyx_memoryview_obj *) - original_obj)->typeinfo)) { - memview = (struct __pyx_memoryview_obj *) original_obj; - new_memview = NULL; - } else { - memview = (struct __pyx_memoryview_obj *) __pyx_memoryview_new( - original_obj, buf_flags, 0, dtype); - new_memview = memview; - if (unlikely(!memview)) - goto fail; - } - buf = &memview->view; - if (unlikely(buf->ndim != ndim)) { - PyErr_Format(PyExc_ValueError, - "Buffer has wrong number of dimensions (expected %d, got %d)", - ndim, buf->ndim); - goto fail; - } - if (new_memview) { - __Pyx_BufFmt_Init(&ctx, stack, dtype); - if (unlikely(!__Pyx_BufFmt_CheckString(&ctx, buf->format))) goto fail; - } - if (unlikely((unsigned) buf->itemsize != dtype->size)) { - PyErr_Format(PyExc_ValueError, - "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "u byte%s) " - "does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "u byte%s)", - buf->itemsize, - (buf->itemsize > 1) ? "s" : "", - dtype->name, - dtype->size, - (dtype->size > 1) ? "s" : ""); - goto fail; - } - if (buf->len > 0) { - for (i = 0; i < ndim; i++) { - spec = axes_specs[i]; - if (unlikely(!__pyx_check_strides(buf, i, ndim, spec))) - goto fail; - if (unlikely(!__pyx_check_suboffsets(buf, i, ndim, spec))) - goto fail; +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject* exc_type) { + if (likely(err == exc_type)) return 1; + if (likely(PyExceptionClass_Check(err))) { + if (likely(PyExceptionClass_Check(exc_type))) { + return __Pyx_inner_PyErr_GivenExceptionMatches2(err, NULL, exc_type); + } else if (likely(PyTuple_Check(exc_type))) { + return __Pyx_PyErr_GivenExceptionMatchesTuple(err, exc_type); + } else { } - if (unlikely(buf->strides && !__pyx_verify_contig(buf, ndim, c_or_f_flag))) - goto fail; - } - if (unlikely(__Pyx_init_memviewslice(memview, ndim, memviewslice, - new_memview != NULL) == -1)) { - goto fail; } - retval = 0; - goto no_fail; -fail: - Py_XDECREF(new_memview); - retval = -1; -no_fail: - __Pyx_RefNannyFinishContext(); - return retval; + return PyErr_GivenExceptionMatches(err, exc_type); } - -/* ObjectToMemviewSlice */ - static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_ds_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) }; - int retcode; - if (obj == Py_None) { - result.memview = (struct __pyx_memoryview_obj *) Py_None; - return result; +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *exc_type1, PyObject *exc_type2) { + assert(PyExceptionClass_Check(exc_type1)); + assert(PyExceptionClass_Check(exc_type2)); + if (likely(err == exc_type1 || err == exc_type2)) return 1; + if (likely(PyExceptionClass_Check(err))) { + return __Pyx_inner_PyErr_GivenExceptionMatches2(err, exc_type1, exc_type2); } - retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, 0, - PyBUF_RECORDS_RO | 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; + return (PyErr_GivenExceptionMatches(err, exc_type1) || PyErr_GivenExceptionMatches(err, exc_type2)); } +#endif /* 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()); @@ -21822,7 +8667,7 @@ static int __Pyx_ValidateAndInit_memviewslice( } /* 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) { diff --git a/somsphere/cython/core.html b/somsphere/cython/core.html new file mode 100644 index 0000000..875a53a --- /dev/null +++ b/somsphere/cython/core.html @@ -0,0 +1,2230 @@ + + + + + + Cython: core.pyx + + + +

Generated by Cython 0.29.21

+

+ Yellow lines hint at Python interaction.
+ Click on a line that starts with a "+" to see the C code that Cython generated for it. +

+

Raw output: core.c

+
+01: #cython: language_level=3
+
  __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+02: import random
+
  __pyx_t_1 = __Pyx_Import(__pyx_n_s_random, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_random, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
 03:
+
+04: import numpy as np
+
  __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
 05: cimport numpy as cnp
+
 06:
+
+07: from somsphere.utils import timeit
+
  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(__pyx_n_s_timeit);
+  __Pyx_GIVEREF(__pyx_n_s_timeit);
+  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_timeit);
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_somsphere_utils, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_timeit); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_timeit, __pyx_t_1) < 0) __PYX_ERR(0, 7, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
 08:
+
+09: DTYPE = np.float
+
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_float); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_DTYPE, __pyx_t_1) < 0) __PYX_ERR(0, 9, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
 10: ctypedef cnp.float_t DTYPE_t
+
 11: # def create_map_batch(np.ndarray X, int n_iter, int n_row, int n_col, int n_pix, np.ndarray importance,
+
 12: #                      np.ndarray dist_lib, np.ndarray weights):
+
 13: #     cdef int t = 0
+
 14: #     cdef int total_t = n_iter * n_row
+
 15: #     cdef float sigma_0 = dist_lib.max()
+
 16: #     cdef float sigma_f = np.min(dist_lib[np.where(dist_lib > 0.)])
+
 17: #
+
 18: #     cdef int i
+
 19: #     cdef float sigma, activation
+
 20: #     cdef np.ndarray accum_w, accum_n, best, inputs
+
 21: #
+
 22: #     for i in range(n_iter):
+
 23: #         sigma = get_sigma(sigma_f, sigma_0, t, total_t)
+
 24: #         accum_w = np.zeros((n_col, n_pix))
+
 25: #         accum_n = np.zeros(n_pix)
+
 26: #         for j in range(n_row):
+
 27: #             inputs = X[j]
+
 28: #             best, activation = get_best_cell(inputs=inputs, importance=importance,
+
 29: #                                              weights=weights, n_pix=n_pix)
+
 30: #             for k in range(n_col):
+
 31: #                 accum_w[k, :] += count_modified_cells(best, dist_lib, sigma) * inputs[k]
+
 32: #             accum_n += count_modified_cells(best, dist_lib, sigma)
+
 33: #
+
 34: #         for l in range(n_col):
+
 35: #             weights[l] = accum_w[l] / accum_n
+
 36: #
+
 37: #         t += n_row
+
+38: def get_alpha(float alpha_end, float alpha_start, int curr_t, int total_t):
+
/* Python wrapper */
+static PyObject *__pyx_pw_4core_1get_alpha(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_4core_get_alpha[] = "\n    Get value of alpha at a given time\n    ";
+static PyMethodDef __pyx_mdef_4core_1get_alpha = {"get_alpha", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_1get_alpha, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4core_get_alpha};
+static PyObject *__pyx_pw_4core_1get_alpha(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  float __pyx_v_alpha_end;
+  float __pyx_v_alpha_start;
+  int __pyx_v_curr_t;
+  int __pyx_v_total_t;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_alpha (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_alpha_end,&__pyx_n_s_alpha_start,&__pyx_n_s_curr_t,&__pyx_n_s_total_t,0};
+    PyObject* values[4] = {0,0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        CYTHON_FALLTHROUGH;
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        CYTHON_FALLTHROUGH;
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha_end)) != 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_alpha_start)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("get_alpha", 1, 4, 4, 1); __PYX_ERR(0, 38, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_curr_t)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("get_alpha", 1, 4, 4, 2); __PYX_ERR(0, 38, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  3:
+        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_total_t)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("get_alpha", 1, 4, 4, 3); __PYX_ERR(0, 38, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_alpha") < 0)) __PYX_ERR(0, 38, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    }
+    __pyx_v_alpha_end = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_alpha_end == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L3_error)
+    __pyx_v_alpha_start = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_alpha_start == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L3_error)
+    __pyx_v_curr_t = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_curr_t == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L3_error)
+    __pyx_v_total_t = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_total_t == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("get_alpha", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 38, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("core.get_alpha", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4core_get_alpha(__pyx_self, __pyx_v_alpha_end, __pyx_v_alpha_start, __pyx_v_curr_t, __pyx_v_total_t);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_4core_get_alpha(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_alpha_end, float __pyx_v_alpha_start, int __pyx_v_curr_t, int __pyx_v_total_t) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_alpha", 0);
+/* … */
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("core.get_alpha", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__6 = PyTuple_Pack(4, __pyx_n_s_alpha_end, __pyx_n_s_alpha_start, __pyx_n_s_curr_t, __pyx_n_s_total_t); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 38, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__6);
+  __Pyx_GIVEREF(__pyx_tuple__6);
+/* … */
+  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_4core_1get_alpha, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 38, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_alpha, __pyx_t_1) < 0) __PYX_ERR(0, 38, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(4, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_somsphere_cython_core_pyx, __pyx_n_s_get_alpha, 38, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 38, __pyx_L1_error)
+
 39:     """
+
 40:     Get value of alpha at a given time
+
 41:     """
+
+42:     return alpha_start * np.power(alpha_end / alpha_start, float(curr_t) / float(total_t))
+
  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_alpha_start); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_power); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(__pyx_v_alpha_start == 0)) {
+    PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+    __PYX_ERR(0, 42, __pyx_L1_error)
+  }
+  __pyx_t_3 = PyFloat_FromDouble((__pyx_v_alpha_end / __pyx_v_alpha_start)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (unlikely(((double)__pyx_v_total_t) == 0)) {
+    PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+    __PYX_ERR(0, 42, __pyx_L1_error)
+  }
+  __pyx_t_5 = PyFloat_FromDouble((((double)__pyx_v_curr_t) / ((double)__pyx_v_total_t))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = NULL;
+  __pyx_t_7 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_6)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_6);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+      __pyx_t_7 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_4)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_t_5};
+    __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_t_5};
+    __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 42, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    if (__pyx_t_6) {
+      __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_5);
+    __pyx_t_3 = 0;
+    __pyx_t_5 = 0;
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
+  goto __pyx_L0;
+
 43:
+
+44: def get_sigma(float sigma_f, float sigma_0, int curr_t, int total_t):
+
/* Python wrapper */
+static PyObject *__pyx_pw_4core_3get_sigma(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_4core_2get_sigma[] = "\n    Get value of sigma at a given time\n    ";
+static PyMethodDef __pyx_mdef_4core_3get_sigma = {"get_sigma", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_3get_sigma, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4core_2get_sigma};
+static PyObject *__pyx_pw_4core_3get_sigma(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  float __pyx_v_sigma_f;
+  float __pyx_v_sigma_0;
+  int __pyx_v_curr_t;
+  int __pyx_v_total_t;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_sigma (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sigma_f,&__pyx_n_s_sigma_0,&__pyx_n_s_curr_t,&__pyx_n_s_total_t,0};
+    PyObject* values[4] = {0,0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        CYTHON_FALLTHROUGH;
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        CYTHON_FALLTHROUGH;
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sigma_f)) != 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_sigma_0)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("get_sigma", 1, 4, 4, 1); __PYX_ERR(0, 44, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_curr_t)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("get_sigma", 1, 4, 4, 2); __PYX_ERR(0, 44, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  3:
+        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_total_t)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("get_sigma", 1, 4, 4, 3); __PYX_ERR(0, 44, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_sigma") < 0)) __PYX_ERR(0, 44, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    }
+    __pyx_v_sigma_f = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_sigma_f == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 44, __pyx_L3_error)
+    __pyx_v_sigma_0 = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_sigma_0 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 44, __pyx_L3_error)
+    __pyx_v_curr_t = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_curr_t == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 44, __pyx_L3_error)
+    __pyx_v_total_t = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_total_t == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 44, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("get_sigma", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 44, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("core.get_sigma", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_4core_2get_sigma(__pyx_self, __pyx_v_sigma_f, __pyx_v_sigma_0, __pyx_v_curr_t, __pyx_v_total_t);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_4core_2get_sigma(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_sigma_f, float __pyx_v_sigma_0, int __pyx_v_curr_t, int __pyx_v_total_t) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_sigma", 0);
+/* … */
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("core.get_sigma", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__8 = PyTuple_Pack(4, __pyx_n_s_sigma_f, __pyx_n_s_sigma_0, __pyx_n_s_curr_t, __pyx_n_s_total_t); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 44, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__8);
+  __Pyx_GIVEREF(__pyx_tuple__8);
+/* … */
+  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_4core_3get_sigma, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 44, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_sigma, __pyx_t_1) < 0) __PYX_ERR(0, 44, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(4, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_somsphere_cython_core_pyx, __pyx_n_s_get_sigma, 44, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 44, __pyx_L1_error)
+
 45:     """
+
 46:     Get value of sigma at a given time
+
 47:     """
+
+48:     return sigma_0 * np.power(sigma_f / sigma_0, float(curr_t) / float(total_t))
+
  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_sigma_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 48, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 48, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_power); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 48, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(__pyx_v_sigma_0 == 0)) {
+    PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+    __PYX_ERR(0, 48, __pyx_L1_error)
+  }
+  __pyx_t_3 = PyFloat_FromDouble((__pyx_v_sigma_f / __pyx_v_sigma_0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 48, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (unlikely(((double)__pyx_v_total_t) == 0)) {
+    PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+    __PYX_ERR(0, 48, __pyx_L1_error)
+  }
+  __pyx_t_5 = PyFloat_FromDouble((((double)__pyx_v_curr_t) / ((double)__pyx_v_total_t))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 48, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = NULL;
+  __pyx_t_7 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_6)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_6);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+      __pyx_t_7 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_4)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_t_5};
+    __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 48, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_t_5};
+    __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 48, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 48, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_8);
+    if (__pyx_t_6) {
+      __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_5);
+    __pyx_t_3 = 0;
+    __pyx_t_5 = 0;
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 48, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 48, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
+  goto __pyx_L0;
+
 49:
+
+50: @timeit
+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_timeit); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 50, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+/* … */
+  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 50, __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;
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_best_cell, __pyx_t_3) < 0) __PYX_ERR(0, 51, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+51: def get_best_cell(cnp.ndarray inputs, cnp.ndarray importance, int n_pix, cnp.ndarray weights, int return_vals):
+
/* Python wrapper */
+static PyObject *__pyx_pw_4core_5get_best_cell(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_4core_4get_best_cell[] = "\n    Return the closest cell to the input object\n    It can return more than one value if needed\n    ";
+static PyMethodDef __pyx_mdef_4core_5get_best_cell = {"get_best_cell", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_5get_best_cell, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4core_4get_best_cell};
+static PyObject *__pyx_pw_4core_5get_best_cell(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyArrayObject *__pyx_v_inputs = 0;
+  PyArrayObject *__pyx_v_importance = 0;
+  int __pyx_v_n_pix;
+  PyArrayObject *__pyx_v_weights = 0;
+  int __pyx_v_return_vals;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_best_cell (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_inputs,&__pyx_n_s_importance,&__pyx_n_s_n_pix,&__pyx_n_s_weights,&__pyx_n_s_return_vals,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);
+        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_inputs)) != 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_importance)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("get_best_cell", 1, 5, 5, 1); __PYX_ERR(0, 51, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_pix)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("get_best_cell", 1, 5, 5, 2); __PYX_ERR(0, 51, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  3:
+        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_weights)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("get_best_cell", 1, 5, 5, 3); __PYX_ERR(0, 51, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  4:
+        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_return_vals)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("get_best_cell", 1, 5, 5, 4); __PYX_ERR(0, 51, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_best_cell") < 0)) __PYX_ERR(0, 51, __pyx_L3_error)
+      }
+    } 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_inputs = ((PyArrayObject *)values[0]);
+    __pyx_v_importance = ((PyArrayObject *)values[1]);
+    __pyx_v_n_pix = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_n_pix == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 51, __pyx_L3_error)
+    __pyx_v_weights = ((PyArrayObject *)values[3]);
+    __pyx_v_return_vals = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_return_vals == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 51, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("get_best_cell", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 51, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("core.get_best_cell", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_inputs), __pyx_ptype_5numpy_ndarray, 1, "inputs", 0))) __PYX_ERR(0, 51, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_importance), __pyx_ptype_5numpy_ndarray, 1, "importance", 0))) __PYX_ERR(0, 51, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_weights), __pyx_ptype_5numpy_ndarray, 1, "weights", 0))) __PYX_ERR(0, 51, __pyx_L1_error)
+  __pyx_r = __pyx_pf_4core_4get_best_cell(__pyx_self, __pyx_v_inputs, __pyx_v_importance, __pyx_v_n_pix, __pyx_v_weights, __pyx_v_return_vals);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_4core_4get_best_cell(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_inputs, PyArrayObject *__pyx_v_importance, int __pyx_v_n_pix, PyArrayObject *__pyx_v_weights, int __pyx_v_return_vals) {
+  CYTHON_UNUSED PyArrayObject *__pyx_v_activation = 0;
+  PyObject *__pyx_v_activations = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_best_cell", 0);
+/* … */
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("core.get_best_cell", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_activation);
+  __Pyx_XDECREF(__pyx_v_activations);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__10 = PyTuple_Pack(7, __pyx_n_s_inputs, __pyx_n_s_importance, __pyx_n_s_n_pix, __pyx_n_s_weights, __pyx_n_s_return_vals, __pyx_n_s_activation, __pyx_n_s_activations); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__10);
+  __Pyx_GIVEREF(__pyx_tuple__10);
+/* … */
+  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_4core_5get_best_cell, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(5, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_somsphere_cython_core_pyx, __pyx_n_s_get_best_cell, 51, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(0, 51, __pyx_L1_error)
+
 52:     """
+
 53:     Return the closest cell to the input object
+
 54:     It can return more than one value if needed
+
 55:     """
+
+56:     cdef cnp.ndarray activation = np.zeros([n_pix, 1], dtype=DTYPE)
+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_pix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = PyList_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyList_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __Pyx_INCREF(__pyx_int_1);
+  __Pyx_GIVEREF(__pyx_int_1);
+  PyList_SET_ITEM(__pyx_t_3, 1, __pyx_int_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_DTYPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(0, 56, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 56, __pyx_L1_error)
+  __pyx_v_activation = ((PyArrayObject *)__pyx_t_4);
+  __pyx_t_4 = 0;
+
 57:
+
+58:     activations = np.sum(np.transpose([importance]) * (np.transpose(np.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0)
+
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_sum); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_transpose); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_v_importance));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_importance));
+  PyList_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_importance));
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_transpose); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_tile); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_n_pix); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6);
+  __Pyx_INCREF(__pyx_int_1);
+  __Pyx_GIVEREF(__pyx_int_1);
+  PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_int_1);
+  __pyx_t_6 = 0;
+  __pyx_t_6 = NULL;
+  __pyx_t_9 = 0;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
+    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7);
+    if (likely(__pyx_t_6)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+      __Pyx_INCREF(__pyx_t_6);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_7, function);
+      __pyx_t_9 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_7)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_6, ((PyObject *)__pyx_v_inputs), __pyx_t_8};
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_6, ((PyObject *)__pyx_v_inputs), __pyx_t_8};
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 58, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_10);
+    if (__pyx_t_6) {
+      __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_6); __pyx_t_6 = NULL;
+    }
+    __Pyx_INCREF(((PyObject *)__pyx_v_inputs));
+    __Pyx_GIVEREF(((PyObject *)__pyx_v_inputs));
+    PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, ((PyObject *)__pyx_v_inputs));
+    __Pyx_GIVEREF(__pyx_t_8);
+    PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_8);
+    __pyx_t_8 = 0;
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_t_7 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
+    if (likely(__pyx_t_7)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_7);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_5, function);
+    }
+  }
+  __pyx_t_2 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = PyNumber_Subtract(__pyx_t_2, ((PyObject *)__pyx_v_weights)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyNumber_Power(__pyx_t_5, __pyx_int_2, Py_None); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = PyNumber_Multiply(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
+  __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_axis, __pyx_int_0) < 0) __PYX_ERR(0, 58, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_v_activations = __pyx_t_4;
+  __pyx_t_4 = 0;
+
 59:
+
+60:     return np.argmin(activations) if return_vals == 1 else np.argsort(activations)[0:return_vals], activations
+
  __Pyx_XDECREF(__pyx_r);
+  if (((__pyx_v_return_vals == 1) != 0)) {
+    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_argmin); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 60, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+      if (likely(__pyx_t_2)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+        __Pyx_INCREF(__pyx_t_2);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_3, function);
+      }
+    }
+    __pyx_t_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_v_activations) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_activations);
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 60, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_4 = __pyx_t_5;
+    __pyx_t_5 = 0;
+  } else {
+    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 60, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_argsort); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = NULL;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+      if (likely(__pyx_t_3)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+        __Pyx_INCREF(__pyx_t_3);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_2, function);
+      }
+    }
+    __pyx_t_5 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_activations) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_activations);
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 60, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = __Pyx_PyObject_GetSlice(__pyx_t_5, 0, __pyx_v_return_vals, NULL, NULL, NULL, 1, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_4 = __pyx_t_2;
+    __pyx_t_2 = 0;
+  }
+  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4);
+  __Pyx_INCREF(__pyx_v_activations);
+  __Pyx_GIVEREF(__pyx_v_activations);
+  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_activations);
+  __pyx_t_4 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
 61:
+
+62: def count_modified_cells(int bmu, cnp.ndarray map_d, float sigma):
+
/* Python wrapper */
+static PyObject *__pyx_pw_4core_7count_modified_cells(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_4core_6count_modified_cells[] = "\n    Neighborhood function which quantifies how much cells around the best matching one are modified\n\n    :param int bmu: best matching unit\n    :param nparray map_d: array of distances computed with :func:`geometry`\n    ";
+static PyMethodDef __pyx_mdef_4core_7count_modified_cells = {"count_modified_cells", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_7count_modified_cells, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4core_6count_modified_cells};
+static PyObject *__pyx_pw_4core_7count_modified_cells(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_v_bmu;
+  PyArrayObject *__pyx_v_map_d = 0;
+  float __pyx_v_sigma;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("count_modified_cells (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_bmu,&__pyx_n_s_map_d,&__pyx_n_s_sigma,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        CYTHON_FALLTHROUGH;
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        CYTHON_FALLTHROUGH;
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        CYTHON_FALLTHROUGH;
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bmu)) != 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_map_d)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("count_modified_cells", 1, 3, 3, 1); __PYX_ERR(0, 62, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sigma)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("count_modified_cells", 1, 3, 3, 2); __PYX_ERR(0, 62, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "count_modified_cells") < 0)) __PYX_ERR(0, 62, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    }
+    __pyx_v_bmu = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_bmu == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 62, __pyx_L3_error)
+    __pyx_v_map_d = ((PyArrayObject *)values[1]);
+    __pyx_v_sigma = __pyx_PyFloat_AsFloat(values[2]); if (unlikely((__pyx_v_sigma == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 62, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("count_modified_cells", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 62, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("core.count_modified_cells", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_map_d), __pyx_ptype_5numpy_ndarray, 1, "map_d", 0))) __PYX_ERR(0, 62, __pyx_L1_error)
+  __pyx_r = __pyx_pf_4core_6count_modified_cells(__pyx_self, __pyx_v_bmu, __pyx_v_map_d, __pyx_v_sigma);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_4core_6count_modified_cells(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_bmu, PyArrayObject *__pyx_v_map_d, float __pyx_v_sigma) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("count_modified_cells", 0);
+/* … */
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("core.count_modified_cells", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__12 = PyTuple_Pack(3, __pyx_n_s_bmu, __pyx_n_s_map_d, __pyx_n_s_sigma); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 62, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__12);
+  __Pyx_GIVEREF(__pyx_tuple__12);
+/* … */
+  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_4core_7count_modified_cells, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 62, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_count_modified_cells, __pyx_t_3) < 0) __PYX_ERR(0, 62, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_codeobj__13 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_somsphere_cython_core_pyx, __pyx_n_s_count_modified_cells, 62, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__13)) __PYX_ERR(0, 62, __pyx_L1_error)
+
 63:     """
+
 64:     Neighborhood function which quantifies how much cells around the best matching one are modified
+
 65:
+
 66:     :param int bmu: best matching unit
+
 67:     :param nparray map_d: array of distances computed with :func:`geometry`
+
 68:     """
+
+69:     return np.exp(-(map_d[bmu] ** 2) / sigma ** 2)
+
  __Pyx_XDECREF(__pyx_r);
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_exp); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_map_d), __pyx_v_bmu, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = PyNumber_Power(__pyx_t_2, __pyx_int_2, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyNumber_Negative(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = PyFloat_FromDouble(powf(__pyx_v_sigma, 2.0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
 70:
+
+71: def create_map_online(cnp.ndarray X, int n_iter, int n_row, int n_col, int n_pix, float alpha_start, float alpha_end,
+
/* Python wrapper */
+static PyObject *__pyx_pw_4core_9create_map_online(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_4core_9create_map_online = {"create_map_online", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_9create_map_online, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_4core_9create_map_online(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyArrayObject *__pyx_v_X = 0;
+  int __pyx_v_n_iter;
+  int __pyx_v_n_row;
+  int __pyx_v_n_col;
+  int __pyx_v_n_pix;
+  float __pyx_v_alpha_start;
+  float __pyx_v_alpha_end;
+  PyArrayObject *__pyx_v_importance = 0;
+  PyArrayObject *__pyx_v_dist_lib = 0;
+  PyArrayObject *__pyx_v_weights = 0;
+  int __pyx_v_random_order;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("create_map_online (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_X,&__pyx_n_s_n_iter,&__pyx_n_s_n_row,&__pyx_n_s_n_col,&__pyx_n_s_n_pix,&__pyx_n_s_alpha_start,&__pyx_n_s_alpha_end,&__pyx_n_s_importance,&__pyx_n_s_dist_lib,&__pyx_n_s_weights,&__pyx_n_s_random_order,0};
+    PyObject* values[11] = {0,0,0,0,0,0,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 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10);
+        CYTHON_FALLTHROUGH;
+        case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9);
+        CYTHON_FALLTHROUGH;
+        case  9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
+        CYTHON_FALLTHROUGH;
+        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
+        CYTHON_FALLTHROUGH;
+        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+        CYTHON_FALLTHROUGH;
+        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+        CYTHON_FALLTHROUGH;
+        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_X)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        CYTHON_FALLTHROUGH;
+        case  1:
+        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_iter)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 1); __PYX_ERR(0, 71, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  2:
+        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_row)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 2); __PYX_ERR(0, 71, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  3:
+        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_col)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 3); __PYX_ERR(0, 71, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  4:
+        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_pix)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 4); __PYX_ERR(0, 71, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  5:
+        if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha_start)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 5); __PYX_ERR(0, 71, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  6:
+        if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha_end)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 6); __PYX_ERR(0, 71, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  7:
+        if (likely((values[7] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_importance)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 7); __PYX_ERR(0, 71, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  8:
+        if (likely((values[8] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dist_lib)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 8); __PYX_ERR(0, 71, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case  9:
+        if (likely((values[9] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_weights)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 9); __PYX_ERR(0, 71, __pyx_L3_error)
+        }
+        CYTHON_FALLTHROUGH;
+        case 10:
+        if (likely((values[10] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_random_order)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 10); __PYX_ERR(0, 71, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create_map_online") < 0)) __PYX_ERR(0, 71, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 11) {
+      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);
+      values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+      values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+      values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
+      values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
+      values[9] = PyTuple_GET_ITEM(__pyx_args, 9);
+      values[10] = PyTuple_GET_ITEM(__pyx_args, 10);
+    }
+    __pyx_v_X = ((PyArrayObject *)values[0]);
+    __pyx_v_n_iter = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_n_iter == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error)
+    __pyx_v_n_row = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_n_row == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error)
+    __pyx_v_n_col = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_n_col == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error)
+    __pyx_v_n_pix = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_n_pix == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error)
+    __pyx_v_alpha_start = __pyx_PyFloat_AsFloat(values[5]); if (unlikely((__pyx_v_alpha_start == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error)
+    __pyx_v_alpha_end = __pyx_PyFloat_AsFloat(values[6]); if (unlikely((__pyx_v_alpha_end == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error)
+    __pyx_v_importance = ((PyArrayObject *)values[7]);
+    __pyx_v_dist_lib = ((PyArrayObject *)values[8]);
+    __pyx_v_weights = ((PyArrayObject *)values[9]);
+    __pyx_v_random_order = __Pyx_PyObject_IsTrue(values[10]); if (unlikely((__pyx_v_random_order == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 72, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 71, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("core.create_map_online", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_X), __pyx_ptype_5numpy_ndarray, 1, "X", 0))) __PYX_ERR(0, 71, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_importance), __pyx_ptype_5numpy_ndarray, 1, "importance", 0))) __PYX_ERR(0, 72, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dist_lib), __pyx_ptype_5numpy_ndarray, 1, "dist_lib", 0))) __PYX_ERR(0, 72, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_weights), __pyx_ptype_5numpy_ndarray, 1, "weights", 0))) __PYX_ERR(0, 72, __pyx_L1_error)
+  __pyx_r = __pyx_pf_4core_8create_map_online(__pyx_self, __pyx_v_X, __pyx_v_n_iter, __pyx_v_n_row, __pyx_v_n_col, __pyx_v_n_pix, __pyx_v_alpha_start, __pyx_v_alpha_end, __pyx_v_importance, __pyx_v_dist_lib, __pyx_v_weights, __pyx_v_random_order);
+  int __pyx_lineno = 0;
+  const char *__pyx_filename = NULL;
+  int __pyx_clineno = 0;
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_4core_8create_map_online(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_X, int __pyx_v_n_iter, int __pyx_v_n_row, int __pyx_v_n_col, int __pyx_v_n_pix, float __pyx_v_alpha_start, float __pyx_v_alpha_end, PyArrayObject *__pyx_v_importance, PyArrayObject *__pyx_v_dist_lib, PyArrayObject *__pyx_v_weights, int __pyx_v_random_order) {
+  int __pyx_v_t;
+  int __pyx_v_total_t;
+  float __pyx_v_sigma_0;
+  float __pyx_v_sigma_f;
+  int __pyx_v_i;
+  int __pyx_v_best;
+  float __pyx_v_alpha;
+  float __pyx_v_sigma;
+  PyObject *__pyx_v_random_indices = 0;
+  PyArrayObject *__pyx_v_inputs = 0;
+  CYTHON_UNUSED PyArrayObject *__pyx_v_activation = 0;
+  CYTHON_UNUSED int __pyx_v_it;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("create_map_online", 0);
+  __Pyx_INCREF((PyObject *)__pyx_v_weights);
+/* … */
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_13);
+  __Pyx_AddTraceback("core.create_map_online", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_random_indices);
+  __Pyx_XDECREF((PyObject *)__pyx_v_inputs);
+  __Pyx_XDECREF((PyObject *)__pyx_v_activation);
+  __Pyx_XDECREF((PyObject *)__pyx_v_weights);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+/* … */
+  __pyx_tuple__14 = PyTuple_Pack(23, __pyx_n_s_X, __pyx_n_s_n_iter, __pyx_n_s_n_row, __pyx_n_s_n_col, __pyx_n_s_n_pix, __pyx_n_s_alpha_start, __pyx_n_s_alpha_end, __pyx_n_s_importance, __pyx_n_s_dist_lib, __pyx_n_s_weights, __pyx_n_s_random_order, __pyx_n_s_t, __pyx_n_s_total_t, __pyx_n_s_sigma_0, __pyx_n_s_sigma_f, __pyx_n_s_i, __pyx_n_s_best, __pyx_n_s_alpha, __pyx_n_s_sigma, __pyx_n_s_random_indices, __pyx_n_s_inputs, __pyx_n_s_activation, __pyx_n_s_it); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 71, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__14);
+  __Pyx_GIVEREF(__pyx_tuple__14);
+/* … */
+  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_4core_9create_map_online, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 71, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_create_map_online, __pyx_t_3) < 0) __PYX_ERR(0, 71, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
 72:                       cnp.ndarray importance, cnp.ndarray dist_lib, cnp.ndarray weights, bint random_order):
+
+73:     cdef int t = 0
+
  __pyx_v_t = 0;
+
+74:     cdef int total_t = n_iter * n_row
+
  __pyx_v_total_t = (__pyx_v_n_iter * __pyx_v_n_row);
+
+75:     cdef float sigma_0 = dist_lib.max()
+
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_dist_lib), __pyx_n_s_max); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 75, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 75, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_4 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 75, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_sigma_0 = __pyx_t_4;
+
+76:     cdef float sigma_f = np.min(dist_lib[np.where(dist_lib > 0.)])
+
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_where); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = PyObject_RichCompare(((PyObject *)__pyx_v_dist_lib), __pyx_float_0_, Py_GT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 76, __pyx_L1_error)
+  __pyx_t_7 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
+    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+    if (likely(__pyx_t_7)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_7);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_6, function);
+    }
+  }
+  __pyx_t_2 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_dist_lib), __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_4 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 76, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_sigma_f = __pyx_t_4;
+
 77:
+
 78:     cdef int i, best
+
 79:     cdef float alpha, sigma
+
 80:     cdef list random_indices
+
+81:     cdef cnp.ndarray inputs = np.zeros([n_col, 1], dtype=DTYPE)
+
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 81, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 81, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_col); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 81, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_6 = PyList_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 81, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyList_SET_ITEM(__pyx_t_6, 0, __pyx_t_1);
+  __Pyx_INCREF(__pyx_int_1);
+  __Pyx_GIVEREF(__pyx_int_1);
+  PyList_SET_ITEM(__pyx_t_6, 1, __pyx_int_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 81, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_6);
+  __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 81, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_DTYPE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_2) < 0) __PYX_ERR(0, 81, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 81, __pyx_L1_error)
+  __pyx_v_inputs = ((PyArrayObject *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+82:     cdef cnp.ndarray activation = np.zeros([n_pix, 1], dtype=DTYPE)
+
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_n_pix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
+  __Pyx_INCREF(__pyx_int_1);
+  __Pyx_GIVEREF(__pyx_int_1);
+  PyList_SET_ITEM(__pyx_t_1, 1, __pyx_int_1);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __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_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_3) < 0) __PYX_ERR(0, 82, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 82, __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_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 82, __pyx_L1_error)
+  __pyx_v_activation = ((PyArrayObject *)__pyx_t_3);
+  __pyx_t_3 = 0;
+
 83:
+
+84:     for it in range(n_iter):
+
  __pyx_t_8 = __pyx_v_n_iter;
+  __pyx_t_9 = __pyx_t_8;
+  for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) {
+    __pyx_v_it = __pyx_t_10;
+
+85:         alpha = get_alpha(alpha_end, alpha_start, t, total_t)
+
    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_get_alpha); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 85, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_2 = PyFloat_FromDouble(__pyx_v_alpha_end); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_6 = PyFloat_FromDouble(__pyx_v_alpha_start); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 85, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 85, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_total_t); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 85, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_11 = NULL;
+    __pyx_t_12 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+      __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_1);
+      if (likely(__pyx_t_11)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+        __Pyx_INCREF(__pyx_t_11);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_1, function);
+        __pyx_t_12 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_1)) {
+      PyObject *__pyx_temp[5] = {__pyx_t_11, __pyx_t_2, __pyx_t_6, __pyx_t_5, __pyx_t_7};
+      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_12, 4+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
+      PyObject *__pyx_temp[5] = {__pyx_t_11, __pyx_t_2, __pyx_t_6, __pyx_t_5, __pyx_t_7};
+      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_12, 4+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_13 = PyTuple_New(4+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 85, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_13);
+      if (__pyx_t_11) {
+        __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_11); __pyx_t_11 = NULL;
+      }
+      __Pyx_GIVEREF(__pyx_t_2);
+      PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_12, __pyx_t_2);
+      __Pyx_GIVEREF(__pyx_t_6);
+      PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_12, __pyx_t_6);
+      __Pyx_GIVEREF(__pyx_t_5);
+      PyTuple_SET_ITEM(__pyx_t_13, 2+__pyx_t_12, __pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_7);
+      PyTuple_SET_ITEM(__pyx_t_13, 3+__pyx_t_12, __pyx_t_7);
+      __pyx_t_2 = 0;
+      __pyx_t_6 = 0;
+      __pyx_t_5 = 0;
+      __pyx_t_7 = 0;
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_13, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_t_3); if (unlikely((__pyx_t_4 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 85, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_v_alpha = __pyx_t_4;
+
+86:         sigma = get_sigma(sigma_f, sigma_0, t, total_t)
+
    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_get_sigma); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 86, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_13 = PyFloat_FromDouble(__pyx_v_sigma_f); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 86, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_13);
+    __pyx_t_7 = PyFloat_FromDouble(__pyx_v_sigma_0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 86, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 86, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_total_t); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 86, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_2 = NULL;
+    __pyx_t_12 = 0;
+    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
+      if (likely(__pyx_t_2)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+        __Pyx_INCREF(__pyx_t_2);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_1, function);
+        __pyx_t_12 = 1;
+      }
+    }
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_1)) {
+      PyObject *__pyx_temp[5] = {__pyx_t_2, __pyx_t_13, __pyx_t_7, __pyx_t_5, __pyx_t_6};
+      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_12, 4+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
+      PyObject *__pyx_temp[5] = {__pyx_t_2, __pyx_t_13, __pyx_t_7, __pyx_t_5, __pyx_t_6};
+      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_12, 4+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_11 = PyTuple_New(4+__pyx_t_12); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 86, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      if (__pyx_t_2) {
+        __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_2); __pyx_t_2 = NULL;
+      }
+      __Pyx_GIVEREF(__pyx_t_13);
+      PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_12, __pyx_t_13);
+      __Pyx_GIVEREF(__pyx_t_7);
+      PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_12, __pyx_t_7);
+      __Pyx_GIVEREF(__pyx_t_5);
+      PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_12, __pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_6);
+      PyTuple_SET_ITEM(__pyx_t_11, 3+__pyx_t_12, __pyx_t_6);
+      __pyx_t_13 = 0;
+      __pyx_t_7 = 0;
+      __pyx_t_5 = 0;
+      __pyx_t_6 = 0;
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_t_3); if (unlikely((__pyx_t_4 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 86, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_v_sigma = __pyx_t_4;
+
+87:         random_indices = random.sample(range(n_row), n_row) if random_order else np.arange(
+
    if ((__pyx_v_random_order != 0)) {
+      __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_random); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 87, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_sample); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 87, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __pyx_t_11 = __Pyx_PyInt_From_int(__pyx_v_n_row); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 87, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_t_11); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 87, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __pyx_t_11 = __Pyx_PyInt_From_int(__pyx_v_n_row); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 87, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      __pyx_t_7 = NULL;
+      __pyx_t_12 = 0;
+      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
+        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+        if (likely(__pyx_t_7)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+          __Pyx_INCREF(__pyx_t_7);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_6, function);
+          __pyx_t_12 = 1;
+        }
+      }
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_5, __pyx_t_11};
+        __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_5, __pyx_t_11};
+        __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      } else
+      #endif
+      {
+        __pyx_t_13 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 87, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_13);
+        if (__pyx_t_7) {
+          __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_7); __pyx_t_7 = NULL;
+        }
+        __Pyx_GIVEREF(__pyx_t_5);
+        PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_12, __pyx_t_5);
+        __Pyx_GIVEREF(__pyx_t_11);
+        PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_12, __pyx_t_11);
+        __pyx_t_5 = 0;
+        __pyx_t_11 = 0;
+        __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_13, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+      }
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(0, 87, __pyx_L1_error)
+      __pyx_t_3 = __pyx_t_1;
+      __pyx_t_1 = 0;
+    } else {
+      __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 87, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_arange); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 87, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_13);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+/* … */
+      if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(0, 87, __pyx_L1_error)
+      __pyx_t_3 = __pyx_t_1;
+      __pyx_t_1 = 0;
+    }
+    __Pyx_XDECREF_SET(__pyx_v_random_indices, ((PyObject*)__pyx_t_3));
+    __pyx_t_3 = 0;
+
+88:             n_row)
+
      __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_n_row); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 88, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_t_11 = NULL;
+      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) {
+        __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_13);
+        if (likely(__pyx_t_11)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13);
+          __Pyx_INCREF(__pyx_t_11);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_13, function);
+        }
+      }
+      __pyx_t_1 = (__pyx_t_11) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_11, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_6);
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+
 89:
+
+90:         for i in range(n_row):
+
    __pyx_t_12 = __pyx_v_n_row;
+    __pyx_t_14 = __pyx_t_12;
+    for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) {
+      __pyx_v_i = __pyx_t_15;
+
+91:             inputs = X[random_indices[i]]
+
      if (unlikely(__pyx_v_random_indices == Py_None)) {
+        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+        __PYX_ERR(0, 91, __pyx_L1_error)
+      }
+      __pyx_t_3 = __Pyx_GetItemInt_List(__pyx_v_random_indices, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 91, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_X), __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 91, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 91, __pyx_L1_error)
+      __Pyx_DECREF_SET(__pyx_v_inputs, ((PyArrayObject *)__pyx_t_1));
+      __pyx_t_1 = 0;
+
+92:             best, activation = get_best_cell(inputs=inputs, importance=importance,
+
      __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_get_best_cell); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 92, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_3 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 92, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_inputs, ((PyObject *)__pyx_v_inputs)) < 0) __PYX_ERR(0, 92, __pyx_L1_error)
+      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_importance, ((PyObject *)__pyx_v_importance)) < 0) __PYX_ERR(0, 92, __pyx_L1_error)
+/* … */
+      __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 92, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_13);
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if ((likely(PyTuple_CheckExact(__pyx_t_13))) || (PyList_CheckExact(__pyx_t_13))) {
+        PyObject* sequence = __pyx_t_13;
+        Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+        if (unlikely(size != 2)) {
+          if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+          else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+          __PYX_ERR(0, 92, __pyx_L1_error)
+        }
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        if (likely(PyTuple_CheckExact(sequence))) {
+          __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); 
+          __pyx_t_1 = PyTuple_GET_ITEM(sequence, 1); 
+        } else {
+          __pyx_t_3 = PyList_GET_ITEM(sequence, 0); 
+          __pyx_t_1 = PyList_GET_ITEM(sequence, 1); 
+        }
+        __Pyx_INCREF(__pyx_t_3);
+        __Pyx_INCREF(__pyx_t_1);
+        #else
+        __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 92, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 92, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        #endif
+        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+      } else {
+        Py_ssize_t index = -1;
+        __pyx_t_6 = PyObject_GetIter(__pyx_t_13); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 92, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+        __pyx_t_16 = Py_TYPE(__pyx_t_6)->tp_iternext;
+        index = 0; __pyx_t_3 = __pyx_t_16(__pyx_t_6); if (unlikely(!__pyx_t_3)) goto __pyx_L7_unpacking_failed;
+        __Pyx_GOTREF(__pyx_t_3);
+        index = 1; __pyx_t_1 = __pyx_t_16(__pyx_t_6); if (unlikely(!__pyx_t_1)) goto __pyx_L7_unpacking_failed;
+        __Pyx_GOTREF(__pyx_t_1);
+        if (__Pyx_IternextUnpackEndCheck(__pyx_t_16(__pyx_t_6), 2) < 0) __PYX_ERR(0, 92, __pyx_L1_error)
+        __pyx_t_16 = NULL;
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        goto __pyx_L8_unpacking_done;
+        __pyx_L7_unpacking_failed:;
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __pyx_t_16 = NULL;
+        if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+        __PYX_ERR(0, 92, __pyx_L1_error)
+        __pyx_L8_unpacking_done:;
+      }
+      __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 92, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 92, __pyx_L1_error)
+      __pyx_v_best = __pyx_t_17;
+      __Pyx_DECREF_SET(__pyx_v_activation, ((PyArrayObject *)__pyx_t_1));
+      __pyx_t_1 = 0;
+
+93:                                              weights=weights, n_pix=n_pix, return_vals=1)
+
      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_weights, ((PyObject *)__pyx_v_weights)) < 0) __PYX_ERR(0, 92, __pyx_L1_error)
+      __pyx_t_13 = __Pyx_PyInt_From_int(__pyx_v_n_pix); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 93, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_13);
+      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_n_pix, __pyx_t_13) < 0) __PYX_ERR(0, 92, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_return_vals, __pyx_int_1) < 0) __PYX_ERR(0, 92, __pyx_L1_error)
+
+94:             weights += alpha * count_modified_cells(best, dist_lib, sigma) * np.transpose(
+
      __pyx_t_13 = PyFloat_FromDouble(__pyx_v_alpha); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 94, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_13);
+      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_count_modified_cells); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 94, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_best); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 94, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_t_11 = PyFloat_FromDouble(__pyx_v_sigma); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 94, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      __pyx_t_5 = NULL;
+      __pyx_t_17 = 0;
+      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
+        if (likely(__pyx_t_5)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+          __Pyx_INCREF(__pyx_t_5);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_3, function);
+          __pyx_t_17 = 1;
+        }
+      }
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_3)) {
+        PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_t_6, ((PyObject *)__pyx_v_dist_lib), __pyx_t_11};
+        __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_17, 3+__pyx_t_17); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+        PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_t_6, ((PyObject *)__pyx_v_dist_lib), __pyx_t_11};
+        __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_17, 3+__pyx_t_17); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      } else
+      #endif
+      {
+        __pyx_t_7 = PyTuple_New(3+__pyx_t_17); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 94, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        if (__pyx_t_5) {
+          __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
+        }
+        __Pyx_GIVEREF(__pyx_t_6);
+        PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_17, __pyx_t_6);
+        __Pyx_INCREF(((PyObject *)__pyx_v_dist_lib));
+        __Pyx_GIVEREF(((PyObject *)__pyx_v_dist_lib));
+        PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_17, ((PyObject *)__pyx_v_dist_lib));
+        __Pyx_GIVEREF(__pyx_t_11);
+        PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_17, __pyx_t_11);
+        __pyx_t_6 = 0;
+        __pyx_t_11 = 0;
+        __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_1);
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      }
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_3 = PyNumber_Multiply(__pyx_t_13, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 94, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_n_s_np); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 94, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_13);
+      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_transpose); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 94, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+/* … */
+      __pyx_t_7 = PyNumber_Multiply(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 94, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_7);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+      __pyx_t_1 = PyNumber_InPlaceAdd(((PyObject *)__pyx_v_weights), __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 94, __pyx_L1_error)
+      __Pyx_DECREF_SET(__pyx_v_weights, ((PyArrayObject *)__pyx_t_1));
+      __pyx_t_1 = 0;
+    }
+  }
+
+95:                 (inputs - np.transpose(weights)))
+
      __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_np); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 95, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_11);
+      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_transpose); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 95, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+      __pyx_t_11 = NULL;
+      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
+        __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_6);
+        if (likely(__pyx_t_11)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+          __Pyx_INCREF(__pyx_t_11);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_6, function);
+        }
+      }
+      __pyx_t_13 = (__pyx_t_11) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_11, ((PyObject *)__pyx_v_weights)) : __Pyx_PyObject_CallOneArg(__pyx_t_6, ((PyObject *)__pyx_v_weights));
+      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
+      if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 95, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_13);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __pyx_t_6 = PyNumber_Subtract(((PyObject *)__pyx_v_inputs), __pyx_t_13); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 95, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+      __pyx_t_13 = NULL;
+      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
+        __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_7);
+        if (likely(__pyx_t_13)) {
+          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+          __Pyx_INCREF(__pyx_t_13);
+          __Pyx_INCREF(function);
+          __Pyx_DECREF_SET(__pyx_t_7, function);
+        }
+      }
+      __pyx_t_1 = (__pyx_t_13) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_13, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6);
+      __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+
diff --git a/somsphere/cython/core.pyx b/somsphere/cython/core.pyx index ab96b7e..1cc9d7e 100644 --- a/somsphere/cython/core.pyx +++ b/somsphere/cython/core.pyx @@ -1,37 +1,95 @@ #cython: language_level=3 -import numpy - -from somsphere.utils import get_best_cell, count_modified_cells, timeit - -def create_map_batch(X, n_row, n_col, accum_w, accum_n, sigma, importance, n_pix, dist_lib, weights): - cdef int i, j, k - cdef int nr = n_row - cdef int nc = n_col - cdef int npix = n_pix - cdef double sig = sigma - cdef double[:] imp = importance - cdef double[:] an = accum_n - for i in range(nr): - inputs = X[i] - best, activation = get_best_cell(inputs=inputs, importance=imp, - weights=weights, n_pix=npix) - for j in range(nc): - accum_w[j, :] += count_modified_cells(best, dist_lib, sig) * inputs[j] - an += count_modified_cells(best, dist_lib, sig) - - for k in range(nc): - weights[k] = accum_w[k] / an - -def create_map_online(X, n_row, alpha, sigma, random_indices, importance, n_pix, dist_lib, weights): - cdef int i - cdef int nr = n_row - cdef int npix = n_pix - cdef double alp = alp - cdef double sig = sigma - cdef double[:] imp = importance - for i in range(nr): - inputs = X[random_indices[i]] - best, activation = get_best_cell(inputs=inputs, importance=imp, - weights=weights, n_pix=npix) - weights += alp * count_modified_cells(best, dist_lib, sig) * numpy.transpose( - (inputs - numpy.transpose(weights))) +import random + +import numpy as np +cimport numpy as cnp + +from somsphere.utils import timeit + +DTYPE = np.float +ctypedef cnp.float_t DTYPE_t +# def create_map_batch(np.ndarray X, int n_iter, int n_row, int n_col, int n_pix, np.ndarray importance, +# np.ndarray dist_lib, np.ndarray weights): +# cdef int t = 0 +# cdef int total_t = n_iter * n_row +# cdef float sigma_0 = dist_lib.max() +# cdef float sigma_f = np.min(dist_lib[np.where(dist_lib > 0.)]) +# +# cdef int i +# cdef float sigma, activation +# cdef np.ndarray accum_w, accum_n, best, inputs +# +# for i in range(n_iter): +# sigma = get_sigma(sigma_f, sigma_0, t, total_t) +# accum_w = np.zeros((n_col, n_pix)) +# accum_n = np.zeros(n_pix) +# for j in range(n_row): +# inputs = X[j] +# best, activation = get_best_cell(inputs=inputs, importance=importance, +# weights=weights, n_pix=n_pix) +# for k in range(n_col): +# accum_w[k, :] += count_modified_cells(best, dist_lib, sigma) * inputs[k] +# accum_n += count_modified_cells(best, dist_lib, sigma) +# +# for l in range(n_col): +# weights[l] = accum_w[l] / accum_n +# +# t += n_row +def get_alpha(float alpha_end, float alpha_start, int curr_t, int total_t): + """ + Get value of alpha at a given time + """ + return alpha_start * np.power(alpha_end / alpha_start, float(curr_t) / float(total_t)) + +def get_sigma(float sigma_f, float sigma_0, int curr_t, int total_t): + """ + Get value of sigma at a given time + """ + return sigma_0 * np.power(sigma_f / sigma_0, float(curr_t) / float(total_t)) + +@timeit +def get_best_cell(cnp.ndarray inputs, cnp.ndarray importance, int n_pix, cnp.ndarray weights, int return_vals): + """ + Return the closest cell to the input object + It can return more than one value if needed + """ + cdef cnp.ndarray activation = np.zeros([n_pix, 1], dtype=DTYPE) + + activations = np.sum(np.transpose([importance]) * (np.transpose(np.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0) + + return np.argmin(activations) if return_vals == 1 else np.argsort(activations)[0:return_vals], activations + +def count_modified_cells(int bmu, cnp.ndarray map_d, float sigma): + """ + Neighborhood function which quantifies how much cells around the best matching one are modified + + :param int bmu: best matching unit + :param nparray map_d: array of distances computed with :func:`geometry` + """ + return np.exp(-(map_d[bmu] ** 2) / sigma ** 2) + +def create_map_online(cnp.ndarray X, int n_iter, int n_row, int n_col, int n_pix, float alpha_start, float alpha_end, + cnp.ndarray importance, cnp.ndarray dist_lib, cnp.ndarray weights, bint random_order): + cdef int t = 0 + cdef int total_t = n_iter * n_row + cdef float sigma_0 = dist_lib.max() + cdef float sigma_f = np.min(dist_lib[np.where(dist_lib > 0.)]) + + cdef int i, best + cdef float alpha, sigma + cdef list random_indices + cdef cnp.ndarray inputs = np.zeros([n_col, 1], dtype=DTYPE) + cdef cnp.ndarray activation = np.zeros([n_pix, 1], dtype=DTYPE) + + for it in range(n_iter): + alpha = get_alpha(alpha_end, alpha_start, t, total_t) + sigma = get_sigma(sigma_f, sigma_0, t, total_t) + random_indices = random.sample(range(n_row), n_row) if random_order else np.arange( + n_row) + + for i in range(n_row): + inputs = X[random_indices[i]] + best, activation = get_best_cell(inputs=inputs, importance=importance, + weights=weights, n_pix=n_pix, return_vals=1) + weights += alpha * count_modified_cells(best, dist_lib, sigma) * np.transpose( + (inputs - np.transpose(weights))) diff --git a/somsphere/utils/__init__.py b/somsphere/utils/__init__.py index c46c862..a0f9ec9 100644 --- a/somsphere/utils/__init__.py +++ b/somsphere/utils/__init__.py @@ -15,7 +15,7 @@ def timed(*args, **kw): output = my_func(*args, **kw) tend = time.time() - print('"{}" took {:.3f} ms to execute\n'.format(my_func.__name__, (tend - tstart) * 1000)) + print('"{}" took {:.3f} s to execute\n'.format(my_func.__name__, (tend - tstart) * 1000)) return output return timed @@ -32,6 +32,16 @@ def get_best_cell(inputs, importance, n_pix, weights, return_vals=1): return numpy.argmin(activations) if return_vals == 1 else numpy.argsort(activations)[0:return_vals], activations +def count_modified_cells(bmu, map_d, sigma): + """ + Neighborhood function which quantifies how much cells around the best matching one are modified + + :param int bmu: best matching unit + :param float map_d: array of distances computed with :func:`geometry` + """ + return numpy.exp(-(map_d[bmu] ** 2) / sigma ** 2) + + def get_index(ix, iy, nx, ny): return iy * nx + ix @@ -110,16 +120,6 @@ def get_sigma(sigma_f, sigma_0, curr_t, total_t): return sigma_0 * numpy.power(sigma_f / sigma_0, float(curr_t) / float(total_t)) -def count_modified_cells(bmu, map_d, sigma): - """ - Neighborhood function which quantifies how much cells around the best matching one are modified - - :param int bmu: best matching unit - :param float map_d: array of distances computed with :func:`geometry` - """ - return numpy.exp(-(map_d[bmu] ** 2) / sigma ** 2) - - def get_map_size(n_top, topology: Topology): if topology == Topology.SPHERE: return 12 * n_top ** 2 diff --git a/test/test_somap.py b/test/test_somap.py index 0d5e2a1..04a0755 100644 --- a/test/test_somap.py +++ b/test/test_somap.py @@ -1,9 +1,23 @@ import unittest +import somsphere from somsphere import SOMap +import numpy as np class TestSOMap(unittest.TestCase): def test_init_error(self): som = SOMap([], [], n_top=0, topology="sphere") + def test_create_map(self): + data = "../resources/SDSS_MGS.train" + # just read magnitudes and colors + dx = np.loadtxt(data, usecols=(1, 2, 3, 4, 5, 6, 7, 8, 9), unpack=True).T + np.shape(dx) + # read zspec (or any other extra column) + dy = np.loadtxt(data, usecols=(0,), unpack=True).T + np.shape(dy) + # create an instance + map = somsphere.SOMap(topology='grid', n_top=15, n_iter=100, periodic=False) + map.create_map(dx, dy) # This actually creates the map using only dx + From e3efa69ca766a796a227c974418c511d5e36aa53 Mon Sep 17 00:00:00 2001 From: Ruiqi Li Date: Thu, 8 Oct 2020 00:34:31 -0400 Subject: [PATCH 6/7] Optimization finished --- Example.ipynb | 90 +- core.cpython-38-x86_64-linux-gnu.c | 1 - somsphere/__init__.py | 136 +- somsphere/cython/core.c | 8925 ---------------------------- somsphere/cython/core.html | 2230 ------- somsphere/cython/core.pyx | 95 - somsphere/utils/__init__.py | 6 +- test/test_somap.py | 67 +- 8 files changed, 153 insertions(+), 11397 deletions(-) delete mode 100644 core.cpython-38-x86_64-linux-gnu.c delete mode 100644 somsphere/cython/core.c delete mode 100644 somsphere/cython/core.html delete mode 100644 somsphere/cython/core.pyx diff --git a/Example.ipynb b/Example.ipynb index 75e8ef0..b1f7d35 100644 --- a/Example.ipynb +++ b/Example.ipynb @@ -34,7 +34,7 @@ ], "source": [ "#just read magnitudes and colors\n", - "Data_X=np.loadtxt(data, usecols=(1,2,3,4,5,6,7,8,9), unpack=True).T\n", + "Data_X=np.loadtxt(data, usecols=(1, 2,3,4,5,6,7,8,9), unpack=True).T\n", "np.shape(Data_X)" ] }, @@ -67,7 +67,7 @@ "outputs": [], "source": [ "#create an instance\n", - "M=somsphere.SOMap(topology='grid', n_top=15, n_iter=100, periodic=False)" + "M=somsphere.SOMap(Data_X, Data_Y, topology='grid', n_top=15, n_iter=100, periodic=False, som_type=\"batch\")" ] }, { @@ -79,32 +79,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "\"__create_map_online\" took 25723.258 ms to execute\n", + "\"__create_map_batch\" took 29650.045 ms to execute\n", "\n" ] } ], "source": [ - "M.create_map(Data_X, Data_Y) #This actually creates the map using only Data_X" + "M.create_map() #This actually creates the map using only Data_X" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 6, "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'M' is not defined", - "output_type": "error", - "traceback": [ - "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", - "\u001B[0;31mNameError\u001B[0m Traceback (most recent call last)", - "\u001B[0;32m\u001B[0m in \u001B[0;36m\u001B[0;34m\u001B[0m\n\u001B[0;32m----> 1\u001B[0;31m \u001B[0mM\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mevaluate_map\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m \u001B[0;31m# Will evaluate Data_Y, basically will take mean for every value of Y per cell\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m", - "\u001B[0;31mNameError\u001B[0m: name 'M' is not defined" - ] - } - ], + "outputs": [], "source": [ "M.evaluate_map() # Will evaluate Data_Y, basically will take mean for every value of Y per cell" ] @@ -116,7 +104,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -133,7 +121,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -143,29 +131,19 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 9, "metadata": {}, "outputs": [ - { - "ename": "ValueError", - "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()", - "output_type": "error", - "traceback": [ - "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", - "\u001B[0;31mValueError\u001B[0m Traceback (most recent call last)", - "\u001B[0;32m\u001B[0m in \u001B[0;36m\u001B[0;34m\u001B[0m\n\u001B[0;32m----> 1\u001B[0;31m \u001B[0mM\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mplot_map\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mData_X\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mData_Y\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m", - "\u001B[0;32m~/dev/somsphere/somsphere/__init__.py\u001B[0m in \u001B[0;36mplot_map\u001B[0;34m(self, min_m, max_m, cbar)\u001B[0m\n\u001B[1;32m 114\u001B[0m \u001B[0maccum_w\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0mkk\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0;34m:\u001B[0m\u001B[0;34m]\u001B[0m \u001B[0;34m+=\u001B[0m \u001B[0mcore\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mcount_modified_cells\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mbest\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mdist_lib\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0msigma\u001B[0m\u001B[0;34m)\u001B[0m \u001B[0;34m*\u001B[0m \u001B[0minputs\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0mkk\u001B[0m\u001B[0;34m]\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 115\u001B[0m \u001B[0maccum_n\u001B[0m \u001B[0;34m+=\u001B[0m \u001B[0mcore\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mcount_modified_cells\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mbest\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mdist_lib\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0msigma\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m--> 116\u001B[0;31m \u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m 117\u001B[0m \u001B[0;32mfor\u001B[0m \u001B[0mkk\u001B[0m \u001B[0;32min\u001B[0m \u001B[0mrange\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mn_col\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 118\u001B[0m \u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mweights\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0mkk\u001B[0m\u001B[0;34m]\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0maccum_w\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0mkk\u001B[0m\u001B[0;34m]\u001B[0m \u001B[0;34m/\u001B[0m \u001B[0maccum_n\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n", - "\u001B[0;32m~/dev/somsphere/somsphere/__init__.py\u001B[0m in \u001B[0;36m__plot_map_grid\u001B[0;34m(self, min_m, max_m, cbar)\u001B[0m\n\u001B[1;32m 229\u001B[0m \u001B[0mM_new\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mnumpy\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mreshape\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mM\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0;34m(\u001B[0m\u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mn_top\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mn_top\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 230\u001B[0m \u001B[0mplt\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mfigure\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mfigsize\u001B[0m\u001B[0;34m=\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;36m8\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0;36m8\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mdpi\u001B[0m\u001B[0;34m=\u001B[0m\u001B[0;36m100\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m--> 231\u001B[0;31m \u001B[0mmin_m\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mM_new\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0mnumpy\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mwhere\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mM_new\u001B[0m \u001B[0;34m>\u001B[0m \u001B[0;34m-\u001B[0m\u001B[0;36m10\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m]\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mmin\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m \u001B[0;32mif\u001B[0m \u001B[0mmin_m\u001B[0m \u001B[0;34m==\u001B[0m \u001B[0;34m-\u001B[0m\u001B[0;36m100\u001B[0m \u001B[0;32melse\u001B[0m \u001B[0mmin_m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m 232\u001B[0m \u001B[0mmax_m\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mM_new\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mmax\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m \u001B[0;32mif\u001B[0m \u001B[0mmax_m\u001B[0m \u001B[0;34m==\u001B[0m \u001B[0;34m-\u001B[0m\u001B[0;36m100\u001B[0m \u001B[0;32melse\u001B[0m \u001B[0mmax_m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 233\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n", - "\u001B[0;31mValueError\u001B[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()" - ] - }, { "data": { + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -175,22 +153,38 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "ValueError", + "evalue": "operands could not be broadcast together with shapes (9,225) (5000,9) ", + "output_type": "error", + "traceback": [ + "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", + "\u001B[0;31mValueError\u001B[0m Traceback (most recent call last)", + "\u001B[0;32m\u001B[0m in \u001B[0;36m\u001B[0;34m\u001B[0m\n\u001B[1;32m 1\u001B[0m \u001B[0;31m#Every time the map is created it will be different given the random weights\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m----> 2\u001B[0;31m \u001B[0mM\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mcreate_map\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m", + "\u001B[0;32m~/dev/somsphere/somsphere/__init__.py\u001B[0m in \u001B[0;36mcreate_map\u001B[0;34m(self, input_weights, random_order, eval_map)\u001B[0m\n\u001B[1;32m 124\u001B[0m \u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0m__create_map_online\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mrandom_order\u001B[0m\u001B[0;34m=\u001B[0m\u001B[0mrandom_order\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0meval_map\u001B[0m\u001B[0;34m=\u001B[0m\u001B[0meval_map\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 125\u001B[0m \u001B[0;32melif\u001B[0m \u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0msom_type\u001B[0m \u001B[0;34m==\u001B[0m \u001B[0mSomType\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mBATCH\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m--> 126\u001B[0;31m \u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0m__create_map_batch\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0meval_map\u001B[0m\u001B[0;34m=\u001B[0m\u001B[0meval_map\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m 127\u001B[0m \u001B[0;32melse\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 128\u001B[0m \u001B[0;32mraise\u001B[0m \u001B[0mException\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34mf\"Unknown type: {self.som_type}\"\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n", + "\u001B[0;32m~/dev/somsphere/somsphere/utils/__init__.py\u001B[0m in \u001B[0;36mtimed\u001B[0;34m(*args, **kw)\u001B[0m\n\u001B[1;32m 13\u001B[0m \u001B[0;32mdef\u001B[0m \u001B[0mtimed\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m*\u001B[0m\u001B[0margs\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0;34m**\u001B[0m\u001B[0mkw\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 14\u001B[0m \u001B[0mtstart\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mtime\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mtime\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m---> 15\u001B[0;31m \u001B[0moutput\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mmy_func\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m*\u001B[0m\u001B[0margs\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0;34m**\u001B[0m\u001B[0mkw\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m 16\u001B[0m \u001B[0mtend\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mtime\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mtime\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 17\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n", + "\u001B[0;32m~/dev/somsphere/somsphere/__init__.py\u001B[0m in \u001B[0;36m__create_map_batch\u001B[0;34m(self, eval_map)\u001B[0m\n\u001B[1;32m 96\u001B[0m \u001B[0;32mfor\u001B[0m \u001B[0mi\u001B[0m \u001B[0;32min\u001B[0m \u001B[0mrange\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mn_row\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 97\u001B[0m \u001B[0minputs\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mX\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0mi\u001B[0m\u001B[0;34m]\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m---> 98\u001B[0;31m best, _ = get_best_cell(inputs=inputs, importance=self.importance,\n\u001B[0m\u001B[1;32m 99\u001B[0m weights=self.weights, n_pix=self.n_pix)\n\u001B[1;32m 100\u001B[0m \u001B[0mcmc\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mcount_modified_cells\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mbest\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mdist_lib\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0msigma\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n", + "\u001B[0;32m~/dev/somsphere/somsphere/utils/__init__.py\u001B[0m in \u001B[0;36mget_best_cell\u001B[0;34m(inputs, importance, n_pix, weights, return_vals)\u001B[0m\n\u001B[1;32m 28\u001B[0m \"\"\"\n\u001B[1;32m 29\u001B[0m activations = numpy.sum(numpy.transpose([importance]) * (\n\u001B[0;32m---> 30\u001B[0;31m numpy.transpose(numpy.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0)\n\u001B[0m\u001B[1;32m 31\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 32\u001B[0m \u001B[0;32mreturn\u001B[0m \u001B[0mnumpy\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0margmin\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mactivations\u001B[0m\u001B[0;34m)\u001B[0m \u001B[0;32mif\u001B[0m \u001B[0mreturn_vals\u001B[0m \u001B[0;34m==\u001B[0m \u001B[0;36m1\u001B[0m \u001B[0;32melse\u001B[0m \u001B[0mnumpy\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0margsort\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mactivations\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0;36m0\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0mreturn_vals\u001B[0m\u001B[0;34m]\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mactivations\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n", + "\u001B[0;31mValueError\u001B[0m: operands could not be broadcast together with shapes (9,225) (5000,9) " + ] + } + ], "source": [ "#Every time the map is created it will be different given the random weights\n", - "M.create_map(Data_X, Data_Y)" + "M.create_map()" ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -208,12 +202,12 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -231,21 +225,21 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Spherical coordinates\n", - "M_sph=somsphere.SOMap(topology='sphere', n_top=8, n_iter=100)" + "M_sph=somsphere.SOMap(Data_X, Data_Y, topology='sphere', n_top=8, n_iter=100)" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "M_sph.create_map(Data_X, Data_Y)" + "M_sph.create_map()" ] }, { @@ -792,7 +786,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.2" + "version": "3.8.5" } }, "nbformat": 4, diff --git a/core.cpython-38-x86_64-linux-gnu.c b/core.cpython-38-x86_64-linux-gnu.c deleted file mode 100644 index 06f2230..0000000 --- a/core.cpython-38-x86_64-linux-gnu.c +++ /dev/null @@ -1 +0,0 @@ -#error Do not use this file, it is the result of a failed Cython compilation. diff --git a/somsphere/__init__.py b/somsphere/__init__.py index 3f303ea..9af1f72 100644 --- a/somsphere/__init__.py +++ b/somsphere/__init__.py @@ -41,11 +41,12 @@ class SOMap(object): :param str importance: Path to the file with importance ranking for attributes, default is none """ - def __init__(self, topology='grid', som_type='online', n_top=28, n_iter=30, alpha_start=0.8, - alpha_end=0.5, periodic=False, dict_dim=None): + def __init__(self, X, Y, topology='grid', som_type='online', n_top=28, n_iter=30, alpha_start=0.8, + alpha_end=0.5, periodic=False, dict_dim=None, importance=None): if topology == 'sphere' and not is_power_2(n_top): - raise Exception("Error, n_top must be power of 2") + raise Exception("n_top must be power of 2") + self.X, self.Y = X, Y self.topology: Topology = Topology(topology) self.som_type: SomType = SomType(som_type) self.n_top = n_top @@ -55,88 +56,65 @@ def __init__(self, topology='grid', som_type='online', n_top=28, n_iter=30, alph self.periodic = periodic self.dict_dim = dict_dim self.dist_lib, self.n_pix = compute_distance(self.topology, self.n_top, periodic=self.periodic) + self.n_row, self.n_col = numpy.shape(X) + self.weights = (numpy.random.rand(self.n_col, self.n_pix)) + self.X[0][0] + importance = numpy.ones(self.n_col) if importance is None else importance + self.importance = importance / numpy.sum(importance) + + def __update_weights(self, input_weights): + self.weights = input_weights if input_weights is not None else self.weights - def create_map(self, X, Y, importance=None, inputs_weights=None, random_order=True, eval_map=False): + @timeit + def __create_map_online(self, random_order=True, eval_map=False): + t, total_t = 0, self.n_iter * self.n_row + sigma_0 = self.dist_lib.max() + sigma_f = numpy.min(self.dist_lib[numpy.where(self.dist_lib > 0.)]) + + for it in range(self.n_iter): + alpha = get_alpha(self.alpha_end, self.alpha_start, t, total_t) + sigma = get_sigma(sigma_f, sigma_0, t, total_t) + random_indices = random.sample(range(self.n_row), self.n_row) if random_order else numpy.arange( + self.n_row) + self.weights = core.create_map_online(self.X, self.dist_lib, self.weights, random_indices, self.importance, + alpha, sigma, self.n_row, self.n_col, self.n_pix, 1) + t += self.n_row + + if eval_map: + self.evaluate_map() + self.save_map(itn=it) + + @timeit + def __create_map_batch(self, eval_map=False): + t, total_t = 0, self.n_iter * self.n_row + sigma_0 = self.dist_lib.max() + sigma_f = numpy.min(self.dist_lib[numpy.where(self.dist_lib > 0.)]) + + for it in range(self.n_iter): + sigma = get_sigma(sigma_f, sigma_0, t, total_t) + accum_w = numpy.zeros((self.n_col, self.n_pix)) + accum_n = numpy.zeros(self.n_pix) + self.weights = core.create_map_batch(self.X, self.dist_lib, self.weights, self.importance, accum_w, + accum_n, sigma, self.n_row, self.n_col, self.n_pix, 1) + t += self.n_row + + if eval_map: + self.evaluate_map() + self.save_map(itn=it) + + def create_map(self, input_weights=None, random_order=True, eval_map=False): """ This functions actually create the maps, it uses random values to initialize the weights """ - n_row, n_col = numpy.shape(X) - importance = numpy.ones(n_col) if importance is None else importance - self.X, self.Y = X, Y - self.importance = importance / numpy.sum(importance) - self.weights = inputs_weights if inputs_weights is not None else (numpy.random.rand(n_col, self.n_pix)) + \ - self.X[0][0] + self.__update_weights(input_weights) if self.som_type == SomType.ONLINE: - self.__create_map_online(n_row=n_row, n_col=n_col, random_order=random_order, eval_map=eval_map) + self.__create_map_online(random_order=random_order, eval_map=eval_map) elif self.som_type == SomType.BATCH: - self.__create_map_batch(n_row=n_row, n_col=n_col, eval_map=eval_map) + self.__create_map_batch(eval_map=eval_map) else: raise Exception(f"Unknown type: {self.som_type}") - def __create_map_online(self, n_row, n_col, random_order=True, eval_map=False): - - core.create_map_online(self.X, self.n_iter, n_row, n_col, self.n_pix, self.alpha_start, self.alpha_end, - self.importance, self.dist_lib, self.weights, random_order) - # t, total_t = 0, self.n_iter * n_row - # sigma_0 = self.dist_lib.max() - # sigma_f = numpy.min(self.dist_lib[numpy.where(self.dist_lib > 0.)]) - # - # for it in range(self.n_iter): - # alpha = get_alpha(self.alpha_end, self.alpha_start, t, total_t) - # sigma = get_sigma(sigma_f, sigma_0, t, total_t) - # random_indices = random.sample(range(n_row), n_row) if random_order else numpy.arange( - # n_row) - # # core.create_map_online(X=self.X, n_row=n_row, alpha=alpha, sigma=sigma, - # # random_indices=random_indices, importance=self.importance, - # # weights=self.weights, n_pix=self.n_pix, dist_lib=self.dist_lib) - # - # for i in range(n_row): - # inputs = self.X[random_indices[i]] - # best, activation = get_best_cell(inputs=inputs, importance=self.importance, - # weights=self.weights, n_pix=self.n_pix, return_vals=1) - # self.weights += alpha * count_modified_cells(1, self.dist_lib, sigma) * numpy.transpose( - # (inputs - numpy.transpose(self.weights))) - # continue - - # t += n_row - - # if eval_map: - # self.evaluate_map() - # self.save_map(itn=it) - - @timeit - def __create_map_batch(self, n_row, n_col, eval_map=False): - return - # t, total_t = 0, self.n_iter * n_row - # sigma_0 = self.dist_lib.max() - # sigma_f = numpy.min(self.dist_lib[numpy.where(self.dist_lib > 0.)]) - # - # for it in range(self.n_iter): - # sigma = get_sigma(sigma_f, sigma_0, t, total_t) - # accum_w = numpy.zeros((n_col, self.n_pix)) - # accum_n = numpy.zeros(self.n_pix) - # core.create_map_batch(X=self.X, n_row=n_row, n_col=n_col, accum_n=accum_n, accum_w=accum_w, sigma=sigma, - # importance=self.importance, weights=self.weights, n_pix=self.n_pix, - # dist_lib=self.dist_lib) - # for i in range(n_row): - # inputs = self.X[i] - # best, activation = get_best_cell(inputs=inputs, importance=self.importance, - # weights=self.weights, n_pix=self.n_pix) - # for kk in range(n_col): - # accum_w[kk, :] += count_modified_cells(best, self.dist_lib, sigma) * inputs[kk] - # accum_n += count_modified_cells(best, self.dist_lib, sigma) - # - # for kk in range(n_col): - # self.weights[kk] = accum_w[kk] / accum_n - # - # t += n_row - # - # if eval_map: - # self.evaluate_map() - # self.save_map(itn=it) - def evaluate_map(self, input_x=None, input_y=None): """ This functions evaluates the map created using the input Y or a new Y (array of labeled attributes) @@ -147,14 +125,13 @@ def evaluate_map(self, input_x=None, input_y=None): :param float input_y: One dimensional array of the values to be assigned to each cell in the map based on the in-memory X passed """ - self.y_vals = {} - self.i_vals = {} + self.y_vals, self.i_vals = {}, {} in_x = self.X if input_x is None else input_x in_y = self.Y if input_y is None else input_y for i in range(len(in_x)): inputs = in_x[i] - best, activation = core.get_best_cell(inputs=inputs, importance=self.importance, weights=self.weights, - n_pix=self.n_pix) + best, activation = core.get_best_cell(inputs, self.importance, self.weights, len(inputs), self.n_pix, 1) + best = best[0] if best not in self.y_vals: self.y_vals[best] = [] self.y_vals[best].append(in_y[i]) @@ -173,8 +150,7 @@ def predict(self, line, best=True): :param bool best: Set to True to get only the best cell; otherwise the 10 closest cells will be returned :return: array with the cell content """ - bests, _ = core.get_best_cell(inputs=line, importance=self.importance, weights=self.weights, n_pix=self.n_pix, - return_vals=10) + bests, _ = core.get_best_cell(line, self.importance, self.weights, len(line), self.n_pix, 10) if best: return bests[0] for ib in range(10): diff --git a/somsphere/cython/core.c b/somsphere/cython/core.c deleted file mode 100644 index 84c71b7..0000000 --- a/somsphere/cython/core.c +++ /dev/null @@ -1,8925 +0,0 @@ -/* Generated by Cython 0.29.21 */ - -/* BEGIN: Cython Metadata -{ - "distutils": { - "depends": [], - "name": "core", - "sources": [ - "somsphere/cython/core.pyx" - ] - }, - "module_name": "core" -} -END: Cython Metadata */ - -#define PY_SSIZE_T_CLEAN -#include "Python.h" -#ifndef Py_PYTHON_H - #error Python headers needed to compile C extensions, please install development version of Python. -#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) - #error Cython requires Python 2.6+ or Python 3.3+. -#else -#define CYTHON_ABI "0_29_21" -#define CYTHON_HEX_VERSION 0x001D15F0 -#define CYTHON_FUTURE_DIVISION 1 -#include -#ifndef offsetof - #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) -#endif -#if !defined(WIN32) && !defined(MS_WINDOWS) - #ifndef __stdcall - #define __stdcall - #endif - #ifndef __cdecl - #define __cdecl - #endif - #ifndef __fastcall - #define __fastcall - #endif -#endif -#ifndef DL_IMPORT - #define DL_IMPORT(t) t -#endif -#ifndef DL_EXPORT - #define DL_EXPORT(t) t -#endif -#define __PYX_COMMA , -#ifndef HAVE_LONG_LONG - #if PY_VERSION_HEX >= 0x02070000 - #define HAVE_LONG_LONG - #endif -#endif -#ifndef PY_LONG_LONG - #define PY_LONG_LONG LONG_LONG -#endif -#ifndef Py_HUGE_VAL - #define Py_HUGE_VAL HUGE_VAL -#endif -#ifdef PYPY_VERSION - #define CYTHON_COMPILING_IN_PYPY 1 - #define CYTHON_COMPILING_IN_PYSTON 0 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #undef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 0 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #if PY_VERSION_HEX < 0x03050000 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #undef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 0 - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #undef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 1 - #undef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 0 - #undef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 0 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #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 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 - #endif - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 - #endif - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #ifndef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 0 - #endif - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #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 - #define CYTHON_COMPILING_IN_CPYTHON 1 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 - #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) - #define CYTHON_USE_PYTYPE_LOOKUP 1 - #endif - #if PY_MAJOR_VERSION < 3 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #if PY_VERSION_HEX < 0x02070000 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #elif !defined(CYTHON_USE_PYLONG_INTERNALS) - #define CYTHON_USE_PYLONG_INTERNALS 1 - #endif - #ifndef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 1 - #endif - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 - #endif - #if PY_VERSION_HEX < 0x030300F0 - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #elif !defined(CYTHON_USE_UNICODE_WRITER) - #define CYTHON_USE_UNICODE_WRITER 1 - #endif - #ifndef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 0 - #endif - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif - #ifndef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 1 - #endif - #ifndef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 1 - #endif - #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT (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) -#endif -#if CYTHON_USE_PYLONG_INTERNALS - #include "longintrepr.h" - #undef SHIFT - #undef BASE - #undef MASK - #ifdef SIZEOF_VOID_P - enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; - #endif -#endif -#ifndef __has_attribute - #define __has_attribute(x) 0 -#endif -#ifndef __has_cpp_attribute - #define __has_cpp_attribute(x) 0 -#endif -#ifndef CYTHON_RESTRICT - #if defined(__GNUC__) - #define CYTHON_RESTRICT __restrict__ - #elif defined(_MSC_VER) && _MSC_VER >= 1400 - #define CYTHON_RESTRICT __restrict - #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - #define CYTHON_RESTRICT restrict - #else - #define CYTHON_RESTRICT - #endif -#endif -#ifndef CYTHON_UNUSED -# if defined(__GNUC__) -# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) -# define CYTHON_UNUSED __attribute__ ((__unused__)) -# else -# define CYTHON_UNUSED -# endif -# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) -# define CYTHON_UNUSED __attribute__ ((__unused__)) -# else -# define CYTHON_UNUSED -# endif -#endif -#ifndef CYTHON_MAYBE_UNUSED_VAR -# if defined(__cplusplus) - template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } -# else -# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) -# endif -#endif -#ifndef CYTHON_NCP_UNUSED -# if CYTHON_COMPILING_IN_CPYTHON -# define CYTHON_NCP_UNUSED -# else -# define CYTHON_NCP_UNUSED CYTHON_UNUSED -# endif -#endif -#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) -#ifdef _MSC_VER - #ifndef _MSC_STDINT_H_ - #if _MSC_VER < 1300 - typedef unsigned char uint8_t; - typedef unsigned int uint32_t; - #else - typedef unsigned __int8 uint8_t; - typedef unsigned __int32 uint32_t; - #endif - #endif -#else - #include -#endif -#ifndef CYTHON_FALLTHROUGH - #if defined(__cplusplus) && __cplusplus >= 201103L - #if __has_cpp_attribute(fallthrough) - #define CYTHON_FALLTHROUGH [[fallthrough]] - #elif __has_cpp_attribute(clang::fallthrough) - #define CYTHON_FALLTHROUGH [[clang::fallthrough]] - #elif __has_cpp_attribute(gnu::fallthrough) - #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] - #endif - #endif - #ifndef CYTHON_FALLTHROUGH - #if __has_attribute(fallthrough) - #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) - #else - #define CYTHON_FALLTHROUGH - #endif - #endif - #if defined(__clang__ ) && defined(__apple_build_version__) - #if __apple_build_version__ < 7000000 - #undef CYTHON_FALLTHROUGH - #define CYTHON_FALLTHROUGH - #endif - #endif -#endif - -#ifndef CYTHON_INLINE - #if defined(__clang__) - #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) - #elif defined(__GNUC__) - #define CYTHON_INLINE __inline__ - #elif defined(_MSC_VER) - #define CYTHON_INLINE __inline - #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - #define CYTHON_INLINE inline - #else - #define CYTHON_INLINE - #endif -#endif - -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) - #define Py_OptimizeFlag 0 -#endif -#define __PYX_BUILD_PY_SSIZE_T "n" -#define CYTHON_FORMAT_SSIZE_T "z" -#if PY_MAJOR_VERSION < 3 - #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) - #define __Pyx_DefaultClassType PyClass_Type -#else - #define __Pyx_BUILTIN_MODULE_NAME "builtins" -#if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2 - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a, 0, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) -#else - #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) -#endif - #define __Pyx_DefaultClassType PyType_Type -#endif -#ifndef Py_TPFLAGS_CHECKTYPES - #define Py_TPFLAGS_CHECKTYPES 0 -#endif -#ifndef Py_TPFLAGS_HAVE_INDEX - #define Py_TPFLAGS_HAVE_INDEX 0 -#endif -#ifndef Py_TPFLAGS_HAVE_NEWBUFFER - #define Py_TPFLAGS_HAVE_NEWBUFFER 0 -#endif -#ifndef Py_TPFLAGS_HAVE_FINALIZE - #define Py_TPFLAGS_HAVE_FINALIZE 0 -#endif -#ifndef METH_STACKLESS - #define METH_STACKLESS 0 -#endif -#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) - #ifndef METH_FASTCALL - #define METH_FASTCALL 0x80 - #endif - typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); - typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, - Py_ssize_t nargs, PyObject *kwnames); -#else - #define __Pyx_PyCFunctionFast _PyCFunctionFast - #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords -#endif -#if CYTHON_FAST_PYCCALL -#define __Pyx_PyFastCFunction_Check(func)\ - ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) -#else -#define __Pyx_PyFastCFunction_Check(func) 0 -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) - #define PyObject_Malloc(s) PyMem_Malloc(s) - #define PyObject_Free(p) PyMem_Free(p) - #define PyObject_Realloc(p) PyMem_Realloc(p) -#endif -#if CYTHON_COMPILING_IN_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) -#else - #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) - #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) -#endif -#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 - #define __Pyx_PyThreadState_Current PyThreadState_GET() -#elif PY_VERSION_HEX >= 0x03060000 - #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() -#elif PY_VERSION_HEX >= 0x03000000 - #define __Pyx_PyThreadState_Current PyThreadState_GET() -#else - #define __Pyx_PyThreadState_Current _PyThreadState_Current -#endif -#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) -#include "pythread.h" -#define Py_tss_NEEDS_INIT 0 -typedef int Py_tss_t; -static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { - *key = PyThread_create_key(); - return 0; -} -static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { - Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); - *key = Py_tss_NEEDS_INIT; - return key; -} -static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { - PyObject_Free(key); -} -static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { - return *key != Py_tss_NEEDS_INIT; -} -static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { - PyThread_delete_key(*key); - *key = Py_tss_NEEDS_INIT; -} -static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { - return PyThread_set_key_value(*key, value); -} -static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { - return PyThread_get_key_value(*key); -} -#endif -#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) -#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) -#else -#define __Pyx_PyDict_NewPresized(n) PyDict_New() -#endif -#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION - #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) - #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) -#else - #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) - #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS -#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) -#else -#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) -#endif -#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) - #define CYTHON_PEP393_ENABLED 1 - #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ - 0 : _PyUnicode_Ready((PyObject *)(op))) - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) - #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) - #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) - #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) - #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) - #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) - #else - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) - #endif -#else - #define CYTHON_PEP393_ENABLED 0 - #define PyUnicode_1BYTE_KIND 1 - #define PyUnicode_2BYTE_KIND 2 - #define PyUnicode_4BYTE_KIND 4 - #define __Pyx_PyUnicode_READY(op) (0) - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) - #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) - #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) - #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) - #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) -#endif -#if CYTHON_COMPILING_IN_PYPY - #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) - #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) -#else - #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) - #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ - PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) - #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) - #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) - #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) -#endif -#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) -#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) -#else - #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) -#endif -#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) - #define PyObject_ASCII(o) PyObject_Repr(o) -#endif -#if PY_MAJOR_VERSION >= 3 - #define PyBaseString_Type PyUnicode_Type - #define PyStringObject PyUnicodeObject - #define PyString_Type PyUnicode_Type - #define PyString_Check PyUnicode_Check - #define PyString_CheckExact PyUnicode_CheckExact -#ifndef PyObject_Unicode - #define PyObject_Unicode PyObject_Str -#endif -#endif -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) - #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) -#else - #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) - #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) -#endif -#ifndef PySet_CheckExact - #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) -#endif -#if PY_VERSION_HEX >= 0x030900A4 - #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) - #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) -#else - #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) - #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) -#endif -#if CYTHON_ASSUME_SAFE_MACROS - #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) -#else - #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) -#endif -#if PY_MAJOR_VERSION >= 3 - #define PyIntObject PyLongObject - #define PyInt_Type PyLong_Type - #define PyInt_Check(op) PyLong_Check(op) - #define PyInt_CheckExact(op) PyLong_CheckExact(op) - #define PyInt_FromString PyLong_FromString - #define PyInt_FromUnicode PyLong_FromUnicode - #define PyInt_FromLong PyLong_FromLong - #define PyInt_FromSize_t PyLong_FromSize_t - #define PyInt_FromSsize_t PyLong_FromSsize_t - #define PyInt_AsLong PyLong_AsLong - #define PyInt_AS_LONG PyLong_AS_LONG - #define PyInt_AsSsize_t PyLong_AsSsize_t - #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask - #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask - #define PyNumber_Int PyNumber_Long -#endif -#if PY_MAJOR_VERSION >= 3 - #define PyBoolObject PyLongObject -#endif -#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY - #ifndef PyUnicode_InternFromString - #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) - #endif -#endif -#if PY_VERSION_HEX < 0x030200A4 - typedef long Py_hash_t; - #define __Pyx_PyInt_FromHash_t PyInt_FromLong - #define __Pyx_PyInt_AsHash_t PyInt_AsLong -#else - #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t - #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t -#endif -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) -#else - #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) -#endif -#if CYTHON_USE_ASYNC_SLOTS - #if PY_VERSION_HEX >= 0x030500B1 - #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods - #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) - #else - #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) - #endif -#else - #define __Pyx_PyType_AsAsync(obj) NULL -#endif -#ifndef __Pyx_PyAsyncMethodsStruct - typedef struct { - unaryfunc am_await; - unaryfunc am_aiter; - unaryfunc am_anext; - } __Pyx_PyAsyncMethodsStruct; -#endif - -#if defined(WIN32) || defined(MS_WINDOWS) - #define _USE_MATH_DEFINES -#endif -#include -#ifdef NAN -#define __PYX_NAN() ((float) NAN) -#else -static CYTHON_INLINE float __PYX_NAN() { - float value; - memset(&value, 0xFF, sizeof(value)); - return value; -} -#endif -#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) -#define __Pyx_truncl trunc -#else -#define __Pyx_truncl truncl -#endif - -#define __PYX_MARK_ERR_POS(f_index, lineno) \ - { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } -#define __PYX_ERR(f_index, lineno, Ln_error) \ - { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } - -#ifndef __PYX_EXTERN_C - #ifdef __cplusplus - #define __PYX_EXTERN_C extern "C" - #else - #define __PYX_EXTERN_C extern - #endif -#endif - -#define __PYX_HAVE__core -#define __PYX_HAVE_API__core -/* Early includes */ -#include -#include -#include "numpy/arrayobject.h" -#include "numpy/ufuncobject.h" - - /* NumPy API declarations from "numpy/__init__.pxd" */ - -#ifdef _OPENMP -#include -#endif /* _OPENMP */ - -#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) -#define CYTHON_WITHOUT_ASSERTIONS -#endif - -typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; - const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; - -#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 -#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 -#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) -#define __PYX_DEFAULT_STRING_ENCODING "" -#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString -#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize -#define __Pyx_uchar_cast(c) ((unsigned char)c) -#define __Pyx_long_cast(x) ((long)x) -#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ - (sizeof(type) < sizeof(Py_ssize_t)) ||\ - (sizeof(type) > sizeof(Py_ssize_t) &&\ - likely(v < (type)PY_SSIZE_T_MAX ||\ - v == (type)PY_SSIZE_T_MAX) &&\ - (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ - v == (type)PY_SSIZE_T_MIN))) ||\ - (sizeof(type) == sizeof(Py_ssize_t) &&\ - (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ - v == (type)PY_SSIZE_T_MAX))) ) -static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { - return (size_t) i < (size_t) limit; -} -#if defined (__cplusplus) && __cplusplus >= 201103L - #include - #define __Pyx_sst_abs(value) std::abs(value) -#elif SIZEOF_INT >= SIZEOF_SIZE_T - #define __Pyx_sst_abs(value) abs(value) -#elif SIZEOF_LONG >= SIZEOF_SIZE_T - #define __Pyx_sst_abs(value) labs(value) -#elif defined (_MSC_VER) - #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) -#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - #define __Pyx_sst_abs(value) llabs(value) -#elif defined (__GNUC__) - #define __Pyx_sst_abs(value) __builtin_llabs(value) -#else - #define __Pyx_sst_abs(value) ((value<0) ? -value : value) -#endif -static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); -static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); -#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) -#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) -#define __Pyx_PyBytes_FromString PyBytes_FromString -#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); -#if PY_MAJOR_VERSION < 3 - #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString - #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize -#else - #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString - #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize -#endif -#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) -#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) -#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) -#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) -#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) -static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { - const Py_UNICODE *u_end = u; - while (*u_end++) ; - return (size_t)(u_end - u - 1); -} -#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) -#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode -#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode -#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) -#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) -static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); -static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); -static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); -static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); -#define __Pyx_PySequence_Tuple(obj)\ - (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) -static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); -static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); -#if CYTHON_ASSUME_SAFE_MACROS -#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) -#else -#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) -#endif -#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) -#if PY_MAJOR_VERSION >= 3 -#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) -#else -#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) -#endif -#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) -#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII -static int __Pyx_sys_getdefaultencoding_not_ascii; -static int __Pyx_init_sys_getdefaultencoding_params(void) { - PyObject* sys; - PyObject* default_encoding = NULL; - PyObject* ascii_chars_u = NULL; - PyObject* ascii_chars_b = NULL; - const char* default_encoding_c; - sys = PyImport_ImportModule("sys"); - if (!sys) goto bad; - default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); - Py_DECREF(sys); - if (!default_encoding) goto bad; - default_encoding_c = PyBytes_AsString(default_encoding); - if (!default_encoding_c) goto bad; - if (strcmp(default_encoding_c, "ascii") == 0) { - __Pyx_sys_getdefaultencoding_not_ascii = 0; - } else { - char ascii_chars[128]; - int c; - for (c = 0; c < 128; c++) { - ascii_chars[c] = c; - } - __Pyx_sys_getdefaultencoding_not_ascii = 1; - ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); - if (!ascii_chars_u) goto bad; - ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); - if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { - PyErr_Format( - PyExc_ValueError, - "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", - default_encoding_c); - goto bad; - } - Py_DECREF(ascii_chars_u); - Py_DECREF(ascii_chars_b); - } - Py_DECREF(default_encoding); - return 0; -bad: - Py_XDECREF(default_encoding); - Py_XDECREF(ascii_chars_u); - Py_XDECREF(ascii_chars_b); - return -1; -} -#endif -#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 -#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) -#else -#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) -#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT -static char* __PYX_DEFAULT_STRING_ENCODING; -static int __Pyx_init_sys_getdefaultencoding_params(void) { - PyObject* sys; - PyObject* default_encoding = NULL; - char* default_encoding_c; - sys = PyImport_ImportModule("sys"); - if (!sys) goto bad; - default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); - Py_DECREF(sys); - if (!default_encoding) goto bad; - default_encoding_c = PyBytes_AsString(default_encoding); - if (!default_encoding_c) goto bad; - __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); - if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; - strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); - Py_DECREF(default_encoding); - return 0; -bad: - Py_XDECREF(default_encoding); - return -1; -} -#endif -#endif - - -/* Test for GCC > 2.95 */ -#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) - #define likely(x) __builtin_expect(!!(x), 1) - #define unlikely(x) __builtin_expect(!!(x), 0) -#else /* !__GNUC__ or GCC < 2.95 */ - #define likely(x) (x) - #define unlikely(x) (x) -#endif /* __GNUC__ */ -static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } - -static PyObject *__pyx_m = NULL; -static PyObject *__pyx_d; -static PyObject *__pyx_b; -static PyObject *__pyx_cython_runtime = NULL; -static PyObject *__pyx_empty_tuple; -static PyObject *__pyx_empty_bytes; -static PyObject *__pyx_empty_unicode; -static int __pyx_lineno; -static int __pyx_clineno = 0; -static const char * __pyx_cfilenm= __FILE__; -static const char *__pyx_filename; - -/* Header.proto */ -#if !defined(CYTHON_CCOMPLEX) - #if defined(__cplusplus) - #define CYTHON_CCOMPLEX 1 - #elif defined(_Complex_I) - #define CYTHON_CCOMPLEX 1 - #else - #define CYTHON_CCOMPLEX 0 - #endif -#endif -#if CYTHON_CCOMPLEX - #ifdef __cplusplus - #include - #else - #include - #endif -#endif -#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) - #undef _Complex_I - #define _Complex_I 1.0fj -#endif - - -static const char *__pyx_f[] = { - "somsphere/cython/core.pyx", - "__init__.pxd", - "type.pxd", -}; - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":697 - * # in Cython to enable them only on the right systems. - * - * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< - * ctypedef npy_int16 int16_t - * ctypedef npy_int32 int32_t - */ -typedef npy_int8 __pyx_t_5numpy_int8_t; - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":698 - * - * ctypedef npy_int8 int8_t - * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< - * ctypedef npy_int32 int32_t - * ctypedef npy_int64 int64_t - */ -typedef npy_int16 __pyx_t_5numpy_int16_t; - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":699 - * ctypedef npy_int8 int8_t - * ctypedef npy_int16 int16_t - * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< - * ctypedef npy_int64 int64_t - * #ctypedef npy_int96 int96_t - */ -typedef npy_int32 __pyx_t_5numpy_int32_t; - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":700 - * ctypedef npy_int16 int16_t - * ctypedef npy_int32 int32_t - * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< - * #ctypedef npy_int96 int96_t - * #ctypedef npy_int128 int128_t - */ -typedef npy_int64 __pyx_t_5numpy_int64_t; - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":704 - * #ctypedef npy_int128 int128_t - * - * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< - * ctypedef npy_uint16 uint16_t - * ctypedef npy_uint32 uint32_t - */ -typedef npy_uint8 __pyx_t_5numpy_uint8_t; - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":705 - * - * ctypedef npy_uint8 uint8_t - * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< - * ctypedef npy_uint32 uint32_t - * ctypedef npy_uint64 uint64_t - */ -typedef npy_uint16 __pyx_t_5numpy_uint16_t; - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":706 - * ctypedef npy_uint8 uint8_t - * ctypedef npy_uint16 uint16_t - * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< - * ctypedef npy_uint64 uint64_t - * #ctypedef npy_uint96 uint96_t - */ -typedef npy_uint32 __pyx_t_5numpy_uint32_t; - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":707 - * ctypedef npy_uint16 uint16_t - * ctypedef npy_uint32 uint32_t - * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< - * #ctypedef npy_uint96 uint96_t - * #ctypedef npy_uint128 uint128_t - */ -typedef npy_uint64 __pyx_t_5numpy_uint64_t; - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":711 - * #ctypedef npy_uint128 uint128_t - * - * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< - * ctypedef npy_float64 float64_t - * #ctypedef npy_float80 float80_t - */ -typedef npy_float32 __pyx_t_5numpy_float32_t; - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":712 - * - * ctypedef npy_float32 float32_t - * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< - * #ctypedef npy_float80 float80_t - * #ctypedef npy_float128 float128_t - */ -typedef npy_float64 __pyx_t_5numpy_float64_t; - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":721 - * # The int types are mapped a bit surprising -- - * # numpy.int corresponds to 'l' and numpy.long to 'q' - * ctypedef npy_long int_t # <<<<<<<<<<<<<< - * ctypedef npy_longlong long_t - * ctypedef npy_longlong longlong_t - */ -typedef npy_long __pyx_t_5numpy_int_t; - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":722 - * # numpy.int corresponds to 'l' and numpy.long to 'q' - * ctypedef npy_long int_t - * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< - * ctypedef npy_longlong longlong_t - * - */ -typedef npy_longlong __pyx_t_5numpy_long_t; - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":723 - * ctypedef npy_long int_t - * ctypedef npy_longlong long_t - * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< - * - * ctypedef npy_ulong uint_t - */ -typedef npy_longlong __pyx_t_5numpy_longlong_t; - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":725 - * ctypedef npy_longlong longlong_t - * - * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< - * ctypedef npy_ulonglong ulong_t - * ctypedef npy_ulonglong ulonglong_t - */ -typedef npy_ulong __pyx_t_5numpy_uint_t; - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":726 - * - * ctypedef npy_ulong uint_t - * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< - * ctypedef npy_ulonglong ulonglong_t - * - */ -typedef npy_ulonglong __pyx_t_5numpy_ulong_t; - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":727 - * ctypedef npy_ulong uint_t - * ctypedef npy_ulonglong ulong_t - * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< - * - * ctypedef npy_intp intp_t - */ -typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":729 - * ctypedef npy_ulonglong ulonglong_t - * - * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< - * ctypedef npy_uintp uintp_t - * - */ -typedef npy_intp __pyx_t_5numpy_intp_t; - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":730 - * - * ctypedef npy_intp intp_t - * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< - * - * ctypedef npy_double float_t - */ -typedef npy_uintp __pyx_t_5numpy_uintp_t; - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":732 - * ctypedef npy_uintp uintp_t - * - * ctypedef npy_double float_t # <<<<<<<<<<<<<< - * ctypedef npy_double double_t - * ctypedef npy_longdouble longdouble_t - */ -typedef npy_double __pyx_t_5numpy_float_t; - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":733 - * - * ctypedef npy_double float_t - * ctypedef npy_double double_t # <<<<<<<<<<<<<< - * ctypedef npy_longdouble longdouble_t - * - */ -typedef npy_double __pyx_t_5numpy_double_t; - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":734 - * ctypedef npy_double float_t - * ctypedef npy_double double_t - * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< - * - * ctypedef npy_cfloat cfloat_t - */ -typedef npy_longdouble __pyx_t_5numpy_longdouble_t; - -/* "core.pyx":10 - * - * DTYPE = np.float - * ctypedef cnp.float_t DTYPE_t # <<<<<<<<<<<<<< - * # def create_map_batch(np.ndarray X, int n_iter, int n_row, int n_col, int n_pix, np.ndarray importance, - * # np.ndarray dist_lib, np.ndarray weights): - */ -typedef __pyx_t_5numpy_float_t __pyx_t_4core_DTYPE_t; -/* Declarations.proto */ -#if CYTHON_CCOMPLEX - #ifdef __cplusplus - typedef ::std::complex< float > __pyx_t_float_complex; - #else - typedef float _Complex __pyx_t_float_complex; - #endif -#else - typedef struct { float real, imag; } __pyx_t_float_complex; -#endif -static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); - -/* Declarations.proto */ -#if CYTHON_CCOMPLEX - #ifdef __cplusplus - typedef ::std::complex< double > __pyx_t_double_complex; - #else - typedef double _Complex __pyx_t_double_complex; - #endif -#else - typedef struct { double real, imag; } __pyx_t_double_complex; -#endif -static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); - - -/*--- Type declarations ---*/ - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":736 - * ctypedef npy_longdouble longdouble_t - * - * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< - * ctypedef npy_cdouble cdouble_t - * ctypedef npy_clongdouble clongdouble_t - */ -typedef npy_cfloat __pyx_t_5numpy_cfloat_t; - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":737 - * - * ctypedef npy_cfloat cfloat_t - * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< - * ctypedef npy_clongdouble clongdouble_t - * - */ -typedef npy_cdouble __pyx_t_5numpy_cdouble_t; - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":738 - * ctypedef npy_cfloat cfloat_t - * ctypedef npy_cdouble cdouble_t - * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< - * - * ctypedef npy_cdouble complex_t - */ -typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":740 - * ctypedef npy_clongdouble clongdouble_t - * - * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< - * - * cdef inline object PyArray_MultiIterNew1(a): - */ -typedef npy_cdouble __pyx_t_5numpy_complex_t; - -/* --- Runtime support code (head) --- */ -/* Refnanny.proto */ -#ifndef CYTHON_REFNANNY - #define CYTHON_REFNANNY 0 -#endif -#if CYTHON_REFNANNY - typedef struct { - void (*INCREF)(void*, PyObject*, int); - void (*DECREF)(void*, PyObject*, int); - void (*GOTREF)(void*, PyObject*, int); - void (*GIVEREF)(void*, PyObject*, int); - void* (*SetupContext)(const char*, int, const char*); - void (*FinishContext)(void**); - } __Pyx_RefNannyAPIStruct; - static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; - static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); - #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; -#ifdef WITH_THREAD - #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - if (acquire_gil) {\ - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ - PyGILState_Release(__pyx_gilstate_save);\ - } else {\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ - } -#else - #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) -#endif - #define __Pyx_RefNannyFinishContext()\ - __Pyx_RefNanny->FinishContext(&__pyx_refnanny) - #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) - #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) - #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) - #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) - #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) -#else - #define __Pyx_RefNannyDeclarations - #define __Pyx_RefNannySetupContext(name, acquire_gil) - #define __Pyx_RefNannyFinishContext() - #define __Pyx_INCREF(r) Py_INCREF(r) - #define __Pyx_DECREF(r) Py_DECREF(r) - #define __Pyx_GOTREF(r) - #define __Pyx_GIVEREF(r) - #define __Pyx_XINCREF(r) Py_XINCREF(r) - #define __Pyx_XDECREF(r) Py_XDECREF(r) - #define __Pyx_XGOTREF(r) - #define __Pyx_XGIVEREF(r) -#endif -#define __Pyx_XDECREF_SET(r, v) do {\ - PyObject *tmp = (PyObject *) r;\ - r = v; __Pyx_XDECREF(tmp);\ - } while (0) -#define __Pyx_DECREF_SET(r, v) do {\ - PyObject *tmp = (PyObject *) r;\ - r = v; __Pyx_DECREF(tmp);\ - } while (0) -#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) -#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) - -/* PyObjectGetAttrStr.proto */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) -#endif - -/* GetBuiltinName.proto */ -static PyObject *__Pyx_GetBuiltinName(PyObject *name); - -/* RaiseArgTupleInvalid.proto */ -static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, - Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); - -/* RaiseDoubleKeywords.proto */ -static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); - -/* ParseKeywords.proto */ -static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ - PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ - const char* function_name); - -/* PyDictVersioning.proto */ -#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS -#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) -#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) -#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ - (version_var) = __PYX_GET_DICT_VERSION(dict);\ - (cache_var) = (value); -#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ - static PY_UINT64_T __pyx_dict_version = 0;\ - static PyObject *__pyx_dict_cached_value = NULL;\ - if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ - (VAR) = __pyx_dict_cached_value;\ - } else {\ - (VAR) = __pyx_dict_cached_value = (LOOKUP);\ - __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ - }\ -} -static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); -static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); -static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); -#else -#define __PYX_GET_DICT_VERSION(dict) (0) -#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) -#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); -#endif - -/* GetModuleGlobalName.proto */ -#if CYTHON_USE_DICT_VERSIONS -#define __Pyx_GetModuleGlobalName(var, name) {\ - 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 - -/* PyFunctionFastCall.proto */ -#if CYTHON_FAST_PYCALL -#define __Pyx_PyFunction_FastCall(func, args, nargs)\ - __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) -#if 1 || PY_VERSION_HEX < 0x030600B1 -static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); -#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 - -/* PyCFunctionFastCall.proto */ -#if CYTHON_FAST_PYCCALL -static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); -#else -#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) -#endif - -/* PyObjectCall.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); -#else -#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) -#endif - -/* ArgTypeTest.proto */ -#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ - ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ - __Pyx__ArgTypeTest(obj, type, name, exact)) -static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); - -/* ExtTypeTest.proto */ -static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); - -/* 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); -#endif - -/* PyObjectCallOneArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); - -/* SliceObject.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice( - PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, - PyObject** py_start, PyObject** py_stop, PyObject** py_slice, - int has_cstart, int has_cstop, int wraparound); - -/* GetItemInt.proto */ -#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ - (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ - __Pyx_GetItemInt_Generic(o, to_py_func(i)))) -#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ - (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, - int wraparound, int boundscheck); -#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ - (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, - int wraparound, int boundscheck); -static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, - int is_list, int wraparound, int boundscheck); - -/* PyObjectCallNoArg.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); -#else -#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) -#endif - -/* ObjectGetItem.proto */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key); -#else -#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) -#endif - -/* RaiseTooManyValuesToUnpack.proto */ -static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); - -/* RaiseNeedMoreValuesToUnpack.proto */ -static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); - -/* IterFinish.proto */ -static CYTHON_INLINE int __Pyx_IterFinish(void); - -/* UnpackItemEndCheck.proto */ -static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); - -/* DictGetItem.proto */ -#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY -static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); -#define __Pyx_PyObject_Dict_GetItem(obj, name)\ - (likely(PyDict_CheckExact(obj)) ?\ - __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) -#else -#define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) -#define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) -#endif - -/* RaiseNoneIterError.proto */ -static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); - -/* PyThreadStateGet.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; -#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; -#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type -#else -#define __Pyx_PyThreadState_declare -#define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() PyErr_Occurred() -#endif - -/* PyErrFetchRestore.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) -#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) -#else -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#endif -#else -#define __Pyx_PyErr_Clear() PyErr_Clear() -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) -#endif - -/* RaiseException.proto */ -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); - -/* 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) -static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); -#else -#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) -#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) -#endif - -/* PyErrExceptionMatches.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) -static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); -#else -#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) -#endif - -/* GetException.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) -static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#else -static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); -#endif - -/* TypeImport.proto */ -#ifndef __PYX_HAVE_RT_ImportType_proto -#define __PYX_HAVE_RT_ImportType_proto -enum __Pyx_ImportType_CheckSize { - __Pyx_ImportType_CheckSize_Error = 0, - __Pyx_ImportType_CheckSize_Warn = 1, - __Pyx_ImportType_CheckSize_Ignore = 2 -}; -static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); -#endif - -/* Import.proto */ -static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); - -/* ImportFrom.proto */ -static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); - -/* CLineInTraceback.proto */ -#ifdef CYTHON_CLINE_IN_TRACEBACK -#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) -#else -static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); -#endif - -/* CodeObjectCache.proto */ -typedef struct { - PyCodeObject* code_object; - int code_line; -} __Pyx_CodeObjectCacheEntry; -struct __Pyx_CodeObjectCache { - int count; - int max_count; - __Pyx_CodeObjectCacheEntry* entries; -}; -static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; -static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); -static PyCodeObject *__pyx_find_code_object(int code_line); -static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); - -/* AddTraceback.proto */ -static void __Pyx_AddTraceback(const char *funcname, int c_line, - int py_line, const char *filename); - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); - -/* RealImag.proto */ -#if CYTHON_CCOMPLEX - #ifdef __cplusplus - #define __Pyx_CREAL(z) ((z).real()) - #define __Pyx_CIMAG(z) ((z).imag()) - #else - #define __Pyx_CREAL(z) (__real__(z)) - #define __Pyx_CIMAG(z) (__imag__(z)) - #endif -#else - #define __Pyx_CREAL(z) ((z).real) - #define __Pyx_CIMAG(z) ((z).imag) -#endif -#if defined(__cplusplus) && CYTHON_CCOMPLEX\ - && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103) - #define __Pyx_SET_CREAL(z,x) ((z).real(x)) - #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) -#else - #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) - #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) -#endif - -/* Arithmetic.proto */ -#if CYTHON_CCOMPLEX - #define __Pyx_c_eq_float(a, b) ((a)==(b)) - #define __Pyx_c_sum_float(a, b) ((a)+(b)) - #define __Pyx_c_diff_float(a, b) ((a)-(b)) - #define __Pyx_c_prod_float(a, b) ((a)*(b)) - #define __Pyx_c_quot_float(a, b) ((a)/(b)) - #define __Pyx_c_neg_float(a) (-(a)) - #ifdef __cplusplus - #define __Pyx_c_is_zero_float(z) ((z)==(float)0) - #define __Pyx_c_conj_float(z) (::std::conj(z)) - #if 1 - #define __Pyx_c_abs_float(z) (::std::abs(z)) - #define __Pyx_c_pow_float(a, b) (::std::pow(a, b)) - #endif - #else - #define __Pyx_c_is_zero_float(z) ((z)==0) - #define __Pyx_c_conj_float(z) (conjf(z)) - #if 1 - #define __Pyx_c_abs_float(z) (cabsf(z)) - #define __Pyx_c_pow_float(a, b) (cpowf(a, b)) - #endif - #endif -#else - static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex); - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex); - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex); - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex); - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex); - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex); - static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex); - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex); - #if 1 - static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex); - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex); - #endif -#endif - -/* Arithmetic.proto */ -#if CYTHON_CCOMPLEX - #define __Pyx_c_eq_double(a, b) ((a)==(b)) - #define __Pyx_c_sum_double(a, b) ((a)+(b)) - #define __Pyx_c_diff_double(a, b) ((a)-(b)) - #define __Pyx_c_prod_double(a, b) ((a)*(b)) - #define __Pyx_c_quot_double(a, b) ((a)/(b)) - #define __Pyx_c_neg_double(a) (-(a)) - #ifdef __cplusplus - #define __Pyx_c_is_zero_double(z) ((z)==(double)0) - #define __Pyx_c_conj_double(z) (::std::conj(z)) - #if 1 - #define __Pyx_c_abs_double(z) (::std::abs(z)) - #define __Pyx_c_pow_double(a, b) (::std::pow(a, b)) - #endif - #else - #define __Pyx_c_is_zero_double(z) ((z)==0) - #define __Pyx_c_conj_double(z) (conj(z)) - #if 1 - #define __Pyx_c_abs_double(z) (cabs(z)) - #define __Pyx_c_pow_double(a, b) (cpow(a, b)) - #endif - #endif -#else - static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex); - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex); - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex); - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex); - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex); - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex); - static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex); - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex); - #if 1 - static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex); - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex); - #endif -#endif - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value); - -/* CIntFromPy.proto */ -static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); - -/* CIntFromPy.proto */ -static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); - -/* FastTypeChecks.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) -static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); -static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); -static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); -#else -#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) -#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) -#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) -#endif -#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) - -/* CheckBinaryVersion.proto */ -static int __Pyx_check_binary_version(void); - -/* InitStrings.proto */ -static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); - - -/* Module declarations from 'cpython.buffer' */ - -/* Module declarations from 'libc.string' */ - -/* Module declarations from 'libc.stdio' */ - -/* Module declarations from '__builtin__' */ - -/* Module declarations from 'cpython.type' */ -static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; - -/* Module declarations from 'cpython' */ - -/* Module declarations from 'cpython.object' */ - -/* Module declarations from 'cpython.ref' */ - -/* Module declarations from 'cpython.mem' */ - -/* Module declarations from 'numpy' */ - -/* Module declarations from 'numpy' */ -static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; -static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; -static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; -static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; -static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; -static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/ - -/* Module declarations from 'core' */ -#define __Pyx_MODULE_NAME "core" -extern int __pyx_module_is_main_core; -int __pyx_module_is_main_core = 0; - -/* Implementation of 'core' */ -static PyObject *__pyx_builtin_range; -static PyObject *__pyx_builtin_RuntimeError; -static PyObject *__pyx_builtin_ValueError; -static PyObject *__pyx_builtin_ImportError; -static const char __pyx_k_X[] = "X"; -static const char __pyx_k_i[] = "i"; -static const char __pyx_k_t[] = "t"; -static const char __pyx_k_it[] = "it"; -static const char __pyx_k_np[] = "np"; -static const char __pyx_k_bmu[] = "bmu"; -static const char __pyx_k_exp[] = "exp"; -static const char __pyx_k_max[] = "max"; -static const char __pyx_k_min[] = "min"; -static const char __pyx_k_sum[] = "sum"; -static const char __pyx_k_axis[] = "axis"; -static const char __pyx_k_best[] = "best"; -static const char __pyx_k_core[] = "core"; -static const char __pyx_k_main[] = "__main__"; -static const char __pyx_k_name[] = "__name__"; -static const char __pyx_k_test[] = "__test__"; -static const char __pyx_k_tile[] = "tile"; -static const char __pyx_k_DTYPE[] = "DTYPE"; -static const char __pyx_k_alpha[] = "alpha"; -static const char __pyx_k_dtype[] = "dtype"; -static const char __pyx_k_float[] = "float"; -static const char __pyx_k_map_d[] = "map_d"; -static const char __pyx_k_n_col[] = "n_col"; -static const char __pyx_k_n_pix[] = "n_pix"; -static const char __pyx_k_n_row[] = "n_row"; -static const char __pyx_k_numpy[] = "numpy"; -static const char __pyx_k_power[] = "power"; -static const char __pyx_k_range[] = "range"; -static const char __pyx_k_sigma[] = "sigma"; -static const char __pyx_k_where[] = "where"; -static const char __pyx_k_zeros[] = "zeros"; -static const char __pyx_k_arange[] = "arange"; -static const char __pyx_k_argmin[] = "argmin"; -static const char __pyx_k_curr_t[] = "curr_t"; -static const char __pyx_k_import[] = "__import__"; -static const char __pyx_k_inputs[] = "inputs"; -static const char __pyx_k_n_iter[] = "n_iter"; -static const char __pyx_k_random[] = "random"; -static const char __pyx_k_sample[] = "sample"; -static const char __pyx_k_timeit[] = "timeit"; -static const char __pyx_k_argsort[] = "argsort"; -static const char __pyx_k_sigma_0[] = "sigma_0"; -static const char __pyx_k_sigma_f[] = "sigma_f"; -static const char __pyx_k_total_t[] = "total_t"; -static const char __pyx_k_weights[] = "weights"; -static const char __pyx_k_dist_lib[] = "dist_lib"; -static const char __pyx_k_alpha_end[] = "alpha_end"; -static const char __pyx_k_get_alpha[] = "get_alpha"; -static const char __pyx_k_get_sigma[] = "get_sigma"; -static const char __pyx_k_transpose[] = "transpose"; -static const char __pyx_k_ValueError[] = "ValueError"; -static const char __pyx_k_activation[] = "activation"; -static const char __pyx_k_importance[] = "importance"; -static const char __pyx_k_ImportError[] = "ImportError"; -static const char __pyx_k_activations[] = "activations"; -static const char __pyx_k_alpha_start[] = "alpha_start"; -static const char __pyx_k_return_vals[] = "return_vals"; -static const char __pyx_k_RuntimeError[] = "RuntimeError"; -static const char __pyx_k_random_order[] = "random_order"; -static const char __pyx_k_get_best_cell[] = "get_best_cell"; -static const char __pyx_k_random_indices[] = "random_indices"; -static const char __pyx_k_somsphere_utils[] = "somsphere.utils"; -static const char __pyx_k_create_map_online[] = "create_map_online"; -static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; -static const char __pyx_k_count_modified_cells[] = "count_modified_cells"; -static const char __pyx_k_somsphere_cython_core_pyx[] = "somsphere/cython/core.pyx"; -static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import"; -static const char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)"; -static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd"; -static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported"; -static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; -static const char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short."; -static PyObject *__pyx_n_s_DTYPE; -static PyObject *__pyx_kp_u_Format_string_allocated_too_shor; -static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2; -static PyObject *__pyx_n_s_ImportError; -static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor; -static PyObject *__pyx_n_s_RuntimeError; -static PyObject *__pyx_n_s_ValueError; -static PyObject *__pyx_n_s_X; -static PyObject *__pyx_n_s_activation; -static PyObject *__pyx_n_s_activations; -static PyObject *__pyx_n_s_alpha; -static PyObject *__pyx_n_s_alpha_end; -static PyObject *__pyx_n_s_alpha_start; -static PyObject *__pyx_n_s_arange; -static PyObject *__pyx_n_s_argmin; -static PyObject *__pyx_n_s_argsort; -static PyObject *__pyx_n_s_axis; -static PyObject *__pyx_n_s_best; -static PyObject *__pyx_n_s_bmu; -static PyObject *__pyx_n_s_cline_in_traceback; -static PyObject *__pyx_n_s_core; -static PyObject *__pyx_n_s_count_modified_cells; -static PyObject *__pyx_n_s_create_map_online; -static PyObject *__pyx_n_s_curr_t; -static PyObject *__pyx_n_s_dist_lib; -static PyObject *__pyx_n_s_dtype; -static PyObject *__pyx_n_s_exp; -static PyObject *__pyx_n_s_float; -static PyObject *__pyx_n_s_get_alpha; -static PyObject *__pyx_n_s_get_best_cell; -static PyObject *__pyx_n_s_get_sigma; -static PyObject *__pyx_n_s_i; -static PyObject *__pyx_n_s_import; -static PyObject *__pyx_n_s_importance; -static PyObject *__pyx_n_s_inputs; -static PyObject *__pyx_n_s_it; -static PyObject *__pyx_n_s_main; -static PyObject *__pyx_n_s_map_d; -static PyObject *__pyx_n_s_max; -static PyObject *__pyx_n_s_min; -static PyObject *__pyx_n_s_n_col; -static PyObject *__pyx_n_s_n_iter; -static PyObject *__pyx_n_s_n_pix; -static PyObject *__pyx_n_s_n_row; -static PyObject *__pyx_n_s_name; -static PyObject *__pyx_n_s_np; -static PyObject *__pyx_n_s_numpy; -static PyObject *__pyx_kp_u_numpy_core_multiarray_failed_to; -static PyObject *__pyx_kp_u_numpy_core_umath_failed_to_impor; -static PyObject *__pyx_n_s_power; -static PyObject *__pyx_n_s_random; -static PyObject *__pyx_n_s_random_indices; -static PyObject *__pyx_n_s_random_order; -static PyObject *__pyx_n_s_range; -static PyObject *__pyx_n_s_return_vals; -static PyObject *__pyx_n_s_sample; -static PyObject *__pyx_n_s_sigma; -static PyObject *__pyx_n_s_sigma_0; -static PyObject *__pyx_n_s_sigma_f; -static PyObject *__pyx_kp_s_somsphere_cython_core_pyx; -static PyObject *__pyx_n_s_somsphere_utils; -static PyObject *__pyx_n_s_sum; -static PyObject *__pyx_n_s_t; -static PyObject *__pyx_n_s_test; -static PyObject *__pyx_n_s_tile; -static PyObject *__pyx_n_s_timeit; -static PyObject *__pyx_n_s_total_t; -static PyObject *__pyx_n_s_transpose; -static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd; -static PyObject *__pyx_n_s_weights; -static PyObject *__pyx_n_s_where; -static PyObject *__pyx_n_s_zeros; -static PyObject *__pyx_pf_4core_get_alpha(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_alpha_end, float __pyx_v_alpha_start, int __pyx_v_curr_t, int __pyx_v_total_t); /* proto */ -static PyObject *__pyx_pf_4core_2get_sigma(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_sigma_f, float __pyx_v_sigma_0, int __pyx_v_curr_t, int __pyx_v_total_t); /* proto */ -static PyObject *__pyx_pf_4core_4get_best_cell(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_inputs, PyArrayObject *__pyx_v_importance, int __pyx_v_n_pix, PyArrayObject *__pyx_v_weights, int __pyx_v_return_vals); /* proto */ -static PyObject *__pyx_pf_4core_6count_modified_cells(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_bmu, PyArrayObject *__pyx_v_map_d, float __pyx_v_sigma); /* proto */ -static PyObject *__pyx_pf_4core_8create_map_online(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_X, int __pyx_v_n_iter, int __pyx_v_n_row, int __pyx_v_n_col, int __pyx_v_n_pix, float __pyx_v_alpha_start, float __pyx_v_alpha_end, PyArrayObject *__pyx_v_importance, PyArrayObject *__pyx_v_dist_lib, PyArrayObject *__pyx_v_weights, int __pyx_v_random_order); /* proto */ -static PyObject *__pyx_float_0_; -static PyObject *__pyx_int_0; -static PyObject *__pyx_int_1; -static PyObject *__pyx_int_2; -static PyObject *__pyx_tuple_; -static PyObject *__pyx_tuple__2; -static PyObject *__pyx_tuple__3; -static PyObject *__pyx_tuple__4; -static PyObject *__pyx_tuple__5; -static PyObject *__pyx_tuple__6; -static PyObject *__pyx_tuple__8; -static PyObject *__pyx_tuple__10; -static PyObject *__pyx_tuple__12; -static PyObject *__pyx_tuple__14; -static PyObject *__pyx_codeobj__7; -static PyObject *__pyx_codeobj__9; -static PyObject *__pyx_codeobj__11; -static PyObject *__pyx_codeobj__13; -static PyObject *__pyx_codeobj__15; -/* Late includes */ - -/* "core.pyx":38 - * # - * # t += n_row - * def get_alpha(float alpha_end, float alpha_start, int curr_t, int total_t): # <<<<<<<<<<<<<< - * """ - * Get value of alpha at a given time - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_4core_1get_alpha(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_4core_get_alpha[] = "\n Get value of alpha at a given time\n "; -static PyMethodDef __pyx_mdef_4core_1get_alpha = {"get_alpha", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_1get_alpha, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4core_get_alpha}; -static PyObject *__pyx_pw_4core_1get_alpha(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - float __pyx_v_alpha_end; - float __pyx_v_alpha_start; - int __pyx_v_curr_t; - int __pyx_v_total_t; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("get_alpha (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_alpha_end,&__pyx_n_s_alpha_start,&__pyx_n_s_curr_t,&__pyx_n_s_total_t,0}; - PyObject* values[4] = {0,0,0,0}; - if (unlikely(__pyx_kwds)) { - Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { - case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha_end)) != 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_alpha_start)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("get_alpha", 1, 4, 4, 1); __PYX_ERR(0, 38, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_curr_t)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("get_alpha", 1, 4, 4, 2); __PYX_ERR(0, 38, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_total_t)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("get_alpha", 1, 4, 4, 3); __PYX_ERR(0, 38, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_alpha") < 0)) __PYX_ERR(0, 38, __pyx_L3_error) - } - } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - values[2] = PyTuple_GET_ITEM(__pyx_args, 2); - values[3] = PyTuple_GET_ITEM(__pyx_args, 3); - } - __pyx_v_alpha_end = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_alpha_end == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L3_error) - __pyx_v_alpha_start = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_alpha_start == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L3_error) - __pyx_v_curr_t = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_curr_t == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L3_error) - __pyx_v_total_t = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_total_t == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L3_error) - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("get_alpha", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 38, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("core.get_alpha", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_4core_get_alpha(__pyx_self, __pyx_v_alpha_end, __pyx_v_alpha_start, __pyx_v_curr_t, __pyx_v_total_t); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_4core_get_alpha(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_alpha_end, float __pyx_v_alpha_start, int __pyx_v_curr_t, int __pyx_v_total_t) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - int __pyx_t_7; - PyObject *__pyx_t_8 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_alpha", 0); - - /* "core.pyx":42 - * Get value of alpha at a given time - * """ - * return alpha_start * np.power(alpha_end / alpha_start, float(curr_t) / float(total_t)) # <<<<<<<<<<<<<< - * - * def get_sigma(float sigma_f, float sigma_0, int curr_t, int total_t): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_alpha_start); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 42, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_power); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 42, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(__pyx_v_alpha_start == 0)) { - PyErr_SetString(PyExc_ZeroDivisionError, "float division"); - __PYX_ERR(0, 42, __pyx_L1_error) - } - __pyx_t_3 = PyFloat_FromDouble((__pyx_v_alpha_end / __pyx_v_alpha_start)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 42, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (unlikely(((double)__pyx_v_total_t) == 0)) { - PyErr_SetString(PyExc_ZeroDivisionError, "float division"); - __PYX_ERR(0, 42, __pyx_L1_error) - } - __pyx_t_5 = PyFloat_FromDouble((((double)__pyx_v_curr_t) / ((double)__pyx_v_total_t))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 42, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = NULL; - __pyx_t_7 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_6)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_7 = 1; - } - } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_4)) { - PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_t_5}; - __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { - PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_t_5}; - __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } else - #endif - { - __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 42, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - if (__pyx_t_6) { - __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; - } - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_3); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_5); - __pyx_t_3 = 0; - __pyx_t_5 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - } - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 42, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; - goto __pyx_L0; - - /* "core.pyx":38 - * # - * # t += n_row - * def get_alpha(float alpha_end, float alpha_start, int curr_t, int total_t): # <<<<<<<<<<<<<< - * """ - * Get value of alpha at a given time - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("core.get_alpha", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "core.pyx":44 - * return alpha_start * np.power(alpha_end / alpha_start, float(curr_t) / float(total_t)) - * - * def get_sigma(float sigma_f, float sigma_0, int curr_t, int total_t): # <<<<<<<<<<<<<< - * """ - * Get value of sigma at a given time - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_4core_3get_sigma(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_4core_2get_sigma[] = "\n Get value of sigma at a given time\n "; -static PyMethodDef __pyx_mdef_4core_3get_sigma = {"get_sigma", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_3get_sigma, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4core_2get_sigma}; -static PyObject *__pyx_pw_4core_3get_sigma(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - float __pyx_v_sigma_f; - float __pyx_v_sigma_0; - int __pyx_v_curr_t; - int __pyx_v_total_t; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("get_sigma (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sigma_f,&__pyx_n_s_sigma_0,&__pyx_n_s_curr_t,&__pyx_n_s_total_t,0}; - PyObject* values[4] = {0,0,0,0}; - if (unlikely(__pyx_kwds)) { - Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { - case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sigma_f)) != 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_sigma_0)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("get_sigma", 1, 4, 4, 1); __PYX_ERR(0, 44, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_curr_t)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("get_sigma", 1, 4, 4, 2); __PYX_ERR(0, 44, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_total_t)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("get_sigma", 1, 4, 4, 3); __PYX_ERR(0, 44, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_sigma") < 0)) __PYX_ERR(0, 44, __pyx_L3_error) - } - } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - values[2] = PyTuple_GET_ITEM(__pyx_args, 2); - values[3] = PyTuple_GET_ITEM(__pyx_args, 3); - } - __pyx_v_sigma_f = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_sigma_f == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 44, __pyx_L3_error) - __pyx_v_sigma_0 = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_sigma_0 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 44, __pyx_L3_error) - __pyx_v_curr_t = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_curr_t == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 44, __pyx_L3_error) - __pyx_v_total_t = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_total_t == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 44, __pyx_L3_error) - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("get_sigma", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 44, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("core.get_sigma", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_4core_2get_sigma(__pyx_self, __pyx_v_sigma_f, __pyx_v_sigma_0, __pyx_v_curr_t, __pyx_v_total_t); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_4core_2get_sigma(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_sigma_f, float __pyx_v_sigma_0, int __pyx_v_curr_t, int __pyx_v_total_t) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - int __pyx_t_7; - PyObject *__pyx_t_8 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_sigma", 0); - - /* "core.pyx":48 - * Get value of sigma at a given time - * """ - * return sigma_0 * np.power(sigma_f / sigma_0, float(curr_t) / float(total_t)) # <<<<<<<<<<<<<< - * - * @timeit - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyFloat_FromDouble(__pyx_v_sigma_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 48, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 48, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_power); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 48, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(__pyx_v_sigma_0 == 0)) { - PyErr_SetString(PyExc_ZeroDivisionError, "float division"); - __PYX_ERR(0, 48, __pyx_L1_error) - } - __pyx_t_3 = PyFloat_FromDouble((__pyx_v_sigma_f / __pyx_v_sigma_0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 48, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (unlikely(((double)__pyx_v_total_t) == 0)) { - PyErr_SetString(PyExc_ZeroDivisionError, "float division"); - __PYX_ERR(0, 48, __pyx_L1_error) - } - __pyx_t_5 = PyFloat_FromDouble((((double)__pyx_v_curr_t) / ((double)__pyx_v_total_t))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 48, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = NULL; - __pyx_t_7 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_6)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_7 = 1; - } - } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_4)) { - PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_t_5}; - __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 48, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { - PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_t_5}; - __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 48, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } else - #endif - { - __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 48, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - if (__pyx_t_6) { - __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; - } - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_3); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_5); - __pyx_t_3 = 0; - __pyx_t_5 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 48, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - } - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 48, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_r = __pyx_t_4; - __pyx_t_4 = 0; - goto __pyx_L0; - - /* "core.pyx":44 - * return alpha_start * np.power(alpha_end / alpha_start, float(curr_t) / float(total_t)) - * - * def get_sigma(float sigma_f, float sigma_0, int curr_t, int total_t): # <<<<<<<<<<<<<< - * """ - * Get value of sigma at a given time - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("core.get_sigma", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "core.pyx":51 - * - * @timeit - * def get_best_cell(cnp.ndarray inputs, cnp.ndarray importance, int n_pix, cnp.ndarray weights, int return_vals): # <<<<<<<<<<<<<< - * """ - * Return the closest cell to the input object - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_4core_5get_best_cell(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_4core_4get_best_cell[] = "\n Return the closest cell to the input object\n It can return more than one value if needed\n "; -static PyMethodDef __pyx_mdef_4core_5get_best_cell = {"get_best_cell", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_5get_best_cell, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4core_4get_best_cell}; -static PyObject *__pyx_pw_4core_5get_best_cell(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyArrayObject *__pyx_v_inputs = 0; - PyArrayObject *__pyx_v_importance = 0; - int __pyx_v_n_pix; - PyArrayObject *__pyx_v_weights = 0; - int __pyx_v_return_vals; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("get_best_cell (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_inputs,&__pyx_n_s_importance,&__pyx_n_s_n_pix,&__pyx_n_s_weights,&__pyx_n_s_return_vals,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); - 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_inputs)) != 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_importance)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("get_best_cell", 1, 5, 5, 1); __PYX_ERR(0, 51, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_pix)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("get_best_cell", 1, 5, 5, 2); __PYX_ERR(0, 51, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_weights)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("get_best_cell", 1, 5, 5, 3); __PYX_ERR(0, 51, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_return_vals)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("get_best_cell", 1, 5, 5, 4); __PYX_ERR(0, 51, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_best_cell") < 0)) __PYX_ERR(0, 51, __pyx_L3_error) - } - } 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_inputs = ((PyArrayObject *)values[0]); - __pyx_v_importance = ((PyArrayObject *)values[1]); - __pyx_v_n_pix = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_n_pix == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 51, __pyx_L3_error) - __pyx_v_weights = ((PyArrayObject *)values[3]); - __pyx_v_return_vals = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_return_vals == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 51, __pyx_L3_error) - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("get_best_cell", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 51, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("core.get_best_cell", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_inputs), __pyx_ptype_5numpy_ndarray, 1, "inputs", 0))) __PYX_ERR(0, 51, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_importance), __pyx_ptype_5numpy_ndarray, 1, "importance", 0))) __PYX_ERR(0, 51, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_weights), __pyx_ptype_5numpy_ndarray, 1, "weights", 0))) __PYX_ERR(0, 51, __pyx_L1_error) - __pyx_r = __pyx_pf_4core_4get_best_cell(__pyx_self, __pyx_v_inputs, __pyx_v_importance, __pyx_v_n_pix, __pyx_v_weights, __pyx_v_return_vals); - - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __pyx_r = NULL; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_4core_4get_best_cell(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_inputs, PyArrayObject *__pyx_v_importance, int __pyx_v_n_pix, PyArrayObject *__pyx_v_weights, int __pyx_v_return_vals) { - CYTHON_UNUSED PyArrayObject *__pyx_v_activation = 0; - PyObject *__pyx_v_activations = NULL; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - int __pyx_t_9; - PyObject *__pyx_t_10 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_best_cell", 0); - - /* "core.pyx":56 - * It can return more than one value if needed - * """ - * cdef cnp.ndarray activation = np.zeros([n_pix, 1], dtype=DTYPE) # <<<<<<<<<<<<<< - * - * activations = np.sum(np.transpose([importance]) * (np.transpose(np.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0) - */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 56, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_pix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = PyList_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 56, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_1); - PyList_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); - __Pyx_INCREF(__pyx_int_1); - __Pyx_GIVEREF(__pyx_int_1); - PyList_SET_ITEM(__pyx_t_3, 1, __pyx_int_1); - __pyx_t_1 = 0; - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 56, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_DTYPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 56, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(0, 56, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 56, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 56, __pyx_L1_error) - __pyx_v_activation = ((PyArrayObject *)__pyx_t_4); - __pyx_t_4 = 0; - - /* "core.pyx":58 - * cdef cnp.ndarray activation = np.zeros([n_pix, 1], dtype=DTYPE) - * - * activations = np.sum(np.transpose([importance]) * (np.transpose(np.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0) # <<<<<<<<<<<<<< - * - * return np.argmin(activations) if return_vals == 1 else np.argsort(activations)[0:return_vals], activations - */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_sum); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_transpose); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)__pyx_v_importance)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_importance)); - PyList_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_importance)); - __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } - } - __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_transpose); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_tile); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_n_pix); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); - __Pyx_INCREF(__pyx_int_1); - __Pyx_GIVEREF(__pyx_int_1); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_int_1); - __pyx_t_6 = 0; - __pyx_t_6 = NULL; - __pyx_t_9 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_6)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_6); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); - __pyx_t_9 = 1; - } - } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_7)) { - PyObject *__pyx_temp[3] = {__pyx_t_6, ((PyObject *)__pyx_v_inputs), __pyx_t_8}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { - PyObject *__pyx_temp[3] = {__pyx_t_6, ((PyObject *)__pyx_v_inputs), __pyx_t_8}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - } else - #endif - { - __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_10); - if (__pyx_t_6) { - __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_6); __pyx_t_6 = NULL; - } - __Pyx_INCREF(((PyObject *)__pyx_v_inputs)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_inputs)); - PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, ((PyObject *)__pyx_v_inputs)); - __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_8); - __pyx_t_8 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - } - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - } - } - __pyx_t_2 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_1); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = PyNumber_Subtract(__pyx_t_2, ((PyObject *)__pyx_v_weights)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyNumber_Power(__pyx_t_5, __pyx_int_2, Py_None); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = PyNumber_Multiply(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5); - __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_axis, __pyx_int_0) < 0) __PYX_ERR(0, 58, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_v_activations = __pyx_t_4; - __pyx_t_4 = 0; - - /* "core.pyx":60 - * activations = np.sum(np.transpose([importance]) * (np.transpose(np.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0) - * - * return np.argmin(activations) if return_vals == 1 else np.argsort(activations)[0:return_vals], activations # <<<<<<<<<<<<<< - * - * def count_modified_cells(int bmu, cnp.ndarray map_d, float sigma): - */ - __Pyx_XDECREF(__pyx_r); - if (((__pyx_v_return_vals == 1) != 0)) { - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_argmin); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 60, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - } - } - __pyx_t_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_v_activations) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_activations); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 60, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_4 = __pyx_t_5; - __pyx_t_5 = 0; - } else { - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 60, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_argsort); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } - } - __pyx_t_5 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_activations) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_activations); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 60, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetSlice(__pyx_t_5, 0, __pyx_v_return_vals, NULL, NULL, NULL, 1, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_4 = __pyx_t_2; - __pyx_t_2 = 0; - } - __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); - __Pyx_INCREF(__pyx_v_activations); - __Pyx_GIVEREF(__pyx_v_activations); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_activations); - __pyx_t_4 = 0; - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - goto __pyx_L0; - - /* "core.pyx":51 - * - * @timeit - * def get_best_cell(cnp.ndarray inputs, cnp.ndarray importance, int n_pix, cnp.ndarray weights, int return_vals): # <<<<<<<<<<<<<< - * """ - * Return the closest cell to the input object - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_10); - __Pyx_AddTraceback("core.get_best_cell", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_activation); - __Pyx_XDECREF(__pyx_v_activations); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "core.pyx":62 - * return np.argmin(activations) if return_vals == 1 else np.argsort(activations)[0:return_vals], activations - * - * def count_modified_cells(int bmu, cnp.ndarray map_d, float sigma): # <<<<<<<<<<<<<< - * """ - * Neighborhood function which quantifies how much cells around the best matching one are modified - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_4core_7count_modified_cells(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_4core_6count_modified_cells[] = "\n Neighborhood function which quantifies how much cells around the best matching one are modified\n\n :param int bmu: best matching unit\n :param nparray map_d: array of distances computed with :func:`geometry`\n "; -static PyMethodDef __pyx_mdef_4core_7count_modified_cells = {"count_modified_cells", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_7count_modified_cells, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4core_6count_modified_cells}; -static PyObject *__pyx_pw_4core_7count_modified_cells(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - int __pyx_v_bmu; - PyArrayObject *__pyx_v_map_d = 0; - float __pyx_v_sigma; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("count_modified_cells (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_bmu,&__pyx_n_s_map_d,&__pyx_n_s_sigma,0}; - PyObject* values[3] = {0,0,0}; - if (unlikely(__pyx_kwds)) { - Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { - case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bmu)) != 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_map_d)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("count_modified_cells", 1, 3, 3, 1); __PYX_ERR(0, 62, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sigma)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("count_modified_cells", 1, 3, 3, 2); __PYX_ERR(0, 62, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "count_modified_cells") < 0)) __PYX_ERR(0, 62, __pyx_L3_error) - } - } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - values[2] = PyTuple_GET_ITEM(__pyx_args, 2); - } - __pyx_v_bmu = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_bmu == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 62, __pyx_L3_error) - __pyx_v_map_d = ((PyArrayObject *)values[1]); - __pyx_v_sigma = __pyx_PyFloat_AsFloat(values[2]); if (unlikely((__pyx_v_sigma == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 62, __pyx_L3_error) - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("count_modified_cells", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 62, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("core.count_modified_cells", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_map_d), __pyx_ptype_5numpy_ndarray, 1, "map_d", 0))) __PYX_ERR(0, 62, __pyx_L1_error) - __pyx_r = __pyx_pf_4core_6count_modified_cells(__pyx_self, __pyx_v_bmu, __pyx_v_map_d, __pyx_v_sigma); - - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __pyx_r = NULL; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_4core_6count_modified_cells(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_bmu, PyArrayObject *__pyx_v_map_d, float __pyx_v_sigma) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("count_modified_cells", 0); - - /* "core.pyx":69 - * :param nparray map_d: array of distances computed with :func:`geometry` - * """ - * return np.exp(-(map_d[bmu] ** 2) / sigma ** 2) # <<<<<<<<<<<<<< - * - * def create_map_online(cnp.ndarray X, int n_iter, int n_row, int n_col, int n_pix, float alpha_start, float alpha_end, - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_exp); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 69, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_map_d), __pyx_v_bmu, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = PyNumber_Power(__pyx_t_2, __pyx_int_2, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 69, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyNumber_Negative(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyFloat_FromDouble(powf(__pyx_v_sigma, 2.0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 69, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 69, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - } - } - __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 69, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "core.pyx":62 - * return np.argmin(activations) if return_vals == 1 else np.argsort(activations)[0:return_vals], activations - * - * def count_modified_cells(int bmu, cnp.ndarray map_d, float sigma): # <<<<<<<<<<<<<< - * """ - * Neighborhood function which quantifies how much cells around the best matching one are modified - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("core.count_modified_cells", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "core.pyx":71 - * return np.exp(-(map_d[bmu] ** 2) / sigma ** 2) - * - * def create_map_online(cnp.ndarray X, int n_iter, int n_row, int n_col, int n_pix, float alpha_start, float alpha_end, # <<<<<<<<<<<<<< - * cnp.ndarray importance, cnp.ndarray dist_lib, cnp.ndarray weights, bint random_order): - * cdef int t = 0 - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_4core_9create_map_online(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyMethodDef __pyx_mdef_4core_9create_map_online = {"create_map_online", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_9create_map_online, METH_VARARGS|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_4core_9create_map_online(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyArrayObject *__pyx_v_X = 0; - int __pyx_v_n_iter; - int __pyx_v_n_row; - int __pyx_v_n_col; - int __pyx_v_n_pix; - float __pyx_v_alpha_start; - float __pyx_v_alpha_end; - PyArrayObject *__pyx_v_importance = 0; - PyArrayObject *__pyx_v_dist_lib = 0; - PyArrayObject *__pyx_v_weights = 0; - int __pyx_v_random_order; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("create_map_online (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_X,&__pyx_n_s_n_iter,&__pyx_n_s_n_row,&__pyx_n_s_n_col,&__pyx_n_s_n_pix,&__pyx_n_s_alpha_start,&__pyx_n_s_alpha_end,&__pyx_n_s_importance,&__pyx_n_s_dist_lib,&__pyx_n_s_weights,&__pyx_n_s_random_order,0}; - PyObject* values[11] = {0,0,0,0,0,0,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 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10); - CYTHON_FALLTHROUGH; - case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9); - CYTHON_FALLTHROUGH; - case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); - CYTHON_FALLTHROUGH; - case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); - CYTHON_FALLTHROUGH; - case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); - CYTHON_FALLTHROUGH; - case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); - CYTHON_FALLTHROUGH; - 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_X)) != 0)) kw_args--; - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_iter)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 1); __PYX_ERR(0, 71, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_row)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 2); __PYX_ERR(0, 71, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 3: - if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_col)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 3); __PYX_ERR(0, 71, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 4: - if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_pix)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 4); __PYX_ERR(0, 71, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 5: - if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha_start)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 5); __PYX_ERR(0, 71, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 6: - if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha_end)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 6); __PYX_ERR(0, 71, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 7: - if (likely((values[7] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_importance)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 7); __PYX_ERR(0, 71, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 8: - if (likely((values[8] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dist_lib)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 8); __PYX_ERR(0, 71, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 9: - if (likely((values[9] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_weights)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 9); __PYX_ERR(0, 71, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 10: - if (likely((values[10] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_random_order)) != 0)) kw_args--; - else { - __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 10); __PYX_ERR(0, 71, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create_map_online") < 0)) __PYX_ERR(0, 71, __pyx_L3_error) - } - } else if (PyTuple_GET_SIZE(__pyx_args) != 11) { - 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); - values[5] = PyTuple_GET_ITEM(__pyx_args, 5); - values[6] = PyTuple_GET_ITEM(__pyx_args, 6); - values[7] = PyTuple_GET_ITEM(__pyx_args, 7); - values[8] = PyTuple_GET_ITEM(__pyx_args, 8); - values[9] = PyTuple_GET_ITEM(__pyx_args, 9); - values[10] = PyTuple_GET_ITEM(__pyx_args, 10); - } - __pyx_v_X = ((PyArrayObject *)values[0]); - __pyx_v_n_iter = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_n_iter == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error) - __pyx_v_n_row = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_n_row == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error) - __pyx_v_n_col = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_n_col == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error) - __pyx_v_n_pix = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_n_pix == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error) - __pyx_v_alpha_start = __pyx_PyFloat_AsFloat(values[5]); if (unlikely((__pyx_v_alpha_start == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error) - __pyx_v_alpha_end = __pyx_PyFloat_AsFloat(values[6]); if (unlikely((__pyx_v_alpha_end == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error) - __pyx_v_importance = ((PyArrayObject *)values[7]); - __pyx_v_dist_lib = ((PyArrayObject *)values[8]); - __pyx_v_weights = ((PyArrayObject *)values[9]); - __pyx_v_random_order = __Pyx_PyObject_IsTrue(values[10]); if (unlikely((__pyx_v_random_order == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 72, __pyx_L3_error) - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 71, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("core.create_map_online", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_X), __pyx_ptype_5numpy_ndarray, 1, "X", 0))) __PYX_ERR(0, 71, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_importance), __pyx_ptype_5numpy_ndarray, 1, "importance", 0))) __PYX_ERR(0, 72, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dist_lib), __pyx_ptype_5numpy_ndarray, 1, "dist_lib", 0))) __PYX_ERR(0, 72, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_weights), __pyx_ptype_5numpy_ndarray, 1, "weights", 0))) __PYX_ERR(0, 72, __pyx_L1_error) - __pyx_r = __pyx_pf_4core_8create_map_online(__pyx_self, __pyx_v_X, __pyx_v_n_iter, __pyx_v_n_row, __pyx_v_n_col, __pyx_v_n_pix, __pyx_v_alpha_start, __pyx_v_alpha_end, __pyx_v_importance, __pyx_v_dist_lib, __pyx_v_weights, __pyx_v_random_order); - - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __pyx_r = NULL; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_4core_8create_map_online(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_X, int __pyx_v_n_iter, int __pyx_v_n_row, int __pyx_v_n_col, int __pyx_v_n_pix, float __pyx_v_alpha_start, float __pyx_v_alpha_end, PyArrayObject *__pyx_v_importance, PyArrayObject *__pyx_v_dist_lib, PyArrayObject *__pyx_v_weights, int __pyx_v_random_order) { - int __pyx_v_t; - int __pyx_v_total_t; - float __pyx_v_sigma_0; - float __pyx_v_sigma_f; - int __pyx_v_i; - int __pyx_v_best; - float __pyx_v_alpha; - float __pyx_v_sigma; - PyObject *__pyx_v_random_indices = 0; - PyArrayObject *__pyx_v_inputs = 0; - CYTHON_UNUSED PyArrayObject *__pyx_v_activation = 0; - CYTHON_UNUSED int __pyx_v_it; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - float __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - int __pyx_t_8; - int __pyx_t_9; - int __pyx_t_10; - PyObject *__pyx_t_11 = NULL; - int __pyx_t_12; - PyObject *__pyx_t_13 = NULL; - int __pyx_t_14; - int __pyx_t_15; - PyObject *(*__pyx_t_16)(PyObject *); - int __pyx_t_17; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("create_map_online", 0); - __Pyx_INCREF((PyObject *)__pyx_v_weights); - - /* "core.pyx":73 - * def create_map_online(cnp.ndarray X, int n_iter, int n_row, int n_col, int n_pix, float alpha_start, float alpha_end, - * cnp.ndarray importance, cnp.ndarray dist_lib, cnp.ndarray weights, bint random_order): - * cdef int t = 0 # <<<<<<<<<<<<<< - * cdef int total_t = n_iter * n_row - * cdef float sigma_0 = dist_lib.max() - */ - __pyx_v_t = 0; - - /* "core.pyx":74 - * cnp.ndarray importance, cnp.ndarray dist_lib, cnp.ndarray weights, bint random_order): - * cdef int t = 0 - * cdef int total_t = n_iter * n_row # <<<<<<<<<<<<<< - * cdef float sigma_0 = dist_lib.max() - * cdef float sigma_f = np.min(dist_lib[np.where(dist_lib > 0.)]) - */ - __pyx_v_total_t = (__pyx_v_n_iter * __pyx_v_n_row); - - /* "core.pyx":75 - * cdef int t = 0 - * cdef int total_t = n_iter * n_row - * cdef float sigma_0 = dist_lib.max() # <<<<<<<<<<<<<< - * cdef float sigma_f = np.min(dist_lib[np.where(dist_lib > 0.)]) - * - */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_dist_lib), __pyx_n_s_max); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 75, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } - } - __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 75, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_4 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 75, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_sigma_0 = __pyx_t_4; - - /* "core.pyx":76 - * cdef int total_t = n_iter * n_row - * cdef float sigma_0 = dist_lib.max() - * cdef float sigma_f = np.min(dist_lib[np.where(dist_lib > 0.)]) # <<<<<<<<<<<<<< - * - * cdef int i, best - */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 76, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 76, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 76, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_where); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 76, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = PyObject_RichCompare(((PyObject *)__pyx_v_dist_lib), __pyx_float_0_, Py_GT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 76, __pyx_L1_error) - __pyx_t_7 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_6, function); - } - } - __pyx_t_2 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 76, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_dist_lib), __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 76, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - } - } - __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_6); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 76, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_4 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 76, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_sigma_f = __pyx_t_4; - - /* "core.pyx":81 - * cdef float alpha, sigma - * cdef list random_indices - * cdef cnp.ndarray inputs = np.zeros([n_col, 1], dtype=DTYPE) # <<<<<<<<<<<<<< - * cdef cnp.ndarray activation = np.zeros([n_pix, 1], dtype=DTYPE) - * - */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 81, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 81, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_col); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 81, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_6 = PyList_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 81, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_1); - PyList_SET_ITEM(__pyx_t_6, 0, __pyx_t_1); - __Pyx_INCREF(__pyx_int_1); - __Pyx_GIVEREF(__pyx_int_1); - PyList_SET_ITEM(__pyx_t_6, 1, __pyx_int_1); - __pyx_t_1 = 0; - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 81, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_6); - __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 81, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_DTYPE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_2) < 0) __PYX_ERR(0, 81, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 81, __pyx_L1_error) - __pyx_v_inputs = ((PyArrayObject *)__pyx_t_2); - __pyx_t_2 = 0; - - /* "core.pyx":82 - * cdef list random_indices - * cdef cnp.ndarray inputs = np.zeros([n_col, 1], dtype=DTYPE) - * cdef cnp.ndarray activation = np.zeros([n_pix, 1], dtype=DTYPE) # <<<<<<<<<<<<<< - * - * for it in range(n_iter): - */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 82, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_n_pix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 82, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyList_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); - __Pyx_INCREF(__pyx_int_1); - __Pyx_GIVEREF(__pyx_int_1); - PyList_SET_ITEM(__pyx_t_1, 1, __pyx_int_1); - __pyx_t_2 = 0; - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __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_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 82, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 82, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_3) < 0) __PYX_ERR(0, 82, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 82, __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_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 82, __pyx_L1_error) - __pyx_v_activation = ((PyArrayObject *)__pyx_t_3); - __pyx_t_3 = 0; - - /* "core.pyx":84 - * cdef cnp.ndarray activation = np.zeros([n_pix, 1], dtype=DTYPE) - * - * for it in range(n_iter): # <<<<<<<<<<<<<< - * alpha = get_alpha(alpha_end, alpha_start, t, total_t) - * sigma = get_sigma(sigma_f, sigma_0, t, total_t) - */ - __pyx_t_8 = __pyx_v_n_iter; - __pyx_t_9 = __pyx_t_8; - for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) { - __pyx_v_it = __pyx_t_10; - - /* "core.pyx":85 - * - * for it in range(n_iter): - * alpha = get_alpha(alpha_end, alpha_start, t, total_t) # <<<<<<<<<<<<<< - * sigma = get_sigma(sigma_f, sigma_0, t, total_t) - * random_indices = random.sample(range(n_row), n_row) if random_order else np.arange( - */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_get_alpha); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_alpha_end); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = PyFloat_FromDouble(__pyx_v_alpha_start); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_total_t); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_11 = NULL; - __pyx_t_12 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_11)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_11); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - __pyx_t_12 = 1; - } - } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_1)) { - PyObject *__pyx_temp[5] = {__pyx_t_11, __pyx_t_2, __pyx_t_6, __pyx_t_5, __pyx_t_7}; - __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_12, 4+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { - PyObject *__pyx_temp[5] = {__pyx_t_11, __pyx_t_2, __pyx_t_6, __pyx_t_5, __pyx_t_7}; - __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_12, 4+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - } else - #endif - { - __pyx_t_13 = PyTuple_New(4+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_13); - if (__pyx_t_11) { - __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_11); __pyx_t_11 = NULL; - } - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_12, __pyx_t_2); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_12, __pyx_t_6); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_13, 2+__pyx_t_12, __pyx_t_5); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_13, 3+__pyx_t_12, __pyx_t_7); - __pyx_t_2 = 0; - __pyx_t_6 = 0; - __pyx_t_5 = 0; - __pyx_t_7 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_13, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_t_3); if (unlikely((__pyx_t_4 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_alpha = __pyx_t_4; - - /* "core.pyx":86 - * for it in range(n_iter): - * alpha = get_alpha(alpha_end, alpha_start, t, total_t) - * sigma = get_sigma(sigma_f, sigma_0, t, total_t) # <<<<<<<<<<<<<< - * random_indices = random.sample(range(n_row), n_row) if random_order else np.arange( - * n_row) - */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_get_sigma); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_13 = PyFloat_FromDouble(__pyx_v_sigma_f); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_13); - __pyx_t_7 = PyFloat_FromDouble(__pyx_v_sigma_0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_total_t); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = NULL; - __pyx_t_12 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); - __pyx_t_12 = 1; - } - } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_1)) { - PyObject *__pyx_temp[5] = {__pyx_t_2, __pyx_t_13, __pyx_t_7, __pyx_t_5, __pyx_t_6}; - __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_12, 4+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { - PyObject *__pyx_temp[5] = {__pyx_t_2, __pyx_t_13, __pyx_t_7, __pyx_t_5, __pyx_t_6}; - __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_12, 4+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - } else - #endif - { - __pyx_t_11 = PyTuple_New(4+__pyx_t_12); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_11); - if (__pyx_t_2) { - __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_2); __pyx_t_2 = NULL; - } - __Pyx_GIVEREF(__pyx_t_13); - PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_12, __pyx_t_13); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_12, __pyx_t_7); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_12, __pyx_t_5); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_11, 3+__pyx_t_12, __pyx_t_6); - __pyx_t_13 = 0; - __pyx_t_7 = 0; - __pyx_t_5 = 0; - __pyx_t_6 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_t_3); if (unlikely((__pyx_t_4 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_sigma = __pyx_t_4; - - /* "core.pyx":87 - * alpha = get_alpha(alpha_end, alpha_start, t, total_t) - * sigma = get_sigma(sigma_f, sigma_0, t, total_t) - * random_indices = random.sample(range(n_row), n_row) if random_order else np.arange( # <<<<<<<<<<<<<< - * n_row) - * - */ - if ((__pyx_v_random_order != 0)) { - __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_random); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_11); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_sample); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = __Pyx_PyInt_From_int(__pyx_v_n_row); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_11); - __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_t_11); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = __Pyx_PyInt_From_int(__pyx_v_n_row); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_11); - __pyx_t_7 = NULL; - __pyx_t_12 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_6, function); - __pyx_t_12 = 1; - } - } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_6)) { - PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_5, __pyx_t_11}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { - PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_5, __pyx_t_11}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - } else - #endif - { - __pyx_t_13 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_13); - if (__pyx_t_7) { - __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_7); __pyx_t_7 = NULL; - } - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_12, __pyx_t_5); - __Pyx_GIVEREF(__pyx_t_11); - PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_12, __pyx_t_11); - __pyx_t_5 = 0; - __pyx_t_11 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_13, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; - } - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(0, 87, __pyx_L1_error) - __pyx_t_3 = __pyx_t_1; - __pyx_t_1 = 0; - } else { - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_arange); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_13); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - - /* "core.pyx":88 - * sigma = get_sigma(sigma_f, sigma_0, t, total_t) - * random_indices = random.sample(range(n_row), n_row) if random_order else np.arange( - * n_row) # <<<<<<<<<<<<<< - * - * for i in range(n_row): - */ - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_n_row); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 88, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_11 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) { - __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_13); - if (likely(__pyx_t_11)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); - __Pyx_INCREF(__pyx_t_11); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_13, function); - } - } - __pyx_t_1 = (__pyx_t_11) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_11, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_6); - __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; - - /* "core.pyx":87 - * alpha = get_alpha(alpha_end, alpha_start, t, total_t) - * sigma = get_sigma(sigma_f, sigma_0, t, total_t) - * random_indices = random.sample(range(n_row), n_row) if random_order else np.arange( # <<<<<<<<<<<<<< - * n_row) - * - */ - if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(0, 87, __pyx_L1_error) - __pyx_t_3 = __pyx_t_1; - __pyx_t_1 = 0; - } - __Pyx_XDECREF_SET(__pyx_v_random_indices, ((PyObject*)__pyx_t_3)); - __pyx_t_3 = 0; - - /* "core.pyx":90 - * n_row) - * - * for i in range(n_row): # <<<<<<<<<<<<<< - * inputs = X[random_indices[i]] - * best, activation = get_best_cell(inputs=inputs, importance=importance, - */ - __pyx_t_12 = __pyx_v_n_row; - __pyx_t_14 = __pyx_t_12; - for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) { - __pyx_v_i = __pyx_t_15; - - /* "core.pyx":91 - * - * for i in range(n_row): - * inputs = X[random_indices[i]] # <<<<<<<<<<<<<< - * best, activation = get_best_cell(inputs=inputs, importance=importance, - * weights=weights, n_pix=n_pix, return_vals=1) - */ - if (unlikely(__pyx_v_random_indices == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(0, 91, __pyx_L1_error) - } - __pyx_t_3 = __Pyx_GetItemInt_List(__pyx_v_random_indices, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 91, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_X), __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 91, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 91, __pyx_L1_error) - __Pyx_DECREF_SET(__pyx_v_inputs, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - /* "core.pyx":92 - * for i in range(n_row): - * inputs = X[random_indices[i]] - * best, activation = get_best_cell(inputs=inputs, importance=importance, # <<<<<<<<<<<<<< - * weights=weights, n_pix=n_pix, return_vals=1) - * weights += alpha * count_modified_cells(best, dist_lib, sigma) * np.transpose( - */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_get_best_cell); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 92, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 92, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_inputs, ((PyObject *)__pyx_v_inputs)) < 0) __PYX_ERR(0, 92, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_importance, ((PyObject *)__pyx_v_importance)) < 0) __PYX_ERR(0, 92, __pyx_L1_error) - - /* "core.pyx":93 - * inputs = X[random_indices[i]] - * best, activation = get_best_cell(inputs=inputs, importance=importance, - * weights=weights, n_pix=n_pix, return_vals=1) # <<<<<<<<<<<<<< - * weights += alpha * count_modified_cells(best, dist_lib, sigma) * np.transpose( - * (inputs - np.transpose(weights))) - */ - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_weights, ((PyObject *)__pyx_v_weights)) < 0) __PYX_ERR(0, 92, __pyx_L1_error) - __pyx_t_13 = __Pyx_PyInt_From_int(__pyx_v_n_pix); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 93, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_13); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_n_pix, __pyx_t_13) < 0) __PYX_ERR(0, 92, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_return_vals, __pyx_int_1) < 0) __PYX_ERR(0, 92, __pyx_L1_error) - - /* "core.pyx":92 - * for i in range(n_row): - * inputs = X[random_indices[i]] - * best, activation = get_best_cell(inputs=inputs, importance=importance, # <<<<<<<<<<<<<< - * weights=weights, n_pix=n_pix, return_vals=1) - * weights += alpha * count_modified_cells(best, dist_lib, sigma) * np.transpose( - */ - __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 92, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_13); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if ((likely(PyTuple_CheckExact(__pyx_t_13))) || (PyList_CheckExact(__pyx_t_13))) { - PyObject* sequence = __pyx_t_13; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 92, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_1 = PyTuple_GET_ITEM(sequence, 1); - } else { - __pyx_t_3 = PyList_GET_ITEM(sequence, 0); - __pyx_t_1 = PyList_GET_ITEM(sequence, 1); - } - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(__pyx_t_1); - #else - __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 92, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 92, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - #endif - __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; - } else { - Py_ssize_t index = -1; - __pyx_t_6 = PyObject_GetIter(__pyx_t_13); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 92, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; - __pyx_t_16 = Py_TYPE(__pyx_t_6)->tp_iternext; - index = 0; __pyx_t_3 = __pyx_t_16(__pyx_t_6); if (unlikely(!__pyx_t_3)) goto __pyx_L7_unpacking_failed; - __Pyx_GOTREF(__pyx_t_3); - index = 1; __pyx_t_1 = __pyx_t_16(__pyx_t_6); if (unlikely(!__pyx_t_1)) goto __pyx_L7_unpacking_failed; - __Pyx_GOTREF(__pyx_t_1); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_16(__pyx_t_6), 2) < 0) __PYX_ERR(0, 92, __pyx_L1_error) - __pyx_t_16 = NULL; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - goto __pyx_L8_unpacking_done; - __pyx_L7_unpacking_failed:; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_16 = NULL; - if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 92, __pyx_L1_error) - __pyx_L8_unpacking_done:; - } - __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 92, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 92, __pyx_L1_error) - __pyx_v_best = __pyx_t_17; - __Pyx_DECREF_SET(__pyx_v_activation, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - - /* "core.pyx":94 - * best, activation = get_best_cell(inputs=inputs, importance=importance, - * weights=weights, n_pix=n_pix, return_vals=1) - * weights += alpha * count_modified_cells(best, dist_lib, sigma) * np.transpose( # <<<<<<<<<<<<<< - * (inputs - np.transpose(weights))) - */ - __pyx_t_13 = PyFloat_FromDouble(__pyx_v_alpha); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_13); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_count_modified_cells); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_best); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_11 = PyFloat_FromDouble(__pyx_v_sigma); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_11); - __pyx_t_5 = NULL; - __pyx_t_17 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_5)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_5); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_17 = 1; - } - } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_3)) { - PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_t_6, ((PyObject *)__pyx_v_dist_lib), __pyx_t_11}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_17, 3+__pyx_t_17); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { - PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_t_6, ((PyObject *)__pyx_v_dist_lib), __pyx_t_11}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_17, 3+__pyx_t_17); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - } else - #endif - { - __pyx_t_7 = PyTuple_New(3+__pyx_t_17); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (__pyx_t_5) { - __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; - } - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_17, __pyx_t_6); - __Pyx_INCREF(((PyObject *)__pyx_v_dist_lib)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_dist_lib)); - PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_17, ((PyObject *)__pyx_v_dist_lib)); - __Pyx_GIVEREF(__pyx_t_11); - PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_17, __pyx_t_11); - __pyx_t_6 = 0; - __pyx_t_11 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - } - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyNumber_Multiply(__pyx_t_13, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_n_s_np); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_13); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_transpose); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; - - /* "core.pyx":95 - * weights=weights, n_pix=n_pix, return_vals=1) - * weights += alpha * count_modified_cells(best, dist_lib, sigma) * np.transpose( - * (inputs - np.transpose(weights))) # <<<<<<<<<<<<<< - */ - __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_np); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 95, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_11); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_transpose); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 95, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { - __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_6); - if (likely(__pyx_t_11)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); - __Pyx_INCREF(__pyx_t_11); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_6, function); - } - } - __pyx_t_13 = (__pyx_t_11) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_11, ((PyObject *)__pyx_v_weights)) : __Pyx_PyObject_CallOneArg(__pyx_t_6, ((PyObject *)__pyx_v_weights)); - __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; - if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 95, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_13); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyNumber_Subtract(((PyObject *)__pyx_v_inputs), __pyx_t_13); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 95, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; - __pyx_t_13 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_13)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_13); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); - } - } - __pyx_t_1 = (__pyx_t_13) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_13, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); - __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "core.pyx":94 - * best, activation = get_best_cell(inputs=inputs, importance=importance, - * weights=weights, n_pix=n_pix, return_vals=1) - * weights += alpha * count_modified_cells(best, dist_lib, sigma) * np.transpose( # <<<<<<<<<<<<<< - * (inputs - np.transpose(weights))) - */ - __pyx_t_7 = PyNumber_Multiply(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyNumber_InPlaceAdd(((PyObject *)__pyx_v_weights), __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_DECREF_SET(__pyx_v_weights, ((PyArrayObject *)__pyx_t_1)); - __pyx_t_1 = 0; - } - } - - /* "core.pyx":71 - * return np.exp(-(map_d[bmu] ** 2) / sigma ** 2) - * - * def create_map_online(cnp.ndarray X, int n_iter, int n_row, int n_col, int n_pix, float alpha_start, float alpha_end, # <<<<<<<<<<<<<< - * cnp.ndarray importance, cnp.ndarray dist_lib, cnp.ndarray weights, bint random_order): - * cdef int t = 0 - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_11); - __Pyx_XDECREF(__pyx_t_13); - __Pyx_AddTraceback("core.create_map_online", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_random_indices); - __Pyx_XDECREF((PyObject *)__pyx_v_inputs); - __Pyx_XDECREF((PyObject *)__pyx_v_activation); - __Pyx_XDECREF((PyObject *)__pyx_v_weights); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":742 - * ctypedef npy_cdouble complex_t - * - * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(1, a) - * - */ - -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":743 - * - * cdef inline object PyArray_MultiIterNew1(a): - * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< - * - * cdef inline object PyArray_MultiIterNew2(a, b): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 743, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":742 - * ctypedef npy_cdouble complex_t - * - * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(1, a) - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":745 - * return PyArray_MultiIterNew(1, a) - * - * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(2, a, b) - * - */ - -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":746 - * - * cdef inline object PyArray_MultiIterNew2(a, b): - * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< - * - * cdef inline object PyArray_MultiIterNew3(a, b, c): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 746, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":745 - * return PyArray_MultiIterNew(1, a) - * - * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(2, a, b) - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":748 - * return PyArray_MultiIterNew(2, a, b) - * - * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(3, a, b, c) - * - */ - -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":749 - * - * cdef inline object PyArray_MultiIterNew3(a, b, c): - * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< - * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 749, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":748 - * return PyArray_MultiIterNew(2, a, b) - * - * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(3, a, b, c) - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":751 - * return PyArray_MultiIterNew(3, a, b, c) - * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(4, a, b, c, d) - * - */ - -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":752 - * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): - * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< - * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 752, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":751 - * return PyArray_MultiIterNew(3, a, b, c) - * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(4, a, b, c, d) - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":754 - * return PyArray_MultiIterNew(4, a, b, c, d) - * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(5, a, b, c, d, e) - * - */ - -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":755 - * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): - * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< - * - * cdef inline tuple PyDataType_SHAPE(dtype d): - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 755, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":754 - * return PyArray_MultiIterNew(4, a, b, c, d) - * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(5, a, b, c, d, e) - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":757 - * return PyArray_MultiIterNew(5, a, b, c, d, e) - * - * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< - * if PyDataType_HASSUBARRAY(d): - * return d.subarray.shape - */ - -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":758 - * - * cdef inline tuple PyDataType_SHAPE(dtype d): - * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< - * return d.subarray.shape - * else: - */ - __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); - if (__pyx_t_1) { - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":759 - * cdef inline tuple PyDataType_SHAPE(dtype d): - * if PyDataType_HASSUBARRAY(d): - * return d.subarray.shape # <<<<<<<<<<<<<< - * else: - * return () - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); - __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); - goto __pyx_L0; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":758 - * - * cdef inline tuple PyDataType_SHAPE(dtype d): - * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< - * return d.subarray.shape - * else: - */ - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":761 - * return d.subarray.shape - * else: - * return () # <<<<<<<<<<<<<< - * - * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: - */ - /*else*/ { - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_empty_tuple); - __pyx_r = __pyx_empty_tuple; - goto __pyx_L0; - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":757 - * return PyArray_MultiIterNew(5, a, b, c, d, e) - * - * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< - * if PyDataType_HASSUBARRAY(d): - * return d.subarray.shape - */ - - /* function exit code */ - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":763 - * return () - * - * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< - * # Recursive utility function used in __getbuffer__ to get format - * # string. The new location in the format string is returned. - */ - -static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) { - PyArray_Descr *__pyx_v_child = 0; - int __pyx_v_endian_detector; - int __pyx_v_little_endian; - PyObject *__pyx_v_fields = 0; - PyObject *__pyx_v_childname = NULL; - PyObject *__pyx_v_new_offset = NULL; - PyObject *__pyx_v_t = NULL; - char *__pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - Py_ssize_t __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - int __pyx_t_5; - int __pyx_t_6; - int __pyx_t_7; - long __pyx_t_8; - char *__pyx_t_9; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_util_dtypestring", 0); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":768 - * - * cdef dtype child - * cdef int endian_detector = 1 # <<<<<<<<<<<<<< - * cdef bint little_endian = ((&endian_detector)[0] != 0) - * cdef tuple fields - */ - __pyx_v_endian_detector = 1; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":769 - * cdef dtype child - * cdef int endian_detector = 1 - * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< - * cdef tuple fields - * - */ - __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":772 - * cdef tuple fields - * - * for childname in descr.names: # <<<<<<<<<<<<<< - * fields = descr.fields[childname] - * child, new_offset = fields - */ - if (unlikely(__pyx_v_descr->names == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(1, 772, __pyx_L1_error) - } - __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; - for (;;) { - if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 772, __pyx_L1_error) - #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 772, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); - __pyx_t_3 = 0; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":773 - * - * for childname in descr.names: - * fields = descr.fields[childname] # <<<<<<<<<<<<<< - * child, new_offset = fields - * - */ - if (unlikely(__pyx_v_descr->fields == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 773, __pyx_L1_error) - } - __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 773, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 773, __pyx_L1_error) - __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); - __pyx_t_3 = 0; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":774 - * for childname in descr.names: - * fields = descr.fields[childname] - * child, new_offset = fields # <<<<<<<<<<<<<< - * - * if (end - f) - (new_offset - offset[0]) < 15: - */ - if (likely(__pyx_v_fields != Py_None)) { - PyObject* sequence = __pyx_v_fields; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 774, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(__pyx_t_4); - #else - __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 774, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 774, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - } else { - __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 774, __pyx_L1_error) - } - if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 774, __pyx_L1_error) - __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); - __pyx_t_3 = 0; - __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); - __pyx_t_4 = 0; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":776 - * child, new_offset = fields - * - * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") - * - */ - __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 776, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 776, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 776, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); - if (unlikely(__pyx_t_6)) { - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":777 - * - * if (end - f) - (new_offset - offset[0]) < 15: - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< - * - * if ((child.byteorder == c'>' and little_endian) or - */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 777, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 777, __pyx_L1_error) - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":776 - * child, new_offset = fields - * - * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") - * - */ - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":779 - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") - * - * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (child.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") - */ - __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0); - if (!__pyx_t_7) { - goto __pyx_L8_next_or; - } else { - } - __pyx_t_7 = (__pyx_v_little_endian != 0); - if (!__pyx_t_7) { - } else { - __pyx_t_6 = __pyx_t_7; - goto __pyx_L7_bool_binop_done; - } - __pyx_L8_next_or:; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":780 - * - * if ((child.byteorder == c'>' and little_endian) or - * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< - * raise ValueError(u"Non-native byte order not supported") - * # One could encode it in the format string and have Cython - */ - __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0); - if (__pyx_t_7) { - } else { - __pyx_t_6 = __pyx_t_7; - goto __pyx_L7_bool_binop_done; - } - __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); - __pyx_t_6 = __pyx_t_7; - __pyx_L7_bool_binop_done:; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":779 - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") - * - * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (child.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") - */ - if (unlikely(__pyx_t_6)) { - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":781 - * if ((child.byteorder == c'>' and little_endian) or - * (child.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< - * # One could encode it in the format string and have Cython - * # complain instead, BUT: < and > in format strings also imply - */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 781, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 781, __pyx_L1_error) - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":779 - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") - * - * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< - * (child.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") - */ - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":791 - * - * # Output padding bytes - * while offset[0] < new_offset: # <<<<<<<<<<<<<< - * f[0] = 120 # "x"; pad byte - * f += 1 - */ - while (1) { - __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 791, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 791, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 791, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (!__pyx_t_6) break; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":792 - * # Output padding bytes - * while offset[0] < new_offset: - * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< - * f += 1 - * offset[0] += 1 - */ - (__pyx_v_f[0]) = 0x78; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":793 - * while offset[0] < new_offset: - * f[0] = 120 # "x"; pad byte - * f += 1 # <<<<<<<<<<<<<< - * offset[0] += 1 - * - */ - __pyx_v_f = (__pyx_v_f + 1); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":794 - * f[0] = 120 # "x"; pad byte - * f += 1 - * offset[0] += 1 # <<<<<<<<<<<<<< - * - * offset[0] += child.itemsize - */ - __pyx_t_8 = 0; - (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":796 - * offset[0] += 1 - * - * offset[0] += child.itemsize # <<<<<<<<<<<<<< - * - * if not PyDataType_HASFIELDS(child): - */ - __pyx_t_8 = 0; - (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":798 - * offset[0] += child.itemsize - * - * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< - * t = child.type_num - * if end - f < 5: - */ - __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); - if (__pyx_t_6) { - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":799 - * - * if not PyDataType_HASFIELDS(child): - * t = child.type_num # <<<<<<<<<<<<<< - * if end - f < 5: - * raise RuntimeError(u"Format string allocated too short.") - */ - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 799, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); - __pyx_t_4 = 0; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":800 - * if not PyDataType_HASFIELDS(child): - * t = child.type_num - * if end - f < 5: # <<<<<<<<<<<<<< - * raise RuntimeError(u"Format string allocated too short.") - * - */ - __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); - if (unlikely(__pyx_t_6)) { - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":801 - * t = child.type_num - * if end - f < 5: - * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< - * - * # Until ticket #99 is fixed, use integers to avoid warnings - */ - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 801, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(1, 801, __pyx_L1_error) - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":800 - * if not PyDataType_HASFIELDS(child): - * t = child.type_num - * if end - f < 5: # <<<<<<<<<<<<<< - * raise RuntimeError(u"Format string allocated too short.") - * - */ - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":804 - * - * # Until ticket #99 is fixed, use integers to avoid warnings - * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< - * elif t == NPY_UBYTE: f[0] = 66 #"B" - * elif t == NPY_SHORT: f[0] = 104 #"h" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 804, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 804, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 804, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 98; - goto __pyx_L15; - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":805 - * # Until ticket #99 is fixed, use integers to avoid warnings - * if t == NPY_BYTE: f[0] = 98 #"b" - * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< - * elif t == NPY_SHORT: f[0] = 104 #"h" - * elif t == NPY_USHORT: f[0] = 72 #"H" - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 805, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 805, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 805, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 66; - goto __pyx_L15; - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":806 - * if t == NPY_BYTE: f[0] = 98 #"b" - * elif t == NPY_UBYTE: f[0] = 66 #"B" - * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< - * elif t == NPY_USHORT: f[0] = 72 #"H" - * elif t == NPY_INT: f[0] = 105 #"i" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 806, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 806, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 806, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x68; - goto __pyx_L15; - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":807 - * elif t == NPY_UBYTE: f[0] = 66 #"B" - * elif t == NPY_SHORT: f[0] = 104 #"h" - * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< - * elif t == NPY_INT: f[0] = 105 #"i" - * elif t == NPY_UINT: f[0] = 73 #"I" - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 807, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 807, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 807, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 72; - goto __pyx_L15; - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":808 - * elif t == NPY_SHORT: f[0] = 104 #"h" - * elif t == NPY_USHORT: f[0] = 72 #"H" - * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< - * elif t == NPY_UINT: f[0] = 73 #"I" - * elif t == NPY_LONG: f[0] = 108 #"l" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 808, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 808, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 808, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x69; - goto __pyx_L15; - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":809 - * elif t == NPY_USHORT: f[0] = 72 #"H" - * elif t == NPY_INT: f[0] = 105 #"i" - * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< - * elif t == NPY_LONG: f[0] = 108 #"l" - * elif t == NPY_ULONG: f[0] = 76 #"L" - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 809, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 809, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 809, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 73; - goto __pyx_L15; - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":810 - * elif t == NPY_INT: f[0] = 105 #"i" - * elif t == NPY_UINT: f[0] = 73 #"I" - * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< - * elif t == NPY_ULONG: f[0] = 76 #"L" - * elif t == NPY_LONGLONG: f[0] = 113 #"q" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 810, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 810, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 810, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x6C; - goto __pyx_L15; - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":811 - * elif t == NPY_UINT: f[0] = 73 #"I" - * elif t == NPY_LONG: f[0] = 108 #"l" - * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< - * elif t == NPY_LONGLONG: f[0] = 113 #"q" - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 811, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 811, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 811, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 76; - goto __pyx_L15; - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":812 - * elif t == NPY_LONG: f[0] = 108 #"l" - * elif t == NPY_ULONG: f[0] = 76 #"L" - * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" - * elif t == NPY_FLOAT: f[0] = 102 #"f" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 812, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 812, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 812, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x71; - goto __pyx_L15; - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":813 - * elif t == NPY_ULONG: f[0] = 76 #"L" - * elif t == NPY_LONGLONG: f[0] = 113 #"q" - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< - * elif t == NPY_FLOAT: f[0] = 102 #"f" - * elif t == NPY_DOUBLE: f[0] = 100 #"d" - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 813, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 813, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 813, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 81; - goto __pyx_L15; - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":814 - * elif t == NPY_LONGLONG: f[0] = 113 #"q" - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" - * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< - * elif t == NPY_DOUBLE: f[0] = 100 #"d" - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 814, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 814, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 814, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x66; - goto __pyx_L15; - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":815 - * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" - * elif t == NPY_FLOAT: f[0] = 102 #"f" - * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 815, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 815, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 815, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x64; - goto __pyx_L15; - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":816 - * elif t == NPY_FLOAT: f[0] = 102 #"f" - * elif t == NPY_DOUBLE: f[0] = 100 #"d" - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 816, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 816, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 816, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 0x67; - goto __pyx_L15; - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":817 - * elif t == NPY_DOUBLE: f[0] = 100 #"d" - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd - * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 817, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 817, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 817, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 90; - (__pyx_v_f[1]) = 0x66; - __pyx_v_f = (__pyx_v_f + 1); - goto __pyx_L15; - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":818 - * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< - * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg - * elif t == NPY_OBJECT: f[0] = 79 #"O" - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 818, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 818, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 818, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 90; - (__pyx_v_f[1]) = 0x64; - __pyx_v_f = (__pyx_v_f + 1); - goto __pyx_L15; - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":819 - * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd - * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< - * elif t == NPY_OBJECT: f[0] = 79 #"O" - * else: - */ - __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 819, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 819, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 819, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_6) { - (__pyx_v_f[0]) = 90; - (__pyx_v_f[1]) = 0x67; - __pyx_v_f = (__pyx_v_f + 1); - goto __pyx_L15; - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":820 - * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd - * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg - * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) - */ - __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 820, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 820, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 820, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (likely(__pyx_t_6)) { - (__pyx_v_f[0]) = 79; - goto __pyx_L15; - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":822 - * elif t == NPY_OBJECT: f[0] = 79 #"O" - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< - * f += 1 - * else: - */ - /*else*/ { - __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 822, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 822, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(1, 822, __pyx_L1_error) - } - __pyx_L15:; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":823 - * else: - * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) - * f += 1 # <<<<<<<<<<<<<< - * else: - * # Cython ignores struct boundary information ("T{...}"), - */ - __pyx_v_f = (__pyx_v_f + 1); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":798 - * offset[0] += child.itemsize - * - * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< - * t = child.type_num - * if end - f < 5: - */ - goto __pyx_L13; - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":827 - * # Cython ignores struct boundary information ("T{...}"), - * # so don't output it - * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< - * return f - * - */ - /*else*/ { - __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 827, __pyx_L1_error) - __pyx_v_f = __pyx_t_9; - } - __pyx_L13:; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":772 - * cdef tuple fields - * - * for childname in descr.names: # <<<<<<<<<<<<<< - * fields = descr.fields[childname] - * child, new_offset = fields - */ - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":828 - * # so don't output it - * f = _util_dtypestring(child, f, end, offset) - * return f # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = __pyx_v_f; - goto __pyx_L0; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":763 - * return () - * - * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< - * # Recursive utility function used in __getbuffer__ to get format - * # string. The new location in the format string is returned. - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF((PyObject *)__pyx_v_child); - __Pyx_XDECREF(__pyx_v_fields); - __Pyx_XDECREF(__pyx_v_childname); - __Pyx_XDECREF(__pyx_v_new_offset); - __Pyx_XDECREF(__pyx_v_t); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":943 - * int _import_umath() except -1 - * - * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< - * Py_INCREF(base) # important to do this before stealing the reference below! - * PyArray_SetBaseObject(arr, base) - */ - -static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("set_array_base", 0); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":944 - * - * cdef inline void set_array_base(ndarray arr, object base): - * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< - * PyArray_SetBaseObject(arr, base) - * - */ - Py_INCREF(__pyx_v_base); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":945 - * cdef inline void set_array_base(ndarray arr, object base): - * Py_INCREF(base) # important to do this before stealing the reference below! - * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< - * - * cdef inline object get_array_base(ndarray arr): - */ - (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":943 - * int _import_umath() except -1 - * - * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< - * Py_INCREF(base) # important to do this before stealing the reference below! - * PyArray_SetBaseObject(arr, base) - */ - - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":947 - * PyArray_SetBaseObject(arr, base) - * - * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< - * base = PyArray_BASE(arr) - * if base is NULL: - */ - -static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { - PyObject *__pyx_v_base; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - __Pyx_RefNannySetupContext("get_array_base", 0); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":948 - * - * cdef inline object get_array_base(ndarray arr): - * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< - * if base is NULL: - * return None - */ - __pyx_v_base = PyArray_BASE(__pyx_v_arr); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":949 - * cdef inline object get_array_base(ndarray arr): - * base = PyArray_BASE(arr) - * if base is NULL: # <<<<<<<<<<<<<< - * return None - * return base - */ - __pyx_t_1 = ((__pyx_v_base == NULL) != 0); - if (__pyx_t_1) { - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":950 - * base = PyArray_BASE(arr) - * if base is NULL: - * return None # <<<<<<<<<<<<<< - * return base - * - */ - __Pyx_XDECREF(__pyx_r); - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":949 - * cdef inline object get_array_base(ndarray arr): - * base = PyArray_BASE(arr) - * if base is NULL: # <<<<<<<<<<<<<< - * return None - * return base - */ - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":951 - * if base is NULL: - * return None - * return base # <<<<<<<<<<<<<< - * - * # Versions of the import_* functions which are more suitable for - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_base)); - __pyx_r = ((PyObject *)__pyx_v_base); - goto __pyx_L0; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":947 - * PyArray_SetBaseObject(arr, base) - * - * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< - * base = PyArray_BASE(arr) - * if base is NULL: - */ - - /* function exit code */ - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":955 - * # Versions of the import_* functions which are more suitable for - * # Cython code. - * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< - * try: - * __pyx_import_array() - */ - -static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { - int __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("import_array", 0); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":956 - * # Cython code. - * cdef inline int import_array() except -1: - * try: # <<<<<<<<<<<<<< - * __pyx_import_array() - * except Exception: - */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_1); - __Pyx_XGOTREF(__pyx_t_2); - __Pyx_XGOTREF(__pyx_t_3); - /*try:*/ { - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":957 - * cdef inline int import_array() except -1: - * try: - * __pyx_import_array() # <<<<<<<<<<<<<< - * except Exception: - * raise ImportError("numpy.core.multiarray failed to import") - */ - __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 957, __pyx_L3_error) - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":956 - * # Cython code. - * cdef inline int import_array() except -1: - * try: # <<<<<<<<<<<<<< - * __pyx_import_array() - * except Exception: - */ - } - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L8_try_end; - __pyx_L3_error:; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":958 - * try: - * __pyx_import_array() - * except Exception: # <<<<<<<<<<<<<< - * raise ImportError("numpy.core.multiarray failed to import") - * - */ - __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - if (__pyx_t_4) { - __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 958, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GOTREF(__pyx_t_7); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":959 - * __pyx_import_array() - * except Exception: - * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< - * - * cdef inline int import_umath() except -1: - */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 959, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 959, __pyx_L5_except_error) - } - goto __pyx_L5_except_error; - __pyx_L5_except_error:; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":956 - * # Cython code. - * cdef inline int import_array() except -1: - * try: # <<<<<<<<<<<<<< - * __pyx_import_array() - * except Exception: - */ - __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); - goto __pyx_L1_error; - __pyx_L8_try_end:; - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":955 - * # Versions of the import_* functions which are more suitable for - * # Cython code. - * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< - * try: - * __pyx_import_array() - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":961 - * raise ImportError("numpy.core.multiarray failed to import") - * - * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() - */ - -static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { - int __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("import_umath", 0); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":962 - * - * cdef inline int import_umath() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: - */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_1); - __Pyx_XGOTREF(__pyx_t_2); - __Pyx_XGOTREF(__pyx_t_3); - /*try:*/ { - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":963 - * cdef inline int import_umath() except -1: - * try: - * _import_umath() # <<<<<<<<<<<<<< - * except Exception: - * raise ImportError("numpy.core.umath failed to import") - */ - __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 963, __pyx_L3_error) - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":962 - * - * cdef inline int import_umath() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: - */ - } - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L8_try_end; - __pyx_L3_error:; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":964 - * try: - * _import_umath() - * except Exception: # <<<<<<<<<<<<<< - * raise ImportError("numpy.core.umath failed to import") - * - */ - __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - if (__pyx_t_4) { - __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 964, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GOTREF(__pyx_t_7); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":965 - * _import_umath() - * except Exception: - * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< - * - * cdef inline int import_ufunc() except -1: - */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 965, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 965, __pyx_L5_except_error) - } - goto __pyx_L5_except_error; - __pyx_L5_except_error:; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":962 - * - * cdef inline int import_umath() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: - */ - __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); - goto __pyx_L1_error; - __pyx_L8_try_end:; - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":961 - * raise ImportError("numpy.core.multiarray failed to import") - * - * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":967 - * raise ImportError("numpy.core.umath failed to import") - * - * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() - */ - -static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { - int __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("import_ufunc", 0); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":968 - * - * cdef inline int import_ufunc() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: - */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_1); - __Pyx_XGOTREF(__pyx_t_2); - __Pyx_XGOTREF(__pyx_t_3); - /*try:*/ { - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":969 - * cdef inline int import_ufunc() except -1: - * try: - * _import_umath() # <<<<<<<<<<<<<< - * except Exception: - * raise ImportError("numpy.core.umath failed to import") - */ - __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 969, __pyx_L3_error) - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":968 - * - * cdef inline int import_ufunc() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: - */ - } - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L8_try_end; - __pyx_L3_error:; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":970 - * try: - * _import_umath() - * except Exception: # <<<<<<<<<<<<<< - * raise ImportError("numpy.core.umath failed to import") - * - */ - __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - if (__pyx_t_4) { - __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 970, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GOTREF(__pyx_t_7); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":971 - * _import_umath() - * except Exception: - * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< - * - * cdef extern from *: - */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 971, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 971, __pyx_L5_except_error) - } - goto __pyx_L5_except_error; - __pyx_L5_except_error:; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":968 - * - * cdef inline int import_ufunc() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: - */ - __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); - goto __pyx_L1_error; - __pyx_L8_try_end:; - } - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":967 - * raise ImportError("numpy.core.umath failed to import") - * - * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyMethodDef __pyx_methods[] = { - {0, 0, 0, 0} -}; - -#if PY_MAJOR_VERSION >= 3 -#if CYTHON_PEP489_MULTI_PHASE_INIT -static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ -static int __pyx_pymod_exec_core(PyObject* module); /*proto*/ -static PyModuleDef_Slot __pyx_moduledef_slots[] = { - {Py_mod_create, (void*)__pyx_pymod_create}, - {Py_mod_exec, (void*)__pyx_pymod_exec_core}, - {0, NULL} -}; -#endif - -static struct PyModuleDef __pyx_moduledef = { - PyModuleDef_HEAD_INIT, - "core", - 0, /* m_doc */ - #if CYTHON_PEP489_MULTI_PHASE_INIT - 0, /* m_size */ - #else - -1, /* m_size */ - #endif - __pyx_methods /* m_methods */, - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_moduledef_slots, /* m_slots */ - #else - NULL, /* m_reload */ - #endif - NULL, /* m_traverse */ - NULL, /* m_clear */ - NULL /* m_free */ -}; -#endif -#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_DTYPE, __pyx_k_DTYPE, sizeof(__pyx_k_DTYPE), 0, 0, 1, 1}, - {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, - {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0}, - {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, - {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0}, - {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, - {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, - {&__pyx_n_s_X, __pyx_k_X, sizeof(__pyx_k_X), 0, 0, 1, 1}, - {&__pyx_n_s_activation, __pyx_k_activation, sizeof(__pyx_k_activation), 0, 0, 1, 1}, - {&__pyx_n_s_activations, __pyx_k_activations, sizeof(__pyx_k_activations), 0, 0, 1, 1}, - {&__pyx_n_s_alpha, __pyx_k_alpha, sizeof(__pyx_k_alpha), 0, 0, 1, 1}, - {&__pyx_n_s_alpha_end, __pyx_k_alpha_end, sizeof(__pyx_k_alpha_end), 0, 0, 1, 1}, - {&__pyx_n_s_alpha_start, __pyx_k_alpha_start, sizeof(__pyx_k_alpha_start), 0, 0, 1, 1}, - {&__pyx_n_s_arange, __pyx_k_arange, sizeof(__pyx_k_arange), 0, 0, 1, 1}, - {&__pyx_n_s_argmin, __pyx_k_argmin, sizeof(__pyx_k_argmin), 0, 0, 1, 1}, - {&__pyx_n_s_argsort, __pyx_k_argsort, sizeof(__pyx_k_argsort), 0, 0, 1, 1}, - {&__pyx_n_s_axis, __pyx_k_axis, sizeof(__pyx_k_axis), 0, 0, 1, 1}, - {&__pyx_n_s_best, __pyx_k_best, sizeof(__pyx_k_best), 0, 0, 1, 1}, - {&__pyx_n_s_bmu, __pyx_k_bmu, sizeof(__pyx_k_bmu), 0, 0, 1, 1}, - {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, - {&__pyx_n_s_core, __pyx_k_core, sizeof(__pyx_k_core), 0, 0, 1, 1}, - {&__pyx_n_s_count_modified_cells, __pyx_k_count_modified_cells, sizeof(__pyx_k_count_modified_cells), 0, 0, 1, 1}, - {&__pyx_n_s_create_map_online, __pyx_k_create_map_online, sizeof(__pyx_k_create_map_online), 0, 0, 1, 1}, - {&__pyx_n_s_curr_t, __pyx_k_curr_t, sizeof(__pyx_k_curr_t), 0, 0, 1, 1}, - {&__pyx_n_s_dist_lib, __pyx_k_dist_lib, sizeof(__pyx_k_dist_lib), 0, 0, 1, 1}, - {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, - {&__pyx_n_s_exp, __pyx_k_exp, sizeof(__pyx_k_exp), 0, 0, 1, 1}, - {&__pyx_n_s_float, __pyx_k_float, sizeof(__pyx_k_float), 0, 0, 1, 1}, - {&__pyx_n_s_get_alpha, __pyx_k_get_alpha, sizeof(__pyx_k_get_alpha), 0, 0, 1, 1}, - {&__pyx_n_s_get_best_cell, __pyx_k_get_best_cell, sizeof(__pyx_k_get_best_cell), 0, 0, 1, 1}, - {&__pyx_n_s_get_sigma, __pyx_k_get_sigma, sizeof(__pyx_k_get_sigma), 0, 0, 1, 1}, - {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, - {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, - {&__pyx_n_s_importance, __pyx_k_importance, sizeof(__pyx_k_importance), 0, 0, 1, 1}, - {&__pyx_n_s_inputs, __pyx_k_inputs, sizeof(__pyx_k_inputs), 0, 0, 1, 1}, - {&__pyx_n_s_it, __pyx_k_it, sizeof(__pyx_k_it), 0, 0, 1, 1}, - {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, - {&__pyx_n_s_map_d, __pyx_k_map_d, sizeof(__pyx_k_map_d), 0, 0, 1, 1}, - {&__pyx_n_s_max, __pyx_k_max, sizeof(__pyx_k_max), 0, 0, 1, 1}, - {&__pyx_n_s_min, __pyx_k_min, sizeof(__pyx_k_min), 0, 0, 1, 1}, - {&__pyx_n_s_n_col, __pyx_k_n_col, sizeof(__pyx_k_n_col), 0, 0, 1, 1}, - {&__pyx_n_s_n_iter, __pyx_k_n_iter, sizeof(__pyx_k_n_iter), 0, 0, 1, 1}, - {&__pyx_n_s_n_pix, __pyx_k_n_pix, sizeof(__pyx_k_n_pix), 0, 0, 1, 1}, - {&__pyx_n_s_n_row, __pyx_k_n_row, sizeof(__pyx_k_n_row), 0, 0, 1, 1}, - {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, - {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, - {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, - {&__pyx_kp_u_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 1, 0, 0}, - {&__pyx_kp_u_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 1, 0, 0}, - {&__pyx_n_s_power, __pyx_k_power, sizeof(__pyx_k_power), 0, 0, 1, 1}, - {&__pyx_n_s_random, __pyx_k_random, sizeof(__pyx_k_random), 0, 0, 1, 1}, - {&__pyx_n_s_random_indices, __pyx_k_random_indices, sizeof(__pyx_k_random_indices), 0, 0, 1, 1}, - {&__pyx_n_s_random_order, __pyx_k_random_order, sizeof(__pyx_k_random_order), 0, 0, 1, 1}, - {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, - {&__pyx_n_s_return_vals, __pyx_k_return_vals, sizeof(__pyx_k_return_vals), 0, 0, 1, 1}, - {&__pyx_n_s_sample, __pyx_k_sample, sizeof(__pyx_k_sample), 0, 0, 1, 1}, - {&__pyx_n_s_sigma, __pyx_k_sigma, sizeof(__pyx_k_sigma), 0, 0, 1, 1}, - {&__pyx_n_s_sigma_0, __pyx_k_sigma_0, sizeof(__pyx_k_sigma_0), 0, 0, 1, 1}, - {&__pyx_n_s_sigma_f, __pyx_k_sigma_f, sizeof(__pyx_k_sigma_f), 0, 0, 1, 1}, - {&__pyx_kp_s_somsphere_cython_core_pyx, __pyx_k_somsphere_cython_core_pyx, sizeof(__pyx_k_somsphere_cython_core_pyx), 0, 0, 1, 0}, - {&__pyx_n_s_somsphere_utils, __pyx_k_somsphere_utils, sizeof(__pyx_k_somsphere_utils), 0, 0, 1, 1}, - {&__pyx_n_s_sum, __pyx_k_sum, sizeof(__pyx_k_sum), 0, 0, 1, 1}, - {&__pyx_n_s_t, __pyx_k_t, sizeof(__pyx_k_t), 0, 0, 1, 1}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {&__pyx_n_s_tile, __pyx_k_tile, sizeof(__pyx_k_tile), 0, 0, 1, 1}, - {&__pyx_n_s_timeit, __pyx_k_timeit, sizeof(__pyx_k_timeit), 0, 0, 1, 1}, - {&__pyx_n_s_total_t, __pyx_k_total_t, sizeof(__pyx_k_total_t), 0, 0, 1, 1}, - {&__pyx_n_s_transpose, __pyx_k_transpose, sizeof(__pyx_k_transpose), 0, 0, 1, 1}, - {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0}, - {&__pyx_n_s_weights, __pyx_k_weights, sizeof(__pyx_k_weights), 0, 0, 1, 1}, - {&__pyx_n_s_where, __pyx_k_where, sizeof(__pyx_k_where), 0, 0, 1, 1}, - {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1}, - {0, 0, 0, 0, 0, 0, 0} -}; -static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { - __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 84, __pyx_L1_error) - __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 777, __pyx_L1_error) - __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 781, __pyx_L1_error) - __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 959, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; -} - -static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":777 - * - * if (end - f) - (new_offset - offset[0]) < 15: - * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< - * - * if ((child.byteorder == c'>' and little_endian) or - */ - __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 777, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple_); - __Pyx_GIVEREF(__pyx_tuple_); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":781 - * if ((child.byteorder == c'>' and little_endian) or - * (child.byteorder == c'<' and not little_endian)): - * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< - * # One could encode it in the format string and have Cython - * # complain instead, BUT: < and > in format strings also imply - */ - __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 781, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__2); - __Pyx_GIVEREF(__pyx_tuple__2); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":801 - * t = child.type_num - * if end - f < 5: - * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< - * - * # Until ticket #99 is fixed, use integers to avoid warnings - */ - __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 801, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__3); - __Pyx_GIVEREF(__pyx_tuple__3); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":959 - * __pyx_import_array() - * except Exception: - * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< - * - * cdef inline int import_umath() except -1: - */ - __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 959, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__4); - __Pyx_GIVEREF(__pyx_tuple__4); - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":965 - * _import_umath() - * except Exception: - * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< - * - * cdef inline int import_ufunc() except -1: - */ - __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 965, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__5); - __Pyx_GIVEREF(__pyx_tuple__5); - - /* "core.pyx":38 - * # - * # t += n_row - * def get_alpha(float alpha_end, float alpha_start, int curr_t, int total_t): # <<<<<<<<<<<<<< - * """ - * Get value of alpha at a given time - */ - __pyx_tuple__6 = PyTuple_Pack(4, __pyx_n_s_alpha_end, __pyx_n_s_alpha_start, __pyx_n_s_curr_t, __pyx_n_s_total_t); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 38, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__6); - __Pyx_GIVEREF(__pyx_tuple__6); - __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(4, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_somsphere_cython_core_pyx, __pyx_n_s_get_alpha, 38, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 38, __pyx_L1_error) - - /* "core.pyx":44 - * return alpha_start * np.power(alpha_end / alpha_start, float(curr_t) / float(total_t)) - * - * def get_sigma(float sigma_f, float sigma_0, int curr_t, int total_t): # <<<<<<<<<<<<<< - * """ - * Get value of sigma at a given time - */ - __pyx_tuple__8 = PyTuple_Pack(4, __pyx_n_s_sigma_f, __pyx_n_s_sigma_0, __pyx_n_s_curr_t, __pyx_n_s_total_t); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 44, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__8); - __Pyx_GIVEREF(__pyx_tuple__8); - __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(4, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_somsphere_cython_core_pyx, __pyx_n_s_get_sigma, 44, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 44, __pyx_L1_error) - - /* "core.pyx":51 - * - * @timeit - * def get_best_cell(cnp.ndarray inputs, cnp.ndarray importance, int n_pix, cnp.ndarray weights, int return_vals): # <<<<<<<<<<<<<< - * """ - * Return the closest cell to the input object - */ - __pyx_tuple__10 = PyTuple_Pack(7, __pyx_n_s_inputs, __pyx_n_s_importance, __pyx_n_s_n_pix, __pyx_n_s_weights, __pyx_n_s_return_vals, __pyx_n_s_activation, __pyx_n_s_activations); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 51, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__10); - __Pyx_GIVEREF(__pyx_tuple__10); - __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(5, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_somsphere_cython_core_pyx, __pyx_n_s_get_best_cell, 51, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(0, 51, __pyx_L1_error) - - /* "core.pyx":62 - * return np.argmin(activations) if return_vals == 1 else np.argsort(activations)[0:return_vals], activations - * - * def count_modified_cells(int bmu, cnp.ndarray map_d, float sigma): # <<<<<<<<<<<<<< - * """ - * Neighborhood function which quantifies how much cells around the best matching one are modified - */ - __pyx_tuple__12 = PyTuple_Pack(3, __pyx_n_s_bmu, __pyx_n_s_map_d, __pyx_n_s_sigma); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 62, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__12); - __Pyx_GIVEREF(__pyx_tuple__12); - __pyx_codeobj__13 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_somsphere_cython_core_pyx, __pyx_n_s_count_modified_cells, 62, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__13)) __PYX_ERR(0, 62, __pyx_L1_error) - - /* "core.pyx":71 - * return np.exp(-(map_d[bmu] ** 2) / sigma ** 2) - * - * def create_map_online(cnp.ndarray X, int n_iter, int n_row, int n_col, int n_pix, float alpha_start, float alpha_end, # <<<<<<<<<<<<<< - * cnp.ndarray importance, cnp.ndarray dist_lib, cnp.ndarray weights, bint random_order): - * cdef int t = 0 - */ - __pyx_tuple__14 = PyTuple_Pack(23, __pyx_n_s_X, __pyx_n_s_n_iter, __pyx_n_s_n_row, __pyx_n_s_n_col, __pyx_n_s_n_pix, __pyx_n_s_alpha_start, __pyx_n_s_alpha_end, __pyx_n_s_importance, __pyx_n_s_dist_lib, __pyx_n_s_weights, __pyx_n_s_random_order, __pyx_n_s_t, __pyx_n_s_total_t, __pyx_n_s_sigma_0, __pyx_n_s_sigma_f, __pyx_n_s_i, __pyx_n_s_best, __pyx_n_s_alpha, __pyx_n_s_sigma, __pyx_n_s_random_indices, __pyx_n_s_inputs, __pyx_n_s_activation, __pyx_n_s_it); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 71, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__14); - __Pyx_GIVEREF(__pyx_tuple__14); - __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(11, 0, 23, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_somsphere_cython_core_pyx, __pyx_n_s_create_map_online, 71, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(0, 71, __pyx_L1_error) - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} - -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); - __pyx_float_0_ = PyFloat_FromDouble(0.); if (unlikely(!__pyx_float_0_)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) - return 0; - __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) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); - /*--- Global init code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_variable_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); - /*--- Variable export code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_function_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); - /*--- Function export code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_type_init_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); - /*--- Type init code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_type_import_code(void) { - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); - /*--- Type import code ---*/ - __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", - #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyTypeObject), - #else - sizeof(PyHeapTypeObject), - #endif - __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 207, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 207, __pyx_L1_error) - __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 230, __pyx_L1_error) - __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 234, __pyx_L1_error) - __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 246, __pyx_L1_error) - __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 839, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_RefNannyFinishContext(); - return -1; -} - -static int __Pyx_modinit_variable_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); - /*--- Variable import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_function_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); - /*--- Function import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - - -#ifndef CYTHON_NO_PYINIT_EXPORT -#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC -#elif PY_MAJOR_VERSION < 3 -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" void -#else -#define __Pyx_PyMODINIT_FUNC void -#endif -#else -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * -#else -#define __Pyx_PyMODINIT_FUNC PyObject * -#endif -#endif - - -#if PY_MAJOR_VERSION < 3 -__Pyx_PyMODINIT_FUNC initcore(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC initcore(void) -#else -__Pyx_PyMODINIT_FUNC PyInit_core(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC PyInit_core(void) -#if CYTHON_PEP489_MULTI_PHASE_INIT -{ - return PyModuleDef_Init(&__pyx_moduledef); -} -static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { - #if PY_VERSION_HEX >= 0x030700A1 - static PY_INT64_T main_interpreter_id = -1; - PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); - if (main_interpreter_id == -1) { - main_interpreter_id = current_id; - return (unlikely(current_id == -1)) ? -1 : 0; - } else if (unlikely(main_interpreter_id != current_id)) - #else - static PyInterpreterState *main_interpreter = NULL; - PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; - if (!main_interpreter) { - main_interpreter = current_interpreter; - } else if (unlikely(main_interpreter != current_interpreter)) - #endif - { - PyErr_SetString( - PyExc_ImportError, - "Interpreter change detected - this module can only be loaded into one interpreter per process."); - return -1; - } - return 0; -} -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) { - 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); - } - Py_DECREF(value); - } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { - PyErr_Clear(); - } else { - result = -1; - } - return result; -} -static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, 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"); - if (unlikely(!modname)) goto bad; - module = PyModule_NewObject(modname); - Py_DECREF(modname); - if (unlikely(!module)) goto bad; - moddict = PyModule_GetDict(module); - if (unlikely(!moddict)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; - return module; -bad: - Py_XDECREF(module); - return NULL; -} - - -static CYTHON_SMALL_CODE int __pyx_pymod_exec_core(PyObject *__pyx_pyinit_module) -#endif -#endif -{ - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannyDeclarations - #if CYTHON_PEP489_MULTI_PHASE_INIT - if (__pyx_m) { - if (__pyx_m == __pyx_pyinit_module) return 0; - PyErr_SetString(PyExc_RuntimeError, "Module 'core' has already been imported. Re-initialisation is not supported."); - return -1; - } - #elif PY_MAJOR_VERSION >= 3 - if (__pyx_m) return __Pyx_NewRef(__pyx_m); - #endif - #if CYTHON_REFNANNY -__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); -if (!__Pyx_RefNanny) { - PyErr_Clear(); - __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); - if (!__Pyx_RefNanny) - Py_FatalError("failed to import 'refnanny' module"); -} -#endif - __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_core(void)", 0); - if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pxy_PyFrame_Initialize_Offsets - __Pxy_PyFrame_Initialize_Offsets(); - #endif - __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pyx_CyFunction_USED - if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_FusedFunction_USED - if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Coroutine_USED - if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Generator_USED - if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_AsyncGen_USED - if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_StopAsyncIteration_USED - if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - /*--- Library function declarations ---*/ - /*--- Threads initialization code ---*/ - #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS - #ifdef WITH_THREAD /* Python build with threading support? */ - PyEval_InitThreads(); - #endif - #endif - /*--- Module creation code ---*/ - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_m = __pyx_pyinit_module; - Py_INCREF(__pyx_m); - #else - #if PY_MAJOR_VERSION < 3 - __pyx_m = Py_InitModule4("core", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); - #else - __pyx_m = PyModule_Create(&__pyx_moduledef); - #endif - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_d); - __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_b); - __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_cython_runtime); - if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); - /*--- Initialize various global constants etc. ---*/ - if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) - if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - if (__pyx_module_is_main_core) { - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - } - #if PY_MAJOR_VERSION >= 3 - { - PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) - if (!PyDict_GetItemString(modules, "core")) { - if (unlikely(PyDict_SetItemString(modules, "core", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) - } - } - #endif - /*--- Builtin init code ---*/ - if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Constants init code ---*/ - if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Global type/function init code ---*/ - (void)__Pyx_modinit_global_init_code(); - (void)__Pyx_modinit_variable_export_code(); - (void)__Pyx_modinit_function_export_code(); - (void)__Pyx_modinit_type_init_code(); - if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) - (void)__Pyx_modinit_variable_import_code(); - (void)__Pyx_modinit_function_import_code(); - /*--- Execution code ---*/ - #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) - if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - - /* "core.pyx":2 - * #cython: language_level=3 - * import random # <<<<<<<<<<<<<< - * - * import numpy as np - */ - __pyx_t_1 = __Pyx_Import(__pyx_n_s_random, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_random, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "core.pyx":4 - * import random - * - * import numpy as np # <<<<<<<<<<<<<< - * cimport numpy as cnp - * - */ - __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "core.pyx":7 - * cimport numpy as cnp - * - * from somsphere.utils import timeit # <<<<<<<<<<<<<< - * - * DTYPE = np.float - */ - __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_n_s_timeit); - __Pyx_GIVEREF(__pyx_n_s_timeit); - PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_timeit); - __pyx_t_2 = __Pyx_Import(__pyx_n_s_somsphere_utils, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_timeit); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_timeit, __pyx_t_1) < 0) __PYX_ERR(0, 7, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "core.pyx":9 - * from somsphere.utils import timeit - * - * DTYPE = np.float # <<<<<<<<<<<<<< - * ctypedef cnp.float_t DTYPE_t - * # def create_map_batch(np.ndarray X, int n_iter, int n_row, int n_col, int n_pix, np.ndarray importance, - */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_float); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_DTYPE, __pyx_t_1) < 0) __PYX_ERR(0, 9, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "core.pyx":38 - * # - * # t += n_row - * def get_alpha(float alpha_end, float alpha_start, int curr_t, int total_t): # <<<<<<<<<<<<<< - * """ - * Get value of alpha at a given time - */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_4core_1get_alpha, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 38, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_alpha, __pyx_t_1) < 0) __PYX_ERR(0, 38, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "core.pyx":44 - * return alpha_start * np.power(alpha_end / alpha_start, float(curr_t) / float(total_t)) - * - * def get_sigma(float sigma_f, float sigma_0, int curr_t, int total_t): # <<<<<<<<<<<<<< - * """ - * Get value of sigma at a given time - */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_4core_3get_sigma, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 44, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_sigma, __pyx_t_1) < 0) __PYX_ERR(0, 44, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "core.pyx":50 - * return sigma_0 * np.power(sigma_f / sigma_0, float(curr_t) / float(total_t)) - * - * @timeit # <<<<<<<<<<<<<< - * def get_best_cell(cnp.ndarray inputs, cnp.ndarray importance, int n_pix, cnp.ndarray weights, int return_vals): - * """ - */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_timeit); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 50, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - - /* "core.pyx":51 - * - * @timeit - * def get_best_cell(cnp.ndarray inputs, cnp.ndarray importance, int n_pix, cnp.ndarray weights, int return_vals): # <<<<<<<<<<<<<< - * """ - * Return the closest cell to the input object - */ - __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_4core_5get_best_cell, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 51, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - - /* "core.pyx":50 - * return sigma_0 * np.power(sigma_f / sigma_0, float(curr_t) / float(total_t)) - * - * @timeit # <<<<<<<<<<<<<< - * def get_best_cell(cnp.ndarray inputs, cnp.ndarray importance, int n_pix, cnp.ndarray weights, int return_vals): - * """ - */ - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 50, __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; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_best_cell, __pyx_t_3) < 0) __PYX_ERR(0, 51, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "core.pyx":62 - * return np.argmin(activations) if return_vals == 1 else np.argsort(activations)[0:return_vals], activations - * - * def count_modified_cells(int bmu, cnp.ndarray map_d, float sigma): # <<<<<<<<<<<<<< - * """ - * Neighborhood function which quantifies how much cells around the best matching one are modified - */ - __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_4core_7count_modified_cells, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 62, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_count_modified_cells, __pyx_t_3) < 0) __PYX_ERR(0, 62, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "core.pyx":71 - * return np.exp(-(map_d[bmu] ** 2) / sigma ** 2) - * - * def create_map_online(cnp.ndarray X, int n_iter, int n_row, int n_col, int n_pix, float alpha_start, float alpha_end, # <<<<<<<<<<<<<< - * cnp.ndarray importance, cnp.ndarray dist_lib, cnp.ndarray weights, bint random_order): - * cdef int t = 0 - */ - __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_4core_9create_map_online, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 71, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_create_map_online, __pyx_t_3) < 0) __PYX_ERR(0, 71, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "core.pyx":1 - * #cython: language_level=3 # <<<<<<<<<<<<<< - * import random - * - */ - __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "../env38/lib/python3.8/site-packages/numpy/__init__.pxd":967 - * raise ImportError("numpy.core.umath failed to import") - * - * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() - */ - - /*--- Wrapped vars code ---*/ - - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - if (__pyx_m) { - if (__pyx_d) { - __Pyx_AddTraceback("init core", __pyx_clineno, __pyx_lineno, __pyx_filename); - } - Py_CLEAR(__pyx_m); - } else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_ImportError, "init core"); - } - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - #if CYTHON_PEP489_MULTI_PHASE_INIT - return (__pyx_m != NULL) ? 0 : -1; - #elif PY_MAJOR_VERSION >= 3 - return __pyx_m; - #else - return; - #endif -} - -/* --- Runtime support code --- */ -/* Refnanny */ -#if CYTHON_REFNANNY -static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { - PyObject *m = NULL, *p = NULL; - void *r = NULL; - m = PyImport_ImportModule(modname); - if (!m) goto end; - p = PyObject_GetAttrString(m, "RefNannyAPI"); - if (!p) goto end; - r = PyLong_AsVoidPtr(p); -end: - Py_XDECREF(p); - Py_XDECREF(m); - return (__Pyx_RefNannyAPIStruct *)r; -} -#endif - -/* PyObjectGetAttrStr */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { - PyTypeObject* tp = Py_TYPE(obj); - if (likely(tp->tp_getattro)) - return tp->tp_getattro(obj, attr_name); -#if PY_MAJOR_VERSION < 3 - if (likely(tp->tp_getattr)) - return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); -#endif - return PyObject_GetAttr(obj, attr_name); -} -#endif - -/* GetBuiltinName */ -static PyObject *__Pyx_GetBuiltinName(PyObject *name) { - PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); - if (unlikely(!result)) { - PyErr_Format(PyExc_NameError, -#if PY_MAJOR_VERSION >= 3 - "name '%U' is not defined", name); -#else - "name '%.200s' is not defined", PyString_AS_STRING(name)); -#endif - } - return result; -} - -/* RaiseArgTupleInvalid */ -static void __Pyx_RaiseArgtupleInvalid( - const char* func_name, - int exact, - Py_ssize_t num_min, - Py_ssize_t num_max, - Py_ssize_t num_found) -{ - Py_ssize_t num_expected; - const char *more_or_less; - if (num_found < num_min) { - num_expected = num_min; - more_or_less = "at least"; - } else { - num_expected = num_max; - more_or_less = "at most"; - } - if (exact) { - more_or_less = "exactly"; - } - PyErr_Format(PyExc_TypeError, - "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", - func_name, more_or_less, num_expected, - (num_expected == 1) ? "" : "s", num_found); -} - -/* RaiseDoubleKeywords */ -static void __Pyx_RaiseDoubleKeywordsError( - const char* func_name, - PyObject* kw_name) -{ - PyErr_Format(PyExc_TypeError, - #if PY_MAJOR_VERSION >= 3 - "%s() got multiple values for keyword argument '%U'", func_name, kw_name); - #else - "%s() got multiple values for keyword argument '%s'", func_name, - PyString_AsString(kw_name)); - #endif -} - -/* ParseKeywords */ -static int __Pyx_ParseOptionalKeywords( - PyObject *kwds, - PyObject **argnames[], - PyObject *kwds2, - PyObject *values[], - Py_ssize_t num_pos_args, - const char* function_name) -{ - PyObject *key = 0, *value = 0; - Py_ssize_t pos = 0; - PyObject*** name; - PyObject*** first_kw_arg = argnames + num_pos_args; - while (PyDict_Next(kwds, &pos, &key, &value)) { - name = first_kw_arg; - while (*name && (**name != key)) name++; - if (*name) { - values[name-argnames] = value; - continue; - } - name = first_kw_arg; - #if PY_MAJOR_VERSION < 3 - if (likely(PyString_Check(key))) { - while (*name) { - if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) - && _PyString_Eq(**name, key)) { - values[name-argnames] = value; - break; - } - name++; - } - if (*name) continue; - else { - PyObject*** argname = argnames; - while (argname != first_kw_arg) { - if ((**argname == key) || ( - (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) - && _PyString_Eq(**argname, key))) { - goto arg_passed_twice; - } - argname++; - } - } - } else - #endif - if (likely(PyUnicode_Check(key))) { - while (*name) { - int cmp = (**name == key) ? 0 : - #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : - #endif - PyUnicode_Compare(**name, key); - if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; - if (cmp == 0) { - values[name-argnames] = value; - break; - } - name++; - } - if (*name) continue; - else { - PyObject*** argname = argnames; - while (argname != first_kw_arg) { - int cmp = (**argname == key) ? 0 : - #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : - #endif - PyUnicode_Compare(**argname, key); - if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; - if (cmp == 0) goto arg_passed_twice; - argname++; - } - } - } else - goto invalid_keyword_type; - if (kwds2) { - if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; - } else { - goto invalid_keyword; - } - } - return 0; -arg_passed_twice: - __Pyx_RaiseDoubleKeywordsError(function_name, key); - goto bad; -invalid_keyword_type: - PyErr_Format(PyExc_TypeError, - "%.200s() keywords must be strings", function_name); - goto bad; -invalid_keyword: - PyErr_Format(PyExc_TypeError, - #if PY_MAJOR_VERSION < 3 - "%.200s() got an unexpected keyword argument '%.200s'", - function_name, PyString_AsString(key)); - #else - "%s() got an unexpected keyword argument '%U'", - function_name, key); - #endif -bad: - return -1; -} - -/* PyDictVersioning */ -#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { - PyObject *dict = Py_TYPE(obj)->tp_dict; - return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; -} -static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { - PyObject **dictptr = NULL; - Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; - if (offset) { -#if CYTHON_COMPILING_IN_CPYTHON - dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); -#else - dictptr = _PyObject_GetDictPtr(obj); -#endif - } - return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; -} -static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { - PyObject *dict = Py_TYPE(obj)->tp_dict; - if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) - return 0; - return obj_dict_version == __Pyx_get_object_dict_version(obj); -} -#endif - -/* GetModuleGlobalName */ -#if CYTHON_USE_DICT_VERSIONS -static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) -#else -static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) -#endif -{ - PyObject *result; -#if !CYTHON_AVOID_BORROWED_REFS -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 - result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } else if (unlikely(PyErr_Occurred())) { - return NULL; - } -#else - result = PyDict_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } -#endif -#else - result = PyObject_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } - PyErr_Clear(); -#endif - return __Pyx_GetBuiltinName(name); -} - -/* PyFunctionFastCall */ -#if CYTHON_FAST_PYCALL -static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, - PyObject *globals) { - PyFrameObject *f; - PyThreadState *tstate = __Pyx_PyThreadState_Current; - PyObject **fastlocals; - Py_ssize_t i; - PyObject *result; - assert(globals != NULL); - /* XXX Perhaps we should create a specialized - PyFrame_New() that doesn't take locals, but does - take builtins without sanity checking them. - */ - assert(tstate != NULL); - f = PyFrame_New(tstate, co, globals, NULL); - if (f == NULL) { - return NULL; - } - fastlocals = __Pyx_PyFrame_GetLocalsplus(f); - for (i = 0; i < na; i++) { - Py_INCREF(*args); - fastlocals[i] = *args++; - } - result = PyEval_EvalFrameEx(f,0); - ++tstate->recursion_depth; - Py_DECREF(f); - --tstate->recursion_depth; - return result; -} -#if 1 || PY_VERSION_HEX < 0x030600B1 -static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { - PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); - PyObject *globals = PyFunction_GET_GLOBALS(func); - PyObject *argdefs = PyFunction_GET_DEFAULTS(func); - PyObject *closure; -#if PY_MAJOR_VERSION >= 3 - PyObject *kwdefs; -#endif - PyObject *kwtuple, **k; - PyObject **d; - Py_ssize_t nd; - Py_ssize_t nk; - PyObject *result; - assert(kwargs == NULL || PyDict_Check(kwargs)); - nk = kwargs ? PyDict_Size(kwargs) : 0; - if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { - return NULL; - } - if ( -#if PY_MAJOR_VERSION >= 3 - co->co_kwonlyargcount == 0 && -#endif - likely(kwargs == NULL || nk == 0) && - co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { - if (argdefs == NULL && co->co_argcount == nargs) { - result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); - goto done; - } - else if (nargs == 0 && argdefs != NULL - && co->co_argcount == Py_SIZE(argdefs)) { - /* function called with no arguments, but all parameters have - a default value: use default values as arguments .*/ - args = &PyTuple_GET_ITEM(argdefs, 0); - result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); - goto done; - } - } - if (kwargs != NULL) { - Py_ssize_t pos, i; - kwtuple = PyTuple_New(2 * nk); - if (kwtuple == NULL) { - result = NULL; - goto done; - } - k = &PyTuple_GET_ITEM(kwtuple, 0); - pos = i = 0; - while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { - Py_INCREF(k[i]); - Py_INCREF(k[i+1]); - i += 2; - } - nk = i / 2; - } - else { - kwtuple = NULL; - k = NULL; - } - closure = PyFunction_GET_CLOSURE(func); -#if PY_MAJOR_VERSION >= 3 - kwdefs = PyFunction_GET_KW_DEFAULTS(func); -#endif - if (argdefs != NULL) { - d = &PyTuple_GET_ITEM(argdefs, 0); - nd = Py_SIZE(argdefs); - } - else { - d = NULL; - nd = 0; - } -#if PY_MAJOR_VERSION >= 3 - result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, kwdefs, closure); -#else - result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, closure); -#endif - Py_XDECREF(kwtuple); -done: - Py_LeaveRecursiveCall(); - return result; -} -#endif -#endif - -/* PyCFunctionFastCall */ -#if CYTHON_FAST_PYCCALL -static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { - PyCFunctionObject *func = (PyCFunctionObject*)func_obj; - PyCFunction meth = PyCFunction_GET_FUNCTION(func); - PyObject *self = PyCFunction_GET_SELF(func); - int flags = PyCFunction_GET_FLAGS(func); - assert(PyCFunction_Check(func)); - assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); - assert(nargs >= 0); - assert(nargs == 0 || args != NULL); - /* _PyCFunction_FastCallDict() must not be called with an exception set, - because it may clear it (directly or indirectly) and so the - caller loses its exception */ - assert(!PyErr_Occurred()); - if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { - return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); - } else { - return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); - } -} -#endif - -/* PyObjectCall */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { - PyObject *result; - ternaryfunc call = func->ob_type->tp_call; - if (unlikely(!call)) - return PyObject_Call(func, arg, kw); - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - result = (*call)(func, arg, kw); - Py_LeaveRecursiveCall(); - if (unlikely(!result) && unlikely(!PyErr_Occurred())) { - PyErr_SetString( - PyExc_SystemError, - "NULL result without error in PyObject_Call"); - } - return result; -} -#endif - -/* ArgTypeTest */ -static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) -{ - if (unlikely(!type)) { - PyErr_SetString(PyExc_SystemError, "Missing type object"); - return 0; - } - else if (exact) { - #if PY_MAJOR_VERSION == 2 - if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; - #endif - } - else { - if (likely(__Pyx_TypeCheck(obj, type))) return 1; - } - PyErr_Format(PyExc_TypeError, - "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", - name, type->tp_name, Py_TYPE(obj)->tp_name); - return 0; -} - -/* ExtTypeTest */ -static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { - if (unlikely(!type)) { - PyErr_SetString(PyExc_SystemError, "Missing type object"); - return 0; - } - if (likely(__Pyx_TypeCheck(obj, type))) - return 1; - PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", - Py_TYPE(obj)->tp_name, type->tp_name); - return 0; -} - -/* 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) { - PyObject *self, *result; - PyCFunction cfunc; - cfunc = PyCFunction_GET_FUNCTION(func); - self = PyCFunction_GET_SELF(func); - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - result = cfunc(self, arg); - Py_LeaveRecursiveCall(); - if (unlikely(!result) && unlikely(!PyErr_Occurred())) { - PyErr_SetString( - PyExc_SystemError, - "NULL result without error in PyObject_Call"); - } - return result; -} -#endif - -/* PyObjectCallOneArg */ -#if CYTHON_COMPILING_IN_CPYTHON -static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *result; - PyObject *args = PyTuple_New(1); - if (unlikely(!args)) return NULL; - Py_INCREF(arg); - PyTuple_SET_ITEM(args, 0, arg); - result = __Pyx_PyObject_Call(func, args, NULL); - Py_DECREF(args); - return result; -} -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { -#if CYTHON_FAST_PYCALL - if (PyFunction_Check(func)) { - return __Pyx_PyFunction_FastCall(func, &arg, 1); - } -#endif - if (likely(PyCFunction_Check(func))) { - if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { - return __Pyx_PyObject_CallMethO(func, arg); -#if CYTHON_FAST_PYCCALL - } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { - return __Pyx_PyCFunction_FastCall(func, &arg, 1); -#endif - } - } - return __Pyx__PyObject_CallOneArg(func, arg); -} -#else -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *result; - PyObject *args = PyTuple_Pack(1, arg); - if (unlikely(!args)) return NULL; - result = __Pyx_PyObject_Call(func, args, NULL); - Py_DECREF(args); - return result; -} -#endif - -/* SliceObject */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj, - Py_ssize_t cstart, Py_ssize_t cstop, - PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice, - int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) { -#if CYTHON_USE_TYPE_SLOTS - PyMappingMethods* mp; -#if PY_MAJOR_VERSION < 3 - PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence; - if (likely(ms && ms->sq_slice)) { - if (!has_cstart) { - if (_py_start && (*_py_start != Py_None)) { - cstart = __Pyx_PyIndex_AsSsize_t(*_py_start); - if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; - } else - cstart = 0; - } - if (!has_cstop) { - if (_py_stop && (*_py_stop != Py_None)) { - cstop = __Pyx_PyIndex_AsSsize_t(*_py_stop); - if ((cstop == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; - } else - cstop = PY_SSIZE_T_MAX; - } - if (wraparound && unlikely((cstart < 0) | (cstop < 0)) && likely(ms->sq_length)) { - Py_ssize_t l = ms->sq_length(obj); - if (likely(l >= 0)) { - if (cstop < 0) { - cstop += l; - if (cstop < 0) cstop = 0; - } - if (cstart < 0) { - cstart += l; - if (cstart < 0) cstart = 0; - } - } else { - if (!PyErr_ExceptionMatches(PyExc_OverflowError)) - goto bad; - PyErr_Clear(); - } - } - return ms->sq_slice(obj, cstart, cstop); - } -#endif - mp = Py_TYPE(obj)->tp_as_mapping; - if (likely(mp && mp->mp_subscript)) -#endif - { - PyObject* result; - PyObject *py_slice, *py_start, *py_stop; - if (_py_slice) { - py_slice = *_py_slice; - } else { - PyObject* owned_start = NULL; - PyObject* owned_stop = NULL; - if (_py_start) { - py_start = *_py_start; - } else { - if (has_cstart) { - owned_start = py_start = PyInt_FromSsize_t(cstart); - if (unlikely(!py_start)) goto bad; - } else - py_start = Py_None; - } - if (_py_stop) { - py_stop = *_py_stop; - } else { - if (has_cstop) { - owned_stop = py_stop = PyInt_FromSsize_t(cstop); - if (unlikely(!py_stop)) { - Py_XDECREF(owned_start); - goto bad; - } - } else - py_stop = Py_None; - } - py_slice = PySlice_New(py_start, py_stop, Py_None); - Py_XDECREF(owned_start); - Py_XDECREF(owned_stop); - if (unlikely(!py_slice)) goto bad; - } -#if CYTHON_USE_TYPE_SLOTS - result = mp->mp_subscript(obj, py_slice); -#else - result = PyObject_GetItem(obj, py_slice); -#endif - if (!_py_slice) { - Py_DECREF(py_slice); - } - return result; - } - PyErr_Format(PyExc_TypeError, - "'%.200s' object is unsliceable", Py_TYPE(obj)->tp_name); -bad: - return NULL; -} - -/* GetItemInt */ -static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { - PyObject *r; - if (!j) return NULL; - r = PyObject_GetItem(o, j); - Py_DECREF(j); - return r; -} -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - Py_ssize_t wrapped_i = i; - if (wraparound & unlikely(i < 0)) { - wrapped_i += PyList_GET_SIZE(o); - } - if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { - PyObject *r = PyList_GET_ITEM(o, wrapped_i); - Py_INCREF(r); - return r; - } - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); -#else - return PySequence_GetItem(o, i); -#endif -} -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - Py_ssize_t wrapped_i = i; - if (wraparound & unlikely(i < 0)) { - wrapped_i += PyTuple_GET_SIZE(o); - } - if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { - PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); - Py_INCREF(r); - return r; - } - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); -#else - return PySequence_GetItem(o, i); -#endif -} -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS - if (is_list || PyList_CheckExact(o)) { - Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); - if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { - PyObject *r = PyList_GET_ITEM(o, n); - Py_INCREF(r); - return r; - } - } - else if (PyTuple_CheckExact(o)) { - Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); - if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { - PyObject *r = PyTuple_GET_ITEM(o, n); - Py_INCREF(r); - return r; - } - } else { - PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; - if (likely(m && m->sq_item)) { - if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { - Py_ssize_t l = m->sq_length(o); - if (likely(l >= 0)) { - i += l; - } else { - if (!PyErr_ExceptionMatches(PyExc_OverflowError)) - return NULL; - PyErr_Clear(); - } - } - return m->sq_item(o, i); - } - } -#else - if (is_list || PySequence_Check(o)) { - return PySequence_GetItem(o, i); - } -#endif - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); -} - -/* PyObjectCallNoArg */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { -#if CYTHON_FAST_PYCALL - if (PyFunction_Check(func)) { - return __Pyx_PyFunction_FastCall(func, NULL, 0); - } -#endif -#ifdef __Pyx_CyFunction_USED - if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func))) -#else - if (likely(PyCFunction_Check(func))) -#endif - { - if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { - return __Pyx_PyObject_CallMethO(func, NULL); - } - } - return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); -} -#endif - -/* ObjectGetItem */ -#if CYTHON_USE_TYPE_SLOTS -static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) { - PyObject *runerr; - Py_ssize_t key_value; - PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence; - if (unlikely(!(m && m->sq_item))) { - PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name); - return NULL; - } - key_value = __Pyx_PyIndex_AsSsize_t(index); - if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { - return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); - } - if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { - PyErr_Clear(); - PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name); - } - return NULL; -} -static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) { - PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping; - if (likely(m && m->mp_subscript)) { - return m->mp_subscript(obj, key); - } - return __Pyx_PyObject_GetIndex(obj, key); -} -#endif - -/* RaiseTooManyValuesToUnpack */ -static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { - PyErr_Format(PyExc_ValueError, - "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); -} - -/* RaiseNeedMoreValuesToUnpack */ -static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { - PyErr_Format(PyExc_ValueError, - "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", - index, (index == 1) ? "" : "s"); -} - -/* IterFinish */ -static CYTHON_INLINE int __Pyx_IterFinish(void) { -#if CYTHON_FAST_THREAD_STATE - PyThreadState *tstate = __Pyx_PyThreadState_Current; - PyObject* exc_type = tstate->curexc_type; - if (unlikely(exc_type)) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) { - PyObject *exc_value, *exc_tb; - exc_value = tstate->curexc_value; - exc_tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; - Py_DECREF(exc_type); - Py_XDECREF(exc_value); - Py_XDECREF(exc_tb); - return 0; - } else { - return -1; - } - } - return 0; -#else - if (unlikely(PyErr_Occurred())) { - if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { - PyErr_Clear(); - return 0; - } else { - return -1; - } - } - return 0; -#endif -} - -/* UnpackItemEndCheck */ -static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { - if (unlikely(retval)) { - Py_DECREF(retval); - __Pyx_RaiseTooManyValuesError(expected); - return -1; - } else { - return __Pyx_IterFinish(); - } - return 0; -} - -/* DictGetItem */ -#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY -static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { - PyObject *value; - value = PyDict_GetItemWithError(d, key); - if (unlikely(!value)) { - if (!PyErr_Occurred()) { - if (unlikely(PyTuple_Check(key))) { - PyObject* args = PyTuple_Pack(1, key); - if (likely(args)) { - PyErr_SetObject(PyExc_KeyError, args); - Py_DECREF(args); - } - } else { - PyErr_SetObject(PyExc_KeyError, key); - } - } - return NULL; - } - Py_INCREF(value); - return value; -} -#endif - -/* RaiseNoneIterError */ -static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); -} - -/* PyErrFetchRestore */ -#if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - tmp_type = tstate->curexc_type; - tmp_value = tstate->curexc_value; - tmp_tb = tstate->curexc_traceback; - tstate->curexc_type = type; - tstate->curexc_value = value; - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); -} -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - *type = tstate->curexc_type; - *value = tstate->curexc_value; - *tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; -} -#endif - -/* RaiseException */ -#if PY_MAJOR_VERSION < 3 -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, - CYTHON_UNUSED PyObject *cause) { - __Pyx_PyThreadState_declare - Py_XINCREF(type); - if (!value || value == Py_None) - value = NULL; - else - Py_INCREF(value); - if (!tb || tb == Py_None) - tb = NULL; - else { - Py_INCREF(tb); - if (!PyTraceBack_Check(tb)) { - PyErr_SetString(PyExc_TypeError, - "raise: arg 3 must be a traceback or None"); - goto raise_error; - } - } - if (PyType_Check(type)) { -#if CYTHON_COMPILING_IN_PYPY - if (!value) { - Py_INCREF(Py_None); - value = Py_None; - } -#endif - PyErr_NormalizeException(&type, &value, &tb); - } else { - if (value) { - PyErr_SetString(PyExc_TypeError, - "instance exception may not have a separate value"); - goto raise_error; - } - value = type; - type = (PyObject*) Py_TYPE(type); - Py_INCREF(type); - if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { - PyErr_SetString(PyExc_TypeError, - "raise: exception class must be a subclass of BaseException"); - goto raise_error; - } - } - __Pyx_PyThreadState_assign - __Pyx_ErrRestore(type, value, tb); - return; -raise_error: - Py_XDECREF(value); - Py_XDECREF(type); - Py_XDECREF(tb); - return; -} -#else -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { - PyObject* owned_instance = NULL; - if (tb == Py_None) { - tb = 0; - } else if (tb && !PyTraceBack_Check(tb)) { - PyErr_SetString(PyExc_TypeError, - "raise: arg 3 must be a traceback or None"); - goto bad; - } - if (value == Py_None) - value = 0; - if (PyExceptionInstance_Check(type)) { - if (value) { - PyErr_SetString(PyExc_TypeError, - "instance exception may not have a separate value"); - goto bad; - } - value = type; - type = (PyObject*) Py_TYPE(value); - } else if (PyExceptionClass_Check(type)) { - PyObject *instance_class = NULL; - if (value && PyExceptionInstance_Check(value)) { - instance_class = (PyObject*) Py_TYPE(value); - if (instance_class != type) { - int is_subclass = PyObject_IsSubclass(instance_class, type); - if (!is_subclass) { - instance_class = NULL; - } else if (unlikely(is_subclass == -1)) { - goto bad; - } else { - type = instance_class; - } - } - } - if (!instance_class) { - PyObject *args; - if (!value) - args = PyTuple_New(0); - else if (PyTuple_Check(value)) { - Py_INCREF(value); - args = value; - } else - args = PyTuple_Pack(1, value); - if (!args) - goto bad; - owned_instance = PyObject_Call(type, args, NULL); - Py_DECREF(args); - if (!owned_instance) - goto bad; - value = owned_instance; - if (!PyExceptionInstance_Check(value)) { - PyErr_Format(PyExc_TypeError, - "calling %R should have returned an instance of " - "BaseException, not %R", - type, Py_TYPE(value)); - goto bad; - } - } - } else { - PyErr_SetString(PyExc_TypeError, - "raise: exception class must be a subclass of BaseException"); - goto bad; - } - if (cause) { - PyObject *fixed_cause; - if (cause == Py_None) { - fixed_cause = NULL; - } else if (PyExceptionClass_Check(cause)) { - fixed_cause = PyObject_CallObject(cause, NULL); - if (fixed_cause == NULL) - goto bad; - } else if (PyExceptionInstance_Check(cause)) { - fixed_cause = cause; - Py_INCREF(fixed_cause); - } else { - PyErr_SetString(PyExc_TypeError, - "exception causes must derive from " - "BaseException"); - goto bad; - } - PyException_SetCause(value, fixed_cause); - } - PyErr_SetObject(type, value); - if (tb) { -#if CYTHON_COMPILING_IN_PYPY - PyObject *tmp_type, *tmp_value, *tmp_tb; - PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); - Py_INCREF(tb); - PyErr_Restore(tmp_type, tmp_value, tb); - Py_XDECREF(tmp_tb); -#else - PyThreadState *tstate = __Pyx_PyThreadState_Current; - PyObject* tmp_tb = tstate->curexc_traceback; - if (tb != tmp_tb) { - Py_INCREF(tb); - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_tb); - } -#endif - } -bad: - Py_XDECREF(owned_instance); - return; -} -#endif - -/* GetTopmostException */ -#if CYTHON_USE_EXC_INFO_STACK -static _PyErr_StackItem * -__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) -{ - _PyErr_StackItem *exc_info = tstate->exc_info; - while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && - exc_info->previous_item != NULL) - { - exc_info = exc_info->previous_item; - } - return exc_info; -} -#endif - -/* SaveResetException */ -#if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - #if CYTHON_USE_EXC_INFO_STACK - _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); - *type = exc_info->exc_type; - *value = exc_info->exc_value; - *tb = exc_info->exc_traceback; - #else - *type = tstate->exc_type; - *value = tstate->exc_value; - *tb = tstate->exc_traceback; - #endif - Py_XINCREF(*type); - Py_XINCREF(*value); - Py_XINCREF(*tb); -} -static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - #if CYTHON_USE_EXC_INFO_STACK - _PyErr_StackItem *exc_info = tstate->exc_info; - tmp_type = exc_info->exc_type; - tmp_value = exc_info->exc_value; - tmp_tb = exc_info->exc_traceback; - exc_info->exc_type = type; - exc_info->exc_value = value; - exc_info->exc_traceback = tb; - #else - tmp_type = tstate->exc_type; - tmp_value = tstate->exc_value; - tmp_tb = tstate->exc_traceback; - tstate->exc_type = type; - tstate->exc_value = value; - tstate->exc_traceback = tb; - #endif - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); -} -#endif - -/* PyErrExceptionMatches */ -#if CYTHON_FAST_THREAD_STATE -static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(tuple); -#if PY_MAJOR_VERSION >= 3 - for (i=0; icurexc_type; - if (exc_type == err) return 1; - if (unlikely(!exc_type)) return 0; - if (unlikely(PyTuple_Check(err))) - return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); - return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); -} -#endif - -/* GetException */ -#if CYTHON_FAST_THREAD_STATE -static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) -#else -static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) -#endif -{ - PyObject *local_type, *local_value, *local_tb; -#if CYTHON_FAST_THREAD_STATE - PyObject *tmp_type, *tmp_value, *tmp_tb; - local_type = tstate->curexc_type; - local_value = tstate->curexc_value; - local_tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; -#else - PyErr_Fetch(&local_type, &local_value, &local_tb); -#endif - PyErr_NormalizeException(&local_type, &local_value, &local_tb); -#if CYTHON_FAST_THREAD_STATE - if (unlikely(tstate->curexc_type)) -#else - if (unlikely(PyErr_Occurred())) -#endif - goto bad; - #if PY_MAJOR_VERSION >= 3 - if (local_tb) { - if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) - goto bad; - } - #endif - Py_XINCREF(local_tb); - Py_XINCREF(local_type); - Py_XINCREF(local_value); - *type = local_type; - *value = local_value; - *tb = local_tb; -#if CYTHON_FAST_THREAD_STATE - #if CYTHON_USE_EXC_INFO_STACK - { - _PyErr_StackItem *exc_info = tstate->exc_info; - tmp_type = exc_info->exc_type; - tmp_value = exc_info->exc_value; - tmp_tb = exc_info->exc_traceback; - exc_info->exc_type = local_type; - exc_info->exc_value = local_value; - exc_info->exc_traceback = local_tb; - } - #else - tmp_type = tstate->exc_type; - tmp_value = tstate->exc_value; - tmp_tb = tstate->exc_traceback; - tstate->exc_type = local_type; - tstate->exc_value = local_value; - tstate->exc_traceback = local_tb; - #endif - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); -#else - PyErr_SetExcInfo(local_type, local_value, local_tb); -#endif - return 0; -bad: - *type = 0; - *value = 0; - *tb = 0; - Py_XDECREF(local_type); - Py_XDECREF(local_value); - Py_XDECREF(local_tb); - return -1; -} - -/* TypeImport */ -#ifndef __PYX_HAVE_RT_ImportType -#define __PYX_HAVE_RT_ImportType -static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, - size_t size, enum __Pyx_ImportType_CheckSize check_size) -{ - PyObject *result = 0; - char warning[200]; - Py_ssize_t basicsize; -#ifdef Py_LIMITED_API - PyObject *py_basicsize; -#endif - result = PyObject_GetAttrString(module, class_name); - if (!result) - goto bad; - if (!PyType_Check(result)) { - PyErr_Format(PyExc_TypeError, - "%.200s.%.200s is not a type object", - module_name, class_name); - goto bad; - } -#ifndef Py_LIMITED_API - basicsize = ((PyTypeObject *)result)->tp_basicsize; -#else - py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); - if (!py_basicsize) - goto bad; - basicsize = PyLong_AsSsize_t(py_basicsize); - Py_DECREF(py_basicsize); - py_basicsize = 0; - if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) - goto bad; -#endif - if ((size_t)basicsize < size) { - PyErr_Format(PyExc_ValueError, - "%.200s.%.200s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); - goto bad; - } - if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { - PyErr_Format(PyExc_ValueError, - "%.200s.%.200s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); - goto bad; - } - else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { - PyOS_snprintf(warning, sizeof(warning), - "%s.%s size changed, may indicate binary incompatibility. " - "Expected %zd from C header, got %zd from PyObject", - module_name, class_name, size, basicsize); - if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; - } - return (PyTypeObject *)result; -bad: - Py_XDECREF(result); - return NULL; -} -#endif - -/* Import */ -static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { - PyObject *empty_list = 0; - PyObject *module = 0; - PyObject *global_dict = 0; - PyObject *empty_dict = 0; - PyObject *list; - #if PY_MAJOR_VERSION < 3 - PyObject *py_import; - py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); - if (!py_import) - goto bad; - #endif - if (from_list) - list = from_list; - else { - empty_list = PyList_New(0); - if (!empty_list) - goto bad; - list = empty_list; - } - global_dict = PyModule_GetDict(__pyx_m); - if (!global_dict) - goto bad; - empty_dict = PyDict_New(); - if (!empty_dict) - goto bad; - { - #if PY_MAJOR_VERSION >= 3 - if (level == -1) { - if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { - module = PyImport_ImportModuleLevelObject( - name, global_dict, empty_dict, list, 1); - if (!module) { - if (!PyErr_ExceptionMatches(PyExc_ImportError)) - goto bad; - PyErr_Clear(); - } - } - level = 0; - } - #endif - if (!module) { - #if PY_MAJOR_VERSION < 3 - PyObject *py_level = PyInt_FromLong(level); - if (!py_level) - goto bad; - module = PyObject_CallFunctionObjArgs(py_import, - name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); - Py_DECREF(py_level); - #else - module = PyImport_ImportModuleLevelObject( - name, global_dict, empty_dict, list, level); - #endif - } - } -bad: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(py_import); - #endif - Py_XDECREF(empty_list); - Py_XDECREF(empty_dict); - return module; -} - -/* ImportFrom */ -static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { - PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); - if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { - PyErr_Format(PyExc_ImportError, - #if PY_MAJOR_VERSION < 3 - "cannot import name %.230s", PyString_AS_STRING(name)); - #else - "cannot import name %S", name); - #endif - } - return value; -} - -/* CLineInTraceback */ -#ifndef CYTHON_CLINE_IN_TRACEBACK -static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { - PyObject *use_cline; - PyObject *ptype, *pvalue, *ptraceback; -#if CYTHON_COMPILING_IN_CPYTHON - PyObject **cython_runtime_dict; -#endif - if (unlikely(!__pyx_cython_runtime)) { - return c_line; - } - __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); -#if CYTHON_COMPILING_IN_CPYTHON - cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); - if (likely(cython_runtime_dict)) { - __PYX_PY_DICT_LOOKUP_IF_MODIFIED( - use_cline, *cython_runtime_dict, - __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) - } else -#endif - { - PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); - if (use_cline_obj) { - use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; - Py_DECREF(use_cline_obj); - } else { - PyErr_Clear(); - use_cline = NULL; - } - } - if (!use_cline) { - 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)) { - c_line = 0; - } - __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); - return c_line; -} -#endif - -/* CodeObjectCache */ -static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { - int start = 0, mid = 0, end = count - 1; - if (end >= 0 && code_line > entries[end].code_line) { - return count; - } - while (start < end) { - mid = start + (end - start) / 2; - if (code_line < entries[mid].code_line) { - end = mid; - } else if (code_line > entries[mid].code_line) { - start = mid + 1; - } else { - return mid; - } - } - if (code_line <= entries[mid].code_line) { - return mid; - } else { - return mid + 1; - } -} -static PyCodeObject *__pyx_find_code_object(int code_line) { - PyCodeObject* code_object; - int pos; - if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { - return NULL; - } - pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); - if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { - return NULL; - } - code_object = __pyx_code_cache.entries[pos].code_object; - Py_INCREF(code_object); - return code_object; -} -static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { - int pos, i; - __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; - if (unlikely(!code_line)) { - return; - } - if (unlikely(!entries)) { - entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); - if (likely(entries)) { - __pyx_code_cache.entries = entries; - __pyx_code_cache.max_count = 64; - __pyx_code_cache.count = 1; - entries[0].code_line = code_line; - entries[0].code_object = code_object; - Py_INCREF(code_object); - } - return; - } - pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); - if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { - PyCodeObject* tmp = entries[pos].code_object; - entries[pos].code_object = code_object; - Py_DECREF(tmp); - return; - } - if (__pyx_code_cache.count == __pyx_code_cache.max_count) { - int new_max = __pyx_code_cache.max_count + 64; - entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( - __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); - if (unlikely(!entries)) { - return; - } - __pyx_code_cache.entries = entries; - __pyx_code_cache.max_count = new_max; - } - for (i=__pyx_code_cache.count; i>pos; i--) { - entries[i] = entries[i-1]; - } - entries[pos].code_line = code_line; - entries[pos].code_object = code_object; - __pyx_code_cache.count++; - Py_INCREF(code_object); -} - -/* AddTraceback */ -#include "compile.h" -#include "frameobject.h" -#include "traceback.h" -static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( - const char *funcname, int c_line, - int py_line, const char *filename) { - PyCodeObject *py_code = 0; - PyObject *py_srcfile = 0; - PyObject *py_funcname = 0; - #if PY_MAJOR_VERSION < 3 - py_srcfile = PyString_FromString(filename); - #else - py_srcfile = PyUnicode_FromString(filename); - #endif - if (!py_srcfile) goto bad; - if (c_line) { - #if PY_MAJOR_VERSION < 3 - py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); - #else - py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); - #endif - } - else { - #if PY_MAJOR_VERSION < 3 - py_funcname = PyString_FromString(funcname); - #else - py_funcname = PyUnicode_FromString(funcname); - #endif - } - if (!py_funcname) goto bad; - py_code = __Pyx_PyCode_New( - 0, - 0, - 0, - 0, - 0, - __pyx_empty_bytes, /*PyObject *code,*/ - __pyx_empty_tuple, /*PyObject *consts,*/ - __pyx_empty_tuple, /*PyObject *names,*/ - __pyx_empty_tuple, /*PyObject *varnames,*/ - __pyx_empty_tuple, /*PyObject *freevars,*/ - __pyx_empty_tuple, /*PyObject *cellvars,*/ - py_srcfile, /*PyObject *filename,*/ - py_funcname, /*PyObject *name,*/ - py_line, - __pyx_empty_bytes /*PyObject *lnotab*/ - ); - Py_DECREF(py_srcfile); - Py_DECREF(py_funcname); - return py_code; -bad: - Py_XDECREF(py_srcfile); - Py_XDECREF(py_funcname); - return NULL; -} -static void __Pyx_AddTraceback(const char *funcname, int c_line, - int py_line, const char *filename) { - PyCodeObject *py_code = 0; - PyFrameObject *py_frame = 0; - PyThreadState *tstate = __Pyx_PyThreadState_Current; - if (c_line) { - c_line = __Pyx_CLineForTraceback(tstate, c_line); - } - py_code = __pyx_find_code_object(c_line ? -c_line : py_line); - if (!py_code) { - py_code = __Pyx_CreateCodeObjectForTraceback( - funcname, c_line, py_line, filename); - if (!py_code) goto bad; - __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); - } - py_frame = PyFrame_New( - tstate, /*PyThreadState *tstate,*/ - py_code, /*PyCodeObject *code,*/ - __pyx_d, /*PyObject *globals,*/ - 0 /*PyObject *locals*/ - ); - if (!py_frame) goto bad; - __Pyx_PyFrame_SetLineNumber(py_frame, py_line); - PyTraceBack_Here(py_frame); -bad: - Py_XDECREF(py_code); - Py_XDECREF(py_frame); -} - -/* CIntFromPyVerify */ -#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ - __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) -#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ - __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) -#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ - {\ - func_type value = func_value;\ - if (sizeof(target_type) < sizeof(func_type)) {\ - if (unlikely(value != (func_type) (target_type) value)) {\ - func_type zero = 0;\ - if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ - return (target_type) -1;\ - if (is_unsigned && unlikely(value < zero))\ - goto raise_neg_overflow;\ - else\ - goto raise_overflow;\ - }\ - }\ - return (target_type) value;\ - } - -/* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { - const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(int) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(int) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(int) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif - } - } - { - int one = 1; int little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&value; - return _PyLong_FromByteArray(bytes, sizeof(int), - little, !is_unsigned); - } -} - -/* Declarations */ -#if CYTHON_CCOMPLEX - #ifdef __cplusplus - static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { - return ::std::complex< float >(x, y); - } - #else - static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { - return x + y*(__pyx_t_float_complex)_Complex_I; - } - #endif -#else - static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { - __pyx_t_float_complex z; - z.real = x; - z.imag = y; - return z; - } -#endif - -/* Arithmetic */ -#if CYTHON_CCOMPLEX -#else - static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { - return (a.real == b.real) && (a.imag == b.imag); - } - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { - __pyx_t_float_complex z; - z.real = a.real + b.real; - z.imag = a.imag + b.imag; - return z; - } - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { - __pyx_t_float_complex z; - z.real = a.real - b.real; - z.imag = a.imag - b.imag; - return z; - } - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { - __pyx_t_float_complex z; - z.real = a.real * b.real - a.imag * b.imag; - z.imag = a.real * b.imag + a.imag * b.real; - return z; - } - #if 1 - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { - if (b.imag == 0) { - return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); - } else if (fabsf(b.real) >= fabsf(b.imag)) { - if (b.real == 0 && b.imag == 0) { - return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag); - } else { - float r = b.imag / b.real; - float s = (float)(1.0) / (b.real + b.imag * r); - return __pyx_t_float_complex_from_parts( - (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); - } - } else { - float r = b.real / b.imag; - float s = (float)(1.0) / (b.imag + b.real * r); - return __pyx_t_float_complex_from_parts( - (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); - } - } - #else - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { - if (b.imag == 0) { - return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); - } else { - float denom = b.real * b.real + b.imag * b.imag; - return __pyx_t_float_complex_from_parts( - (a.real * b.real + a.imag * b.imag) / denom, - (a.imag * b.real - a.real * b.imag) / denom); - } - } - #endif - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) { - __pyx_t_float_complex z; - z.real = -a.real; - z.imag = -a.imag; - return z; - } - static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) { - return (a.real == 0) && (a.imag == 0); - } - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) { - __pyx_t_float_complex z; - z.real = a.real; - z.imag = -a.imag; - return z; - } - #if 1 - static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) { - #if !defined(HAVE_HYPOT) || defined(_MSC_VER) - return sqrtf(z.real*z.real + z.imag*z.imag); - #else - return hypotf(z.real, z.imag); - #endif - } - static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { - __pyx_t_float_complex z; - float r, lnr, theta, z_r, z_theta; - if (b.imag == 0 && b.real == (int)b.real) { - if (b.real < 0) { - float denom = a.real * a.real + a.imag * a.imag; - a.real = a.real / denom; - a.imag = -a.imag / denom; - b.real = -b.real; - } - switch ((int)b.real) { - case 0: - z.real = 1; - z.imag = 0; - return z; - case 1: - return a; - case 2: - return __Pyx_c_prod_float(a, a); - case 3: - z = __Pyx_c_prod_float(a, a); - return __Pyx_c_prod_float(z, a); - case 4: - z = __Pyx_c_prod_float(a, a); - return __Pyx_c_prod_float(z, z); - } - } - if (a.imag == 0) { - if (a.real == 0) { - return a; - } else if (b.imag == 0) { - z.real = powf(a.real, b.real); - z.imag = 0; - return z; - } else if (a.real > 0) { - r = a.real; - theta = 0; - } else { - r = -a.real; - theta = atan2f(0.0, -1.0); - } - } else { - r = __Pyx_c_abs_float(a); - theta = atan2f(a.imag, a.real); - } - lnr = logf(r); - z_r = expf(lnr * b.real - theta * b.imag); - z_theta = theta * b.real + lnr * b.imag; - z.real = z_r * cosf(z_theta); - z.imag = z_r * sinf(z_theta); - return z; - } - #endif -#endif - -/* Declarations */ -#if CYTHON_CCOMPLEX - #ifdef __cplusplus - static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { - return ::std::complex< double >(x, y); - } - #else - static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { - return x + y*(__pyx_t_double_complex)_Complex_I; - } - #endif -#else - static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { - __pyx_t_double_complex z; - z.real = x; - z.imag = y; - return z; - } -#endif - -/* Arithmetic */ -#if CYTHON_CCOMPLEX -#else - static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { - return (a.real == b.real) && (a.imag == b.imag); - } - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { - __pyx_t_double_complex z; - z.real = a.real + b.real; - z.imag = a.imag + b.imag; - return z; - } - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { - __pyx_t_double_complex z; - z.real = a.real - b.real; - z.imag = a.imag - b.imag; - return z; - } - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { - __pyx_t_double_complex z; - z.real = a.real * b.real - a.imag * b.imag; - z.imag = a.real * b.imag + a.imag * b.real; - return z; - } - #if 1 - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { - if (b.imag == 0) { - return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); - } else if (fabs(b.real) >= fabs(b.imag)) { - if (b.real == 0 && b.imag == 0) { - return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag); - } else { - double r = b.imag / b.real; - double s = (double)(1.0) / (b.real + b.imag * r); - return __pyx_t_double_complex_from_parts( - (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); - } - } else { - double r = b.real / b.imag; - double s = (double)(1.0) / (b.imag + b.real * r); - return __pyx_t_double_complex_from_parts( - (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); - } - } - #else - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { - if (b.imag == 0) { - return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); - } else { - double denom = b.real * b.real + b.imag * b.imag; - return __pyx_t_double_complex_from_parts( - (a.real * b.real + a.imag * b.imag) / denom, - (a.imag * b.real - a.real * b.imag) / denom); - } - } - #endif - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) { - __pyx_t_double_complex z; - z.real = -a.real; - z.imag = -a.imag; - return z; - } - static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) { - return (a.real == 0) && (a.imag == 0); - } - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) { - __pyx_t_double_complex z; - z.real = a.real; - z.imag = -a.imag; - return z; - } - #if 1 - static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) { - #if !defined(HAVE_HYPOT) || defined(_MSC_VER) - return sqrt(z.real*z.real + z.imag*z.imag); - #else - return hypot(z.real, z.imag); - #endif - } - static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { - __pyx_t_double_complex z; - double r, lnr, theta, z_r, z_theta; - if (b.imag == 0 && b.real == (int)b.real) { - if (b.real < 0) { - double denom = a.real * a.real + a.imag * a.imag; - a.real = a.real / denom; - a.imag = -a.imag / denom; - b.real = -b.real; - } - switch ((int)b.real) { - case 0: - z.real = 1; - z.imag = 0; - return z; - case 1: - return a; - case 2: - return __Pyx_c_prod_double(a, a); - case 3: - z = __Pyx_c_prod_double(a, a); - return __Pyx_c_prod_double(z, a); - case 4: - z = __Pyx_c_prod_double(a, a); - return __Pyx_c_prod_double(z, z); - } - } - if (a.imag == 0) { - if (a.real == 0) { - return a; - } else if (b.imag == 0) { - z.real = pow(a.real, b.real); - z.imag = 0; - return z; - } else if (a.real > 0) { - r = a.real; - theta = 0; - } else { - r = -a.real; - theta = atan2(0.0, -1.0); - } - } else { - r = __Pyx_c_abs_double(a); - theta = atan2(a.imag, a.real); - } - lnr = log(r); - z_r = exp(lnr * b.real - theta * b.imag); - z_theta = theta * b.real + lnr * b.imag; - z.real = z_r * cos(z_theta); - z.imag = z_r * sin(z_theta); - return z; - } - #endif -#endif - -/* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) { - const enum NPY_TYPES neg_one = (enum NPY_TYPES) ((enum NPY_TYPES) 0 - (enum NPY_TYPES) 1), const_zero = (enum NPY_TYPES) 0; - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(enum NPY_TYPES) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(enum NPY_TYPES) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif - } - } - { - int one = 1; int little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&value; - return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES), - little, !is_unsigned); - } -} - -/* CIntFromPy */ -static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { - const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; - const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if (sizeof(int) < sizeof(long)) { - __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (int) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { -#if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (int) 0; - case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) - case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { - return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); - } - } - break; - case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { - return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); - } - } - break; - case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { - return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); - } - } - break; - } -#endif -#if CYTHON_COMPILING_IN_CPYTHON - if (unlikely(Py_SIZE(x) < 0)) { - goto raise_neg_overflow; - } -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (int) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#endif - if (sizeof(int) <= sizeof(unsigned long)) { - __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { - __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif - } - } else { -#if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (int) 0; - case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) - case -2: - if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case 2: - if (8 * sizeof(int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case -3: - if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case 3: - if (8 * sizeof(int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case -4: - if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case 4: - if (8 * sizeof(int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { - return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - } -#endif - if (sizeof(int) <= sizeof(long)) { - __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { - __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif - } - } - { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else - int val; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } - #endif - if (likely(v)) { - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); - Py_DECREF(v); - if (likely(!ret)) - return val; - } -#endif - return (int) -1; - } - } else { - int val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (int) -1; - val = __Pyx_PyInt_As_int(tmp); - Py_DECREF(tmp); - return val; - } -raise_overflow: - PyErr_SetString(PyExc_OverflowError, - "value too large to convert to int"); - return (int) -1; -raise_neg_overflow: - PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to int"); - return (int) -1; -} - -/* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { - const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(long) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(long) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(long) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif - } - } - { - int one = 1; int little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&value; - return _PyLong_FromByteArray(bytes, sizeof(long), - little, !is_unsigned); - } -} - -/* CIntFromPy */ -static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { - const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; - const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if (sizeof(long) < sizeof(long)) { - __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (long) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { -#if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { - return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); - } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { - return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); - } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { - return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); - } - } - break; - } -#endif -#if CYTHON_COMPILING_IN_CPYTHON - if (unlikely(Py_SIZE(x) < 0)) { - goto raise_neg_overflow; - } -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (long) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#endif - if (sizeof(long) <= sizeof(unsigned long)) { - __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { - __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif - } - } else { -#if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)x)->ob_digit; - switch (Py_SIZE(x)) { - case 0: return (long) 0; - case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) - case -2: - if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case 2: - if (8 * sizeof(long) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case -3: - if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case 3: - if (8 * sizeof(long) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case -4: - if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case 4: - if (8 * sizeof(long) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { - return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - } -#endif - if (sizeof(long) <= sizeof(long)) { - __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { - __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif - } - } - { -#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) - PyErr_SetString(PyExc_RuntimeError, - "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); -#else - long val; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } - #endif - if (likely(v)) { - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - int ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); - Py_DECREF(v); - if (likely(!ret)) - return val; - } -#endif - return (long) -1; - } - } else { - long val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (long) -1; - val = __Pyx_PyInt_As_long(tmp); - Py_DECREF(tmp); - return val; - } -raise_overflow: - PyErr_SetString(PyExc_OverflowError, - "value too large to convert to long"); - return (long) -1; -raise_neg_overflow: - PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to long"); - return (long) -1; -} - -/* FastTypeChecks */ -#if CYTHON_COMPILING_IN_CPYTHON -static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { - while (a) { - a = a->tp_base; - if (a == b) - return 1; - } - return b == &PyBaseObject_Type; -} -static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { - PyObject *mro; - if (a == b) return 1; - mro = a->tp_mro; - if (likely(mro)) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(mro); - for (i = 0; i < n; i++) { - if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) - return 1; - } - return 0; - } - return __Pyx_InBases(a, b); -} -#if PY_MAJOR_VERSION == 2 -static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { - PyObject *exception, *value, *tb; - int res; - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ErrFetch(&exception, &value, &tb); - res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; - if (unlikely(res == -1)) { - PyErr_WriteUnraisable(err); - res = 0; - } - if (!res) { - res = PyObject_IsSubclass(err, exc_type2); - if (unlikely(res == -1)) { - PyErr_WriteUnraisable(err); - res = 0; - } - } - __Pyx_ErrRestore(exception, value, tb); - return res; -} -#else -static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { - int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; - if (!res) { - res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); - } - return res; -} -#endif -static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { - Py_ssize_t i, n; - assert(PyExceptionClass_Check(exc_type)); - n = PyTuple_GET_SIZE(tuple); -#if PY_MAJOR_VERSION >= 3 - for (i=0; ip) { - #if PY_MAJOR_VERSION < 3 - if (t->is_unicode) { - *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); - } else if (t->intern) { - *t->p = PyString_InternFromString(t->s); - } else { - *t->p = PyString_FromStringAndSize(t->s, t->n - 1); - } - #else - if (t->is_unicode | t->is_str) { - if (t->intern) { - *t->p = PyUnicode_InternFromString(t->s); - } else if (t->encoding) { - *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); - } else { - *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); - } - } else { - *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); - } - #endif - if (!*t->p) - return -1; - if (PyObject_Hash(*t->p) == -1) - return -1; - ++t; - } - return 0; -} - -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { - return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); -} -static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { - Py_ssize_t ignore; - return __Pyx_PyObject_AsStringAndSize(o, &ignore); -} -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT -#if !CYTHON_PEP393_ENABLED -static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { - char* defenc_c; - PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); - if (!defenc) return NULL; - defenc_c = PyBytes_AS_STRING(defenc); -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII - { - char* end = defenc_c + PyBytes_GET_SIZE(defenc); - char* c; - for (c = defenc_c; c < end; c++) { - if ((unsigned char) (*c) >= 128) { - PyUnicode_AsASCIIString(o); - return NULL; - } - } - } -#endif - *length = PyBytes_GET_SIZE(defenc); - return defenc_c; -} -#else -static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { - if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII - if (likely(PyUnicode_IS_ASCII(o))) { - *length = PyUnicode_GET_LENGTH(o); - return PyUnicode_AsUTF8(o); - } else { - PyUnicode_AsASCIIString(o); - return NULL; - } -#else - return PyUnicode_AsUTF8AndSize(o, length); -#endif -} -#endif -#endif -static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT - if ( -#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII - __Pyx_sys_getdefaultencoding_not_ascii && -#endif - PyUnicode_Check(o)) { - return __Pyx_PyUnicode_AsStringAndSize(o, length); - } else -#endif -#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) - if (PyByteArray_Check(o)) { - *length = PyByteArray_GET_SIZE(o); - return PyByteArray_AS_STRING(o); - } else -#endif - { - char* result; - int r = PyBytes_AsStringAndSize(o, &result, length); - if (unlikely(r < 0)) { - return NULL; - } else { - return result; - } - } -} -static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { - int is_true = x == Py_True; - if (is_true | (x == Py_False) | (x == Py_None)) return is_true; - else return PyObject_IsTrue(x); -} -static 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)) { - if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, - "__int__ returned non-int (type %.200s). " - "The ability to return an instance of a strict subclass of int " - "is deprecated, and may be removed in a future version of Python.", - Py_TYPE(result)->tp_name)) { - Py_DECREF(result); - return NULL; - } - return result; - } -#endif - PyErr_Format(PyExc_TypeError, - "__%.4s__ returned non-%.4s (type %.200s)", - type_name, type_name, Py_TYPE(result)->tp_name); - Py_DECREF(result); - return NULL; -} -static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { -#if CYTHON_USE_TYPE_SLOTS - PyNumberMethods *m; -#endif - const char *name = NULL; - PyObject *res = NULL; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x) || PyLong_Check(x))) -#else - if (likely(PyLong_Check(x))) -#endif - return __Pyx_NewRef(x); -#if CYTHON_USE_TYPE_SLOTS - m = Py_TYPE(x)->tp_as_number; - #if PY_MAJOR_VERSION < 3 - if (m && m->nb_int) { - name = "int"; - res = m->nb_int(x); - } - else if (m && m->nb_long) { - name = "long"; - res = m->nb_long(x); - } - #else - if (likely(m && m->nb_int)) { - name = "int"; - res = m->nb_int(x); - } - #endif -#else - if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { - res = PyNumber_Int(x); - } -#endif - if (likely(res)) { -#if PY_MAJOR_VERSION < 3 - if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { -#else - if (unlikely(!PyLong_CheckExact(res))) { -#endif - return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); - } - } - else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_TypeError, - "an integer is required"); - } - return res; -} -static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { - Py_ssize_t ival; - PyObject *x; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_CheckExact(b))) { - if (sizeof(Py_ssize_t) >= sizeof(long)) - return PyInt_AS_LONG(b); - else - return PyInt_AsSsize_t(b); - } -#endif - if (likely(PyLong_CheckExact(b))) { - #if CYTHON_USE_PYLONG_INTERNALS - const digit* digits = ((PyLongObject*)b)->ob_digit; - const Py_ssize_t size = Py_SIZE(b); - if (likely(__Pyx_sst_abs(size) <= 1)) { - ival = likely(size) ? digits[0] : 0; - if (size == -1) ival = -ival; - return ival; - } else { - switch (size) { - case 2: - if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { - return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case -2: - if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { - return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case 3: - if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { - return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case -3: - if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { - return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case 4: - if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { - return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case -4: - if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { - return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - } - } - #endif - return PyLong_AsSsize_t(b); - } - x = PyNumber_Index(b); - if (!x) return -1; - ival = PyInt_AsSsize_t(x); - Py_DECREF(x); - return ival; -} -static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { - return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); -} -static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { - return PyInt_FromSize_t(ival); -} - - -#endif /* Py_PYTHON_H */ diff --git a/somsphere/cython/core.html b/somsphere/cython/core.html deleted file mode 100644 index 875a53a..0000000 --- a/somsphere/cython/core.html +++ /dev/null @@ -1,2230 +0,0 @@ - - - - - - Cython: core.pyx - - - -

Generated by Cython 0.29.21

-

- Yellow lines hint at Python interaction.
- Click on a line that starts with a "+" to see the C code that Cython generated for it. -

-

Raw output: core.c

-
+01: #cython: language_level=3
-
  __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-
+02: import random
-
  __pyx_t_1 = __Pyx_Import(__pyx_n_s_random, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_random, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
 03:
-
+04: import numpy as np
-
  __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
 05: cimport numpy as cnp
-
 06:
-
+07: from somsphere.utils import timeit
-
  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(__pyx_n_s_timeit);
-  __Pyx_GIVEREF(__pyx_n_s_timeit);
-  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_timeit);
-  __pyx_t_2 = __Pyx_Import(__pyx_n_s_somsphere_utils, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_timeit); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_timeit, __pyx_t_1) < 0) __PYX_ERR(0, 7, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
 08:
-
+09: DTYPE = np.float
-
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_float); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_DTYPE, __pyx_t_1) < 0) __PYX_ERR(0, 9, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-
 10: ctypedef cnp.float_t DTYPE_t
-
 11: # def create_map_batch(np.ndarray X, int n_iter, int n_row, int n_col, int n_pix, np.ndarray importance,
-
 12: #                      np.ndarray dist_lib, np.ndarray weights):
-
 13: #     cdef int t = 0
-
 14: #     cdef int total_t = n_iter * n_row
-
 15: #     cdef float sigma_0 = dist_lib.max()
-
 16: #     cdef float sigma_f = np.min(dist_lib[np.where(dist_lib > 0.)])
-
 17: #
-
 18: #     cdef int i
-
 19: #     cdef float sigma, activation
-
 20: #     cdef np.ndarray accum_w, accum_n, best, inputs
-
 21: #
-
 22: #     for i in range(n_iter):
-
 23: #         sigma = get_sigma(sigma_f, sigma_0, t, total_t)
-
 24: #         accum_w = np.zeros((n_col, n_pix))
-
 25: #         accum_n = np.zeros(n_pix)
-
 26: #         for j in range(n_row):
-
 27: #             inputs = X[j]
-
 28: #             best, activation = get_best_cell(inputs=inputs, importance=importance,
-
 29: #                                              weights=weights, n_pix=n_pix)
-
 30: #             for k in range(n_col):
-
 31: #                 accum_w[k, :] += count_modified_cells(best, dist_lib, sigma) * inputs[k]
-
 32: #             accum_n += count_modified_cells(best, dist_lib, sigma)
-
 33: #
-
 34: #         for l in range(n_col):
-
 35: #             weights[l] = accum_w[l] / accum_n
-
 36: #
-
 37: #         t += n_row
-
+38: def get_alpha(float alpha_end, float alpha_start, int curr_t, int total_t):
-
/* Python wrapper */
-static PyObject *__pyx_pw_4core_1get_alpha(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4core_get_alpha[] = "\n    Get value of alpha at a given time\n    ";
-static PyMethodDef __pyx_mdef_4core_1get_alpha = {"get_alpha", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_1get_alpha, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4core_get_alpha};
-static PyObject *__pyx_pw_4core_1get_alpha(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  float __pyx_v_alpha_end;
-  float __pyx_v_alpha_start;
-  int __pyx_v_curr_t;
-  int __pyx_v_total_t;
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("get_alpha (wrapper)", 0);
-  {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_alpha_end,&__pyx_n_s_alpha_start,&__pyx_n_s_curr_t,&__pyx_n_s_total_t,0};
-    PyObject* values[4] = {0,0,0,0};
-    if (unlikely(__pyx_kwds)) {
-      Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha_end)) != 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_alpha_start)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("get_alpha", 1, 4, 4, 1); __PYX_ERR(0, 38, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_curr_t)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("get_alpha", 1, 4, 4, 2); __PYX_ERR(0, 38, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_total_t)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("get_alpha", 1, 4, 4, 3); __PYX_ERR(0, 38, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_alpha") < 0)) __PYX_ERR(0, 38, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      goto __pyx_L5_argtuple_error;
-    } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-    }
-    __pyx_v_alpha_end = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_alpha_end == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L3_error)
-    __pyx_v_alpha_start = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_alpha_start == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L3_error)
-    __pyx_v_curr_t = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_curr_t == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L3_error)
-    __pyx_v_total_t = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_total_t == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L3_error)
-  }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("get_alpha", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 38, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("core.get_alpha", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return NULL;
-  __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_4core_get_alpha(__pyx_self, __pyx_v_alpha_end, __pyx_v_alpha_start, __pyx_v_curr_t, __pyx_v_total_t);
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_4core_get_alpha(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_alpha_end, float __pyx_v_alpha_start, int __pyx_v_curr_t, int __pyx_v_total_t) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("get_alpha", 0);
-/* … */
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_6);
-  __Pyx_XDECREF(__pyx_t_8);
-  __Pyx_AddTraceback("core.get_alpha", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-/* … */
-  __pyx_tuple__6 = PyTuple_Pack(4, __pyx_n_s_alpha_end, __pyx_n_s_alpha_start, __pyx_n_s_curr_t, __pyx_n_s_total_t); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 38, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__6);
-  __Pyx_GIVEREF(__pyx_tuple__6);
-/* … */
-  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_4core_1get_alpha, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 38, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_alpha, __pyx_t_1) < 0) __PYX_ERR(0, 38, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(4, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_somsphere_cython_core_pyx, __pyx_n_s_get_alpha, 38, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 38, __pyx_L1_error)
-
 39:     """
-
 40:     Get value of alpha at a given time
-
 41:     """
-
+42:     return alpha_start * np.power(alpha_end / alpha_start, float(curr_t) / float(total_t))
-
  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_alpha_start); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 42, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_power); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 42, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(__pyx_v_alpha_start == 0)) {
-    PyErr_SetString(PyExc_ZeroDivisionError, "float division");
-    __PYX_ERR(0, 42, __pyx_L1_error)
-  }
-  __pyx_t_3 = PyFloat_FromDouble((__pyx_v_alpha_end / __pyx_v_alpha_start)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 42, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (unlikely(((double)__pyx_v_total_t) == 0)) {
-    PyErr_SetString(PyExc_ZeroDivisionError, "float division");
-    __PYX_ERR(0, 42, __pyx_L1_error)
-  }
-  __pyx_t_5 = PyFloat_FromDouble((((double)__pyx_v_curr_t) / ((double)__pyx_v_total_t))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 42, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_6 = NULL;
-  __pyx_t_7 = 0;
-  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
-    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
-    if (likely(__pyx_t_6)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
-      __Pyx_INCREF(__pyx_t_6);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_4, function);
-      __pyx_t_7 = 1;
-    }
-  }
-  #if CYTHON_FAST_PYCALL
-  if (PyFunction_Check(__pyx_t_4)) {
-    PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_t_5};
-    __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  } else
-  #endif
-  #if CYTHON_FAST_PYCCALL
-  if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
-    PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_t_5};
-    __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  } else
-  #endif
-  {
-    __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 42, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_8);
-    if (__pyx_t_6) {
-      __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL;
-    }
-    __Pyx_GIVEREF(__pyx_t_3);
-    PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_3);
-    __Pyx_GIVEREF(__pyx_t_5);
-    PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_5);
-    __pyx_t_3 = 0;
-    __pyx_t_5 = 0;
-    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-  }
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_4 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 42, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_r = __pyx_t_4;
-  __pyx_t_4 = 0;
-  goto __pyx_L0;
-
 43:
-
+44: def get_sigma(float sigma_f, float sigma_0, int curr_t, int total_t):
-
/* Python wrapper */
-static PyObject *__pyx_pw_4core_3get_sigma(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4core_2get_sigma[] = "\n    Get value of sigma at a given time\n    ";
-static PyMethodDef __pyx_mdef_4core_3get_sigma = {"get_sigma", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_3get_sigma, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4core_2get_sigma};
-static PyObject *__pyx_pw_4core_3get_sigma(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  float __pyx_v_sigma_f;
-  float __pyx_v_sigma_0;
-  int __pyx_v_curr_t;
-  int __pyx_v_total_t;
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("get_sigma (wrapper)", 0);
-  {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sigma_f,&__pyx_n_s_sigma_0,&__pyx_n_s_curr_t,&__pyx_n_s_total_t,0};
-    PyObject* values[4] = {0,0,0,0};
-    if (unlikely(__pyx_kwds)) {
-      Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-        CYTHON_FALLTHROUGH;
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sigma_f)) != 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_sigma_0)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("get_sigma", 1, 4, 4, 1); __PYX_ERR(0, 44, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_curr_t)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("get_sigma", 1, 4, 4, 2); __PYX_ERR(0, 44, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_total_t)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("get_sigma", 1, 4, 4, 3); __PYX_ERR(0, 44, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_sigma") < 0)) __PYX_ERR(0, 44, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
-      goto __pyx_L5_argtuple_error;
-    } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
-    }
-    __pyx_v_sigma_f = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_sigma_f == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 44, __pyx_L3_error)
-    __pyx_v_sigma_0 = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_sigma_0 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 44, __pyx_L3_error)
-    __pyx_v_curr_t = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_curr_t == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 44, __pyx_L3_error)
-    __pyx_v_total_t = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_total_t == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 44, __pyx_L3_error)
-  }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("get_sigma", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 44, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("core.get_sigma", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return NULL;
-  __pyx_L4_argument_unpacking_done:;
-  __pyx_r = __pyx_pf_4core_2get_sigma(__pyx_self, __pyx_v_sigma_f, __pyx_v_sigma_0, __pyx_v_curr_t, __pyx_v_total_t);
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-
-  /* function exit code */
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_4core_2get_sigma(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_sigma_f, float __pyx_v_sigma_0, int __pyx_v_curr_t, int __pyx_v_total_t) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("get_sigma", 0);
-/* … */
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_6);
-  __Pyx_XDECREF(__pyx_t_8);
-  __Pyx_AddTraceback("core.get_sigma", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-/* … */
-  __pyx_tuple__8 = PyTuple_Pack(4, __pyx_n_s_sigma_f, __pyx_n_s_sigma_0, __pyx_n_s_curr_t, __pyx_n_s_total_t); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 44, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__8);
-  __Pyx_GIVEREF(__pyx_tuple__8);
-/* … */
-  __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_4core_3get_sigma, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 44, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_sigma, __pyx_t_1) < 0) __PYX_ERR(0, 44, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(4, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_somsphere_cython_core_pyx, __pyx_n_s_get_sigma, 44, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 44, __pyx_L1_error)
-
 45:     """
-
 46:     Get value of sigma at a given time
-
 47:     """
-
+48:     return sigma_0 * np.power(sigma_f / sigma_0, float(curr_t) / float(total_t))
-
  __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_sigma_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 48, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 48, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_power); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 48, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(__pyx_v_sigma_0 == 0)) {
-    PyErr_SetString(PyExc_ZeroDivisionError, "float division");
-    __PYX_ERR(0, 48, __pyx_L1_error)
-  }
-  __pyx_t_3 = PyFloat_FromDouble((__pyx_v_sigma_f / __pyx_v_sigma_0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 48, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (unlikely(((double)__pyx_v_total_t) == 0)) {
-    PyErr_SetString(PyExc_ZeroDivisionError, "float division");
-    __PYX_ERR(0, 48, __pyx_L1_error)
-  }
-  __pyx_t_5 = PyFloat_FromDouble((((double)__pyx_v_curr_t) / ((double)__pyx_v_total_t))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 48, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_6 = NULL;
-  __pyx_t_7 = 0;
-  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
-    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
-    if (likely(__pyx_t_6)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
-      __Pyx_INCREF(__pyx_t_6);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_4, function);
-      __pyx_t_7 = 1;
-    }
-  }
-  #if CYTHON_FAST_PYCALL
-  if (PyFunction_Check(__pyx_t_4)) {
-    PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_t_5};
-    __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 48, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  } else
-  #endif
-  #if CYTHON_FAST_PYCCALL
-  if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
-    PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_t_5};
-    __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 48, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  } else
-  #endif
-  {
-    __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 48, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_8);
-    if (__pyx_t_6) {
-      __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL;
-    }
-    __Pyx_GIVEREF(__pyx_t_3);
-    PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_3);
-    __Pyx_GIVEREF(__pyx_t_5);
-    PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_5);
-    __pyx_t_3 = 0;
-    __pyx_t_5 = 0;
-    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 48, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-  }
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_4 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 48, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_r = __pyx_t_4;
-  __pyx_t_4 = 0;
-  goto __pyx_L0;
-
 49:
-
+50: @timeit
-
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_timeit); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 50, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-/* … */
-  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 50, __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;
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_best_cell, __pyx_t_3) < 0) __PYX_ERR(0, 51, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-
+51: def get_best_cell(cnp.ndarray inputs, cnp.ndarray importance, int n_pix, cnp.ndarray weights, int return_vals):
-
/* Python wrapper */
-static PyObject *__pyx_pw_4core_5get_best_cell(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4core_4get_best_cell[] = "\n    Return the closest cell to the input object\n    It can return more than one value if needed\n    ";
-static PyMethodDef __pyx_mdef_4core_5get_best_cell = {"get_best_cell", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_5get_best_cell, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4core_4get_best_cell};
-static PyObject *__pyx_pw_4core_5get_best_cell(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_inputs = 0;
-  PyArrayObject *__pyx_v_importance = 0;
-  int __pyx_v_n_pix;
-  PyArrayObject *__pyx_v_weights = 0;
-  int __pyx_v_return_vals;
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("get_best_cell (wrapper)", 0);
-  {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_inputs,&__pyx_n_s_importance,&__pyx_n_s_n_pix,&__pyx_n_s_weights,&__pyx_n_s_return_vals,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);
-        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_inputs)) != 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_importance)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("get_best_cell", 1, 5, 5, 1); __PYX_ERR(0, 51, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_pix)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("get_best_cell", 1, 5, 5, 2); __PYX_ERR(0, 51, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_weights)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("get_best_cell", 1, 5, 5, 3); __PYX_ERR(0, 51, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_return_vals)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("get_best_cell", 1, 5, 5, 4); __PYX_ERR(0, 51, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_best_cell") < 0)) __PYX_ERR(0, 51, __pyx_L3_error)
-      }
-    } 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_inputs = ((PyArrayObject *)values[0]);
-    __pyx_v_importance = ((PyArrayObject *)values[1]);
-    __pyx_v_n_pix = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_n_pix == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 51, __pyx_L3_error)
-    __pyx_v_weights = ((PyArrayObject *)values[3]);
-    __pyx_v_return_vals = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_return_vals == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 51, __pyx_L3_error)
-  }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("get_best_cell", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 51, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("core.get_best_cell", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return NULL;
-  __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_inputs), __pyx_ptype_5numpy_ndarray, 1, "inputs", 0))) __PYX_ERR(0, 51, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_importance), __pyx_ptype_5numpy_ndarray, 1, "importance", 0))) __PYX_ERR(0, 51, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_weights), __pyx_ptype_5numpy_ndarray, 1, "weights", 0))) __PYX_ERR(0, 51, __pyx_L1_error)
-  __pyx_r = __pyx_pf_4core_4get_best_cell(__pyx_self, __pyx_v_inputs, __pyx_v_importance, __pyx_v_n_pix, __pyx_v_weights, __pyx_v_return_vals);
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-
-  /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_4core_4get_best_cell(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_inputs, PyArrayObject *__pyx_v_importance, int __pyx_v_n_pix, PyArrayObject *__pyx_v_weights, int __pyx_v_return_vals) {
-  CYTHON_UNUSED PyArrayObject *__pyx_v_activation = 0;
-  PyObject *__pyx_v_activations = NULL;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("get_best_cell", 0);
-/* … */
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_6);
-  __Pyx_XDECREF(__pyx_t_7);
-  __Pyx_XDECREF(__pyx_t_8);
-  __Pyx_XDECREF(__pyx_t_10);
-  __Pyx_AddTraceback("core.get_best_cell", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XDECREF((PyObject *)__pyx_v_activation);
-  __Pyx_XDECREF(__pyx_v_activations);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-/* … */
-  __pyx_tuple__10 = PyTuple_Pack(7, __pyx_n_s_inputs, __pyx_n_s_importance, __pyx_n_s_n_pix, __pyx_n_s_weights, __pyx_n_s_return_vals, __pyx_n_s_activation, __pyx_n_s_activations); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 51, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__10);
-  __Pyx_GIVEREF(__pyx_tuple__10);
-/* … */
-  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_4core_5get_best_cell, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 51, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(5, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_somsphere_cython_core_pyx, __pyx_n_s_get_best_cell, 51, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(0, 51, __pyx_L1_error)
-
 52:     """
-
 53:     Return the closest cell to the input object
-
 54:     It can return more than one value if needed
-
 55:     """
-
+56:     cdef cnp.ndarray activation = np.zeros([n_pix, 1], dtype=DTYPE)
-
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 56, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_pix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = PyList_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 56, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyList_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
-  __Pyx_INCREF(__pyx_int_1);
-  __Pyx_GIVEREF(__pyx_int_1);
-  PyList_SET_ITEM(__pyx_t_3, 1, __pyx_int_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_3);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
-  __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 56, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_DTYPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 56, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(0, 56, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 56, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 56, __pyx_L1_error)
-  __pyx_v_activation = ((PyArrayObject *)__pyx_t_4);
-  __pyx_t_4 = 0;
-
 57:
-
+58:     activations = np.sum(np.transpose([importance]) * (np.transpose(np.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0)
-
  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_sum); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_transpose); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_INCREF(((PyObject *)__pyx_v_importance));
-  __Pyx_GIVEREF(((PyObject *)__pyx_v_importance));
-  PyList_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_importance));
-  __pyx_t_5 = NULL;
-  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
-    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
-    if (likely(__pyx_t_5)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
-      __Pyx_INCREF(__pyx_t_5);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_2, function);
-    }
-  }
-  __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_transpose); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_6);
-  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_tile); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_7);
-  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-  __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_n_pix); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_6);
-  __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_8);
-  __Pyx_GIVEREF(__pyx_t_6);
-  PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6);
-  __Pyx_INCREF(__pyx_int_1);
-  __Pyx_GIVEREF(__pyx_int_1);
-  PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_int_1);
-  __pyx_t_6 = 0;
-  __pyx_t_6 = NULL;
-  __pyx_t_9 = 0;
-  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
-    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7);
-    if (likely(__pyx_t_6)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
-      __Pyx_INCREF(__pyx_t_6);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_7, function);
-      __pyx_t_9 = 1;
-    }
-  }
-  #if CYTHON_FAST_PYCALL
-  if (PyFunction_Check(__pyx_t_7)) {
-    PyObject *__pyx_temp[3] = {__pyx_t_6, ((PyObject *)__pyx_v_inputs), __pyx_t_8};
-    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-  } else
-  #endif
-  #if CYTHON_FAST_PYCCALL
-  if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
-    PyObject *__pyx_temp[3] = {__pyx_t_6, ((PyObject *)__pyx_v_inputs), __pyx_t_8};
-    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-  } else
-  #endif
-  {
-    __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 58, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_10);
-    if (__pyx_t_6) {
-      __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_6); __pyx_t_6 = NULL;
-    }
-    __Pyx_INCREF(((PyObject *)__pyx_v_inputs));
-    __Pyx_GIVEREF(((PyObject *)__pyx_v_inputs));
-    PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, ((PyObject *)__pyx_v_inputs));
-    __Pyx_GIVEREF(__pyx_t_8);
-    PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_8);
-    __pyx_t_8 = 0;
-    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 58, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
-  }
-  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-  __pyx_t_7 = NULL;
-  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
-    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
-    if (likely(__pyx_t_7)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
-      __Pyx_INCREF(__pyx_t_7);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_5, function);
-    }
-  }
-  __pyx_t_2 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = PyNumber_Subtract(__pyx_t_2, ((PyObject *)__pyx_v_weights)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = PyNumber_Power(__pyx_t_5, __pyx_int_2, Py_None); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = PyNumber_Multiply(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_5);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
-  __pyx_t_5 = 0;
-  __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_axis, __pyx_int_0) < 0) __PYX_ERR(0, 58, __pyx_L1_error)
-  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 58, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_v_activations = __pyx_t_4;
-  __pyx_t_4 = 0;
-
 59:
-
+60:     return np.argmin(activations) if return_vals == 1 else np.argsort(activations)[0:return_vals], activations
-
  __Pyx_XDECREF(__pyx_r);
-  if (((__pyx_v_return_vals == 1) != 0)) {
-    __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_argmin); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 60, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __pyx_t_2 = NULL;
-    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
-      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
-      if (likely(__pyx_t_2)) {
-        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
-        __Pyx_INCREF(__pyx_t_2);
-        __Pyx_INCREF(function);
-        __Pyx_DECREF_SET(__pyx_t_3, function);
-      }
-    }
-    __pyx_t_5 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_v_activations) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_activations);
-    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 60, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_4 = __pyx_t_5;
-    __pyx_t_5 = 0;
-  } else {
-    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 60, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_argsort); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_3 = NULL;
-    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
-      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
-      if (likely(__pyx_t_3)) {
-        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
-        __Pyx_INCREF(__pyx_t_3);
-        __Pyx_INCREF(function);
-        __Pyx_DECREF_SET(__pyx_t_2, function);
-      }
-    }
-    __pyx_t_5 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_activations) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_activations);
-    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-    if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 60, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-    __pyx_t_2 = __Pyx_PyObject_GetSlice(__pyx_t_5, 0, __pyx_v_return_vals, NULL, NULL, NULL, 1, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-    __pyx_t_4 = __pyx_t_2;
-    __pyx_t_2 = 0;
-  }
-  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_GIVEREF(__pyx_t_4);
-  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4);
-  __Pyx_INCREF(__pyx_v_activations);
-  __Pyx_GIVEREF(__pyx_v_activations);
-  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_activations);
-  __pyx_t_4 = 0;
-  __pyx_r = __pyx_t_2;
-  __pyx_t_2 = 0;
-  goto __pyx_L0;
-
 61:
-
+62: def count_modified_cells(int bmu, cnp.ndarray map_d, float sigma):
-
/* Python wrapper */
-static PyObject *__pyx_pw_4core_7count_modified_cells(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_4core_6count_modified_cells[] = "\n    Neighborhood function which quantifies how much cells around the best matching one are modified\n\n    :param int bmu: best matching unit\n    :param nparray map_d: array of distances computed with :func:`geometry`\n    ";
-static PyMethodDef __pyx_mdef_4core_7count_modified_cells = {"count_modified_cells", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_7count_modified_cells, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4core_6count_modified_cells};
-static PyObject *__pyx_pw_4core_7count_modified_cells(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  int __pyx_v_bmu;
-  PyArrayObject *__pyx_v_map_d = 0;
-  float __pyx_v_sigma;
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("count_modified_cells (wrapper)", 0);
-  {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_bmu,&__pyx_n_s_map_d,&__pyx_n_s_sigma,0};
-    PyObject* values[3] = {0,0,0};
-    if (unlikely(__pyx_kwds)) {
-      Py_ssize_t kw_args;
-      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
-      switch (pos_args) {
-        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-        CYTHON_FALLTHROUGH;
-        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-        CYTHON_FALLTHROUGH;
-        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-        CYTHON_FALLTHROUGH;
-        case  0: break;
-        default: goto __pyx_L5_argtuple_error;
-      }
-      kw_args = PyDict_Size(__pyx_kwds);
-      switch (pos_args) {
-        case  0:
-        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_bmu)) != 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_map_d)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("count_modified_cells", 1, 3, 3, 1); __PYX_ERR(0, 62, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sigma)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("count_modified_cells", 1, 3, 3, 2); __PYX_ERR(0, 62, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "count_modified_cells") < 0)) __PYX_ERR(0, 62, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
-      goto __pyx_L5_argtuple_error;
-    } else {
-      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
-      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
-      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
-    }
-    __pyx_v_bmu = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_bmu == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 62, __pyx_L3_error)
-    __pyx_v_map_d = ((PyArrayObject *)values[1]);
-    __pyx_v_sigma = __pyx_PyFloat_AsFloat(values[2]); if (unlikely((__pyx_v_sigma == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 62, __pyx_L3_error)
-  }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("count_modified_cells", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 62, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("core.count_modified_cells", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return NULL;
-  __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_map_d), __pyx_ptype_5numpy_ndarray, 1, "map_d", 0))) __PYX_ERR(0, 62, __pyx_L1_error)
-  __pyx_r = __pyx_pf_4core_6count_modified_cells(__pyx_self, __pyx_v_bmu, __pyx_v_map_d, __pyx_v_sigma);
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-
-  /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_4core_6count_modified_cells(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_bmu, PyArrayObject *__pyx_v_map_d, float __pyx_v_sigma) {
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("count_modified_cells", 0);
-/* … */
-  /* function exit code */
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_4);
-  __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_AddTraceback("core.count_modified_cells", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-/* … */
-  __pyx_tuple__12 = PyTuple_Pack(3, __pyx_n_s_bmu, __pyx_n_s_map_d, __pyx_n_s_sigma); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 62, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__12);
-  __Pyx_GIVEREF(__pyx_tuple__12);
-/* … */
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_4core_7count_modified_cells, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 62, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_count_modified_cells, __pyx_t_3) < 0) __PYX_ERR(0, 62, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_codeobj__13 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_somsphere_cython_core_pyx, __pyx_n_s_count_modified_cells, 62, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__13)) __PYX_ERR(0, 62, __pyx_L1_error)
-
 63:     """
-
 64:     Neighborhood function which quantifies how much cells around the best matching one are modified
-
 65:
-
 66:     :param int bmu: best matching unit
-
 67:     :param nparray map_d: array of distances computed with :func:`geometry`
-
 68:     """
-
+69:     return np.exp(-(map_d[bmu] ** 2) / sigma ** 2)
-
  __Pyx_XDECREF(__pyx_r);
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_exp); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 69, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_GetItemInt(((PyObject *)__pyx_v_map_d), __pyx_v_bmu, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_4 = PyNumber_Power(__pyx_t_2, __pyx_int_2, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 69, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = PyNumber_Negative(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_4 = PyFloat_FromDouble(powf(__pyx_v_sigma, 2.0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 69, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_4);
-  __pyx_t_5 = __Pyx_PyNumber_Divide(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 69, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __pyx_t_4 = NULL;
-  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
-    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
-    if (likely(__pyx_t_4)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
-      __Pyx_INCREF(__pyx_t_4);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_3, function);
-    }
-  }
-  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 69, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_r = __pyx_t_1;
-  __pyx_t_1 = 0;
-  goto __pyx_L0;
-
 70:
-
+71: def create_map_online(cnp.ndarray X, int n_iter, int n_row, int n_col, int n_pix, float alpha_start, float alpha_end,
-
/* Python wrapper */
-static PyObject *__pyx_pw_4core_9create_map_online(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static PyMethodDef __pyx_mdef_4core_9create_map_online = {"create_map_online", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4core_9create_map_online, METH_VARARGS|METH_KEYWORDS, 0};
-static PyObject *__pyx_pw_4core_9create_map_online(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
-  PyArrayObject *__pyx_v_X = 0;
-  int __pyx_v_n_iter;
-  int __pyx_v_n_row;
-  int __pyx_v_n_col;
-  int __pyx_v_n_pix;
-  float __pyx_v_alpha_start;
-  float __pyx_v_alpha_end;
-  PyArrayObject *__pyx_v_importance = 0;
-  PyArrayObject *__pyx_v_dist_lib = 0;
-  PyArrayObject *__pyx_v_weights = 0;
-  int __pyx_v_random_order;
-  PyObject *__pyx_r = 0;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("create_map_online (wrapper)", 0);
-  {
-    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_X,&__pyx_n_s_n_iter,&__pyx_n_s_n_row,&__pyx_n_s_n_col,&__pyx_n_s_n_pix,&__pyx_n_s_alpha_start,&__pyx_n_s_alpha_end,&__pyx_n_s_importance,&__pyx_n_s_dist_lib,&__pyx_n_s_weights,&__pyx_n_s_random_order,0};
-    PyObject* values[11] = {0,0,0,0,0,0,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 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10);
-        CYTHON_FALLTHROUGH;
-        case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9);
-        CYTHON_FALLTHROUGH;
-        case  9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
-        CYTHON_FALLTHROUGH;
-        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
-        CYTHON_FALLTHROUGH;
-        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
-        CYTHON_FALLTHROUGH;
-        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
-        CYTHON_FALLTHROUGH;
-        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_X)) != 0)) kw_args--;
-        else goto __pyx_L5_argtuple_error;
-        CYTHON_FALLTHROUGH;
-        case  1:
-        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_iter)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 1); __PYX_ERR(0, 71, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  2:
-        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_row)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 2); __PYX_ERR(0, 71, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  3:
-        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_col)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 3); __PYX_ERR(0, 71, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  4:
-        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n_pix)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 4); __PYX_ERR(0, 71, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  5:
-        if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha_start)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 5); __PYX_ERR(0, 71, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  6:
-        if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_alpha_end)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 6); __PYX_ERR(0, 71, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  7:
-        if (likely((values[7] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_importance)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 7); __PYX_ERR(0, 71, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  8:
-        if (likely((values[8] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dist_lib)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 8); __PYX_ERR(0, 71, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case  9:
-        if (likely((values[9] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_weights)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 9); __PYX_ERR(0, 71, __pyx_L3_error)
-        }
-        CYTHON_FALLTHROUGH;
-        case 10:
-        if (likely((values[10] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_random_order)) != 0)) kw_args--;
-        else {
-          __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, 10); __PYX_ERR(0, 71, __pyx_L3_error)
-        }
-      }
-      if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create_map_online") < 0)) __PYX_ERR(0, 71, __pyx_L3_error)
-      }
-    } else if (PyTuple_GET_SIZE(__pyx_args) != 11) {
-      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);
-      values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
-      values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
-      values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
-      values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
-      values[9] = PyTuple_GET_ITEM(__pyx_args, 9);
-      values[10] = PyTuple_GET_ITEM(__pyx_args, 10);
-    }
-    __pyx_v_X = ((PyArrayObject *)values[0]);
-    __pyx_v_n_iter = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_n_iter == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error)
-    __pyx_v_n_row = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_n_row == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error)
-    __pyx_v_n_col = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_n_col == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error)
-    __pyx_v_n_pix = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_n_pix == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error)
-    __pyx_v_alpha_start = __pyx_PyFloat_AsFloat(values[5]); if (unlikely((__pyx_v_alpha_start == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error)
-    __pyx_v_alpha_end = __pyx_PyFloat_AsFloat(values[6]); if (unlikely((__pyx_v_alpha_end == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error)
-    __pyx_v_importance = ((PyArrayObject *)values[7]);
-    __pyx_v_dist_lib = ((PyArrayObject *)values[8]);
-    __pyx_v_weights = ((PyArrayObject *)values[9]);
-    __pyx_v_random_order = __Pyx_PyObject_IsTrue(values[10]); if (unlikely((__pyx_v_random_order == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 72, __pyx_L3_error)
-  }
-  goto __pyx_L4_argument_unpacking_done;
-  __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("create_map_online", 1, 11, 11, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 71, __pyx_L3_error)
-  __pyx_L3_error:;
-  __Pyx_AddTraceback("core.create_map_online", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __Pyx_RefNannyFinishContext();
-  return NULL;
-  __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_X), __pyx_ptype_5numpy_ndarray, 1, "X", 0))) __PYX_ERR(0, 71, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_importance), __pyx_ptype_5numpy_ndarray, 1, "importance", 0))) __PYX_ERR(0, 72, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dist_lib), __pyx_ptype_5numpy_ndarray, 1, "dist_lib", 0))) __PYX_ERR(0, 72, __pyx_L1_error)
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_weights), __pyx_ptype_5numpy_ndarray, 1, "weights", 0))) __PYX_ERR(0, 72, __pyx_L1_error)
-  __pyx_r = __pyx_pf_4core_8create_map_online(__pyx_self, __pyx_v_X, __pyx_v_n_iter, __pyx_v_n_row, __pyx_v_n_col, __pyx_v_n_pix, __pyx_v_alpha_start, __pyx_v_alpha_end, __pyx_v_importance, __pyx_v_dist_lib, __pyx_v_weights, __pyx_v_random_order);
-  int __pyx_lineno = 0;
-  const char *__pyx_filename = NULL;
-  int __pyx_clineno = 0;
-
-  /* function exit code */
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-
-static PyObject *__pyx_pf_4core_8create_map_online(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_X, int __pyx_v_n_iter, int __pyx_v_n_row, int __pyx_v_n_col, int __pyx_v_n_pix, float __pyx_v_alpha_start, float __pyx_v_alpha_end, PyArrayObject *__pyx_v_importance, PyArrayObject *__pyx_v_dist_lib, PyArrayObject *__pyx_v_weights, int __pyx_v_random_order) {
-  int __pyx_v_t;
-  int __pyx_v_total_t;
-  float __pyx_v_sigma_0;
-  float __pyx_v_sigma_f;
-  int __pyx_v_i;
-  int __pyx_v_best;
-  float __pyx_v_alpha;
-  float __pyx_v_sigma;
-  PyObject *__pyx_v_random_indices = 0;
-  PyArrayObject *__pyx_v_inputs = 0;
-  CYTHON_UNUSED PyArrayObject *__pyx_v_activation = 0;
-  CYTHON_UNUSED int __pyx_v_it;
-  PyObject *__pyx_r = NULL;
-  __Pyx_RefNannyDeclarations
-  __Pyx_RefNannySetupContext("create_map_online", 0);
-  __Pyx_INCREF((PyObject *)__pyx_v_weights);
-/* … */
-  /* function exit code */
-  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
-  goto __pyx_L0;
-  __pyx_L1_error:;
-  __Pyx_XDECREF(__pyx_t_1);
-  __Pyx_XDECREF(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3);
-  __Pyx_XDECREF(__pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_6);
-  __Pyx_XDECREF(__pyx_t_7);
-  __Pyx_XDECREF(__pyx_t_11);
-  __Pyx_XDECREF(__pyx_t_13);
-  __Pyx_AddTraceback("core.create_map_online", __pyx_clineno, __pyx_lineno, __pyx_filename);
-  __pyx_r = NULL;
-  __pyx_L0:;
-  __Pyx_XDECREF(__pyx_v_random_indices);
-  __Pyx_XDECREF((PyObject *)__pyx_v_inputs);
-  __Pyx_XDECREF((PyObject *)__pyx_v_activation);
-  __Pyx_XDECREF((PyObject *)__pyx_v_weights);
-  __Pyx_XGIVEREF(__pyx_r);
-  __Pyx_RefNannyFinishContext();
-  return __pyx_r;
-}
-/* … */
-  __pyx_tuple__14 = PyTuple_Pack(23, __pyx_n_s_X, __pyx_n_s_n_iter, __pyx_n_s_n_row, __pyx_n_s_n_col, __pyx_n_s_n_pix, __pyx_n_s_alpha_start, __pyx_n_s_alpha_end, __pyx_n_s_importance, __pyx_n_s_dist_lib, __pyx_n_s_weights, __pyx_n_s_random_order, __pyx_n_s_t, __pyx_n_s_total_t, __pyx_n_s_sigma_0, __pyx_n_s_sigma_f, __pyx_n_s_i, __pyx_n_s_best, __pyx_n_s_alpha, __pyx_n_s_sigma, __pyx_n_s_random_indices, __pyx_n_s_inputs, __pyx_n_s_activation, __pyx_n_s_it); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 71, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_tuple__14);
-  __Pyx_GIVEREF(__pyx_tuple__14);
-/* … */
-  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_4core_9create_map_online, NULL, __pyx_n_s_core); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 71, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_create_map_online, __pyx_t_3) < 0) __PYX_ERR(0, 71, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-
 72:                       cnp.ndarray importance, cnp.ndarray dist_lib, cnp.ndarray weights, bint random_order):
-
+73:     cdef int t = 0
-
  __pyx_v_t = 0;
-
+74:     cdef int total_t = n_iter * n_row
-
  __pyx_v_total_t = (__pyx_v_n_iter * __pyx_v_n_row);
-
+75:     cdef float sigma_0 = dist_lib.max()
-
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_dist_lib), __pyx_n_s_max); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 75, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = NULL;
-  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
-    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
-    if (likely(__pyx_t_3)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
-      __Pyx_INCREF(__pyx_t_3);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_2, function);
-    }
-  }
-  __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2);
-  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 75, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_4 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 75, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_v_sigma_0 = __pyx_t_4;
-
+76:     cdef float sigma_f = np.min(dist_lib[np.where(dist_lib > 0.)])
-
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 76, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 76, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 76, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_5);
-  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_where); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 76, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_6);
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  __pyx_t_5 = PyObject_RichCompare(((PyObject *)__pyx_v_dist_lib), __pyx_float_0_, Py_GT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 76, __pyx_L1_error)
-  __pyx_t_7 = NULL;
-  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
-    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
-    if (likely(__pyx_t_7)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
-      __Pyx_INCREF(__pyx_t_7);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_6, function);
-    }
-  }
-  __pyx_t_2 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5);
-  __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
-  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 76, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-  __pyx_t_6 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_dist_lib), __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 76, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_6);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = NULL;
-  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
-    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
-    if (likely(__pyx_t_2)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
-      __Pyx_INCREF(__pyx_t_2);
-      __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_3, function);
-    }
-  }
-  __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_6);
-  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 76, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_4 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 76, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_v_sigma_f = __pyx_t_4;
-
 77:
-
 78:     cdef int i, best
-
 79:     cdef float alpha, sigma
-
 80:     cdef list random_indices
-
+81:     cdef cnp.ndarray inputs = np.zeros([n_col, 1], dtype=DTYPE)
-
  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 81, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 81, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_n_col); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 81, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_6 = PyList_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 81, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_6);
-  __Pyx_GIVEREF(__pyx_t_1);
-  PyList_SET_ITEM(__pyx_t_6, 0, __pyx_t_1);
-  __Pyx_INCREF(__pyx_int_1);
-  __Pyx_GIVEREF(__pyx_int_1);
-  PyList_SET_ITEM(__pyx_t_6, 1, __pyx_int_1);
-  __pyx_t_1 = 0;
-  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 81, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_6);
-  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_6);
-  __pyx_t_6 = 0;
-  __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 81, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_6);
-  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_DTYPE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_2) < 0) __PYX_ERR(0, 81, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-  if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 81, __pyx_L1_error)
-  __pyx_v_inputs = ((PyArrayObject *)__pyx_t_2);
-  __pyx_t_2 = 0;
-
+82:     cdef cnp.ndarray activation = np.zeros([n_pix, 1], dtype=DTYPE)
-
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 82, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_6);
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_n_pix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 82, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GIVEREF(__pyx_t_2);
-  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
-  __Pyx_INCREF(__pyx_int_1);
-  __Pyx_GIVEREF(__pyx_int_1);
-  PyList_SET_ITEM(__pyx_t_1, 1, __pyx_int_1);
-  __pyx_t_2 = 0;
-  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __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_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 82, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 82, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_3) < 0) __PYX_ERR(0, 82, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 82, __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_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 82, __pyx_L1_error)
-  __pyx_v_activation = ((PyArrayObject *)__pyx_t_3);
-  __pyx_t_3 = 0;
-
 83:
-
+84:     for it in range(n_iter):
-
  __pyx_t_8 = __pyx_v_n_iter;
-  __pyx_t_9 = __pyx_t_8;
-  for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) {
-    __pyx_v_it = __pyx_t_10;
-
+85:         alpha = get_alpha(alpha_end, alpha_start, t, total_t)
-
    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_get_alpha); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 85, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_2 = PyFloat_FromDouble(__pyx_v_alpha_end); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_2);
-    __pyx_t_6 = PyFloat_FromDouble(__pyx_v_alpha_start); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 85, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_6);
-    __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 85, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_total_t); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 85, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_7);
-    __pyx_t_11 = NULL;
-    __pyx_t_12 = 0;
-    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
-      __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_1);
-      if (likely(__pyx_t_11)) {
-        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
-        __Pyx_INCREF(__pyx_t_11);
-        __Pyx_INCREF(function);
-        __Pyx_DECREF_SET(__pyx_t_1, function);
-        __pyx_t_12 = 1;
-      }
-    }
-    #if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(__pyx_t_1)) {
-      PyObject *__pyx_temp[5] = {__pyx_t_11, __pyx_t_2, __pyx_t_6, __pyx_t_5, __pyx_t_7};
-      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_12, 4+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error)
-      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-    } else
-    #endif
-    #if CYTHON_FAST_PYCCALL
-    if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
-      PyObject *__pyx_temp[5] = {__pyx_t_11, __pyx_t_2, __pyx_t_6, __pyx_t_5, __pyx_t_7};
-      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_12, 4+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error)
-      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-    } else
-    #endif
-    {
-      __pyx_t_13 = PyTuple_New(4+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 85, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_13);
-      if (__pyx_t_11) {
-        __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_11); __pyx_t_11 = NULL;
-      }
-      __Pyx_GIVEREF(__pyx_t_2);
-      PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_12, __pyx_t_2);
-      __Pyx_GIVEREF(__pyx_t_6);
-      PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_12, __pyx_t_6);
-      __Pyx_GIVEREF(__pyx_t_5);
-      PyTuple_SET_ITEM(__pyx_t_13, 2+__pyx_t_12, __pyx_t_5);
-      __Pyx_GIVEREF(__pyx_t_7);
-      PyTuple_SET_ITEM(__pyx_t_13, 3+__pyx_t_12, __pyx_t_7);
-      __pyx_t_2 = 0;
-      __pyx_t_6 = 0;
-      __pyx_t_5 = 0;
-      __pyx_t_7 = 0;
-      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_13, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
-    }
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_t_3); if (unlikely((__pyx_t_4 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 85, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_v_alpha = __pyx_t_4;
-
+86:         sigma = get_sigma(sigma_f, sigma_0, t, total_t)
-
    __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_get_sigma); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 86, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_13 = PyFloat_FromDouble(__pyx_v_sigma_f); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 86, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_13);
-    __pyx_t_7 = PyFloat_FromDouble(__pyx_v_sigma_0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 86, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_7);
-    __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 86, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_5);
-    __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_total_t); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 86, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_6);
-    __pyx_t_2 = NULL;
-    __pyx_t_12 = 0;
-    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
-      __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
-      if (likely(__pyx_t_2)) {
-        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
-        __Pyx_INCREF(__pyx_t_2);
-        __Pyx_INCREF(function);
-        __Pyx_DECREF_SET(__pyx_t_1, function);
-        __pyx_t_12 = 1;
-      }
-    }
-    #if CYTHON_FAST_PYCALL
-    if (PyFunction_Check(__pyx_t_1)) {
-      PyObject *__pyx_temp[5] = {__pyx_t_2, __pyx_t_13, __pyx_t_7, __pyx_t_5, __pyx_t_6};
-      __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_12, 4+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error)
-      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
-      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-    } else
-    #endif
-    #if CYTHON_FAST_PYCCALL
-    if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
-      PyObject *__pyx_temp[5] = {__pyx_t_2, __pyx_t_13, __pyx_t_7, __pyx_t_5, __pyx_t_6};
-      __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_12, 4+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error)
-      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
-      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-    } else
-    #endif
-    {
-      __pyx_t_11 = PyTuple_New(4+__pyx_t_12); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 86, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_11);
-      if (__pyx_t_2) {
-        __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_2); __pyx_t_2 = NULL;
-      }
-      __Pyx_GIVEREF(__pyx_t_13);
-      PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_12, __pyx_t_13);
-      __Pyx_GIVEREF(__pyx_t_7);
-      PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_12, __pyx_t_7);
-      __Pyx_GIVEREF(__pyx_t_5);
-      PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_12, __pyx_t_5);
-      __Pyx_GIVEREF(__pyx_t_6);
-      PyTuple_SET_ITEM(__pyx_t_11, 3+__pyx_t_12, __pyx_t_6);
-      __pyx_t_13 = 0;
-      __pyx_t_7 = 0;
-      __pyx_t_5 = 0;
-      __pyx_t_6 = 0;
-      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
-    }
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_t_3); if (unlikely((__pyx_t_4 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 86, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_v_sigma = __pyx_t_4;
-
+87:         random_indices = random.sample(range(n_row), n_row) if random_order else np.arange(
-
    if ((__pyx_v_random_order != 0)) {
-      __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_random); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 87, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_11);
-      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_sample); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 87, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_6);
-      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
-      __pyx_t_11 = __Pyx_PyInt_From_int(__pyx_v_n_row); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 87, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_11);
-      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_t_11); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 87, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_5);
-      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
-      __pyx_t_11 = __Pyx_PyInt_From_int(__pyx_v_n_row); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 87, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_11);
-      __pyx_t_7 = NULL;
-      __pyx_t_12 = 0;
-      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
-        __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
-        if (likely(__pyx_t_7)) {
-          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
-          __Pyx_INCREF(__pyx_t_7);
-          __Pyx_INCREF(function);
-          __Pyx_DECREF_SET(__pyx_t_6, function);
-          __pyx_t_12 = 1;
-        }
-      }
-      #if CYTHON_FAST_PYCALL
-      if (PyFunction_Check(__pyx_t_6)) {
-        PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_5, __pyx_t_11};
-        __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error)
-        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
-        __Pyx_GOTREF(__pyx_t_1);
-        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
-      } else
-      #endif
-      #if CYTHON_FAST_PYCCALL
-      if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
-        PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_5, __pyx_t_11};
-        __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error)
-        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
-        __Pyx_GOTREF(__pyx_t_1);
-        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
-        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
-      } else
-      #endif
-      {
-        __pyx_t_13 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 87, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_13);
-        if (__pyx_t_7) {
-          __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_7); __pyx_t_7 = NULL;
-        }
-        __Pyx_GIVEREF(__pyx_t_5);
-        PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_12, __pyx_t_5);
-        __Pyx_GIVEREF(__pyx_t_11);
-        PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_12, __pyx_t_11);
-        __pyx_t_5 = 0;
-        __pyx_t_11 = 0;
-        __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_13, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
-        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
-      }
-      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-      if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(0, 87, __pyx_L1_error)
-      __pyx_t_3 = __pyx_t_1;
-      __pyx_t_1 = 0;
-    } else {
-      __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 87, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_6);
-      __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_arange); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 87, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_13);
-      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-/* … */
-      if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_1)->tp_name), 0))) __PYX_ERR(0, 87, __pyx_L1_error)
-      __pyx_t_3 = __pyx_t_1;
-      __pyx_t_1 = 0;
-    }
-    __Pyx_XDECREF_SET(__pyx_v_random_indices, ((PyObject*)__pyx_t_3));
-    __pyx_t_3 = 0;
-
+88:             n_row)
-
      __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_n_row); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 88, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_6);
-      __pyx_t_11 = NULL;
-      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) {
-        __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_13);
-        if (likely(__pyx_t_11)) {
-          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13);
-          __Pyx_INCREF(__pyx_t_11);
-          __Pyx_INCREF(function);
-          __Pyx_DECREF_SET(__pyx_t_13, function);
-        }
-      }
-      __pyx_t_1 = (__pyx_t_11) ? __Pyx_PyObject_Call2Args(__pyx_t_13, __pyx_t_11, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_6);
-      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
-      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
-
 89:
-
+90:         for i in range(n_row):
-
    __pyx_t_12 = __pyx_v_n_row;
-    __pyx_t_14 = __pyx_t_12;
-    for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) {
-      __pyx_v_i = __pyx_t_15;
-
+91:             inputs = X[random_indices[i]]
-
      if (unlikely(__pyx_v_random_indices == Py_None)) {
-        PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
-        __PYX_ERR(0, 91, __pyx_L1_error)
-      }
-      __pyx_t_3 = __Pyx_GetItemInt_List(__pyx_v_random_indices, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 91, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_X), __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 91, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 91, __pyx_L1_error)
-      __Pyx_DECREF_SET(__pyx_v_inputs, ((PyArrayObject *)__pyx_t_1));
-      __pyx_t_1 = 0;
-
+92:             best, activation = get_best_cell(inputs=inputs, importance=importance,
-
      __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_get_best_cell); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 92, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      __pyx_t_3 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 92, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_inputs, ((PyObject *)__pyx_v_inputs)) < 0) __PYX_ERR(0, 92, __pyx_L1_error)
-      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_importance, ((PyObject *)__pyx_v_importance)) < 0) __PYX_ERR(0, 92, __pyx_L1_error)
-/* … */
-      __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 92, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_13);
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      if ((likely(PyTuple_CheckExact(__pyx_t_13))) || (PyList_CheckExact(__pyx_t_13))) {
-        PyObject* sequence = __pyx_t_13;
-        Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
-        if (unlikely(size != 2)) {
-          if (size > 2) __Pyx_RaiseTooManyValuesError(2);
-          else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
-          __PYX_ERR(0, 92, __pyx_L1_error)
-        }
-        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        if (likely(PyTuple_CheckExact(sequence))) {
-          __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); 
-          __pyx_t_1 = PyTuple_GET_ITEM(sequence, 1); 
-        } else {
-          __pyx_t_3 = PyList_GET_ITEM(sequence, 0); 
-          __pyx_t_1 = PyList_GET_ITEM(sequence, 1); 
-        }
-        __Pyx_INCREF(__pyx_t_3);
-        __Pyx_INCREF(__pyx_t_1);
-        #else
-        __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 92, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_3);
-        __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 92, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
-        #endif
-        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
-      } else {
-        Py_ssize_t index = -1;
-        __pyx_t_6 = PyObject_GetIter(__pyx_t_13); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 92, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_6);
-        __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
-        __pyx_t_16 = Py_TYPE(__pyx_t_6)->tp_iternext;
-        index = 0; __pyx_t_3 = __pyx_t_16(__pyx_t_6); if (unlikely(!__pyx_t_3)) goto __pyx_L7_unpacking_failed;
-        __Pyx_GOTREF(__pyx_t_3);
-        index = 1; __pyx_t_1 = __pyx_t_16(__pyx_t_6); if (unlikely(!__pyx_t_1)) goto __pyx_L7_unpacking_failed;
-        __Pyx_GOTREF(__pyx_t_1);
-        if (__Pyx_IternextUnpackEndCheck(__pyx_t_16(__pyx_t_6), 2) < 0) __PYX_ERR(0, 92, __pyx_L1_error)
-        __pyx_t_16 = NULL;
-        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-        goto __pyx_L8_unpacking_done;
-        __pyx_L7_unpacking_failed:;
-        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-        __pyx_t_16 = NULL;
-        if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
-        __PYX_ERR(0, 92, __pyx_L1_error)
-        __pyx_L8_unpacking_done:;
-      }
-      __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 92, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 92, __pyx_L1_error)
-      __pyx_v_best = __pyx_t_17;
-      __Pyx_DECREF_SET(__pyx_v_activation, ((PyArrayObject *)__pyx_t_1));
-      __pyx_t_1 = 0;
-
+93:                                              weights=weights, n_pix=n_pix, return_vals=1)
-
      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_weights, ((PyObject *)__pyx_v_weights)) < 0) __PYX_ERR(0, 92, __pyx_L1_error)
-      __pyx_t_13 = __Pyx_PyInt_From_int(__pyx_v_n_pix); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 93, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_13);
-      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_n_pix, __pyx_t_13) < 0) __PYX_ERR(0, 92, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
-      if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_return_vals, __pyx_int_1) < 0) __PYX_ERR(0, 92, __pyx_L1_error)
-
+94:             weights += alpha * count_modified_cells(best, dist_lib, sigma) * np.transpose(
-
      __pyx_t_13 = PyFloat_FromDouble(__pyx_v_alpha); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 94, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_13);
-      __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_count_modified_cells); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 94, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_best); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 94, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_6);
-      __pyx_t_11 = PyFloat_FromDouble(__pyx_v_sigma); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 94, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_11);
-      __pyx_t_5 = NULL;
-      __pyx_t_17 = 0;
-      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
-        __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
-        if (likely(__pyx_t_5)) {
-          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
-          __Pyx_INCREF(__pyx_t_5);
-          __Pyx_INCREF(function);
-          __Pyx_DECREF_SET(__pyx_t_3, function);
-          __pyx_t_17 = 1;
-        }
-      }
-      #if CYTHON_FAST_PYCALL
-      if (PyFunction_Check(__pyx_t_3)) {
-        PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_t_6, ((PyObject *)__pyx_v_dist_lib), __pyx_t_11};
-        __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_17, 3+__pyx_t_17); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error)
-        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-        __Pyx_GOTREF(__pyx_t_1);
-        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
-      } else
-      #endif
-      #if CYTHON_FAST_PYCCALL
-      if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
-        PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_t_6, ((PyObject *)__pyx_v_dist_lib), __pyx_t_11};
-        __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_17, 3+__pyx_t_17); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error)
-        __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
-        __Pyx_GOTREF(__pyx_t_1);
-        __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-        __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
-      } else
-      #endif
-      {
-        __pyx_t_7 = PyTuple_New(3+__pyx_t_17); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 94, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_7);
-        if (__pyx_t_5) {
-          __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
-        }
-        __Pyx_GIVEREF(__pyx_t_6);
-        PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_17, __pyx_t_6);
-        __Pyx_INCREF(((PyObject *)__pyx_v_dist_lib));
-        __Pyx_GIVEREF(((PyObject *)__pyx_v_dist_lib));
-        PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_17, ((PyObject *)__pyx_v_dist_lib));
-        __Pyx_GIVEREF(__pyx_t_11);
-        PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_17, __pyx_t_11);
-        __pyx_t_6 = 0;
-        __pyx_t_11 = 0;
-        __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
-        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-      }
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __pyx_t_3 = PyNumber_Multiply(__pyx_t_13, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 94, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-      __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_n_s_np); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 94, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_13);
-      __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_transpose); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 94, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_7);
-      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
-/* … */
-      __pyx_t_7 = PyNumber_Multiply(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 94, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_7);
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-      __pyx_t_1 = PyNumber_InPlaceAdd(((PyObject *)__pyx_v_weights), __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-      if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 94, __pyx_L1_error)
-      __Pyx_DECREF_SET(__pyx_v_weights, ((PyArrayObject *)__pyx_t_1));
-      __pyx_t_1 = 0;
-    }
-  }
-
+95:                 (inputs - np.transpose(weights)))
-
      __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_np); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 95, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_11);
-      __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_transpose); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 95, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_6);
-      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
-      __pyx_t_11 = NULL;
-      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
-        __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_6);
-        if (likely(__pyx_t_11)) {
-          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
-          __Pyx_INCREF(__pyx_t_11);
-          __Pyx_INCREF(function);
-          __Pyx_DECREF_SET(__pyx_t_6, function);
-        }
-      }
-      __pyx_t_13 = (__pyx_t_11) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_11, ((PyObject *)__pyx_v_weights)) : __Pyx_PyObject_CallOneArg(__pyx_t_6, ((PyObject *)__pyx_v_weights));
-      __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
-      if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 95, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_13);
-      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-      __pyx_t_6 = PyNumber_Subtract(((PyObject *)__pyx_v_inputs), __pyx_t_13); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 95, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_6);
-      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
-      __pyx_t_13 = NULL;
-      if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
-        __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_7);
-        if (likely(__pyx_t_13)) {
-          PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
-          __Pyx_INCREF(__pyx_t_13);
-          __Pyx_INCREF(function);
-          __Pyx_DECREF_SET(__pyx_t_7, function);
-        }
-      }
-      __pyx_t_1 = (__pyx_t_13) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_13, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6);
-      __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
-      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
-      if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_1);
-      __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-
diff --git a/somsphere/cython/core.pyx b/somsphere/cython/core.pyx deleted file mode 100644 index 1cc9d7e..0000000 --- a/somsphere/cython/core.pyx +++ /dev/null @@ -1,95 +0,0 @@ -#cython: language_level=3 -import random - -import numpy as np -cimport numpy as cnp - -from somsphere.utils import timeit - -DTYPE = np.float -ctypedef cnp.float_t DTYPE_t -# def create_map_batch(np.ndarray X, int n_iter, int n_row, int n_col, int n_pix, np.ndarray importance, -# np.ndarray dist_lib, np.ndarray weights): -# cdef int t = 0 -# cdef int total_t = n_iter * n_row -# cdef float sigma_0 = dist_lib.max() -# cdef float sigma_f = np.min(dist_lib[np.where(dist_lib > 0.)]) -# -# cdef int i -# cdef float sigma, activation -# cdef np.ndarray accum_w, accum_n, best, inputs -# -# for i in range(n_iter): -# sigma = get_sigma(sigma_f, sigma_0, t, total_t) -# accum_w = np.zeros((n_col, n_pix)) -# accum_n = np.zeros(n_pix) -# for j in range(n_row): -# inputs = X[j] -# best, activation = get_best_cell(inputs=inputs, importance=importance, -# weights=weights, n_pix=n_pix) -# for k in range(n_col): -# accum_w[k, :] += count_modified_cells(best, dist_lib, sigma) * inputs[k] -# accum_n += count_modified_cells(best, dist_lib, sigma) -# -# for l in range(n_col): -# weights[l] = accum_w[l] / accum_n -# -# t += n_row -def get_alpha(float alpha_end, float alpha_start, int curr_t, int total_t): - """ - Get value of alpha at a given time - """ - return alpha_start * np.power(alpha_end / alpha_start, float(curr_t) / float(total_t)) - -def get_sigma(float sigma_f, float sigma_0, int curr_t, int total_t): - """ - Get value of sigma at a given time - """ - return sigma_0 * np.power(sigma_f / sigma_0, float(curr_t) / float(total_t)) - -@timeit -def get_best_cell(cnp.ndarray inputs, cnp.ndarray importance, int n_pix, cnp.ndarray weights, int return_vals): - """ - Return the closest cell to the input object - It can return more than one value if needed - """ - cdef cnp.ndarray activation = np.zeros([n_pix, 1], dtype=DTYPE) - - activations = np.sum(np.transpose([importance]) * (np.transpose(np.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0) - - return np.argmin(activations) if return_vals == 1 else np.argsort(activations)[0:return_vals], activations - -def count_modified_cells(int bmu, cnp.ndarray map_d, float sigma): - """ - Neighborhood function which quantifies how much cells around the best matching one are modified - - :param int bmu: best matching unit - :param nparray map_d: array of distances computed with :func:`geometry` - """ - return np.exp(-(map_d[bmu] ** 2) / sigma ** 2) - -def create_map_online(cnp.ndarray X, int n_iter, int n_row, int n_col, int n_pix, float alpha_start, float alpha_end, - cnp.ndarray importance, cnp.ndarray dist_lib, cnp.ndarray weights, bint random_order): - cdef int t = 0 - cdef int total_t = n_iter * n_row - cdef float sigma_0 = dist_lib.max() - cdef float sigma_f = np.min(dist_lib[np.where(dist_lib > 0.)]) - - cdef int i, best - cdef float alpha, sigma - cdef list random_indices - cdef cnp.ndarray inputs = np.zeros([n_col, 1], dtype=DTYPE) - cdef cnp.ndarray activation = np.zeros([n_pix, 1], dtype=DTYPE) - - for it in range(n_iter): - alpha = get_alpha(alpha_end, alpha_start, t, total_t) - sigma = get_sigma(sigma_f, sigma_0, t, total_t) - random_indices = random.sample(range(n_row), n_row) if random_order else np.arange( - n_row) - - for i in range(n_row): - inputs = X[random_indices[i]] - best, activation = get_best_cell(inputs=inputs, importance=importance, - weights=weights, n_pix=n_pix, return_vals=1) - weights += alpha * count_modified_cells(best, dist_lib, sigma) * np.transpose( - (inputs - np.transpose(weights))) diff --git a/somsphere/utils/__init__.py b/somsphere/utils/__init__.py index a0f9ec9..0bf163e 100644 --- a/somsphere/utils/__init__.py +++ b/somsphere/utils/__init__.py @@ -15,7 +15,7 @@ def timed(*args, **kw): output = my_func(*args, **kw) tend = time.time() - print('"{}" took {:.3f} s to execute\n'.format(my_func.__name__, (tend - tstart) * 1000)) + print('"{}" took {:.3f} ms to execute\n'.format(my_func.__name__, (tend - tstart) * 1000)) return output return timed @@ -37,7 +37,7 @@ def count_modified_cells(bmu, map_d, sigma): Neighborhood function which quantifies how much cells around the best matching one are modified :param int bmu: best matching unit - :param float map_d: array of distances computed with :func:`geometry` + :param ndarray map_d: array of distances computed with :func:`geometry` """ return numpy.exp(-(map_d[bmu] ** 2) / sigma ** 2) @@ -139,7 +139,7 @@ def compute_distance(topology: Topology, n_top, periodic=False): :param int n_top: Size of map, for grid Size=n_top*n_top, for hex Size=n_top*(n_top+1[2]) if Ntop is even[odd] and for sphere Size=12*n_top*n_top and top must be power of 2 - :param str periodic: Use periodic boundary conditions ('yes'/'no'), valid for 'hex' and 'grid' only + :param bool periodic: Use periodic boundary conditions ('yes'/'no'), valid for 'hex' and 'grid' only :return: 2D array with distances pre computed between cells and total number of units :rtype: 2D float array, int """ diff --git a/test/test_somap.py b/test/test_somap.py index 04a0755..522f997 100644 --- a/test/test_somap.py +++ b/test/test_somap.py @@ -1,23 +1,60 @@ import unittest -import somsphere -from somsphere import SOMap +import core import numpy as np +import somsphere +from somsphere import SOMap, get_best_cell, count_modified_cells + class TestSOMap(unittest.TestCase): - def test_init_error(self): - som = SOMap([], [], n_top=0, topology="sphere") - - def test_create_map(self): + def setUp(self) -> None: data = "../resources/SDSS_MGS.train" - # just read magnitudes and colors - dx = np.loadtxt(data, usecols=(1, 2, 3, 4, 5, 6, 7, 8, 9), unpack=True).T - np.shape(dx) - # read zspec (or any other extra column) - dy = np.loadtxt(data, usecols=(0,), unpack=True).T - np.shape(dy) - # create an instance - map = somsphere.SOMap(topology='grid', n_top=15, n_iter=100, periodic=False) - map.create_map(dx, dy) # This actually creates the map using only dx + self.dx = np.loadtxt(data, usecols=(1, 2, 3, 4, 5, 6, 7, 8, 9), unpack=True).T + self.dy = np.loadtxt(data, usecols=(0,), unpack=True).T + + def test_create_map_online(self): + map = somsphere.SOMap(self.dx, self.dy, topology='grid', n_top=15, n_iter=100, periodic=False) + map.create_map() + + map = somsphere.SOMap(self.dx, self.dy, topology='sphere', n_top=8, n_iter=100, periodic=False) + map.create_map() + + map = somsphere.SOMap(self.dx, self.dy, topology='hex', n_top=15, n_iter=100, periodic=False) + map.create_map() + + def test_create_map_batch(self): + map = somsphere.SOMap(self.dx, self.dy, topology='grid', n_top=15, n_iter=100, periodic=False, som_type="batch") + map.create_map() + + map = somsphere.SOMap(self.dx, self.dy, topology='sphere', n_top=8, n_iter=100, periodic=False, + som_type="batch") + map.create_map() + + map = somsphere.SOMap(self.dx, self.dy, topology='hex', n_top=15, n_iter=100, periodic=False, som_type="batch") + map.create_map() + + def test_get_best_cell(self): + n_pix = 225 + n_col = 9 + weights = np.random.rand(n_col, n_pix) + random_indices = np.random.randint(5000, size=5000) + importance = np.random.rand(n_col) + inputs = self.dx[random_indices[0]] + old_best, old_activations = get_best_cell(inputs=inputs, importance=importance, weights=weights, + n_pix=n_pix, return_vals=1) + new_best, new_activations = core.get_best_cell(inputs, importance, weights, n_col, n_pix, 1) + + self.assertEqual(0, sum(old_activations - new_activations)) + self.assertEqual(old_best, new_best[0]) + + def test_count_modified_cells(self): + bmu = [1] + n_pix = 225 + sigma = 0.7 + dist_lib = np.random.rand(n_pix, n_pix) + + old_cmc = count_modified_cells(1, dist_lib, sigma) + new_cmc = core.count_modified_cells(bmu, dist_lib, sigma) + np.allclose(old_cmc, new_cmc) From d630bf74dcce26c0ec6a632b5b27969e10102a92 Mon Sep 17 00:00:00 2001 From: Ruiqi Li Date: Thu, 8 Oct 2020 01:12:34 -0400 Subject: [PATCH 7/7] Minor problem with hex graph --- Example.ipynb | 168 ++++++++++++++---------------------------- somsphere/__init__.py | 2 +- 2 files changed, 57 insertions(+), 113 deletions(-) diff --git a/Example.ipynb b/Example.ipynb index b1f7d35..d9f77cf 100644 --- a/Example.ipynb +++ b/Example.ipynb @@ -72,25 +72,16 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\"__create_map_batch\" took 29650.045 ms to execute\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "M.create_map() #This actually creates the map using only Data_X" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -99,29 +90,16 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "M.plot_map()" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -131,47 +109,18 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "M.plot_map()" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "operands could not be broadcast together with shapes (9,225) (5000,9) ", - "output_type": "error", - "traceback": [ - "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", - "\u001B[0;31mValueError\u001B[0m Traceback (most recent call last)", - "\u001B[0;32m\u001B[0m in \u001B[0;36m\u001B[0;34m\u001B[0m\n\u001B[1;32m 1\u001B[0m \u001B[0;31m#Every time the map is created it will be different given the random weights\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m----> 2\u001B[0;31m \u001B[0mM\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mcreate_map\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m", - "\u001B[0;32m~/dev/somsphere/somsphere/__init__.py\u001B[0m in \u001B[0;36mcreate_map\u001B[0;34m(self, input_weights, random_order, eval_map)\u001B[0m\n\u001B[1;32m 124\u001B[0m \u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0m__create_map_online\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mrandom_order\u001B[0m\u001B[0;34m=\u001B[0m\u001B[0mrandom_order\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0meval_map\u001B[0m\u001B[0;34m=\u001B[0m\u001B[0meval_map\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 125\u001B[0m \u001B[0;32melif\u001B[0m \u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0msom_type\u001B[0m \u001B[0;34m==\u001B[0m \u001B[0mSomType\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mBATCH\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m--> 126\u001B[0;31m \u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0m__create_map_batch\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0meval_map\u001B[0m\u001B[0;34m=\u001B[0m\u001B[0meval_map\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m 127\u001B[0m \u001B[0;32melse\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 128\u001B[0m \u001B[0;32mraise\u001B[0m \u001B[0mException\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34mf\"Unknown type: {self.som_type}\"\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n", - "\u001B[0;32m~/dev/somsphere/somsphere/utils/__init__.py\u001B[0m in \u001B[0;36mtimed\u001B[0;34m(*args, **kw)\u001B[0m\n\u001B[1;32m 13\u001B[0m \u001B[0;32mdef\u001B[0m \u001B[0mtimed\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m*\u001B[0m\u001B[0margs\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0;34m**\u001B[0m\u001B[0mkw\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 14\u001B[0m \u001B[0mtstart\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mtime\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mtime\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m---> 15\u001B[0;31m \u001B[0moutput\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mmy_func\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m*\u001B[0m\u001B[0margs\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0;34m**\u001B[0m\u001B[0mkw\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m 16\u001B[0m \u001B[0mtend\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mtime\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mtime\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 17\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n", - "\u001B[0;32m~/dev/somsphere/somsphere/__init__.py\u001B[0m in \u001B[0;36m__create_map_batch\u001B[0;34m(self, eval_map)\u001B[0m\n\u001B[1;32m 96\u001B[0m \u001B[0;32mfor\u001B[0m \u001B[0mi\u001B[0m \u001B[0;32min\u001B[0m \u001B[0mrange\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mn_row\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 97\u001B[0m \u001B[0minputs\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mX\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0mi\u001B[0m\u001B[0;34m]\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m---> 98\u001B[0;31m best, _ = get_best_cell(inputs=inputs, importance=self.importance,\n\u001B[0m\u001B[1;32m 99\u001B[0m weights=self.weights, n_pix=self.n_pix)\n\u001B[1;32m 100\u001B[0m \u001B[0mcmc\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mcount_modified_cells\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mbest\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mdist_lib\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0msigma\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n", - "\u001B[0;32m~/dev/somsphere/somsphere/utils/__init__.py\u001B[0m in \u001B[0;36mget_best_cell\u001B[0;34m(inputs, importance, n_pix, weights, return_vals)\u001B[0m\n\u001B[1;32m 28\u001B[0m \"\"\"\n\u001B[1;32m 29\u001B[0m activations = numpy.sum(numpy.transpose([importance]) * (\n\u001B[0;32m---> 30\u001B[0;31m numpy.transpose(numpy.tile(inputs, (n_pix, 1))) - weights) ** 2, axis=0)\n\u001B[0m\u001B[1;32m 31\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 32\u001B[0m \u001B[0;32mreturn\u001B[0m \u001B[0mnumpy\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0margmin\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mactivations\u001B[0m\u001B[0;34m)\u001B[0m \u001B[0;32mif\u001B[0m \u001B[0mreturn_vals\u001B[0m \u001B[0;34m==\u001B[0m \u001B[0;36m1\u001B[0m \u001B[0;32melse\u001B[0m \u001B[0mnumpy\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0margsort\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mactivations\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0;36m0\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0mreturn_vals\u001B[0m\u001B[0;34m]\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mactivations\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n", - "\u001B[0;31mValueError\u001B[0m: operands could not be broadcast together with shapes (9,225) (5000,9) " - ] - } - ], + "outputs": [], "source": [ "#Every time the map is created it will be different given the random weights\n", "M.create_map()" @@ -179,22 +128,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "M.evaluate_map()\n", "M.plot_map()" @@ -202,22 +138,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlwAAAJvCAYAAACu8g+zAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAdWUlEQVR4nO3dbYylZ3kf8P+9Z3bXeL1ewKpNHBPFLQ4JSSVXoJZGFNy3CCkkkFaoNKpaSD6UFPUDfbeiqpGqNh8imZaGqkIFhUpR1Q8QGtqYRCgQlDaNCFGoiEOaNATjusaJt16v39Z7ztz9cI7JsFlgztrXcz855/eTjsYz58xzX56dmb30v+69n9Z7DwAAdU6MLgAAYNdpuAAAimm4AACKabgAAIppuAAAimm4AACKabgAAIodjC4AANhNrbXrkpwasPQzvfenB6z7VTUHnwIAz7fW2nU3JE89Pmb5h5LcPqemS8IFAFQ49XiSdyY5PeGil5K8K3lJ1smahgsA2H2nk1w3uogZ0HABAGUOMm2zMdfGxr9SBAAoNtdGEADYASc3j6msJlxrGxIuAIBiGi4AgGJGigBAGZvm1yRcAADF5toIAgA74CDTbppfTrjWNiRcAADFJFwAQBl7uNYkXAAAxTRcAADF5pq8AQA7YOqT5m2aBwDYUxIuAKCMTfNrEi4AgGJzbQQBgB0w9cGnlydcaxsSLgCAYhouAIBiRooAQBmb5tckXAAAxebaCAIAO2Dqg0+nXGsbEi4AgGISLgCgjIRrTcIFAFBMwwUAUMxIEQAo41iINQkXAECxuTaCAMAOmPpeinNtbCRcAADFNFwAAMXmmrwBADvApvk1CRcAQLG5NoIAwA5w0vyahAsAoJiECwAoYw/XmoQLAKCYhgsAoNhckzcAYAc4aX5NwgUAUGyujSAAsANsml+TcAEAFJtrIwgA7AAHn65JuAAAimm4AACKGSkCAGVsml+TcAEAFJtrIwgA7AAHn65JuAAAis21EQQAdoBjIdYkXAAAxY6fcP1w64V1HM9ydAFJnhhdQObxdXh4dAEbnx1dQJLTowtI+oOjK0h+9fzoCpJvOzO6gmQ5g5/PBy6NriD57dEFbPzq6AJm4kd6b6Nr2HdGigBAGcdCrBkpAgAUm2sjCADsgINFcnLCgeZBT7Kabr3jknABABSTcAEAZQ4OkgMJl4QLAKCahgsAoJiRIgBQ5uTEm+ZPjj819KokXAAAxSRcAECZIZvmZ0jCBQBQTMMFAFDMSBEAKHNykZycMN45eTjdWtuQcAEAFJNwAQB1Fpk23plwg/42JFwAAMUkXABAnYNMG+/YwwUAsJ80XAAAxYwUAYA6RopJJFwAAOUkXABAHQlXEgkXAEA5CRcAUOdE1oef7jkJFwBAMQ0XAEAxI0UAoM5Bph0pupciAMB+knABAHUkXEkkXAAA5SRcAECdRRwLEQkXAEC54ydcpwurOK5zowtIctPoApI8MbqAJKvRBWzcMbqAzOLPo83gZ+OV94+uIPPI7Gfw/XDjw6MrSG4ZXcDGnxldQJLLowtgFubw6wkA2FU2zScxUgQAKCfhAgDqLKLbiIQLAKCchgsAoJiQDwCoM/U5XH3CtbYg4QIAKCbhAgDqHES3EQkXAEA5DRcAUOdgwGMLrbW7W2ufaq1dbK093Fr7cGvt5Ve85rrW2ntaa4+01h5vrX2wtbbVDRU0XADAPntdkvckeXWSv5zkZJKfa62dOfKadyX5niRv3rz+1iQf2mYRU1UAYBedbe0r7vNzqfd+6coX9d5ff/T91tpbkzyc5JVJPtlaO5fkB5N8f+/95zeveVuS32itvbr3/j+OU4yECwCoM26k+ECSC0cedx+z4nObt+c3b1+Zder1sWdf0Hv/XJL7k/zZY15TwgUA7KTbklw88v4fSreu1Fo7keRfJflvvffPbj78kiTP9N4fveLlX9o8dywaLgCgzolMe/Dp4Zf/62Lv/bEtP/s9Sb4jyWuez5ISI0UAgLTWfjzJG5L8+d77A0eeeijJqdbaC6/4lFs2zx2LhAsAqDP1wadb3tqnrXfW/5sk35fkrt775694yaeTXE7yF5N8cPM5L0/yTUl+6bjraLgAgH32niTfn+SNSS621p7dl3Wh9/5U7/1Ca+19Se5prZ1P8ljWDdovHfdfKCYaLgBgv/3Q5u0nrvj425L8xOa/35n17rAPJjmd5GeT/J1tFtFwAQB1Zj5S7L23Y7zm6STv2DyuiU3zAADFJFwAQJ1FRh0LMSsSLgCAYhIuAKDOzPdwTUXCBQBQTMMFAFDMSBEAqLPItN2GTfMAAPtJwgUA1Jn6WIgp19qChAsAoJiECwCoM/WxEPZwAQDsp+P3nLcWVnFc8ri1S6MLyGxn5ENcGF1AkuXoApKcGV1A5vFnsRpdQHLbDP4sbjk/uoK18zP4nnhgdAHMghYGAKhjpJjESBEAoJyECwCoI+FKIuECACin4QIAKGakCADUOZFp/2X7TKOkmZYFALA7JFwAQJ2pN83P4Cy8q5FwAQAUk3ABAHUkXEkkXAAA5TRcAADFjBQBgDqLTHssxJRrbUHCBQBQTMIFANSxaT6JhAsAoJyECwCos8i03cZywrW2IOECACim4QIAKGakCADUmXrT/Ew7GwkXAECxmfaBAMBOcPBpEgkXAEA5CRcAUMceriQSLgCAchouAIBiMw3eAICdYKSYRMIFAFBupn0gALATTmTaoxpmGiXNtCwAgN0h4QIA6tjDlUTCBQBQ7vh94M2FVRzXdaMLSHJ6dAFJnhhdQJIXjy5g49zoApKcH11Aki+NLiDJpdEFJDkzuoDM4+swg99TJ+fwZ5HklhtHV5C8+LHRFTAHMw3eAICdYKSYxEgRAKDcTPtAAGAnLDLtsRBTrrUFCRcAQDENFwBAMSNFAKCOTfNJJFwAAOVm2gcCADthkWm7DZvmAQD2k4QLAKhjD1cSCRcAQDkNFwBAsZkGbwDATnDSfBIJFwBAOQkXAFDHpvkkEi4AgHIz7QMBgJ0g4Uoi4QIAKKfhAgAoNtPgDQDYCScy7VENM42SZloWAMDukHABAHVsmk8i4QIAKDfTPhAA2AkSriQSLgCAchouAIBiMw3eAICdsMi0x0JMudYWJFwAAMUkXABAHZvmk0i4AADKabgAAIrNNHgDAHbCItN2GzPdNP9Hq+G6eXQBmcdX7MzoApI8NrqAjdOjC0hy3egCMo9fME+MLiDz+H6Yw9dhDr8j5vC7MplFHSfPja6AOZjBtyIAsLNsmk9iDxcAQLmZ9oEAwE5w8GkSCRcAQDkNFwBAMSNFAKCOTfNJJFwAAOVm2gcCADvBwadJJFwAAOUkXABAHcdCJJFwAQCU03ABABQzUgQA6jgWIomECwCg3Ez7QABgJ0i4kki4AADKzbQPBAB2goQriYQLAKCchgsAoNhMgzcAYBf0E0mf8PT3PtMoaaZlAQDsDgkXAFBmdbB+TLneHEm4AACKzbQPBAB2gYRrTcIFAFBMwwUAUEzDBQCUWS5alosTEz7aVvW11l7bWvtIa+3B1lpvrb3piudvaa39xOb5J1trH22t3bHt10HDBQDsszNJPpPkHVc+0VprST6c5I8neWOSP5XkC0k+1lo7s80iM91aBgDsgtXBQVYH26VOz229nuTysV/fe783yb1Jsu6vvsIdSV6d5Dt677++ec0PJXkoyV9P8u+Pu46ECwDYRWdbazceeZy+hms8+zlPP/uB3vthkktJXrPNhTRcAMAueiDJhSOPu6/hGp9Lcn+SH22tvai1dqq19o+T3JbkG7a5kJEiAFBmtVhkteVG9ue23pdHircluXjkqUvbXqv3frm19leSvC/J+SSrJB/LegS51f/U8Ruum7a5bJE51HAtgeTz7YnRBSS5YXQBG4+PLiDX8CO8o5ajC0jyyOgCkjw2uoAcGX4MtNV24kJz+J7wO2KUi7335/wT2Xv/dJI7W2vnkpzqvf9ea+2Xk/zKNteRcAEAZQ6zyGq7MOg5rtdLrtt7v5AkmyMhXpXkn27z+RouAGBvtdZuSPKyIx+6vbV2Z5Lzvff7W2tvTvJ7We/l+pNJ/nWSD/fef26bdTRcAECZZRZZTphwLbdPuF6V5ONH3r9n8/YDSd6a9eb4e5LckuT/JvkPSf75totouACAvdV7/0S+xgb43vu7k7z7ua7jWAgAgGISLgCgzCqLrCbMd1Y5nGytbUi4AACKSbgAgDLTJ1zTbdDfhoQLAKCYhAsAKCPhWpNwAQAU03ABABQzUgQAyhgprkm4AACKSbgAgDKrLLKUcEm4AACqSbgAgDKrHLi1TyRcAADlNFwAAMWMFAGAMqucyCqLCdebJwkXAEAxCRcAUGZ98KmES8IFAFBMwwUAUMxIEQAos8wiywlHisvJVtqOhAsAoJiECwAoc5iDSTfNH7qXIgDAfpJwAQBlHAuxJuECACim4QIAKGakCACUMVJcO37DdUdhFcf09JnRFSRPnrludAm5/omnR5eQ05dGV7Bx8+gCkjaHr8UMfjZyYXQBSU6PLiDJudEFZB4HET0xuoCNGfyOmM3XgqEkXABAmVVOTJxw9cnW2oY9XAAAxSRcAECZ6W/tI+ECANhLGi4AgGJGigBAmVUOspqw3ZjrsRASLgCAYhIuAKDM4cQHnx7aNA8AsJ8kXABAmelv7SPhAgDYSxouAIBiRooAQJllTkx80vzhZGttQ8IFAFBMwgUAlJn+4FOb5gEA9pKECwAoM/2xEPZwAQDsJQ0XAEAxI0UAoIyR4pqECwCgmIQLACizymLSg08lXAAAe0rDBQBQzEgRACjjpPk1CRcAQDEJFwBQZpUTEx8LsZpsrW1IuAAAikm4AIAy0x98Ot1a25BwAQAU03ABABQzUgQAyhgprkm4AACKHTvh+p2bX1JZx7FMeXDaV/NMTo0uIafOPDO6hFx/5snRJSRJFjP4578vuePC6BKS86MLSPL46AIyj6/DE6MLyDxq4A/M4FfESNPfS1HCBQCwl8ZHRgDAzpr+1j6Hk621DQkXAEAxDRcAQDEjRQCgjGMh1iRcAADFJFwAQJlVTkyccM0zS5pnVQAAO0TCBQCUWU588OmUa21DwgUAUEzDBQBQzEgRACgz/Unz4++xezUSLgCAYhIuAKDM4cQHnx7aNA8AsJ8kXABAGbf2WZNwAQAU03ABABQzUgQAyriX4to8qwIA2CESLgCgzDKLLNxLUcIFAFBNwwUAUMxIEQAoM/29FOfZ2ki4AACKzbMNBAB2gnsprkm4AACKSbgAgDLupbgm4QIAKKbhAgAoZqQIAJRZZpETTpqXcAEAVDt2wvVUrq+s41gezK2jS8iTM/g6LLIcXUJO55nRJSRJbs6XRpeQ3Dy6gOTsuYujS8iZRw5Hl5DcMLqAJBdGF5Dk6dEFJFmNLmDjkdEFJDk9uoCx1pvmpzz4VMIFALCX7OECAMo4FmJNwgUAUEzDBQBQzEgRAChjpLgm4QIAKCbhAgDKHE6ccB1KuAAA9pOECwAos8wiza19JFwAANU0XADA3mqtvba19pHW2oOttd5ae9MVz9/QWvvx1toDrbWnWmv3tdbevu06RooAQJlVFjkx73spnknymSTvT/Khqzx/T5K/kORvJPndJN+V5N+21h7svf/0cRfRcAEAe6v3fm+Se5OktXa1l3xnkg/03j+xef+9rbW/neRPJ9FwAQDjrROuIQefnr2igbrUe790DZf870m+t7X2/iQPJrkrybckeec2F7GHCwDYRQ8kuXDkcfc1XufvJrlvc71nknw0yTt675/c5iISLgBgF92W5OKR968l3UrWDderk3xvki8keW2S92z2cH3suBfRcAEAZQaOFC/23h97Ltdqrb0gyb9M8n299/+6+fD/bK3dmeQfJDl2w2WkCABwdSc3j8MrPr7Klj2UhAsAKDP3k+ZbazckedmRD92+SbDO997vb639QpIfa609lfVI8XVJ/maSv7fNOhouAGCfvSrJx4+8f8/m7QeSvDXJW5L8aJKfTPLirJuuH07y77ZZRMMFAJQ5zEFWE7Ybh1uutTlf66oHcG2efyjJ255bVfZwAQCU03ABABQzUgQAyqwm3jR/DfdSnISECwCgmIQLACizyomJE655ZknzrAoAYIdIuACAMuuDSOd78OlUJFwAAMU0XAAAxYwUAYAyqxykTdhuTHmq/TYkXAAAxY7dBj6YWyvrOJYv5qWjS8iTuX50CbM41O1ULo0uIUnyaF44uoQ8mheNLiFnT18cXUJedstvjy4hLzhzeXQJOTn+xzOz+PG8MLqAjTOjC0hybnQBYx1mMenfW4cz+DvyaiRcAADF5jnoBAB2wmriYyHmMAW6GgkXAEAxDRcAQDEjRQCgjJHimoQLAKCYhAsAKLPMifRJE655ZknzrAoAYIdIuACAMutb7bi1j4QLAKCYhgsAoNg8czcAYCc4FmJNwgUAUEzCBQCUOZw44TqUcAEA7CcNFwBAMSNFAKDMMoucMFKUcAEAVJNwAQBlVlmkT9huSLgAAPaUhAsAKLNOuOzhknABABTTcAEAFDNSBADKGCmuSbgAAIpJuACAMqvDRfrhhAnXhGttQ8IFAFBMwgUAlFktFzlcTpc69QnX2oaECwCgmIYLAKCYkSIAUGa1PEhbTtdu9AnX2oaECwCg2LHbwI/lL1XW8UfGk3nB6BJyfZ4aXUJWMzlY7tG8aHQJeTQvHF1Cbs7Do0vIYrEcXULOnrs4uoTcevDQ6BJy3YOjK0hybnQBG+O/LZM5/HkMtFqeSJt00/w8s6R5VgUAsEPmOegEAHbCarmYOOGaxwTmShIuAIBiGi4AgGJGigBAmeVykXbZSFHCBQBQTMIFAJTpq4P01YTtxpRrbUHCBQBQTMMFAFBsnrkbALAblov1Y8r1ZkjCBQBQTMIFANSRcCWRcAEAlJNwAQB1Vi1ZtmnXmyEJFwBAMQ0XAEAxI0UAoM5y85hyvRmScAEAFJNwAQB1JFxJJFwAAOUkXABAHQlXEgkXAEA5DRcAQDEjRQCgzjLJ5YnXmyEJFwBAMQkXAFBntXlMud4MSbgAAIpJuACAOo6FSCLhAgAop+ECAChmpAgA1DFSTCLhAgAod+yE61fyyso6juWZnB5dQlZZjC5hFjXclEdGl5AkuTUPji4hT+YFo0vIk7l+dAmzcH2eHF1CLp45O7qEvOLm3xpdQk4+NrqCjfF/bSTnRhcwmIQriYQLAKCcPVwAQJ1Vpk2dHHwKALCfNFwAAMWMFAGAOjbNJ5FwAQCUk3ABAHUkXEkkXAAA5TRcAADFjBQBgDqXN48p15shCRcAQDEJFwBQZ5VpT3930jwAwH6ScAEAddxLMYmECwCgnIYLAKCYkSIAUMdJ80kkXAAA5SRcAEAdCVcSCRcAQDkJFwBQR8KVRMIFAFBOwwUAUMxIEQCo46T5JBIuAIByEi4AoI5N80kkXAAA5SRcAECdy0kWE683QxIuAGBvtdZe21r7SGvtwdZab6296Yrn+1d5/MNt1tFwAQD77EySzyR5x1d5/huuePxAkp7kg9ssYqQIANRZZdqjGv5grbOttaPPXOq9X7ry5b33e5PcmyRXvP7Z5x86+n5r7Y1JPt57/51typJwAQC76IEkF4487n6uF2yt3ZLku5O8b9vPPXbC9fO//oZtr/28e/G3/p/RJeT8QzeNLiF59LrRFeS2b/+t0SUkSc7m4ugSktw6uoA8k9OjS5iFm/LI6BJm4fpzT40uIWfPzeFnMzl7aXwdi+Xh6BIy9G+NccdC3JZ8xV8SfyjdugZ/a3PND237iUaKAMAuuth7f+x5vuYPJPnJ3vvT236ihgsAqLMjt/Zprf25JC9P8teu5fPt4QIA+Pp+MMmne++fuZZPlnABAHurtXZDkpcd+dDtrbU7k5zvvd+/ec2NSd6c5O9f6zoaLgCgzjLTnjS//fjyVUk+fuT9ezZvP5DkrZv/fkuSluQ/XmtZGi4AYG/13j+RdTP1tV7z3iTvfS7raLgAgDqXM+2OcfdSBADYTxouAIBiRooAQJ1x91KcFQkXAEAxCRcAUGdHTpp/riRcAADFJFwAQJ1lpo13pkzTtiDhAgAopuECAChmpAgA1Lmcr3PjnIL1ZkjCBQBQTMIFANRx8GkSCRcAQDkJFwBQx7EQSSRcAADlNFwAAMWMFAGAOu6lmETCBQBQTsIFANSZ+iBSB58CAOwnCRcAUGeVaeMde7gAAPaThgsAoJiRIgBQZ5mkTbzeDEm4AACKHT/hekthFcd0/g3fOLqE5IbRBWQW3fsDn7tjdAlJkp95/QtHl5BvPvO7o0vIy/Obo0vIoxn/Z/GK3De6hLww/290CfliXjq6hNyU3x9dQpLk0ulTo0vIwenxu7iH/u0p4Uoi4QIAKKfhAgAoZtM8AFBn6hGfkSIAwH6ScAEAdVaZdtP8+H+jcFUSLgCAYhIuAKCOPVxJJFwAAOU0XAAAxYwUAYA6RopJJFwAAOUkXABAnWWSPuF6joUAANhPEi4AoM7UiZOECwBgP2m4AACKGSkCAHVsmk8i4QIAKCfhAgDqSLiSSLgAAMpJuACAOsskhxOuN+VaW5BwAQAU03ABABQzUgQA6qwy7aZ5I0UAgP0k4QIA6iwzbbwj4QIA2E8SLgCgjoQriYQLAKCchgsAoJiRIgBQ53KMFCPhAgAod/yE67M/UlfFcX32rtEVJHfeNbqC5FtHF5DkhtEFrD3+X/7Y6BJy313Xjy4hp265NLqEfD7fPLqEnMr4r8OlnBpdQl6aL44uIb+WO0eXkCR5ZT49uoRcnydHl5BvHLn4YaY9+HTKtbYg4QIAKKbhAgAoZtM8AFBnmaRNuJ6RIgDAfpJwAQB1JFxJJFwAAOUkXABAncuRcEXCBQBQTsMFAFDMSBEAqLOKkWIkXAAA5SRcAECtmaZOU5JwAQAU03ABABTTcAEAFNNwAQAU03ABABTTcAEAFNNwAQAU03ABABRz8CkAUOjy5jHlevMj4QIAKKbhAgAoZqQIABRabh5Trjc/Ei4AgGISLgCgkE3ziYQLAKCchgsAoJiRIgBQyKb5RMIFAFBOwgUAFFpm2o3sEi4AgL3Ueu+jawAAdkxr7cYkF5L7kpydcOWLSV6RJOd6749NuPDXJOECACim4QIAKGbTPABQyLEQiYQLAKCchAsAKORYiETCBQBQTsIFABSyhyuRcAEAlNNwAQAUM1IEAApdzrSb5qdc6/gkXAAAxSRcAEAhm+YTCRcAsMdaa69trX2ktfZga6231t50ldd8W2vtp1trF1prT7TWPtVa+6Zt1pFwAQCFZn/w6Zkkn0ny/iQfuvLJ1tqfSPKLSd6X5J8leSzJtyd5eptFNFwAwN7qvd+b5N4kaa1d7SX/IsnP9N7/0ZGP/e9t1zFSBAB20dnW2o1HHqe3vUBr7USS707yv1prP9tae7i19stXGzt+PRouAKDQcsAjSfJAkgtHHndfQ/E3J7khyT9J8tEk35Xkp5J8qLX2um0uZKQIAOyi25JcPPL+pWu4xrPB1H/uvb9r89+/1lr7ziRvT/ILx72QhgsAKDTs4NOLvffHnuPFfj/ryOy+Kz7+G0les82FjBQBAK6i9/5Mkk8lefkVT31Lki9scy0JFwBQaN4Hn7bWbkjysiMfur21dmeS8733+5P8WJL/1Fr7ZJKPJ3l9ku9Jctc262i4AIB99qqsG6ln3bN5+4Ekb+29/1Rr7e1Zb7p/d5LfTPJXe++/uM0irff+fBQLAPBlrbUbk1xIPpz12aJTeSLJm5Lk3POwh+t5I+ECAArN/qT5Sdg0DwBQTMIFABSa96b5qUi4AACKabgAAIoZKQIAhYadND8rEi4AgGISLgCgkIQrkXABAJSTcAEAhRwLkUi4AADKabgAAIoZKQIAhdxLMZFwAQCUk3ABAIVsmk8kXAAA5SRcAEChy5m23XDwKQDAXtJwAQAUM1IEAArZNJ9IuAAAykm4AIBCDj5NJFwAAOUkXABAIXu4EgkXAEA5DRcAQDEjRQCg0OUki4nXmx8JFwBAMQkXAFDIpvlEwwUAlLq04+sdT+u9j64BANgxrbXrknw+yUsGLP9Qktt7708PWPuqNFwAQIlN03VqwNLPzKnZSjRcAADl/CtFAIBiGi4AgGIaLgCAYhouAIBiGi4AgGIaLgCAYhouAIBi/x/PYe5I43K6AQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "M.evaluate_map(input_y=Data_X[:,0])\n", "M.plot_map()" @@ -278,7 +201,7 @@ "# To test with fixed weights, so answer is always the same (to be able to compare)\n", "# need more iterations to make sure it converges\n", "M=somsphere.SOMap(Data_X, Data_Y,topology='grid', n_top=15, n_iter=300, periodic=False)\n", - "print(M.n_dim, 'dimensions') #dimensions\n", + "print(M.n_col, 'dimensions') #dimensions\n", "print(M.n_pix, 'cells') #cells" ] }, @@ -289,7 +212,7 @@ "outputs": [], "source": [ "#weights are supposed to be random, but we can make them linear for testing\n", - "W = np.linspace(0,20,M.n_dim*M.n_pix).reshape(M.n_dim,M.n_pix)\n", + "W = np.linspace(0,20,M.n_col*M.n_pix).reshape(M.n_col,M.n_pix)\n", "#look carefully onhow this was created, elements go from 0 to 20 with a difference of \n", "#W[0][1]-W[0][0] = 0.009881422924901186\n", "print('dw = ', W[0][1]-W[0][0])\n", @@ -302,7 +225,7 @@ "metadata": {}, "outputs": [], "source": [ - "M.create_map(inputs_weights=W, random_order=False)" + "M.create_map(input_weights=W, random_order=False)" ] }, { @@ -330,7 +253,7 @@ "outputs": [], "source": [ "# If I create the map again, results should be the same\n", - "M.create_map(inputs_weights=W, random_order=False)\n", + "M.create_map(input_weights=W, random_order=False)\n", "M.evaluate_map()\n", "M.plot_map()" ] @@ -363,7 +286,7 @@ "source": [ "#weights, the number of pixels is different\n", "#weights are supposed to be random, but we can make them linear for testing\n", - "W = np.linspace(0,20,M_sph.n_dim*M_sph.n_pix).reshape(M_sph.n_dim,M_sph.n_pix)\n", + "W = np.linspace(0,20,M_sph.n_col*M_sph.n_pix).reshape(M_sph.n_col,M_sph.n_pix)\n", "#look carefully onhow this was created, elements go from 0 to 20 with a difference of \n", "#W[0][1]-W[0][0] = 0.009881422924901186\n", "print('dw = ', W[0][1]-W[0][0])\n", @@ -376,7 +299,7 @@ "metadata": {}, "outputs": [], "source": [ - "M_sph.create_map(inputs_weights=W, random_order=False)" + "M_sph.create_map(input_weights=W, random_order=False)" ] }, { @@ -405,7 +328,7 @@ "metadata": {}, "outputs": [], "source": [ - "M_sph.create_map(inputs_weights=W, random_order=False)" + "M_sph.create_map(input_weights=W, random_order=False)" ] }, { @@ -436,7 +359,7 @@ "source": [ "# hexagonal topology with periodic conditions\n", "M_hex=somsphere.SOMap(Data_X, Data_Y,topology='hex', n_top=15, n_iter=300, periodic=True)\n", - "print(M_hex.n_dim, 'dimensions') #dimensions\n", + "print(M_hex.n_col, 'dimensions') #dimensions\n", "print(M_hex.n_pix, 'cells') #cells" ] }, @@ -446,8 +369,8 @@ "metadata": {}, "outputs": [], "source": [ - "W=np.linspace(0,20,M_hex.n_dim*M_hex.n_pix).reshape(M_hex.n_dim,M_hex.n_pix)\n", - "M_hex.create_map(inputs_weights=W, random_order=False)\n", + "W=np.linspace(0,20,M_hex.n_col*M_hex.n_pix).reshape(M_hex.n_col,M_hex.n_pix)\n", + "M_hex.create_map(input_weights=W, random_order=False)\n", "M_hex.evaluate_map()\n", "M_hex.plot_map()" ] @@ -558,7 +481,7 @@ "metadata": {}, "outputs": [], "source": [ - "M_sph_R.ivals[0]\n" + "M_sph_R.i_vals[0]\n" ] }, { @@ -567,12 +490,12 @@ "metadata": {}, "outputs": [], "source": [ - "HR=np.zeros(M_sph_R.npix)\n", - "MR=np.zeros(M_sph_R.npix)\n", - "for i in xrange(M_sph_R.npix):\n", + "HR=np.zeros(M_sph_R.n_pix)\n", + "MR=np.zeros(M_sph_R.n_pix)\n", + "for i in xrange(M_sph_R.n_pix):\n", " try:\n", - " HR[i]=len(M_sph_R.ivals[i])\n", - " MR[i]=np.mean(M_sph_R.yvals[i])\n", + " HR[i]=len(M_sph_R.i_vals[i])\n", + " MR[i]=np.mean(M_sph_R.y_vals[i])\n", " except:\n", " pass" ] @@ -701,12 +624,12 @@ "metadata": {}, "outputs": [], "source": [ - "H=np.zeros(M_sph.npix)\n", - "MM=np.zeros(M_sph.npix)\n", - "for i in xrange(M_sph.npix):\n", + "H=np.zeros(M_sph.n_pix)\n", + "MM=np.zeros(M_sph.n_pix)\n", + "for i in xrange(M_sph.n_pix):\n", " try:\n", - " H[i]=len(M_sph.ivals[i])\n", - " MM[i]=np.mean(M_sph.yvals[i])\n", + " H[i]=len(M_sph.i_vals[i])\n", + " MM[i]=np.mean(M_sph.y_vals[i])\n", " except:\n", " pass" ] @@ -762,6 +685,27 @@ "plt.hist(MR1, normed=True, alpha=0.5)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null, diff --git a/somsphere/__init__.py b/somsphere/__init__.py index 9af1f72..e17b983 100644 --- a/somsphere/__init__.py +++ b/somsphere/__init__.py @@ -130,7 +130,7 @@ def evaluate_map(self, input_x=None, input_y=None): in_y = self.Y if input_y is None else input_y for i in range(len(in_x)): inputs = in_x[i] - best, activation = core.get_best_cell(inputs, self.importance, self.weights, len(inputs), self.n_pix, 1) + best, _ = core.get_best_cell(inputs, self.importance, self.weights, len(inputs), self.n_pix, 1) best = best[0] if best not in self.y_vals: self.y_vals[best] = []