{ "__type": "IngestedDoc", "__tag": 4010, "_content": {}, "_ordered_sections": [], "item_file": null, "item_line": null, "item_type": null, "aliases": [], "example_section_data": { "__type": "Section", "__tag": 4015, "children": [], "title": [], "level": 0, "target": null }, "see_also": [], "signature": null, "references": null, "qa": "release:1.16.0-notes", "arbitrary": [ { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "This NumPy release is the last one to support Python 2.7 and will be maintained as a long term release with bug fixes until 2020. Support for Python 3.4 been dropped, the supported Python versions are 2.7 and 3.5-3.7. The wheels on PyPI are linked with OpenBLAS v0.3.4+, which should fix the known threading issues found in previous OpenBLAS versions." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Downstream developers building this release should use Cython >= 0.29 and, if using OpenBLAS, OpenBLAS > v0.3.4." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "This release has seen a lot of refactoring and features many bug fixes, improved code organization, and better cross platform compatibility. Not all of these improvements will be visible to users, but they should help make maintenance easier going forward." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "NumPy 1.16.0 Release Notes" } ], "level": 0, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "BulletList", "__tag": 4053, "ordered": false, "start": 1, "children": [ { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Experimental (opt-in only) support for overriding numpy functions, see " }, { "__type": "InlineCode", "__tag": 4051, "value": "__array_function__" }, { "__type": "Text", "__tag": 4046, "value": " below." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The " }, { "__type": "InlineCode", "__tag": 4051, "value": "matmul" }, { "__type": "Text", "__tag": 4046, "value": " function is now a ufunc. This provides better performance and allows overriding with " }, { "__type": "InlineCode", "__tag": 4051, "value": "__array_ufunc__" }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Improved support for the ARM and POWER architectures." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Improved support for AIX and PyPy." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Improved interop with ctypes." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Improved support for PEP 3118." } ] } ] } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Highlights" } ], "level": 1, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "BulletList", "__tag": 4053, "ordered": false, "start": 1, "children": [ { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "New functions added to the " }, { "__type": "InlineRole", "__tag": 4003, "value": "numpy.lib.recfuntions", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " module to ease the structured assignment changes:" } ] }, { "__type": "Blockquote", "__tag": 4059, "children": [ { "__type": "BulletList", "__tag": 4053, "ordered": false, "start": 1, "children": [ { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "assign_fields_by_name" } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "structured_to_unstructured" } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "unstructured_to_structured" } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "apply_along_fields" } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "require_fields" } ] } ] } ] } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "See the user guide at for more info." } ] } ] } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "New functions" } ], "level": 1, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "BulletList", "__tag": 4053, "ordered": false, "start": 1, "children": [ { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The type dictionaries " }, { "__type": "InlineRole", "__tag": 4003, "value": "numpy.core.typeNA", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineRole", "__tag": 4003, "value": "numpy.core.sctypeNA", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " are deprecated. They were buggy and not documented and will be removed in the 1.18 release. Use " }, { "__type": "InlineCode", "__tag": 4051, "value": "numpy.sctypeDict" }, { "__type": "Text", "__tag": 4046, "value": " instead." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The " }, { "__type": "InlineRole", "__tag": 4003, "value": "numpy.asscalar", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " function is deprecated. It is an alias to the more powerful " }, { "__type": "InlineRole", "__tag": 4003, "value": "numpy.ndarray.item", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": ", not tested, and fails for scalars." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The " }, { "__type": "InlineRole", "__tag": 4003, "value": "numpy.set_array_ops", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineRole", "__tag": 4003, "value": "numpy.get_array_ops", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " functions are deprecated. As part of " }, { "__type": "InlineRole", "__tag": 4003, "value": "NEP 15", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": ", they have been deprecated along with the C-API functions " }, { "__type": "InlineCode", "__tag": 4051, "value": "PyArray_SetNumericOps" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "PyArray_GetNumericOps" }, { "__type": "Text", "__tag": 4046, "value": ". Users who wish to override the inner loop functions in built-in ufuncs should use " }, { "__type": "InlineCode", "__tag": 4051, "value": "PyUFunc_ReplaceLoopBySignature" }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The " }, { "__type": "CrossRef", "__tag": 4002, "value": "numpy.unravel_index", "reference": { "__type": "RefInfo", "__tag": 4000, "module": "numpy", "version": "*", "kind": "api", "path": "numpy:unravel_index" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": " keyword argument " }, { "__type": "InlineCode", "__tag": 4051, "value": "dims" }, { "__type": "Text", "__tag": 4046, "value": " is deprecated, use " }, { "__type": "InlineCode", "__tag": 4051, "value": "shape" }, { "__type": "Text", "__tag": 4046, "value": " instead." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The " }, { "__type": "CrossRef", "__tag": 4002, "value": "numpy.histogram", "reference": { "__type": "RefInfo", "__tag": 4000, "module": "numpy", "version": "*", "kind": "api", "path": "numpy:histogram" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": " " }, { "__type": "InlineCode", "__tag": 4051, "value": "normed" }, { "__type": "Text", "__tag": 4046, "value": " argument is deprecated. It was deprecated previously, but no warning was issued." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The " }, { "__type": "InlineCode", "__tag": 4051, "value": "positive" }, { "__type": "Text", "__tag": 4046, "value": " operator (" }, { "__type": "InlineCode", "__tag": 4051, "value": "+" }, { "__type": "Text", "__tag": 4046, "value": ") applied to non-numerical arrays is deprecated. See below for details." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Passing an iterator to the stack functions is deprecated" } ] } ] } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "New deprecations" } ], "level": 1, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "BulletList", "__tag": 4053, "ordered": false, "start": 1, "children": [ { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "NaT comparisons now return " }, { "__type": "InlineCode", "__tag": 4051, "value": "False" }, { "__type": "Text", "__tag": 4046, "value": " without a warning, finishing a deprecation cycle begun in NumPy 1.11." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "np.lib.function_base.unique" }, { "__type": "Text", "__tag": 4046, "value": " was removed, finishing a deprecation cycle begun in NumPy 1.4. Use " }, { "__type": "CrossRef", "__tag": 4002, "value": "numpy.unique", "reference": { "__type": "RefInfo", "__tag": 4000, "module": "numpy", "version": "*", "kind": "api", "path": "numpy:unique" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": " instead." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "multi-field indexing now returns views instead of copies, finishing a deprecation cycle begun in NumPy 1.7. The change was previously attempted in NumPy 1.14 but reverted until now." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "np.PackageLoader" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.pkgload" }, { "__type": "Text", "__tag": 4046, "value": " have been removed. These were deprecated in 1.10, had no tests, and seem to no longer work in 1.15." } ] } ] } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Expired deprecations" } ], "level": 1, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "BulletList", "__tag": 4053, "ordered": false, "start": 1, "children": [ { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "NumPy 1.17 will drop support for Python 2.7." } ] } ] } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Future changes" } ], "level": 1, "target": null }, { "__type": "Section", "__tag": 4015, "children": [], "title": [ { "__type": "Text", "__tag": 4046, "value": "Compatibility notes" } ], "level": 1, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "On Windows, the installed script for running f2py is now an " }, { "__type": "InlineCode", "__tag": 4051, "value": ".exe" }, { "__type": "Text", "__tag": 4046, "value": " file rather than a " }, { "__type": "InlineCode", "__tag": 4051, "value": "*.py" }, { "__type": "Text", "__tag": 4046, "value": " file and should be run from the command line as " }, { "__type": "InlineCode", "__tag": 4051, "value": "f2py" }, { "__type": "Text", "__tag": 4046, "value": " whenever the " }, { "__type": "InlineCode", "__tag": 4051, "value": "Scripts" }, { "__type": "Text", "__tag": 4046, "value": " directory is in the path. Running " }, { "__type": "InlineCode", "__tag": 4051, "value": "f2py" }, { "__type": "Text", "__tag": 4046, "value": " as a module " }, { "__type": "InlineCode", "__tag": 4051, "value": "python -m numpy.f2py [...]" }, { "__type": "Text", "__tag": 4046, "value": " will work without path modification in any version of NumPy." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "f2py script on Windows" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Consistent with the behavior of NaN, all comparisons other than inequality checks with datetime64 or timedelta64 NaT (\"not-a-time\") values now always return " }, { "__type": "InlineCode", "__tag": 4051, "value": "False" }, { "__type": "Text", "__tag": 4046, "value": ", and inequality checks with NaT now always return " }, { "__type": "InlineCode", "__tag": 4051, "value": "True" }, { "__type": "Text", "__tag": 4046, "value": ". This includes comparisons between NaT values. For compatibility with the old behavior, use " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.isnat" }, { "__type": "Text", "__tag": 4046, "value": " to explicitly check for NaT or convert datetime64/timedelta64 arrays with " }, { "__type": "InlineCode", "__tag": 4051, "value": ".astype(np.int64)" }, { "__type": "Text", "__tag": 4046, "value": " before making comparisons." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "NaT comparisons" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The memory alignment of complex types is now the same as a C-struct composed of two floating point values, while before it was equal to the size of the type. For many users (for instance on x64/unix/gcc) this means that complex64 is now 4-byte aligned instead of 8-byte aligned. An important consequence is that aligned structured dtypes may now have a different size. For instance, " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.dtype('c8,u1', align=True)" }, { "__type": "Text", "__tag": 4046, "value": " used to have an itemsize of 16 (on x64/gcc) but now it is 12." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "More in detail, the complex64 type now has the same alignment as a C-struct " }, { "__type": "InlineCode", "__tag": 4051, "value": "struct {float r, i;}" }, { "__type": "Text", "__tag": 4046, "value": ", according to the compiler used to compile numpy, and similarly for the complex128 and complex256 types." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "complex64/128 alignment has changed" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "len(np.mgrid)" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "len(np.ogrid)" }, { "__type": "Text", "__tag": 4046, "value": " are now considered nonsensical and raise a " }, { "__type": "InlineCode", "__tag": 4051, "value": "TypeError" }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "nd_grid __len__ removal" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Previously, only the " }, { "__type": "InlineCode", "__tag": 4051, "value": "dims" }, { "__type": "Text", "__tag": 4046, "value": " keyword argument was accepted for specification of the shape of the array to be used for unraveling. " }, { "__type": "InlineCode", "__tag": 4051, "value": "dims" }, { "__type": "Text", "__tag": 4046, "value": " remains supported, but is now deprecated." } ] } ], "title": [ { "__type": "InlineCode", "__tag": 4051, "value": "np.unravel_index" }, { "__type": "Text", "__tag": 4046, "value": " now accepts " }, { "__type": "InlineCode", "__tag": 4051, "value": "shape" }, { "__type": "Text", "__tag": 4046, "value": " keyword argument" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Indexing a structured array with multiple fields, e.g., " }, { "__type": "InlineCode", "__tag": 4051, "value": "arr[['f1', 'f3']]" }, { "__type": "Text", "__tag": 4046, "value": ", returns a view into the original array instead of a copy. The returned view will often have extra padding bytes corresponding to intervening fields in the original array, unlike before, which will affect code such as " }, { "__type": "InlineCode", "__tag": 4051, "value": "arr[['f1', 'f3']].view('float64')" }, { "__type": "Text", "__tag": 4046, "value": ". This change has been planned since numpy 1.7. Operations hitting this path have emitted " }, { "__type": "InlineCode", "__tag": 4051, "value": "FutureWarnings" }, { "__type": "Text", "__tag": 4046, "value": " since then. Additional " }, { "__type": "InlineCode", "__tag": 4051, "value": "FutureWarnings" }, { "__type": "Text", "__tag": 4046, "value": " about this change were added in 1.12." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "To help users update their code to account for these changes, a number of functions have been added to the " }, { "__type": "InlineCode", "__tag": 4051, "value": "numpy.lib.recfunctions" }, { "__type": "Text", "__tag": 4046, "value": " module which safely allow such operations. For instance, the code above can be replaced with " }, { "__type": "InlineCode", "__tag": 4051, "value": "structured_to_unstructured(arr[['f1', 'f3']], dtype='float64')" }, { "__type": "Text", "__tag": 4046, "value": ". See the \"accessing multiple fields\" section of the " }, { "__type": "Link", "__tag": 4049, "children": [ { "__type": "Text", "__tag": 4046, "value": "user guide" } ], "url": "https://docs.scipy.org/doc/numpy/user/basics.rec.html#accessing-multiple-fields", "title": "" }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "multi-field views return a view instead of a copy" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The " }, { "__type": "InlineCode", "__tag": 4051, "value": "NPY_FEATURE_VERSION" }, { "__type": "Text", "__tag": 4046, "value": " was incremented to 0x0000D, due to the addition of:" } ] }, { "__type": "BulletList", "__tag": 4053, "ordered": false, "start": 1, "children": [ { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "PyUFuncObject.core_dim_flags" } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "PyUFuncObject.core_dim_sizes" } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "PyUFuncObject.identity_value" } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "PyUFunc_FromFuncAndDataAndSignatureAndIdentity" } ] } ] } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "C API changes" } ], "level": 1, "target": null }, { "__type": "Section", "__tag": 4015, "children": [], "title": [ { "__type": "Text", "__tag": 4046, "value": "New Features" } ], "level": 1, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "This method (" }, { "__type": "InlineCode", "__tag": 4051, "value": "bins='stone'" }, { "__type": "Text", "__tag": 4046, "value": ") for optimizing the bin number is a generalization of the Scott's rule. The Scott's rule assumes the distribution is approximately Normal, while the " }, { "__type": "CrossRef", "__tag": 4002, "value": "ISE", "reference": { "__type": "LocalRef", "__tag": 4022, "kind": "docs", "path": "release:1.16.0-notes" }, "kind": "exists" }, { "__type": "Text", "__tag": 4046, "value": " is a non-parametric method based on cross-validation." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Integrated squared error (ISE) estimator added to " }, { "__type": "InlineCode", "__tag": 4051, "value": "histogram" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "New keyword " }, { "__type": "InlineCode", "__tag": 4051, "value": "max_rows" }, { "__type": "Text", "__tag": 4046, "value": " in " }, { "__type": "CrossRef", "__tag": 4002, "value": "numpy.loadtxt", "reference": { "__type": "RefInfo", "__tag": 4000, "module": "numpy", "version": "*", "kind": "api", "path": "numpy:loadtxt" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": " sets the maximum rows of the content to be read after " }, { "__type": "InlineCode", "__tag": 4051, "value": "skiprows" }, { "__type": "Text", "__tag": 4046, "value": ", as in " }, { "__type": "CrossRef", "__tag": 4002, "value": "numpy.genfromtxt", "reference": { "__type": "RefInfo", "__tag": 4000, "module": "numpy", "version": "*", "kind": "api", "path": "numpy:genfromtxt" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ], "title": [ { "__type": "InlineCode", "__tag": 4051, "value": "max_rows" }, { "__type": "Text", "__tag": 4046, "value": " keyword added for " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.loadtxt" } ], "level": 2, "target": "ISE" }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The modulus (remainder) operator is now supported for two operands of type " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.timedelta64" }, { "__type": "Text", "__tag": 4046, "value": ". The operands may have different units and the return value will match the type of the operands." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "modulus operator support added for " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.timedelta64" }, { "__type": "Text", "__tag": 4046, "value": " operands" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [], "title": [ { "__type": "Text", "__tag": 4046, "value": "Improvements" } ], "level": 1, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Up to protocol 4, numpy array pickling created 2 spurious copies of the data being serialized. With pickle protocol 5, and the " }, { "__type": "InlineCode", "__tag": 4051, "value": "PickleBuffer" }, { "__type": "Text", "__tag": 4046, "value": " API, a large variety of numpy arrays can now be serialized without any copy using out-of-band buffers, and with one less copy using in-band buffers. This results, for large arrays, in an up to 66% drop in peak memory usage." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "no-copy pickling of numpy arrays" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "NumPy builds should no longer interact with the host machine shell directly. " }, { "__type": "InlineCode", "__tag": 4051, "value": "exec_command" }, { "__type": "Text", "__tag": 4046, "value": " has been replaced with " }, { "__type": "InlineCode", "__tag": 4051, "value": "subprocess.check_output" }, { "__type": "Text", "__tag": 4046, "value": " where appropriate." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "build shell independence" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "When used in a front-end that supports it, " }, { "__type": "InlineRole", "__tag": 4003, "value": "Polynomial", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " instances are now rendered through LaTeX. The current format is experimental, and is subject to change." } ] } ], "title": [ { "__type": "InlineRole", "__tag": 4003, "value": "np.polynomial.Polynomial", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " classes render in LaTeX in Jupyter notebooks" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Even when no elements needed to be drawn, " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.random.randint" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.random.choice" }, { "__type": "Text", "__tag": 4046, "value": " raised an error when the arguments described an empty distribution. This has been fixed so that e.g. " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.random.choice([], 0) == np.array([], dtype=float64)" }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ], "title": [ { "__type": "InlineCode", "__tag": 4051, "value": "randint" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "choice" }, { "__type": "Text", "__tag": 4046, "value": " now work on empty distributions" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Previously, a " }, { "__type": "InlineCode", "__tag": 4051, "value": "LinAlgError" }, { "__type": "Text", "__tag": 4046, "value": " would be raised when an empty matrix/empty matrices (with zero rows and/or columns) is/are passed in. Now outputs of appropriate shapes are returned." } ] } ], "title": [ { "__type": "InlineCode", "__tag": 4051, "value": "linalg.lstsq" }, { "__type": "Text", "__tag": 4046, "value": ", " }, { "__type": "InlineCode", "__tag": 4051, "value": "linalg.qr" }, { "__type": "Text", "__tag": 4046, "value": ", and " }, { "__type": "InlineCode", "__tag": 4051, "value": "linalg.svd" }, { "__type": "Text", "__tag": 4046, "value": " now work with empty arrays" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "This should help track down problems." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Chain exceptions to give better error messages for invalid PEP3118 format strings" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Einsum was synchronized with the current upstream work." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Einsum optimization path updates and efficiency improvements" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "In particular, they now work for masked arrays." } ] } ], "title": [ { "__type": "InlineRole", "__tag": 4003, "value": "numpy.angle", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineRole", "__tag": 4003, "value": "numpy.expand_dims", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " now work on " }, { "__type": "InlineCode", "__tag": 4051, "value": "ndarray" }, { "__type": "Text", "__tag": 4046, "value": " subclasses" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Setting " }, { "__type": "InlineCode", "__tag": 4051, "value": "NPY_NO_DEPRECATED_API" }, { "__type": "Text", "__tag": 4046, "value": " to a value of 0 will suppress the current compiler warnings when the deprecated numpy API is used." } ] } ], "title": [ { "__type": "InlineCode", "__tag": 4051, "value": "NPY_NO_DEPRECATED_API" }, { "__type": "Text", "__tag": 4046, "value": " compiler warning suppression" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "New kwargs " }, { "__type": "InlineCode", "__tag": 4051, "value": "prepend" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "append" }, { "__type": "Text", "__tag": 4046, "value": ", allow for values to be inserted on either end of the differences. Similar to options for " }, { "__type": "InlineRole", "__tag": 4003, "value": "ediff1d", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": ". Now the inverse of " }, { "__type": "InlineRole", "__tag": 4003, "value": "cumsum", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " can be obtained easily via " }, { "__type": "InlineCode", "__tag": 4051, "value": "prepend=0" }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ], "title": [ { "__type": "InlineCode", "__tag": 4051, "value": "np.diff" }, { "__type": "Text", "__tag": 4046, "value": " Added kwargs prepend and append" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Support for ARM CPUs has been updated to accommodate 32 and 64 bit targets, and also big and little endian byte ordering. AARCH32 memory alignment issues have been addressed. CI testing has been expanded to include AARCH64 targets via the services of shippable.com." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "ARM support updated" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineRole", "__tag": 4003, "value": "numpy.distutils", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " has always overridden rather than appended to " }, { "__type": "InlineRole", "__tag": 4003, "value": "LDFLAGS", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " and other similar such environment variables for compiling Fortran extensions. Now, if the " }, { "__type": "InlineRole", "__tag": 4003, "value": "NPY_DISTUTILS_APPEND_FLAGS", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " environment variable is set to 1, the behavior will be appending. This applied to: " }, { "__type": "InlineRole", "__tag": 4003, "value": "LDFLAGS", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": ", " }, { "__type": "InlineRole", "__tag": 4003, "value": "F77FLAGS", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": ", " }, { "__type": "InlineRole", "__tag": 4003, "value": "F90FLAGS", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": ", " }, { "__type": "InlineRole", "__tag": 4003, "value": "FREEFLAGS", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": ", " }, { "__type": "InlineRole", "__tag": 4003, "value": "FOPT", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": ", " }, { "__type": "InlineRole", "__tag": 4003, "value": "FDEBUG", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": ", and " }, { "__type": "InlineRole", "__tag": 4003, "value": "FFLAGS", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": ". See gh-11525 for more details." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Appending to build flags" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "By using a numerical value in the signature of a generalized ufunc, one can indicate that the given function requires input or output to have dimensions with the given size. E.g., the signature of a function that converts a polar angle to a two-dimensional cartesian unit vector would be " }, { "__type": "InlineCode", "__tag": 4051, "value": "()->(2)" }, { "__type": "Text", "__tag": 4046, "value": "; that for one that converts two spherical angles to a three-dimensional unit vector would be " }, { "__type": "InlineCode", "__tag": 4051, "value": "(),()->(3)" }, { "__type": "Text", "__tag": 4046, "value": "; and that for the cross product of two three-dimensional vectors would be " }, { "__type": "InlineCode", "__tag": 4051, "value": "(3),(3)->(3)" }, { "__type": "Text", "__tag": 4046, "value": "." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Note that to the elementary function these dimensions are not treated any differently from variable ones indicated with a name starting with a letter; the loop still is passed the corresponding size, but it can now count on that size being equal to the fixed one given in the signature." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Generalized ufunc signatures now allow fixed-size dimensions" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Some functions, in particular numpy's implementation of " }, { "__type": "InlineCode", "__tag": 4051, "value": "@" }, { "__type": "Text", "__tag": 4046, "value": " as " }, { "__type": "InlineCode", "__tag": 4051, "value": "matmul" }, { "__type": "Text", "__tag": 4046, "value": ", are very similar to generalized ufuncs in that they operate over core dimensions, but one could not present them as such because they were able to deal with inputs in which a dimension is missing. To support this, it is now allowed to postfix a dimension name with a question mark to indicate that the dimension does not necessarily have to be present." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "With this addition, the signature for " }, { "__type": "InlineCode", "__tag": 4051, "value": "matmul" }, { "__type": "Text", "__tag": 4046, "value": " can be expressed as " }, { "__type": "InlineCode", "__tag": 4051, "value": "(m?,n),(n,p?)->(m?,p?)" }, { "__type": "Text", "__tag": 4046, "value": ". This indicates that if, e.g., the second operand has only one dimension, for the purposes of the elementary function it will be treated as if that input has core shape " }, { "__type": "InlineCode", "__tag": 4051, "value": "(n, 1)" }, { "__type": "Text", "__tag": 4046, "value": ", and the output has the corresponding core shape of " }, { "__type": "InlineCode", "__tag": 4051, "value": "(m, 1)" }, { "__type": "Text", "__tag": 4046, "value": ". The actual output array, however, has the flexible dimension removed, i.e., it will have shape " }, { "__type": "InlineCode", "__tag": 4051, "value": "(..., m)" }, { "__type": "Text", "__tag": 4046, "value": ". Similarly, if both arguments have only a single dimension, the inputs will be presented as having shapes " }, { "__type": "InlineCode", "__tag": 4051, "value": "(1, n)" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "(n, 1)" }, { "__type": "Text", "__tag": 4046, "value": " to the elementary function, and the output as " }, { "__type": "InlineCode", "__tag": 4051, "value": "(1, 1)" }, { "__type": "Text", "__tag": 4046, "value": ", while the actual output array returned will have shape " }, { "__type": "InlineCode", "__tag": 4051, "value": "()" }, { "__type": "Text", "__tag": 4046, "value": ". In this way, the signature allows one to use a single elementary function for four related but different signatures, " }, { "__type": "InlineCode", "__tag": 4051, "value": "(m,n),(n,p)->(m,p)" }, { "__type": "Text", "__tag": 4046, "value": ", " }, { "__type": "InlineCode", "__tag": 4051, "value": "(n),(n,p)->(p)" }, { "__type": "Text", "__tag": 4046, "value": ", " }, { "__type": "InlineCode", "__tag": 4051, "value": "(m,n),(n)->(m)" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "(n),(n)->()" }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Generalized ufunc signatures now allow flexible dimensions" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The " }, { "__type": "InlineCode", "__tag": 4051, "value": "out" }, { "__type": "Text", "__tag": 4046, "value": " argument to these functions is now always tested for memory overlap to avoid corrupted results when memory overlap occurs." } ] } ], "title": [ { "__type": "InlineCode", "__tag": 4051, "value": "np.clip" }, { "__type": "Text", "__tag": 4046, "value": " and the " }, { "__type": "InlineCode", "__tag": 4051, "value": "clip" }, { "__type": "Text", "__tag": 4046, "value": " method check for memory overlap" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "A further possible value has been added to the " }, { "__type": "InlineCode", "__tag": 4051, "value": "cov" }, { "__type": "Text", "__tag": 4046, "value": " parameter of the " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.polyfit" }, { "__type": "Text", "__tag": 4046, "value": " function. With " }, { "__type": "InlineCode", "__tag": 4051, "value": "cov='unscaled'" }, { "__type": "Text", "__tag": 4046, "value": " the scaling of the covariance matrix is disabled completely (similar to setting " }, { "__type": "InlineCode", "__tag": 4051, "value": "absolute_sigma=True" }, { "__type": "Text", "__tag": 4046, "value": " in " }, { "__type": "InlineCode", "__tag": 4051, "value": "scipy.optimize.curve_fit" }, { "__type": "Text", "__tag": 4046, "value": "). This would be useful in occasions, where the weights are given by 1/sigma with sigma being the (known) standard errors of (Gaussian distributed) data points, in which case the unscaled matrix is already a correct estimate for the covariance matrix." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "New value " }, { "__type": "InlineCode", "__tag": 4051, "value": "unscaled" }, { "__type": "Text", "__tag": 4046, "value": " for option " }, { "__type": "InlineCode", "__tag": 4051, "value": "cov" }, { "__type": "Text", "__tag": 4046, "value": " in " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.polyfit" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The " }, { "__type": "InlineCode", "__tag": 4051, "value": "help" }, { "__type": "Text", "__tag": 4046, "value": " function, when applied to numeric types such as " }, { "__type": "CrossRef", "__tag": 4002, "value": "numpy.intc", "reference": { "__type": "RefInfo", "__tag": 4000, "module": "numpy", "version": "*", "kind": "api", "path": "numpy:int32" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": ", " }, { "__type": "CrossRef", "__tag": 4002, "value": "numpy.int_", "reference": { "__type": "RefInfo", "__tag": 4000, "module": "numpy", "version": "*", "kind": "api", "path": "numpy:int64" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": ", and " }, { "__type": "CrossRef", "__tag": 4002, "value": "numpy.longlong", "reference": { "__type": "RefInfo", "__tag": 4000, "module": "numpy", "version": "*", "kind": "api", "path": "numpy:longlong" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": ", now lists all of the aliased names for that type, distinguishing between platform -dependent and -independent aliases." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Detailed docstrings for scalar numeric types" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The " }, { "__type": "InlineCode", "__tag": 4051, "value": "__module__" }, { "__type": "Text", "__tag": 4046, "value": " attribute on most NumPy functions has been updated to refer to the preferred public module from which to access a function, rather than the module in which the function happens to be defined. This produces more informative displays for functions in tools such as IPython, e.g., instead of " }, { "__type": "InlineCode", "__tag": 4051, "value": "" }, { "__type": "Text", "__tag": 4046, "value": " you now see " }, { "__type": "InlineCode", "__tag": 4051, "value": "" }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ], "title": [ { "__type": "InlineCode", "__tag": 4051, "value": "__module__" }, { "__type": "Text", "__tag": 4046, "value": " attribute now points to public modules" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "On systems that support transparent hugepages over the madvise system call numpy now marks that large memory allocations can be backed by hugepages which reduces page fault overhead and can in some fault heavy cases improve performance significantly. On Linux the setting for huge pages to be used, " }, { "__type": "InlineRole", "__tag": 4003, "value": "/sys/kernel/mm/transparent_hugepage/enabled", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": ", must be at least " }, { "__type": "InlineRole", "__tag": 4003, "value": "madvise", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": ". Systems which already have it set to " }, { "__type": "InlineRole", "__tag": 4003, "value": "always", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " will not see much difference as the kernel will automatically use huge pages where appropriate." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Users of very old Linux kernels (~3.x and older) should make sure that " }, { "__type": "InlineRole", "__tag": 4003, "value": "/sys/kernel/mm/transparent_hugepage/defrag", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " is not set to " }, { "__type": "InlineRole", "__tag": 4003, "value": "always", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " to avoid performance problems due concurrency issues in the memory defragmentation." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Large allocations marked as suitable for transparent hugepages" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "We now default to use " }, { "__type": "InlineRole", "__tag": 4003, "value": "fenv.h", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " for floating point status error reporting. Previously we had a broken default that sometimes would not report underflow, overflow, and invalid floating point operations. Now we can support non-glibc distributions like Alpine Linux as long as they ship " }, { "__type": "InlineRole", "__tag": 4003, "value": "fenv.h", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Alpine Linux (and other musl c library distros) support" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Large arrays (greater than " }, { "__type": "InlineCode", "__tag": 4051, "value": "512 * 512" }, { "__type": "Text", "__tag": 4046, "value": ") now use a blocking algorithm based on copying the data directly into the appropriate slice of the resulting array. This results in significant speedups for these large arrays, particularly for arrays being blocked along more than 2 dimensions." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Speedup " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.block" }, { "__type": "Text", "__tag": 4046, "value": " for large arrays" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Previously the caller was responsible for keeping the array alive for the lifetime of the pointer." } ] } ], "title": [ { "__type": "InlineCode", "__tag": 4051, "value": "arr.ctypes.data_as(...)" }, { "__type": "Text", "__tag": 4046, "value": " holds a reference to arr" } ], "level": 3, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The implementation of " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.take" }, { "__type": "Text", "__tag": 4046, "value": " no longer makes an unnecessary copy of the source array when its " }, { "__type": "InlineCode", "__tag": 4051, "value": "writeable" }, { "__type": "Text", "__tag": 4046, "value": " flag is set to " }, { "__type": "InlineCode", "__tag": 4051, "value": "False" }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Speedup " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.take" }, { "__type": "Text", "__tag": 4046, "value": " for read-only arrays" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.core.records.fromfile" }, { "__type": "Text", "__tag": 4046, "value": " function now supports " }, { "__type": "InlineCode", "__tag": 4051, "value": "pathlib.Path" }, { "__type": "Text", "__tag": 4046, "value": " and other path-like objects in addition to a file object. Furthermore, the " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.load" }, { "__type": "Text", "__tag": 4046, "value": " function now also supports path-like objects when using memory mapping (" }, { "__type": "InlineCode", "__tag": 4051, "value": "mmap_mode" }, { "__type": "Text", "__tag": 4046, "value": " keyword argument)." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Support path-like objects for more functions" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Universal functions have an " }, { "__type": "InlineCode", "__tag": 4051, "value": ".identity" }, { "__type": "Text", "__tag": 4046, "value": " which is used when " }, { "__type": "InlineCode", "__tag": 4051, "value": ".reduce" }, { "__type": "Text", "__tag": 4046, "value": " is called on an empty axis." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "As of this release, the logical binary ufuncs, " }, { "__type": "InlineRole", "__tag": 4003, "value": "logical_and", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": ", " }, { "__type": "InlineRole", "__tag": 4003, "value": "logical_or", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": ", and " }, { "__type": "InlineRole", "__tag": 4003, "value": "logical_xor", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": ", now have " }, { "__type": "InlineCode", "__tag": 4051, "value": "identity" }, { "__type": "Text", "__tag": 4046, "value": " s of type " }, { "__type": "InlineRole", "__tag": 4003, "value": "bool", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": ", where previously they were of type " }, { "__type": "InlineRole", "__tag": 4003, "value": "int", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": ". This restores the 1.14 behavior of getting " }, { "__type": "InlineCode", "__tag": 4051, "value": "bool" }, { "__type": "Text", "__tag": 4046, "value": " s when reducing empty object arrays with these ufuncs, while also keeping the 1.15 behavior of getting " }, { "__type": "InlineCode", "__tag": 4051, "value": "int" }, { "__type": "Text", "__tag": 4046, "value": " s when reducing empty object arrays with arithmetic ufuncs like " }, { "__type": "InlineCode", "__tag": 4051, "value": "add" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "multiply" }, { "__type": "Text", "__tag": 4046, "value": "." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Additionally, " }, { "__type": "InlineRole", "__tag": 4003, "value": "logaddexp", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " now has an identity of " }, { "__type": "InlineCode", "__tag": 4051, "value": "-inf" }, { "__type": "Text", "__tag": 4046, "value": ", allowing it to be called on empty sequences, where previously it could not be." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "This is possible thanks to the new " }, { "__type": "InlineCode", "__tag": 4051, "value": "PyUFunc_FromFuncAndDataAndSignatureAndIdentity" }, { "__type": "Text", "__tag": 4046, "value": ", which allows arbitrary values to be used as identities now." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Better behaviour of ufunc identities during reductions" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Numpy has always supported taking a value or type from " }, { "__type": "InlineCode", "__tag": 4051, "value": "ctypes" }, { "__type": "Text", "__tag": 4046, "value": " and converting it into an array or dtype, but only behaved correctly for simpler types. As of this release, this caveat is lifted - now:" } ] }, { "__type": "BulletList", "__tag": 4053, "ordered": false, "start": 1, "children": [ { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The " }, { "__type": "InlineCode", "__tag": 4051, "value": "_pack_" }, { "__type": "Text", "__tag": 4046, "value": " attribute of " }, { "__type": "InlineCode", "__tag": 4051, "value": "ctypes.Structure" }, { "__type": "Text", "__tag": 4046, "value": ", used to emulate C's " }, { "__type": "InlineCode", "__tag": 4051, "value": "__attribute__((packed))" }, { "__type": "Text", "__tag": 4046, "value": ", is respected." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Endianness of all ctypes objects is preserved" } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "ctypes.Union" }, { "__type": "Text", "__tag": 4046, "value": " is supported" } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Non-representable constructs raise exceptions, rather than producing dangerously incorrect results:" } ] }, { "__type": "BulletList", "__tag": 4053, "ordered": false, "start": 1, "children": [ { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Bitfields are no longer interpreted as sub-arrays" } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Pointers are no longer replaced with the type that they point to" } ] } ] } ] } ] } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Improved conversion from ctypes objects" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "This matches the " }, { "__type": "InlineCode", "__tag": 4051, "value": ".contents" }, { "__type": "Text", "__tag": 4046, "value": " member of normal ctypes arrays, and can be used to construct an " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.array" }, { "__type": "Text", "__tag": 4046, "value": " around the pointers contents. This replaces " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.array(some_nd_pointer)" }, { "__type": "Text", "__tag": 4046, "value": ", which stopped working in 1.15. As a side effect of this change, " }, { "__type": "InlineCode", "__tag": 4051, "value": "ndpointer" }, { "__type": "Text", "__tag": 4046, "value": " now supports dtypes with overlapping fields and padding." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "A new " }, { "__type": "InlineCode", "__tag": 4051, "value": "ndpointer.contents" }, { "__type": "Text", "__tag": 4046, "value": " member" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "CrossRef", "__tag": 4002, "value": "numpy.matmul", "reference": { "__type": "RefInfo", "__tag": 4000, "module": "numpy", "version": "*", "kind": "api", "path": "numpy:matmul" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": " is now a ufunc which means that both the function and the " }, { "__type": "InlineCode", "__tag": 4051, "value": "__matmul__" }, { "__type": "Text", "__tag": 4046, "value": " operator can now be overridden by " }, { "__type": "InlineCode", "__tag": 4051, "value": "__array_ufunc__" }, { "__type": "Text", "__tag": 4046, "value": ". Its implementation has also changed. It uses the same BLAS routines as " }, { "__type": "CrossRef", "__tag": 4002, "value": "numpy.dot", "reference": { "__type": "RefInfo", "__tag": 4000, "module": "numpy", "version": "*", "kind": "api", "path": "numpy:dot" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": ", ensuring its performance is similar for large matrices." } ] } ], "title": [ { "__type": "InlineCode", "__tag": 4051, "value": "matmul" }, { "__type": "Text", "__tag": 4046, "value": " is now a " }, { "__type": "InlineCode", "__tag": 4051, "value": "ufunc" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "These functions used to be limited to scalar stop and start values, but can now take arrays, which will be properly broadcast and result in an output which has one axis prepended. This can be used, e.g., to obtain linearly interpolated points between sets of points." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Start and stop arrays for " }, { "__type": "InlineCode", "__tag": 4051, "value": "linspace" }, { "__type": "Text", "__tag": 4046, "value": ", " }, { "__type": "InlineCode", "__tag": 4051, "value": "logspace" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "geomspace" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "We now use additional free CI services, thanks to the companies that provide:" } ] }, { "__type": "BulletList", "__tag": 4053, "ordered": false, "start": 1, "children": [ { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Codecoverage testing via codecov.io" } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Arm testing via shippable.com" } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Additional test runs on azure pipelines" } ] } ] } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "These are in addition to our continued use of travis, appveyor (for wheels) and LGTM" } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "CI extended with additional services" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [], "title": [ { "__type": "Text", "__tag": 4046, "value": "Changes" } ], "level": 1, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Previously, comparison ufuncs such as " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.equal" }, { "__type": "Text", "__tag": 4046, "value": " would return " }, { "__type": "InlineRole", "__tag": 4003, "value": "NotImplemented", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " if their arguments had structured dtypes, to help comparison operators such as " }, { "__type": "InlineCode", "__tag": 4051, "value": "__eq__" }, { "__type": "Text", "__tag": 4046, "value": " deal with those. This is no longer needed, as the relevant logic has moved to the comparison operators proper (which thus do continue to return " }, { "__type": "InlineRole", "__tag": 4003, "value": "NotImplemented", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " as needed). Hence, like all other ufuncs, the comparison ufuncs will now error on structured dtypes." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Comparison ufuncs will now error rather than return NotImplemented" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Previously, " }, { "__type": "InlineCode", "__tag": 4051, "value": "+array" }, { "__type": "Text", "__tag": 4046, "value": " unconditionally returned a copy. Now, it will raise a " }, { "__type": "InlineCode", "__tag": 4051, "value": "DeprecationWarning" }, { "__type": "Text", "__tag": 4046, "value": " if the array is not numerical (i.e., if " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.positive(array)" }, { "__type": "Text", "__tag": 4046, "value": " raises a " }, { "__type": "InlineCode", "__tag": 4051, "value": "TypeError" }, { "__type": "Text", "__tag": 4046, "value": ". For " }, { "__type": "InlineCode", "__tag": 4051, "value": "ndarray" }, { "__type": "Text", "__tag": 4046, "value": " subclasses that override the default " }, { "__type": "InlineCode", "__tag": 4051, "value": "__array_ufunc__" }, { "__type": "Text", "__tag": 4046, "value": " implementation, the " }, { "__type": "InlineCode", "__tag": 4051, "value": "TypeError" }, { "__type": "Text", "__tag": 4046, "value": " is passed on." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Positive will now raise a deprecation warning for non-numerical arrays" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Previously, " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.lib.mixins.NDArrayOperatorsMixin" }, { "__type": "Text", "__tag": 4046, "value": " did not implement the special methods for Python's matrix multiplication operator (" }, { "__type": "InlineCode", "__tag": 4051, "value": "@" }, { "__type": "Text", "__tag": 4046, "value": "). This has changed now that " }, { "__type": "InlineCode", "__tag": 4051, "value": "matmul" }, { "__type": "Text", "__tag": 4046, "value": " is a ufunc and can be overridden using " }, { "__type": "InlineCode", "__tag": 4051, "value": "__array_ufunc__" }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ], "title": [ { "__type": "InlineCode", "__tag": 4051, "value": "NDArrayOperatorsMixin" }, { "__type": "Text", "__tag": 4046, "value": " now implements matrix multiplication" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "So far, " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.polyfit" }, { "__type": "Text", "__tag": 4046, "value": " used a non-standard factor in the scaling of the the covariance matrix. Namely, rather than using the standard " }, { "__type": "InlineCode", "__tag": 4051, "value": "chisq/(M-N)" }, { "__type": "Text", "__tag": 4046, "value": ", it scaled it with " }, { "__type": "InlineCode", "__tag": 4051, "value": "chisq/(M-N-2)" }, { "__type": "Text", "__tag": 4046, "value": " where M is the number of data points and N is the number of parameters. This scaling is inconsistent with other fitting programs such as e.g. " }, { "__type": "InlineCode", "__tag": 4051, "value": "scipy.optimize.curve_fit" }, { "__type": "Text", "__tag": 4046, "value": " and was changed to " }, { "__type": "InlineCode", "__tag": 4051, "value": "chisq/(M-N)" }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "The scaling of the covariance matrix in " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.polyfit" }, { "__type": "Text", "__tag": 4046, "value": " is different" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "As part of code introduced in 1.10, " }, { "__type": "InlineCode", "__tag": 4051, "value": "float32" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "float64" }, { "__type": "Text", "__tag": 4046, "value": " set invalid float status when a Nan is encountered in " }, { "__type": "CrossRef", "__tag": 4002, "value": "numpy.maximum", "reference": { "__type": "RefInfo", "__tag": 4000, "module": "numpy", "version": "*", "kind": "api", "path": "numpy:maximum" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "CrossRef", "__tag": 4002, "value": "numpy.minimum", "reference": { "__type": "RefInfo", "__tag": 4000, "module": "numpy", "version": "*", "kind": "api", "path": "numpy:minimum" }, "kind": "module" }, { "__type": "Text", "__tag": 4046, "value": ", when using SSE2 semantics. This caused a " }, { "__type": "InlineRole", "__tag": 4003, "value": "RuntimeWarning", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " to sometimes be emitted. In 1.15 we fixed the inconsistencies which caused the warnings to become more conspicuous. Now no warnings will be emitted." } ] } ], "title": [ { "__type": "InlineCode", "__tag": 4051, "value": "maximum" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "minimum" }, { "__type": "Text", "__tag": 4046, "value": " no longer emit warnings" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The two modules were merged, according to " }, { "__type": "InlineRole", "__tag": 4003, "value": "NEP 15", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": ". Previously " }, { "__type": "InlineRole", "__tag": 4003, "value": "np.core.umath", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineRole", "__tag": 4003, "value": "np.core.multiarray", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " were separate c-extension modules. They are now python wrappers to the single " }, { "__type": "InlineRole", "__tag": 4003, "value": "np.core/_multiarray_math", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " c-extension module." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Umath and multiarray c-extension modules merged into a single module" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineRole", "__tag": 4003, "value": "numpy.ndarray.getfield", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " now checks the dtype and offset arguments to prevent accessing invalid memory locations." } ] } ], "title": [ { "__type": "InlineCode", "__tag": 4051, "value": "getfield" }, { "__type": "Text", "__tag": 4046, "value": " validity checks extended" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "NumPy has a new experimental mechanism for overriding the implementation of almost all NumPy functions on non-NumPy arrays by defining an " }, { "__type": "InlineCode", "__tag": 4051, "value": "__array_function__" }, { "__type": "Text", "__tag": 4046, "value": " method, as described in " }, { "__type": "InlineRole", "__tag": 4003, "value": "NEP 18", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": "." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "This feature is not yet been enabled by default, but has been released to facilitate experimentation by potential users. See the NEP for details on setting the appropriate environment variable. We expect the NumPy 1.17 release will enable overrides by default, which will also be more performant due to a new implementation written in C." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "NumPy functions now support overrides with " }, { "__type": "InlineCode", "__tag": 4051, "value": "__array_function__" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "We now disallow setting the " }, { "__type": "InlineCode", "__tag": 4051, "value": "writeable" }, { "__type": "Text", "__tag": 4046, "value": " flag True on arrays created from " }, { "__type": "InlineCode", "__tag": 4051, "value": "fromstring(readonly-buffer)" }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Arrays based off readonly buffers cannot be set " }, { "__type": "InlineCode", "__tag": 4051, "value": "writeable" } ], "level": 2, "target": null } ], "local_refs": [] }