{ "__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.10.0-notes", "arbitrary": [ { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "This release supports Python 2.6 - 2.7 and 3.2 - 3.5." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "NumPy 1.10.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": "numpy.distutils now supports parallel compilation via the --parallel/-j argument passed to setup.py build" } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "numpy.distutils now supports additional customization via site.cfg to control compilation parameters, i.e. runtime libraries, extra linking/compilation flags." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Addition of " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.linalg.multi_dot" } ] }, { "__type": "Text", "__tag": 4046, "value": ": compute the dot product of two or more arrays in a single function call, while automatically selecting the fastest evaluation order." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The new function " }, { "__type": "InlineRole", "__tag": 4003, "value": "np.stack", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " provides a general interface for joining a sequence of arrays along a new axis, complementing " }, { "__type": "InlineRole", "__tag": 4003, "value": "np.concatenate", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " for joining along an existing axis." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Addition of " }, { "__type": "InlineRole", "__tag": 4003, "value": "nanprod", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " to the set of nanfunctions." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Support for the '@' operator in Python 3.5." } ] } ] } ] } ], "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": "The _dotblas module has been removed. CBLAS Support is now in Multiarray." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The testcalcs.py file has been removed." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The polytemplate.py file has been removed." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "npy_PyFile_Dup and npy_PyFile_DupClose have been removed from npy_3kcompat.h." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "splitcmdline has been removed from numpy/distutils/exec_command.py." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "try_run and get_output have been removed from numpy/distutils/command/config.py" } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The a._format attribute is no longer supported for array printing." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Keywords " }, { "__type": "InlineCode", "__tag": 4051, "value": "skiprows" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "missing" }, { "__type": "Text", "__tag": 4046, "value": " removed from np.genfromtxt." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Keyword " }, { "__type": "InlineCode", "__tag": 4051, "value": "old_behavior" }, { "__type": "Text", "__tag": 4046, "value": " removed from np.correlate." } ] } ] } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Dropped Support" } ], "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": "In array comparisons like " }, { "__type": "InlineCode", "__tag": 4051, "value": "arr1 == arr2" }, { "__type": "Text", "__tag": 4046, "value": ", many corner cases involving strings or structured dtypes that used to return scalars now issue " }, { "__type": "InlineCode", "__tag": 4051, "value": "FutureWarning" }, { "__type": "Text", "__tag": 4046, "value": " or " }, { "__type": "InlineCode", "__tag": 4051, "value": "DeprecationWarning" }, { "__type": "Text", "__tag": 4046, "value": ", and in the future will be change to either perform elementwise comparisons or raise an error." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "In " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.lib.split" }, { "__type": "Text", "__tag": 4046, "value": " an empty array in the result always had dimension " }, { "__type": "InlineCode", "__tag": 4051, "value": "(0,)" }, { "__type": "Text", "__tag": 4046, "value": " no matter the dimensions of the array being split. In Numpy 1.11 that behavior will be changed so that the dimensions will be preserved. A " }, { "__type": "InlineCode", "__tag": 4051, "value": "FutureWarning" }, { "__type": "Text", "__tag": 4046, "value": " for this change has been in place since Numpy 1.9 but, due to a bug, sometimes no warning was raised and the dimensions were already preserved." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The SafeEval class will be removed in Numpy 1.11." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The alterdot and restoredot functions will be removed in Numpy 1.11." } ] } ] } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "See below for more details on these changes." } ] } ], "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": "Default casting for inplace operations has changed to " }, { "__type": "InlineCode", "__tag": 4051, "value": "'same_kind'" }, { "__type": "Text", "__tag": 4046, "value": ". For instance, if n is an array of integers, and f is an array of floats, then " }, { "__type": "InlineCode", "__tag": 4051, "value": "n += f" }, { "__type": "Text", "__tag": 4046, "value": " will result in a " }, { "__type": "InlineCode", "__tag": 4051, "value": "TypeError" }, { "__type": "Text", "__tag": 4046, "value": ", whereas in previous Numpy versions the floats would be silently cast to ints. In the unlikely case that the example code is not an actual bug, it can be updated in a backward compatible way by rewriting it as " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.add(n, f, out=n, casting='unsafe')" }, { "__type": "Text", "__tag": 4046, "value": ". The old " }, { "__type": "InlineCode", "__tag": 4051, "value": "'unsafe'" }, { "__type": "Text", "__tag": 4046, "value": " default has been deprecated since Numpy 1.7." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Default casting rule change" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The numpy version string for development builds has been changed from " }, { "__type": "InlineCode", "__tag": 4051, "value": "x.y.z.dev-githash" }, { "__type": "Text", "__tag": 4046, "value": " to " }, { "__type": "InlineCode", "__tag": 4051, "value": "x.y.z.dev0+githash" }, { "__type": "Text", "__tag": 4046, "value": " (note the +) in order to comply with PEP 440." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "numpy version string" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "NPY_RELAXED_STRIDE_CHECKING is now true by default." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "UPDATE: In 1.10.2 the default value of NPY_RELAXED_STRIDE_CHECKING was changed to false for back compatibility reasons. More time is needed before it can be made the default. As part of the roadmap a deprecation of dimension changing views of f_contiguous not c_contiguous arrays was also added." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "relaxed stride checking" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Using axis != 0 has raised a DeprecationWarning since NumPy 1.7, it now raises an error." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Concatenation of 1d arrays along any but " }, { "__type": "InlineCode", "__tag": 4051, "value": "axis=0" }, { "__type": "Text", "__tag": 4046, "value": " raises " }, { "__type": "InlineCode", "__tag": 4051, "value": "IndexError" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "There was inconsistent behavior between " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "x.ravel()" } ] }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.ravel(x)" } ] }, { "__type": "Text", "__tag": 4046, "value": ", as well as between " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "x.diagonal()" } ] }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.diagonal(x)" } ] }, { "__type": "Text", "__tag": 4046, "value": ", with the methods preserving subtypes while the functions did not. This has been fixed and the functions now behave like the methods, preserving subtypes except in the case of matrices. Matrices are special cased for backward compatibility and still return 1-D arrays as before. If you need to preserve the matrix subtype, use the methods instead of the functions." } ] } ], "title": [ { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.ravel" } ] }, { "__type": "Text", "__tag": 4046, "value": ", " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.diagonal" } ] }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.diag" } ] }, { "__type": "Text", "__tag": 4046, "value": " now preserve subtypes" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Previously, a view was returned except when no change was made in the order of the axes, in which case the input array was returned. A view is now returned in all cases." } ] } ], "title": [ { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "rollaxis" } ] }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "swapaxes" } ] }, { "__type": "Text", "__tag": 4046, "value": " always return a view" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Previously, an inconsistency existed between 1-D inputs (returning a base ndarray) and higher dimensional ones (which preserved subclasses). Behavior has been unified, and the return will now be a base ndarray. Subclasses can still override this behavior by providing their own " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "nonzero" } ] }, { "__type": "Text", "__tag": 4046, "value": " method." } ] } ], "title": [ { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "nonzero" } ] }, { "__type": "Text", "__tag": 4046, "value": " now returns base ndarrays" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The changes to " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "swapaxes" } ] }, { "__type": "Text", "__tag": 4046, "value": " also apply to the " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "PyArray_SwapAxes" } ] }, { "__type": "Text", "__tag": 4046, "value": " C function, which now returns a view in all cases." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The changes to " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "nonzero" } ] }, { "__type": "Text", "__tag": 4046, "value": " also apply to the " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "PyArray_Nonzero" } ] }, { "__type": "Text", "__tag": 4046, "value": " C function, which now returns a base ndarray in all cases." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The dtype structure (PyArray_Descr) has a new member at the end to cache its hash value. This shouldn't affect any well-written applications." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The change to the concatenation function DeprecationWarning also affects PyArray_ConcatenateArrays," } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "C API" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Previously the returned types for recarray fields accessed by attribute and by index were inconsistent, and fields of string type were returned as chararrays. Now, fields accessed by either attribute or indexing will return an ndarray for fields of non-structured type, and a recarray for fields of structured type. Notably, this affect recarrays containing strings with whitespace, as trailing whitespace is trimmed from chararrays but kept in ndarrays of string type. Also, the dtype.type of nested structured fields is now inherited." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "recarray field return types" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Viewing an ndarray as a recarray now automatically converts the dtype to np.record. See new record array documentation. Additionally, viewing a recarray with a non-structured dtype no longer converts the result's type to ndarray - the result will remain a recarray." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "recarray views" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "When using the 'out' keyword argument of a ufunc, a tuple of arrays, one per ufunc output, can be provided. For ufuncs with a single output a single array is also a valid 'out' keyword argument. Previously a single array could be provided in the 'out' keyword argument, and it would be used as the first output for ufuncs with multiple outputs, is deprecated, and will result in a " }, { "__type": "InlineRole", "__tag": 4003, "value": "DeprecationWarning", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " now and an error in the future." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "'out' keyword argument of ufuncs now accepts tuples of arrays" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Indexing an ndarray using a byte-string in Python 3 now raises an IndexError instead of a ValueError." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "byte-array indices now raises an IndexError" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "For such (rare) masked arrays, getting a single masked item no longer returns a corrupted masked array, but a fully masked version of the item." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Masked arrays containing objects with arrays" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Similar to mean, median and percentile now emits a Runtime warning and returns " }, { "__type": "InlineRole", "__tag": 4003, "value": "NaN", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " in slices where a " }, { "__type": "InlineRole", "__tag": 4003, "value": "NaN", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " is present. To compute the median or percentile while ignoring invalid values use the new " }, { "__type": "InlineRole", "__tag": 4003, "value": "nanmedian", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " or " }, { "__type": "InlineRole", "__tag": 4003, "value": "nanpercentile", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " functions." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Median warns and returns nan when invalid values are encountered" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "All functions from numpy.testing were once available from numpy.ma.testutils but not all of them were redefined to work with masked arrays. Most of those functions have now been removed from numpy.ma.testutils with a small subset retained in order to preserve backward compatibility. In the long run this should help avoid mistaken use of the wrong functions, but it may cause import problems for some." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Functions available from numpy.ma.testutils have changed" } ], "level": 2, "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": "Previously customization of compilation of dependency libraries and numpy itself was only accomplishable via code changes in the distutils package. Now numpy.distutils reads in the following extra flags from each group of the " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "site.cfg" } ] }, { "__type": "Text", "__tag": 4046, "value": ":" } ] }, { "__type": "BulletList", "__tag": 4053, "ordered": false, "start": 1, "children": [ { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "DefList", "__tag": 4033, "children": [ { "__type": "DefListItem", "__tag": 4037, "dt": { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "runtime_library_dirs/rpath" }, { "__type": "Text", "__tag": 4046, "value": ", sets runtime library directories to override" } ] }, "dd": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "LD_LIBRARY_PATH" } ] } ] } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "extra_compile_args" }, { "__type": "Text", "__tag": 4046, "value": ", add extra flags to the compilation of sources" } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "extra_link_args" }, { "__type": "Text", "__tag": 4046, "value": ", add extra flags when linking libraries" } ] } ] } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "This should, at least partially, complete user customization." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Reading extra flags from site.cfg" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.cbrt" } ] }, { "__type": "Text", "__tag": 4046, "value": " wraps the C99 cube root function " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "cbrt" } ] }, { "__type": "Text", "__tag": 4046, "value": ". Compared to " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.power(x, 1./3.)" } ] }, { "__type": "Text", "__tag": 4046, "value": " it is well defined for negative real floats and a bit faster." } ] } ], "title": [ { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.cbrt" } ] }, { "__type": "Text", "__tag": 4046, "value": " to compute cube root for real floats" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "By passing " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "--parallel=n" } ] }, { "__type": "Text", "__tag": 4046, "value": " or " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "-j n" } ] }, { "__type": "Text", "__tag": 4046, "value": " to " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "setup.py build" } ] }, { "__type": "Text", "__tag": 4046, "value": " the compilation of extensions is now performed in " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "n" } ] }, { "__type": "Text", "__tag": 4046, "value": " parallel processes. The parallelization is limited to files within one extension so projects using Cython will not profit because it builds extensions from single files." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "numpy.distutils now allows parallel compilation" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "A " }, { "__type": "InlineCode", "__tag": 4051, "value": "max_rows" }, { "__type": "Text", "__tag": 4046, "value": " argument has been added to " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "genfromtxt" } ] }, { "__type": "Text", "__tag": 4046, "value": " to limit the number of rows read in a single call. Using this functionality, it is possible to read in multiple arrays stored in a single file by making repeated calls to the function." } ] } ], "title": [ { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "genfromtxt" } ] }, { "__type": "Text", "__tag": 4046, "value": " has a new " }, { "__type": "InlineCode", "__tag": 4051, "value": "max_rows" }, { "__type": "Text", "__tag": 4046, "value": " argument" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.broadcast_to" } ] }, { "__type": "Text", "__tag": 4046, "value": " manually broadcasts an array to a given shape according to numpy's broadcasting rules. The functionality is similar to broadcast_arrays, which in fact has been rewritten to use broadcast_to internally, but only a single array is necessary." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "New function " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.broadcast_to" } ] }, { "__type": "Text", "__tag": 4046, "value": " for invoking array broadcasting" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "When Python emits a warning, it records that this warning has been emitted in the module that caused the warning, in a module attribute " }, { "__type": "InlineCode", "__tag": 4051, "value": "__warningregistry__" }, { "__type": "Text", "__tag": 4046, "value": ". Once this has happened, it is not possible to emit the warning again, unless you clear the relevant entry in " }, { "__type": "InlineCode", "__tag": 4051, "value": "__warningregistry__" }, { "__type": "Text", "__tag": 4046, "value": ". This makes is hard and fragile to test warnings, because if your test comes after another that has already caused the warning, you will not be able to emit the warning or test it. The context manager " }, { "__type": "InlineCode", "__tag": 4051, "value": "clear_and_catch_warnings" }, { "__type": "Text", "__tag": 4046, "value": " clears warnings from the module registry on entry and resets them on exit, meaning that warnings can be re-raised." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "New context manager " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "clear_and_catch_warnings" } ] }, { "__type": "Text", "__tag": 4046, "value": " for testing warnings" } ], "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": "fweights" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "aweights" }, { "__type": "Text", "__tag": 4046, "value": " arguments add new functionality to covariance calculations by applying two types of weighting to observation vectors. An array of " }, { "__type": "InlineCode", "__tag": 4051, "value": "fweights" }, { "__type": "Text", "__tag": 4046, "value": " indicates the number of repeats of each observation vector, and an array of " }, { "__type": "InlineCode", "__tag": 4051, "value": "aweights" }, { "__type": "Text", "__tag": 4046, "value": " provides their relative importance or probability." } ] } ], "title": [ { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "cov" } ] }, { "__type": "Text", "__tag": 4046, "value": " has new " }, { "__type": "InlineCode", "__tag": 4051, "value": "fweights" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "aweights" }, { "__type": "Text", "__tag": 4046, "value": " arguments" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Python 3.5 adds support for a matrix multiplication operator '@' proposed in PEP465. Preliminary support for that has been implemented, and an equivalent function " }, { "__type": "InlineCode", "__tag": 4051, "value": "matmul" }, { "__type": "Text", "__tag": 4046, "value": " has also been added for testing purposes and use in earlier Python versions. The function is preliminary and the order and number of its optional arguments can be expected to change." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Support for the '@' operator in Python 3.5+" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The default normalization has the direct transforms unscaled and the inverse transforms are scaled by " }, { "__type": "InlineMath", "__tag": 4057, "value": "1/n" }, { "__type": "Text", "__tag": 4046, "value": ". It is possible to obtain unitary transforms by setting the keyword argument " }, { "__type": "InlineCode", "__tag": 4051, "value": "norm" }, { "__type": "Text", "__tag": 4046, "value": " to " }, { "__type": "InlineCode", "__tag": 4051, "value": "\"ortho\"" }, { "__type": "Text", "__tag": 4046, "value": " (default is " }, { "__type": "InlineRole", "__tag": 4003, "value": "None", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": ") so that both direct and inverse transforms will be scaled by " }, { "__type": "InlineMath", "__tag": 4057, "value": "1/\\\\sqrt{n}" }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "New argument " }, { "__type": "InlineCode", "__tag": 4051, "value": "norm" }, { "__type": "Text", "__tag": 4046, "value": " to fft functions" } ], "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": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.digitize" } ] }, { "__type": "Text", "__tag": 4046, "value": " is now implemented in terms of " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.searchsorted" } ] }, { "__type": "Text", "__tag": 4046, "value": ". This means that a binary search is used to bin the values, which scales much better for larger number of bins than the previous linear search. It also removes the requirement for the input array to be 1-dimensional." } ] } ], "title": [ { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.digitize" } ] }, { "__type": "Text", "__tag": 4046, "value": " using binary search" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.poly" } ] }, { "__type": "Text", "__tag": 4046, "value": " will now cast 1-dimensional input arrays of integer type to double precision floating point, to prevent integer overflow when computing the monic polynomial. It is still possible to obtain higher precision results by passing in an array of object type, filled e.g. with Python ints." } ] } ], "title": [ { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.poly" } ] }, { "__type": "Text", "__tag": 4046, "value": " now casts integer inputs to float" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.interp" } ] }, { "__type": "Text", "__tag": 4046, "value": " now has a new parameter " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "period" } ] }, { "__type": "Text", "__tag": 4046, "value": " that supplies the period of the input data " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "xp" } ] }, { "__type": "Text", "__tag": 4046, "value": ". In such case, the input data is properly normalized to the given period and one end point is added to each extremity of " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "xp" } ] }, { "__type": "Text", "__tag": 4046, "value": " in order to close the previous and the next period cycles, resulting in the correct interpolation behavior." } ] } ], "title": [ { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.interp" } ] }, { "__type": "Text", "__tag": 4046, "value": " can now be used with periodic functions" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "constant_values" }, { "__type": "Text", "__tag": 4046, "value": " parameters now accepts NumPy arrays and float values. NumPy arrays are supported as input for " }, { "__type": "InlineCode", "__tag": 4051, "value": "pad_width" }, { "__type": "Text", "__tag": 4046, "value": ", and an exception is raised if its values are not of integral type." } ] } ], "title": [ { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.pad" } ] }, { "__type": "Text", "__tag": 4046, "value": " supports more input types for " }, { "__type": "InlineCode", "__tag": 4051, "value": "pad_width" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "constant_values" } ], "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": " parameter was added to " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.argmax" } ] }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.argmin" } ] }, { "__type": "Text", "__tag": 4046, "value": " for consistency with " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "ndarray.argmax" } ] }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "ndarray.argmin" } ] }, { "__type": "Text", "__tag": 4046, "value": ". The new parameter behaves exactly as it does in those methods." } ] } ], "title": [ { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.argmax" } ] }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.argmin" } ] }, { "__type": "Text", "__tag": 4046, "value": " now support an " }, { "__type": "InlineCode", "__tag": 4051, "value": "out" }, { "__type": "Text", "__tag": 4046, "value": " argument" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "All of the functions " }, { "__type": "InlineCode", "__tag": 4051, "value": "in complex.h" }, { "__type": "Text", "__tag": 4046, "value": " are now detected. There are new fallback implementations of the following functions." } ] }, { "__type": "BulletList", "__tag": 4053, "ordered": false, "start": 1, "children": [ { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "npy_ctan," } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "npy_cacos, npy_casin, npy_catan" } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "npy_ccosh, npy_csinh, npy_ctanh," } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "npy_cacosh, npy_casinh, npy_catanh" } ] } ] } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "As a result of these improvements, there will be some small changes in returned values, especially for corner cases." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "More system C99 complex functions detected and used" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The strings produced by " }, { "__type": "InlineCode", "__tag": 4051, "value": "float.hex" }, { "__type": "Text", "__tag": 4046, "value": " look like " }, { "__type": "InlineCode", "__tag": 4051, "value": "0x1.921fb54442d18p+1" }, { "__type": "Text", "__tag": 4046, "value": ", so this is not the hex used to represent unsigned integer types." } ] } ], "title": [ { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.loadtxt" } ] }, { "__type": "Text", "__tag": 4046, "value": " support for the strings produced by the " }, { "__type": "InlineCode", "__tag": 4051, "value": "float.hex" }, { "__type": "Text", "__tag": 4046, "value": " method" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "In order to properly handle minimal values of integer types, " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.isclose" } ] }, { "__type": "Text", "__tag": 4046, "value": " will now cast to the float dtype during comparisons. This aligns its behavior with what was provided by " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.allclose" } ] }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ], "title": [ { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.isclose" } ] }, { "__type": "Text", "__tag": 4046, "value": " properly handles minimal values of integer dtypes" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.allclose" } ] }, { "__type": "Text", "__tag": 4046, "value": " now uses " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.isclose" } ] }, { "__type": "Text", "__tag": 4046, "value": " internally and inherits the ability to compare NaNs as equal by setting " }, { "__type": "InlineCode", "__tag": 4051, "value": "equal_nan=True" }, { "__type": "Text", "__tag": 4046, "value": ". Subclasses, such as " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.ma.MaskedArray" } ] }, { "__type": "Text", "__tag": 4046, "value": ", are also preserved now." } ] } ], "title": [ { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.allclose" } ] }, { "__type": "Text", "__tag": 4046, "value": " uses " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.isclose" } ] }, { "__type": "Text", "__tag": 4046, "value": " internally." } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.genfromtxt" } ] }, { "__type": "Text", "__tag": 4046, "value": " now correctly handles integers larger than " }, { "__type": "InlineCode", "__tag": 4051, "value": "2**31-1" }, { "__type": "Text", "__tag": 4046, "value": " on 32-bit systems and larger than " }, { "__type": "InlineCode", "__tag": 4051, "value": "2**63-1" }, { "__type": "Text", "__tag": 4046, "value": " on 64-bit systems (it previously crashed with an " }, { "__type": "InlineCode", "__tag": 4051, "value": "OverflowError" }, { "__type": "Text", "__tag": 4046, "value": " in these cases). Integers larger than " }, { "__type": "InlineCode", "__tag": 4051, "value": "2**63-1" }, { "__type": "Text", "__tag": 4046, "value": " are converted to floating-point values." } ] } ], "title": [ { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.genfromtxt" } ] }, { "__type": "Text", "__tag": 4046, "value": " now handles large integers correctly" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The functions " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.load" } ] }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.save" } ] }, { "__type": "Text", "__tag": 4046, "value": " have additional keyword arguments for controlling backward compatibility of pickled Python objects. This enables Numpy on Python 3 to load npy files containing object arrays that were generated on Python 2." } ] } ], "title": [ { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.load" } ] }, { "__type": "Text", "__tag": 4046, "value": ", " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.save" } ] }, { "__type": "Text", "__tag": 4046, "value": " have pickle backward compatibility flags" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Built-in assumptions that the baseclass behaved like a plain array are being removed. In particular, setting and getting elements and ranges will respect baseclass overrides of " }, { "__type": "InlineCode", "__tag": 4051, "value": "__setitem__" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "__getitem__" }, { "__type": "Text", "__tag": 4046, "value": ", and arithmetic will respect overrides of " }, { "__type": "InlineCode", "__tag": 4051, "value": "__add__" }, { "__type": "Text", "__tag": 4046, "value": ", " }, { "__type": "InlineCode", "__tag": 4051, "value": "__sub__" }, { "__type": "Text", "__tag": 4046, "value": ", etc." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "MaskedArray support for more complicated base classes" } ], "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": "The cblas versions of dot, inner, and vdot have been integrated into the multiarray module. In particular, vdot is now a multiarray function, which it was not before." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "dotblas functionality moved to multiarray" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Inputs to generalized universal functions are now more strictly checked against the function's signature: all core dimensions are now required to be present in input arrays; core dimensions with the same label must have the exact same size; and output core dimension's must be specified, either by a same label input core dimension or by a passed-in output array." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "stricter check of gufunc signature compliance" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Views returned by " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.einsum" } ] }, { "__type": "Text", "__tag": 4046, "value": " will now be writeable whenever the input array is writeable." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "views returned from " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.einsum" } ] }, { "__type": "Text", "__tag": 4046, "value": " are writeable" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.argmin" } ] }, { "__type": "Text", "__tag": 4046, "value": " now skips NaT values in datetime64 and timedelta64 arrays, making it consistent with " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.min" } ] }, { "__type": "Text", "__tag": 4046, "value": ", " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.argmax" } ] }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.max" } ] }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ], "title": [ { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "np.argmin" } ] }, { "__type": "Text", "__tag": 4046, "value": " skips NaT values" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [], "title": [ { "__type": "Text", "__tag": 4046, "value": "Deprecations" } ], "level": 1, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Normally, comparison operations on arrays perform elementwise comparisons and return arrays of booleans. But in some corner cases, especially involving strings are structured dtypes, NumPy has historically returned a scalar instead. For example " } ] }, { "__type": "Code", "__tag": 4050, "value": "### Current behaviour\n\nnp.arange(2) == \"foo\"\n# -> False\n\nnp.arange(2) < \"foo\"\n# -> True on Python 2, error on Python 3\n\nnp.ones(2, dtype=\"i4,i4\") == np.ones(2, dtype=\"i4,i4,i4\")\n# -> False", "execution_status": null }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Continuing work started in 1.9, in 1.10 these comparisons will now raise " }, { "__type": "InlineCode", "__tag": 4051, "value": "FutureWarning" }, { "__type": "Text", "__tag": 4046, "value": " or " }, { "__type": "InlineCode", "__tag": 4051, "value": "DeprecationWarning" }, { "__type": "Text", "__tag": 4046, "value": ", and in the future they will be modified to behave more consistently with other comparison operations, e.g. " } ] }, { "__type": "Code", "__tag": 4050, "value": "### Future behaviour\n\nnp.arange(2) == \"foo\"\n# -> array([False, False])\n\nnp.arange(2) < \"foo\"\n# -> error, strings and numbers are not orderable\n\nnp.ones(2, dtype=\"i4,i4\") == np.ones(2, dtype=\"i4,i4,i4\")\n# -> [False, False]", "execution_status": null } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Array comparisons involving strings or structured dtypes" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The SafeEval class in numpy/lib/utils.py is deprecated and will be removed in the next release." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "SafeEval" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The alterdot and restoredot functions no longer do anything, and are deprecated." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "alterdot, restoredot" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "These ways of loading packages are now deprecated." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "pkgload, PackageLoader" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The values for the " }, { "__type": "InlineCode", "__tag": 4051, "value": "bias" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "ddof" }, { "__type": "Text", "__tag": 4046, "value": " arguments to the " }, { "__type": "InlineCode", "__tag": 4051, "value": "corrcoef" }, { "__type": "Text", "__tag": 4046, "value": " function canceled in the division implied by the correlation coefficient and so had no effect on the returned values." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "We now deprecate these arguments to " }, { "__type": "InlineCode", "__tag": 4051, "value": "corrcoef" }, { "__type": "Text", "__tag": 4046, "value": " and the masked array version " }, { "__type": "InlineCode", "__tag": 4051, "value": "ma.corrcoef" }, { "__type": "Text", "__tag": 4046, "value": "." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Because we are deprecating the " }, { "__type": "InlineCode", "__tag": 4051, "value": "bias" }, { "__type": "Text", "__tag": 4046, "value": " argument to " }, { "__type": "InlineCode", "__tag": 4051, "value": "ma.corrcoef" }, { "__type": "Text", "__tag": 4046, "value": ", we also deprecate the use of the " }, { "__type": "InlineCode", "__tag": 4051, "value": "allow_masked" }, { "__type": "Text", "__tag": 4046, "value": " argument as a positional argument, as its position will change with the removal of " }, { "__type": "InlineCode", "__tag": 4051, "value": "bias" }, { "__type": "Text", "__tag": 4046, "value": ". " }, { "__type": "InlineCode", "__tag": 4051, "value": "allow_masked" }, { "__type": "Text", "__tag": 4046, "value": " will in due course become a keyword-only argument." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "bias, ddof arguments to corrcoef" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Since 1.6, creating a dtype object from its string representation, e.g. " }, { "__type": "InlineCode", "__tag": 4051, "value": "'f4'" }, { "__type": "Text", "__tag": 4046, "value": ", would issue a deprecation warning if the size did not correspond to an existing type, and default to creating a dtype of the default size for the type. Starting with this release, this will now raise a " }, { "__type": "InlineCode", "__tag": 4051, "value": "TypeError" }, { "__type": "Text", "__tag": 4046, "value": "." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The only exception is object dtypes, where both " }, { "__type": "InlineCode", "__tag": 4051, "value": "'O4'" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "'O8'" }, { "__type": "Text", "__tag": 4046, "value": " will still issue a deprecation warning. This platform-dependent representation will raise an error in the next release." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "In preparation for this upcoming change, the string representation of an object dtype, i.e. " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.dtype(object).str" }, { "__type": "Text", "__tag": 4046, "value": ", no longer includes the item size, i.e. will return " }, { "__type": "InlineCode", "__tag": 4051, "value": "'|O'" }, { "__type": "Text", "__tag": 4046, "value": " instead of " }, { "__type": "InlineCode", "__tag": 4051, "value": "'|O4'" }, { "__type": "Text", "__tag": 4046, "value": " or " }, { "__type": "InlineCode", "__tag": 4051, "value": "'|O8'" }, { "__type": "Text", "__tag": 4046, "value": " as before." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "dtype string representation changes" } ], "level": 2, "target": null } ], "local_refs": [] }