{"action":"created","issue":{"url":"https://api.github.com/repos/martensm/pywaifu/issues/11","repository_url":"https://api.github.com/repos/martensm/pywaifu","labels_url":"https://api.github.com/repos/martensm/pywaifu/issues/11/labels{/name}","comments_url":"https://api.github.com/repos/martensm/pywaifu/issues/11/comments","events_url":"https://api.github.com/repos/martensm/pywaifu/issues/11/events","html_url":"https://github.com/martensm/pywaifu/pull/11","id":234312304,"number":11,"title":"Update numpy to 1.13.0","user":{"login":"pyup-bot","id":16239342,"avatar_url":"https://avatars3.githubusercontent.com/u/16239342?v=3","gravatar_id":"","url":"https://api.github.com/users/pyup-bot","html_url":"https://github.com/pyup-bot","followers_url":"https://api.github.com/users/pyup-bot/followers","following_url":"https://api.github.com/users/pyup-bot/following{/other_user}","gists_url":"https://api.github.com/users/pyup-bot/gists{/gist_id}","starred_url":"https://api.github.com/users/pyup-bot/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/pyup-bot/subscriptions","organizations_url":"https://api.github.com/users/pyup-bot/orgs","repos_url":"https://api.github.com/users/pyup-bot/repos","events_url":"https://api.github.com/users/pyup-bot/events{/privacy}","received_events_url":"https://api.github.com/users/pyup-bot/received_events","type":"User","site_admin":false},"labels":[],"state":"open","locked":false,"assignee":null,"assignees":[],"milestone":null,"comments":0,"created_at":"2017-06-07T19:10:13Z","updated_at":"2017-06-07T19:15:17Z","closed_at":null,"pull_request":{"url":"https://api.github.com/repos/martensm/pywaifu/pulls/11","html_url":"https://github.com/martensm/pywaifu/pull/11","diff_url":"https://github.com/martensm/pywaifu/pull/11.diff","patch_url":"https://github.com/martensm/pywaifu/pull/11.patch"},"body":"\nThere's a new version of [numpy](https://pypi.python.org/pypi/numpy) available.\nYou are currently using **1.12.1**. I have updated it to **1.13.0**\n\n\n\nThese links might come in handy:  <a href=\"https://pypi.python.org/pypi/numpy\">PyPI</a> | <a href=\"https://pyup.io/changelogs/numpy/\">Changelog</a> | <a href=\"http://www.numpy.org\">Homepage</a> \n\n\n\n### Changelog\n> \n>### 1.13.0\n\n>==========================\n\n>This release supports Python 2.7 and 3.4 - 3.6.\n\n\n>Highlights\n>==========\n\n> * Operations like ``a + b + c`` will reuse temporaries on some platforms,\n>   resulting in less memory use and faster execution.\n> * Inplace operations check if inputs overlap outputs and create temporaries\n>   to avoid problems.\n> * New ``__array_ufunc__`` attribute provides improved ability for classes to\n>   override default ufunc behavior.\n> * New ``np.block`` function for creating blocked arrays.\n\n\n>New functions\n>=============\n\n>* New ``np.positive`` ufunc.\n>* New ``np.divmod`` ufunc provides more efficient divmod.\n>* New ``np.isnat`` ufunc tests for NaT special values.\n>* New ``np.heaviside`` ufunc computes the Heaviside function.\n>* New ``np.isin`` function, improves on ``in1d``.\n>* New ``np.block`` function for creating blocked arrays.\n>* New ``PyArray_MapIterArrayCopyIfOverlap`` added to NumPy C-API.\n\n>See below for details.\n\n\n>Deprecations\n>============\n\n>* Calling ``np.fix``, ``np.isposinf``, and ``np.isneginf`` with ``f(x, y=out)``\n>  is deprecated - the argument should be passed as ``f(x, out=out)``, which\n>  matches other ufunc-like interfaces.\n>* Use of the C-API ``NPY_CHAR`` type number deprecated since version 1.7 will\n>  now raise deprecation warnings at runtime. Extensions built with older f2py\n>  versions need to be recompiled to remove the warning.\n>* ``np.ma.argsort``, ``np.ma.minimum.reduce``, and ``np.ma.maximum.reduce``\n>  should be called with an explicit `axis` argument when applied to arrays with\n>  more than 2 dimensions, as the default value of this argument (``None``) is\n>  inconsistent with the rest of numpy (``-1``, ``0``, and ``0``, respectively).\n>* ``np.ma.MaskedArray.mini`` is deprecated, as it almost duplicates the\n>  functionality of ``np.MaskedArray.min``. Exactly equivalent behaviour\n>  can be obtained with ``np.ma.minimum.reduce``.\n>* The single-argument form of ``np.ma.minimum`` and ``np.ma.maximum`` is\n>  deprecated. ``np.maximum``. ``np.ma.minimum(x)`` should now be spelt\n>  ``np.ma.minimum.reduce(x)``, which is consistent with how this would be done\n>  with ``np.minimum``.\n>* Calling ``ndarray.conjugate`` on non-numeric dtypes is deprecated (it\n>  should match the behavior of ``np.conjugate``, which throws an error).\n>* Calling ``expand_dims`` when the ``axis`` keyword does not satisfy\n>  ``-a.ndim - 1 &lt;= axis &lt;= a.ndim``, where ``a`` is the array being reshaped,\n>  is deprecated.\n\n\n>Future Changes\n>==============\n\n>* Assignment between structured arrays with different field names will change\n>  in NumPy 1.14. Previously, fields in the dst would be set to the value of the\n>  identically-named field in the src. In numpy 1.14 fields will instead be\n>  assigned &#39;by position&#39;: The n-th field of the dst will be set to the n-th\n>  field of the src array. Note that the ``FutureWarning`` raised in NumPy 1.12\n>  incorrectly reported this change as scheduled for NumPy 1.13 rather than\n>  NumPy 1.14.\n\n\n>Build System Changes\n>====================\n\n>* ``numpy.distutils`` now automatically determines C-file dependencies with\n>  GCC compatible compilers.\n\n\n>Compatibility notes\n>===================\n\n>Error type changes\n>------------------\n\n>* ``numpy.hstack()`` now throws ``ValueError`` instead of ``IndexError`` when\n>  input is empty.\n>* Functions taking an axis argument, when that argument is out of range, now\n>  throw ``np.AxisError`` instead of a mixture of ``IndexError`` and\n>  ``ValueError``. For backwards compatibility, ``AxisError`` subclasses both of\n>  these.\n\n>Tuple object dtypes\n>-------------------\n\n>Support has been removed for certain obscure dtypes that were unintentionally\n>allowed, of the form ``(old_dtype, new_dtype)``, where either of the dtypes\n>is or contains the ``object`` dtype. As an exception, dtypes of the form\n>``(object, [(&#39;name&#39;, object)])`` are still supported due to evidence of\n>existing use.\n\n>DeprecationWarning to error\n>---------------------------\n>See Changes section for more detail.\n\n>* ``partition``, TypeError when non-integer partition index is used.\n>* ``NpyIter_AdvancedNew``, ValueError when ``oa_ndim == 0`` and ``op_axes`` is NULL\n>* ``negative(bool_)``, TypeError when negative applied to booleans.\n>* ``subtract(bool_, bool_)``, TypeError when subtracting boolean from boolean.\n>* ``np.equal, np.not_equal``, object identity doesn&#39;t override failed comparison.\n>* ``np.equal, np.not_equal``, object identity doesn&#39;t override non-boolean comparison.\n>* Deprecated boolean indexing behavior dropped. See Changes below for details.\n>* Deprecated ``np.alterdot()`` and ``np.restoredot()`` removed.\n\n>FutureWarning to changed behavior\n>---------------------------------\n>See Changes section for more detail.\n\n>* ``numpy.average`` preserves subclasses\n>* ``array == None`` and ``array != None`` do element-wise comparison.\n>* ``np.equal, np.not_equal``, object identity doesn&#39;t override comparison result.\n\n>dtypes are now always true\n>--------------------------\n\n>Previously ``bool(dtype)`` would fall back to the default python\n>implementation, which checked if ``len(dtype) &gt; 0``. Since ``dtype`` objects\n>implement ``__len__`` as the number of record fields, ``bool`` of scalar dtypes\n>would evaluate to ``False``, which was unintuitive. Now ``bool(dtype) == True``\n>for all dtypes.\n\n>``__getslice__`` and ``__setslice__`` are no longer needed in ``ndarray`` subclasses\n>------------------------------------------------------------------------------------\n>When subclassing np.ndarray in Python 2.7, it is no longer _necessary_ to\n>implement ``__*slice__`` on the derived class, as ``__*item__`` will intercept\n>these calls correctly.\n\n>Any code that did implement these will work exactly as before. Code that\n>invokes``ndarray.__getslice__`` (e.g. through ``super(...).__getslice__``) will\n>now issue a DeprecationWarning - ``.__getitem__(slice(start, end))`` should be\n>used instead.\n\n>Indexing MaskedArrays/Constants with ``...`` (ellipsis) now returns MaskedArray\n>-------------------------------------------------------------------------------\n>This behavior mirrors that of np.ndarray, and accounts for nested arrays in\n>MaskedArrays of object dtype, and ellipsis combined with other forms of\n>indexing.\n\n>C API changes\n>=============\n\n>GUfuncs on empty arrays and NpyIter axis removal\n>------------------------------------------------\n>It is now allowed to remove a zero-sized axis from NpyIter. Which may mean\n>that code removing axes from NpyIter has to add an additional check when\n>accessing the removed dimensions later on.\n\n>The largest followup change is that gufuncs are now allowed to have zero-sized\n>inner dimensions. This means that a gufunc now has to anticipate an empty inner\n>dimension, while this was never possible and an error raised instead.\n\n>For most gufuncs no change should be necessary. However, it is now possible\n>for gufuncs with a signature such as ``(..., N, M) -&gt; (..., M)`` to return\n>a valid result if ``N=0`` without further wrapping code.\n\n>``PyArray_MapIterArrayCopyIfOverlap`` added to NumPy C-API\n>----------------------------------------------------------\n>Similar to ``PyArray_MapIterArray`` but with an additional ``copy_if_overlap``\n>argument. If ``copy_if_overlap != 0``,  checks if input has memory overlap with\n>any of the other arrays and make copies as appropriate to avoid problems if the\n>input is modified during the iteration. See the documentation for more complete\n>documentation.\n\n\n>New Features\n>============\n\n>``__array_ufunc__`` added\n>-------------------------\n>This is the renamed and redesigned ``__numpy_ufunc__``. Any class, ndarray\n>subclass or not, can define this method or set it to ``None`` in order to\n>override the behavior of NumPy&#39;s ufuncs. This works quite similarly to Python&#39;s\n>``__mul__`` and other binary operation routines. See the documentation for a\n>more detailed description of the implementation and behavior of this new\n>option. The API is provisional, we do not yet guarantee backward compatibility\n>as modifications may be made pending feedback. See the NEP_ and\n>documentation_ for more details.\n\n>.. _NEP: https://github.com/numpy/numpy/blob/master/doc/neps/ufunc-overrides.rst\n>.. _documentation: https://github.com/charris/numpy/blob/master/doc/source/reference/arrays.classes.rst\n\n>New ``positive`` ufunc\n>----------------------\n>This ufunc corresponds to unary `+`, but unlike `+` on an ndarray it will raise\n>an error if array values do not support numeric operations.\n\n>New ``divmod`` ufunc\n>--------------------\n>This ufunc corresponds to the Python builtin `divmod`, and is used to implement\n>`divmod` when called on numpy arrays. ``np.divmod(x, y)`` calculates a result\n>equivalent to ``(np.floor_divide(x, y), np.remainder(x, y))`` but is\n>approximately twice as fast as calling the functions separately.\n\n>``np.isnat`` ufunc tests for NaT special datetime and timedelta values\n>----------------------------------------------------------------------\n>The new ufunc ``np.isnat`` finds the positions of special NaT values\n>within datetime and timedelta arrays. This is analogous to ``np.isnan``.\n\n>``np.heaviside`` ufunc computes the Heaviside function\n>------------------------------------------------------\n>The new function ``np.heaviside(x, h0)`` (a ufunc) computes the Heaviside\n>function:\n>.. code::\n>                       { 0   if x &lt; 0,\n>    heaviside(x, h0) = { h0  if x == 0,\n>                       { 1   if x &gt; 0.\n\n>``np.block`` function for creating blocked arrays\n>-------------------------------------------------\n>Add a new ``block`` function to the current stacking functions ``vstack``,\n>``hstack``, and ``stack``. This allows concatenation across multiple axes\n>simultaneously, with a similar syntax to array creation, but where elements\n>can themselves be arrays. For instance::\n\n>    &gt;&gt;&gt; A = np.eye(2) * 2\n>    &gt;&gt;&gt; B = np.eye(3) * 3\n>    &gt;&gt;&gt; np.block([\n>    ...     [A,               np.zeros((2, 3))],\n>    ...     [np.ones((3, 2)), B               ]\n>    ... ])\n>    array([[ 2.,  0.,  0.,  0.,  0.],\n>           [ 0.,  2.,  0.,  0.,  0.],\n>           [ 1.,  1.,  3.,  0.,  0.],\n>           [ 1.,  1.,  0.,  3.,  0.],\n>           [ 1.,  1.,  0.,  0.,  3.]])\n\n>While primarily useful for block matrices, this works for arbitrary dimensions\n>of arrays.\n\n>It is similar to Matlab&#39;s square bracket notation for creating block matrices.\n\n>``isin`` function, improving on ``in1d``\n>----------------------------------------\n>The new function ``isin`` tests whether each element of an N-dimensonal\n>array is present anywhere within a second array. It is an enhancement\n>of ``in1d`` that preserves the shape of the first array.\n\n>Temporary elision\n>-----------------\n>On platforms providing the ``backtrace`` function NumPy will try to avoid\n>creating temporaries in expression involving basic numeric types.\n>For example ``d = a + b + c`` is transformed to ``d = a + b; d += c`` which can\n>improve performance for large arrays as less memory bandwidth is required to\n>perform the operation.\n\n>``axes`` argument for ``unique``\n>--------------------------------\n>In an N-dimensional array, the user can now choose the axis along which to look\n>for duplicate N-1-dimensional elements using ``numpy.unique``. The original\n>behaviour is recovered if ``axis=None`` (default).\n\n>``np.gradient`` now supports unevenly spaced data\n>-------------------------------------------------\n>Users can now specify a not-constant spacing for data.\n>In particular ``np.gradient`` can now take:\n\n>1. A single scalar to specify a sample distance for all dimensions.\n>2. N scalars to specify a constant sample distance for each dimension.\n>   i.e. ``dx``, ``dy``, ``dz``, ...\n>3. N arrays to specify the coordinates of the values along each dimension of F.\n>   The length of the array must match the size of the corresponding dimension\n>4. Any combination of N scalars/arrays with the meaning of 2. and 3.\n\n>This means that, e.g., it is now possible to do the following::\n\n>    &gt;&gt;&gt; f = np.array([[1, 2, 6], [3, 4, 5]], dtype=np.float)\n>    &gt;&gt;&gt; dx = 2.\n>    &gt;&gt;&gt; y = [1., 1.5, 3.5]\n>    &gt;&gt;&gt; np.gradient(f, dx, y)\n>    [array([[ 1. ,  1. , -0.5], [ 1. ,  1. , -0.5]]),\n>     array([[ 2. ,  2. ,  2. ], [ 2. ,  1.7,  0.5]])]\n\n>Support for returning arrays of arbitrary dimensions in ``apply_along_axis``\n>----------------------------------------------------------------------------\n>Previously, only scalars or 1D arrays could be returned by the function passed\n>to ``apply_along_axis``. Now, it can return an array of any dimensionality\n>(including 0D), and the shape of this array replaces the axis of the array\n>being iterated over.\n\n>``.ndim`` property added to ``dtype`` to complement ``.shape``\n>--------------------------------------------------------------\n>For consistency with ``ndarray`` and ``broadcast``, ``d.ndim`` is a shorthand\n>for ``len(d.shape)``.\n\n>Support for tracemalloc in Python 3.6\n>-------------------------------------\n>NumPy now supports memory tracing with tracemalloc_ module of Python 3.6 or\n>newer. Memory allocations from NumPy are placed into the domain defined by\n>``numpy.lib.tracemalloc_domain``.\n>Note that NumPy allocation will not show up in tracemalloc_ of earlier Python\n>versions.\n\n>.. _tracemalloc: https://docs.python.org/3/library/tracemalloc.html\n\n>NumPy may be built with relaxed stride checking debugging\n>---------------------------------------------------------\n>Setting NPY_RELAXED_STRIDES_DEBUG=1 in the environment when relaxed stride\n>checking is enabled will cause NumPy to be compiled with the affected strides\n>set to the maximum value of npy_intp in order to help detect invalid usage of\n>the strides in downstream projects. When enabled, invalid usage often results\n>in an error being raised, but the exact type of error depends on the details of\n>the code. TypeError and OverflowError have been observed in the wild.\n\n>It was previously the case that this option was disabled for releases and\n>enabled in master and changing between the two required editing the code. It is\n>now disabled by default but can be enabled for test builds.\n\n\n>Improvements\n>============\n\n>Ufunc behavior for overlapping inputs\n>-------------------------------------\n\n>Operations where ufunc input and output operands have memory overlap\n>produced undefined results in previous NumPy versions, due to data\n>dependency issues. In NumPy 1.13.0, results from such operations are\n>now defined to be the same as for equivalent operations where there is\n>no memory overlap.\n\n>Operations affected now make temporary copies, as needed to eliminate\n>data dependency. As detecting these cases is computationally\n>expensive, a heuristic is used, which may in rare cases result to\n>needless temporary copies.  For operations where the data dependency\n>is simple enough for the heuristic to analyze, temporary copies will\n>not be made even if the arrays overlap, if it can be deduced copies\n>are not necessary.  As an example,``np.add(a, b, out=a)`` will not\n>involve copies.\n\n>To illustrate a previously undefined operation::\n\n>    &gt;&gt;&gt; x = np.arange(16).astype(float)\n>    &gt;&gt;&gt; np.add(x[1:], x[:-1], out=x[1:])\n\n>In NumPy 1.13.0 the last line is guaranteed to be equivalent to::\n\n>    &gt;&gt;&gt; np.add(x[1:].copy(), x[:-1].copy(), out=x[1:])\n\n>A similar operation with simple non-problematic data dependence is::\n\n>    &gt;&gt;&gt; x = np.arange(16).astype(float)\n>    &gt;&gt;&gt; np.add(x[1:], x[:-1], out=x[:-1])\n\n>It will continue to produce the same results as in previous NumPy\n>versions, and will not involve unnecessary temporary copies.\n\n>The change applies also to in-place binary operations, for example::\n\n>    &gt;&gt;&gt; x = np.random.rand(500, 500)\n>    &gt;&gt;&gt; x += x.T\n\n>This statement is now guaranteed to be equivalent to ``x[...] = x + x.T``,\n>whereas in previous NumPy versions the results were undefined.\n\n>Partial support for 64-bit f2py extensions with MinGW\n>-----------------------------------------------------\n>Extensions that incorporate Fortran libraries can now be built using the free\n>MinGW_ toolset, also under Python 3.5. This works best for extensions that only\n>do calculations and uses the runtime modestly (reading and writing from files,\n>for instance). Note that this does not remove the need for Mingwpy; if you make\n>extensive use of the runtime, you will most likely run into issues_. Instead,\n>it should be regarded as a band-aid until Mingwpy is fully functional.\n\n>Extensions can also be compiled using the MinGW toolset using the runtime\n>library from the (moveable) WinPython 3.4 distribution, which can be useful for\n>programs with a PySide1/Qt4 front-end.\n\n>.. _MinGW: https://sf.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/6.2.0/threads-win32/seh/\n\n>.. _issues: https://mingwpy.github.io/issues.html\n\n>Performance improvements for ``packbits`` and ``unpackbits``\n>------------------------------------------------------------\n>The functions ``numpy.packbits`` with boolean input and ``numpy.unpackbits`` have\n>been optimized to be a significantly faster for contiguous data.\n\n>Fix for PPC long double floating point information\n>--------------------------------------------------\n>In previous versions of NumPy, the ``finfo`` function returned invalid\n>information about the `double double`_ format of the ``longdouble`` float type\n>on Power PC (PPC).  The invalid values resulted from the failure of the NumPy\n>algorithm to deal with the variable number of digits in the significand\n>that are a feature of `PPC long doubles`.  This release by-passes the failing\n>algorithm by using heuristics to detect the presence of the PPC double double\n>format.  A side-effect of using these heuristics is that the ``finfo``\n>function is faster than previous releases.\n\n>.. _PPC long doubles: https://www.ibm.com/support/knowledgecenter/en/ssw_aix_71/com.ibm.aix.genprogc/128bit_long_double_floating-point_datatype.htm\n\n>.. _double double: https://en.wikipedia.org/wiki/Quadruple-precision_floating-point_formatDouble-double_arithmetic\n\n>Better default repr for ``ndarray`` subclasses\n>----------------------------------------------\n>Subclasses of ndarray with no ``repr`` specialization now correctly indent\n>their data and type lines.\n\n>More reliable comparisons of masked arrays\n>------------------------------------------\n>Comparisons of masked arrays were buggy for masked scalars and failed for\n>structured arrays with dimension higher than one. Both problems are now\n>solved. In the process, it was ensured that in getting the result for a\n>structured array, masked fields are properly ignored, i.e., the result is equal\n>if all fields that are non-masked in both are equal, thus making the behaviour\n>identical to what one gets by comparing an unstructured masked array and then\n>doing ``.all()`` over some axis.\n\n>np.matrix with booleans elements can now be created using the string syntax\n>---------------------------------------------------------------------------\n>``np.matrix`` failed whenever one attempts to use it with booleans, e.g.,\n>``np.matrix(&#39;True&#39;)``. Now, this works as expected.\n\n>More ``linalg`` operations now accept empty vectors and matrices\n>----------------------------------------------------------------\n>All of the following functions in ``np.linalg`` now work when given input\n>arrays with a 0 in the last two dimensions: ``det``, ``slogdet``, ``pinv``,\n>``eigvals``, ``eigvalsh``, ``eig``, ``eigh``.\n\n>Bundled version of LAPACK is now 3.2.2\n>--------------------------------------\n>NumPy comes bundled with a minimal implementation of lapack for systems without\n>a lapack library installed, under the name of ``lapack_lite``. This has been\n>upgraded from LAPACK 3.0.0 (June 30, 1999) to LAPACK 3.2.2 (June 30, 2010). See\n>the `LAPACK changelogs`_ for details on the all the changes this entails.\n\n>While no new features are exposed through ``numpy``, this fixes some bugs\n>regarding &quot;workspace&quot; sizes, and in some places may use faster algorithms.\n\n>.. _`LAPACK changelogs`: http://www.netlib.org/lapack/release_notes.html_4_history_of_lapack_releases\n\n>``reduce`` of ``np.hypot.reduce`` and ``np.logical_xor`` allowed in more cases\n>------------------------------------------------------------------------------\n>This now works on empty arrays, returning 0, and can reduce over multiple axes.\n>Previously, a ``ValueError`` was thrown in these cases.\n\n>Better ``repr`` of object arrays\n>--------------------------------\n>Object arrays that contain themselves no longer cause a recursion error.\n\n>Object arrays that contain ``list`` objects are now printed in a way that makes\n>clear the difference between a 2d object array, and a 1d object array of lists.\n\n>Changes\n>=======\n\n>``argsort`` on masked arrays takes the same default arguments as ``sort``\n>-------------------------------------------------------------------------\n>By default, ``argsort`` now places the masked values at the end of the sorted\n>array, in the same way that ``sort`` already did. Additionally, the\n>``end_with`` argument is added to ``argsort``, for consistency with ``sort``.\n>Note that this argument is not added at the end, so breaks any code that\n>passed ``fill_value`` as a positional argument.\n\n>``average`` now preserves subclasses\n>------------------------------------\n>For ndarray subclasses, ``numpy.average`` will now return an instance of the\n>subclass, matching the behavior of most other NumPy functions such as ``mean``.\n>As a consequence, also calls that returned a scalar may now return a subclass\n>array scalar.\n\n>``array == None`` and ``array != None`` do element-wise comparison\n>------------------------------------------------------------------\n>Previously these operations returned scalars ``False`` and ``True`` respectively.\n\n>``np.equal, np.not_equal`` for object arrays ignores object identity\n>--------------------------------------------------------------------\n>Previously, these functions always treated identical objects as equal. This had\n>the effect of overriding comparison failures, comparison of objects that did\n>not return booleans, such as np.arrays, and comparison of objects where the\n>results differed from object identity, such as NaNs.\n\n>Boolean indexing changes\n>------------------------\n>* Boolean array-likes (such as lists of python bools) are always treated as\n>  boolean indexes.\n\n>* Boolean scalars (including python ``True``) are legal boolean indexes and\n>  never treated as integers.\n\n>* Boolean indexes must match the dimension of the axis that they index.\n\n>* Boolean indexes used on the lhs of an assignment must match the dimensions of\n>  the rhs.\n\n>* Boolean indexing into scalar arrays return a new 1-d array.  This means that\n>  ``array(1)[array(True)]`` gives ``array([1])`` and not the original array.\n\n>``np.random.multivariate_normal`` behavior with bad covariance matrix\n>---------------------------------------------------------------------\n\n>It is now possible to adjust the behavior the function will have when dealing\n>with the covariance matrix by using two new keyword arguments:\n\n>* ``tol`` can be used to specify a tolerance to use when checking that\n>  the covariance matrix is positive semidefinite.\n\n>* ``check_valid`` can be used to configure what the function will do in the\n>  presence of a matrix that is not positive semidefinite. Valid options are\n>  ``ignore``, ``warn`` and ``raise``. The default value, ``warn`` keeps the\n>  the behavior used on previous releases.\n\n>``assert_array_less`` compares ``np.inf`` and ``-np.inf`` now\n>-------------------------------------------------------------\n>Previously, ``np.testing.assert_array_less`` ignored all infinite values. This\n>is not the expected behavior both according to documentation and intuitively.\n>Now, -inf &lt; x &lt; inf is considered ``True`` for any real number x and all\n>other cases fail.\n\n>``assert_array_`` and masked arrays ``assert_equal`` hide less warnings\n>-----------------------------------------------------------------------\n>Some warnings that were previously hidden by the ``assert_array_``\n>functions are not hidden anymore. In most cases the warnings should be\n>correct and, should they occur, will require changes to the tests using\n>these functions.\n>For the masked array ``assert_equal`` version, warnings may occur when\n>comparing NaT. The function presently does not handle NaT or NaN\n>specifically and it may be best to avoid it at this time should a warning\n>show up due to this change.\n\n>``offset`` attribute value in ``memmap`` objects\n>------------------------------------------------\n>The ``offset`` attribute in a ``memmap`` object is now set to the\n>offset into the file. This is a behaviour change only for offsets\n>greater than ``mmap.ALLOCATIONGRANULARITY``.\n\n>``np.real`` and ``np.imag`` return scalars for scalar inputs\n>------------------------------------------------------------\n>Previously, ``np.real`` and ``np.imag`` used to return array objects when\n>provided a scalar input, which was inconsistent with other functions like\n>``np.angle`` and ``np.conj``.\n\n>The polynomial convenience classes cannot be passed to ufuncs\n>-------------------------------------------------------------\n>The ABCPolyBase class, from which the convenience classes are derived, sets\n>``__array_ufun__ = None`` in order of opt out of ufuncs. If a polynomial\n>convenience class instance is passed as an argument to a ufunc, a ``TypeError``\n>will now be raised.\n\n>Output arguments to ufuncs can be tuples also for ufunc methods\n>---------------------------------------------------------------\n>For calls to ufuncs, it was already possible, and recommended, to use an\n>``out`` argument with a tuple for ufuncs with multiple outputs. This has now\n>been extended to output arguments in the ``reduce``, ``accumulate``, and\n>``reduceat`` methods. This is mostly for compatibility with ``__array_ufunc``;\n>there are no ufuncs yet that have more than one output.\n\n\n\n\n\n\n*Got merge conflicts? Close this PR and delete the branch. I'll create a new PR for you.*\n\nHappy merging! 🤖\n"},"comment":{"url":"https://api.github.com/repos/martensm/pywaifu/issues/comments/306896700","html_url":"https://github.com/martensm/pywaifu/pull/11#issuecomment-306896700","issue_url":"https://api.github.com/repos/martensm/pywaifu/issues/11","id":306896700,"user":{"login":"codecov[bot]","id":22429695,"avatar_url":"https://avatars1.githubusercontent.com/in/254?v=3","gravatar_id":"","url":"https://api.github.com/users/codecov%5Bbot%5D","html_url":"https://github.com/apps/codecov","followers_url":"https://api.github.com/users/codecov%5Bbot%5D/followers","following_url":"https://api.github.com/users/codecov%5Bbot%5D/following{/other_user}","gists_url":"https://api.github.com/users/codecov%5Bbot%5D/gists{/gist_id}","starred_url":"https://api.github.com/users/codecov%5Bbot%5D/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/codecov%5Bbot%5D/subscriptions","organizations_url":"https://api.github.com/users/codecov%5Bbot%5D/orgs","repos_url":"https://api.github.com/users/codecov%5Bbot%5D/repos","events_url":"https://api.github.com/users/codecov%5Bbot%5D/events{/privacy}","received_events_url":"https://api.github.com/users/codecov%5Bbot%5D/received_events","type":"Bot","site_admin":false},"created_at":"2017-06-07T19:15:17Z","updated_at":"2017-06-07T19:15:17Z","body":"# [Codecov](https://codecov.io/gh/martensm/pywaifu/pull/11?src=pr&el=h1) Report\n> Merging [#11](https://codecov.io/gh/martensm/pywaifu/pull/11?src=pr&el=desc) into [master](https://codecov.io/gh/martensm/pywaifu/commit/53d669262a77984f9b22b0268e026967d5fb2be7?src=pr&el=desc) will **not change** coverage.\n> The diff coverage is `n/a`.\n\n[![Impacted file tree graph](https://codecov.io/gh/martensm/pywaifu/pull/11/graphs/tree.svg?width=650&height=150&src=pr&token=euvh785CGC)](https://codecov.io/gh/martensm/pywaifu/pull/11?src=pr&el=tree)\n\n```diff\n@@         Coverage Diff          @@\n##           master   #11   +/-   ##\n====================================\n  Coverage       0%    0%           \n====================================\n  Files           1     1           \n  Lines           3     3           \n====================================\n  Misses          3     3\n```\n\n\n\n------\n\n[Continue to review full report at Codecov](https://codecov.io/gh/martensm/pywaifu/pull/11?src=pr&el=continue).\n> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)\n> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`\n> Powered by [Codecov](https://codecov.io/gh/martensm/pywaifu/pull/11?src=pr&el=footer). Last update [53d6692...723cafb](https://codecov.io/gh/martensm/pywaifu/pull/11?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).\n"}}
{"actor":{"display_login":"codecov"}}