{ "__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.9.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.4." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "NumPy 1.9.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": "Numerous performance improvements in various areas, most notably indexing and operations on small arrays are significantly faster. Indexing operations now also release the GIL." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Addition of " }, { "__type": "InlineRole", "__tag": 4003, "value": "nanmedian", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineRole", "__tag": 4003, "value": "nanpercentile", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " rounds out the nanfunction set." } ] } ] } ] } ], "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 oldnumeric and numarray modules have been removed." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The doc/pyrex and doc/cython directories have been removed." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The doc/numpybook directory has been removed." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The numpy/testing/numpytest.py file has been removed together with the importall function it contained." } ] } ] } ] } ], "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": "The numpy/polynomial/polytemplate.py file will be removed in NumPy 1.10.0." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Default casting for inplace operations will change to 'same_kind' in Numpy 1.10.0. This will certainly break some code that is currently ignoring the warning." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Relaxed stride checking will be the default in 1.10.0" } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "String version checks will break because, e.g., '1.9' > '1.10' is True. A NumpyVersion class has been added that can be used for such comparisons." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The diagonal and diag functions will return writeable views in 1.10.0" } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The " }, { "__type": "InlineRole", "__tag": 4003, "value": "S", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " and/or " }, { "__type": "InlineRole", "__tag": 4003, "value": "a", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " dtypes may be changed to represent Python strings instead of bytes, in Python 3 these two types are very different." } ] } ] } ] } ], "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": "In NumPy 1.8, the diagonal and diag functions returned readonly copies, in NumPy 1.9 they return readonly views, and in 1.10 they will return writeable views." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "The diagonal and diag functions return readonly views." } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "In previous numpy versions operations involving floating point scalars containing special values " }, { "__type": "InlineCode", "__tag": 4051, "value": "NaN" }, { "__type": "Text", "__tag": 4046, "value": ", " }, { "__type": "InlineCode", "__tag": 4051, "value": "Inf" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "-Inf" }, { "__type": "Text", "__tag": 4046, "value": " caused the result type to be at least " }, { "__type": "InlineCode", "__tag": 4051, "value": "float64" }, { "__type": "Text", "__tag": 4046, "value": ". As the special values can be represented in the smallest available floating point type, the upcast is not performed anymore." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "For example the dtype of:" } ] }, { "__type": "Blockquote", "__tag": 4059, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "np.array([1.], dtype=np.float32) * float('nan')" } ] } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "now remains " }, { "__type": "InlineCode", "__tag": 4051, "value": "float32" }, { "__type": "Text", "__tag": 4046, "value": " instead of being cast to " }, { "__type": "InlineCode", "__tag": 4051, "value": "float64" }, { "__type": "Text", "__tag": 4046, "value": ". Operations involving non-special values have not been changed." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Special scalar float values don't cause upcast to double anymore" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "If given more than one percentile to compute numpy.percentile returns an array instead of a list. A single percentile still returns a scalar. The array is equivalent to converting the list returned in older versions to an array via " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.array" }, { "__type": "Text", "__tag": 4046, "value": "." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "If the " }, { "__type": "InlineCode", "__tag": 4051, "value": "overwrite_input" }, { "__type": "Text", "__tag": 4046, "value": " option is used the input is only partially instead of fully sorted." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Percentile output changes" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "All " }, { "__type": "InlineCode", "__tag": 4051, "value": "tofile" }, { "__type": "Text", "__tag": 4046, "value": " exceptions are now " }, { "__type": "InlineCode", "__tag": 4051, "value": "IOError" }, { "__type": "Text", "__tag": 4046, "value": ", some were previously " }, { "__type": "InlineCode", "__tag": 4051, "value": "ValueError" }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "ndarray.tofile exception type" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Two changes to numpy.ma.core._check_fill_value:" } ] }, { "__type": "BulletList", "__tag": 4053, "ordered": false, "start": 1, "children": [ { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "When the fill value is a string and the array type is not one of 'OSUV', TypeError is raised instead of the default fill value being used." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "When the fill value overflows the array type, TypeError is raised instead of OverflowError." } ] } ] } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Invalid fill value exceptions" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "This may cause problems with folks who depended on the polynomial classes being derived from PolyBase. They are now all derived from the abstract base class ABCPolyBase. Strictly speaking, there should be a deprecation involved, but no external code making use of the old baseclass could be found." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Polynomial Classes no longer derived from PolyBase" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "A bug in one of the algorithms to generate a binomial random variate has been fixed. This change will likely alter the number of random draws performed, and hence the sequence location will be different after a call to distribution.crk_binomial_btpe. Any tests which rely on the RNG being in a known state should be checked and/or updated as a result." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Using numpy.random.binomial may change the RNG state vs. numpy < 1.9" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "np.random.seed" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.random.RandomState" }, { "__type": "Text", "__tag": 4046, "value": " now throw a " }, { "__type": "InlineCode", "__tag": 4051, "value": "ValueError" }, { "__type": "Text", "__tag": 4046, "value": " if the seed cannot safely be converted to 32 bit unsigned integers. Applications that now fail can be fixed by masking the higher 32 bit values to zero: " }, { "__type": "InlineCode", "__tag": 4051, "value": "seed = seed & 0xFFFFFFFF" }, { "__type": "Text", "__tag": 4046, "value": ". This is what is done silently in older versions so the random stream remains the same." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Random seed enforced to be a 32 bit unsigned integer" } ], "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 " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.argmin" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.argmax" }, { "__type": "Text", "__tag": 4046, "value": " and their equivalent C-API functions is now checked to match the desired output shape exactly. If the check fails a " }, { "__type": "InlineCode", "__tag": 4051, "value": "ValueError" }, { "__type": "Text", "__tag": 4046, "value": " instead of " }, { "__type": "InlineCode", "__tag": 4051, "value": "TypeError" }, { "__type": "Text", "__tag": 4046, "value": " is raised." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Argmin and argmax out argument" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Remove unnecessary broadcasting notation restrictions. " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.einsum('ijk,j->ijk', A, B)" }, { "__type": "Text", "__tag": 4046, "value": " can also be written as " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.einsum('ij...,j->ij...', A, B)" }, { "__type": "Text", "__tag": 4046, "value": " (ellipsis is no longer required on 'j')" } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Einsum" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The NumPy indexing has seen a complete rewrite in this version. This makes most advanced integer indexing operations much faster and should have no other implications. However some subtle changes and deprecations were introduced in advanced indexing operations:" } ] }, { "__type": "BulletList", "__tag": 4053, "ordered": false, "start": 1, "children": [ { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Boolean indexing into scalar arrays will always return a new 1-d array. This means that " }, { "__type": "InlineCode", "__tag": 4051, "value": "array(1)[array(True)]" }, { "__type": "Text", "__tag": 4046, "value": " gives " }, { "__type": "InlineCode", "__tag": 4051, "value": "array([1])" }, { "__type": "Text", "__tag": 4046, "value": " and not the original array." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Advanced indexing into one dimensional arrays used to have (undocumented) special handling regarding repeating the value array in assignments when the shape of the value array was too small or did not match. Code using this will raise an error. For compatibility you can use " }, { "__type": "InlineCode", "__tag": 4051, "value": "arr.flat[index] = values" }, { "__type": "Text", "__tag": 4046, "value": ", which uses the old code branch. (for example " }, { "__type": "InlineCode", "__tag": 4051, "value": "a = np.ones(10); a[np.arange(10)] = [1, 2, 3]" }, { "__type": "Text", "__tag": 4046, "value": ")" } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The iteration order over advanced indexes used to be always C-order. In NumPy 1.9. the iteration order adapts to the inputs and is not guaranteed (with the exception of a " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "single" } ] }, { "__type": "Text", "__tag": 4046, "value": " advanced index which is never reversed for compatibility reasons). This means that the result is undefined if multiple values are assigned to the same element. An example for this is " }, { "__type": "InlineCode", "__tag": 4051, "value": "arr[[0, 0], [1, 1]] = [1, 2]" }, { "__type": "Text", "__tag": 4046, "value": ", which may set " }, { "__type": "InlineCode", "__tag": 4051, "value": "arr[0, 1]" }, { "__type": "Text", "__tag": 4046, "value": " to either 1 or 2." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Equivalent to the iteration order, the memory layout of the advanced indexing result is adapted for faster indexing and cannot be predicted." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "All indexing operations return a view or a copy. No indexing operation will return the original array object. (For example " }, { "__type": "InlineCode", "__tag": 4051, "value": "arr[...]" }, { "__type": "Text", "__tag": 4046, "value": ")" } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "In the future Boolean array-likes (such as lists of python bools) will always be treated as Boolean indexes and Boolean scalars (including python " }, { "__type": "InlineCode", "__tag": 4051, "value": "True" }, { "__type": "Text", "__tag": 4046, "value": ") will be a legal " }, { "__type": "Emphasis", "__tag": 4047, "children": [ { "__type": "Text", "__tag": 4046, "value": "boolean" } ] }, { "__type": "Text", "__tag": 4046, "value": " index. At this time, this is already the case for scalar arrays to allow the general " }, { "__type": "InlineCode", "__tag": 4051, "value": "positive = a[a > 0]" }, { "__type": "Text", "__tag": 4046, "value": " to work when " }, { "__type": "InlineCode", "__tag": 4051, "value": "a" }, { "__type": "Text", "__tag": 4046, "value": " is zero dimensional." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "In NumPy 1.8 it was possible to use " }, { "__type": "InlineCode", "__tag": 4051, "value": "array(True)" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "array(False)" }, { "__type": "Text", "__tag": 4046, "value": " equivalent to 1 and 0 if the result of the operation was a scalar. This will raise an error in NumPy 1.9 and, as noted above, treated as a boolean index in the future." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "All non-integer array-likes are deprecated, object arrays of custom integer like objects may have to be cast explicitly." } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The error reporting for advanced indexing is more informative, however the error type has changed in some cases. (Broadcasting errors of indexing arrays are reported as " }, { "__type": "InlineCode", "__tag": 4051, "value": "IndexError" }, { "__type": "Text", "__tag": 4046, "value": ")" } ] } ] }, { "__type": "ListItem", "__tag": 4054, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Indexing with more then one ellipsis (" }, { "__type": "InlineCode", "__tag": 4051, "value": "..." }, { "__type": "Text", "__tag": 4046, "value": ") is deprecated." } ] } ] } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Indexing" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Non-integer axis indexes to reduction ufuncs like " }, { "__type": "InlineRole", "__tag": 4003, "value": "add.reduce", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " or " }, { "__type": "InlineRole", "__tag": 4003, "value": "sum", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " are deprecated." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Non-integer reduction axis indexes are deprecated" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "promote_types" }, { "__type": "Text", "__tag": 4046, "value": " function now returns a valid string length when given an integer or float dtype as one argument and a string dtype as another argument. Previously it always returned the input string dtype, even if it wasn't long enough to store the max integer/float value converted to a string." } ] } ], "title": [ { "__type": "InlineCode", "__tag": 4051, "value": "promote_types" }, { "__type": "Text", "__tag": 4046, "value": " and string dtype" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "can_cast" }, { "__type": "Text", "__tag": 4046, "value": " function now returns False in \"safe\" casting mode for integer/float dtype and string dtype if the string dtype length is not long enough to store the max integer/float value converted to a string. Previously " }, { "__type": "InlineCode", "__tag": 4051, "value": "can_cast" }, { "__type": "Text", "__tag": 4046, "value": " in \"safe\" mode returned True for integer/float dtype and a string dtype of any length." } ] } ], "title": [ { "__type": "InlineCode", "__tag": 4051, "value": "can_cast" }, { "__type": "Text", "__tag": 4046, "value": " and string dtype" } ], "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": "astype" }, { "__type": "Text", "__tag": 4046, "value": " method now returns an error if the string dtype to cast to is not long enough in \"safe\" casting mode to hold the max value of integer/float array that is being casted. Previously the casting was allowed even if the result was truncated." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "astype and string dtype" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineRole", "__tag": 4003, "value": "npyio.recfromcsv", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " no longer accepts the undocumented " }, { "__type": "InlineRole", "__tag": 4003, "value": "update", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " keyword, which used to override the " }, { "__type": "InlineRole", "__tag": 4003, "value": "dtype", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " keyword." } ] } ], "title": [ { "__type": "InlineRole", "__tag": 4003, "value": "npyio.recfromcsv", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " keyword arguments change" } ], "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": "doc/swig" }, { "__type": "Text", "__tag": 4046, "value": " directory has been moved to " }, { "__type": "InlineCode", "__tag": 4051, "value": "tools/swig" }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "The " }, { "__type": "InlineCode", "__tag": 4051, "value": "doc/swig" }, { "__type": "Text", "__tag": 4046, "value": " directory moved" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The unused " }, { "__type": "InlineCode", "__tag": 4051, "value": "simple_capsule_dtor" }, { "__type": "Text", "__tag": 4046, "value": " function has been removed from " }, { "__type": "InlineCode", "__tag": 4051, "value": "npy_3kcompat.h" }, { "__type": "Text", "__tag": 4046, "value": ". Note that this header is not meant to be used outside of numpy; other projects should be using their own copy of this file when needed." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "The " }, { "__type": "InlineCode", "__tag": 4051, "value": "npy_3kcompat.h" }, { "__type": "Text", "__tag": 4046, "value": " header changed" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "When directly accessing the " }, { "__type": "InlineCode", "__tag": 4051, "value": "sq_item" }, { "__type": "Text", "__tag": 4046, "value": " or " }, { "__type": "InlineCode", "__tag": 4051, "value": "sq_ass_item" }, { "__type": "Text", "__tag": 4046, "value": " PyObject slots for item getting, negative indices will not be supported anymore. " }, { "__type": "InlineCode", "__tag": 4051, "value": "PySequence_GetItem" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "PySequence_SetItem" }, { "__type": "Text", "__tag": 4046, "value": " however fix negative indices so that they can be used there." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Negative indices in C-Api " }, { "__type": "InlineCode", "__tag": 4051, "value": "sq_item" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "sq_ass_item" }, { "__type": "Text", "__tag": 4046, "value": " sequence methods" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "When " }, { "__type": "InlineCode", "__tag": 4051, "value": "NpyIter_RemoveAxis" }, { "__type": "Text", "__tag": 4046, "value": " is now called, the iterator range will be reset." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "When a multi index is being tracked and an iterator is not buffered, it is possible to use " }, { "__type": "InlineCode", "__tag": 4051, "value": "NpyIter_RemoveAxis" }, { "__type": "Text", "__tag": 4046, "value": ". In this case an iterator can shrink in size. Because the total size of an iterator is limited, the iterator may be too large before these calls. In this case its size will be set to " }, { "__type": "InlineCode", "__tag": 4051, "value": "-1" }, { "__type": "Text", "__tag": 4046, "value": " and an error issued not at construction time but when removing the multi index, setting the iterator range, or getting the next function." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "This has no effect on currently working code, but highlights the necessity of checking for an error return if these conditions can occur. In most cases the arrays being iterated are as large as the iterator so that such a problem cannot occur." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "This change was already applied to the 1.8.1 release." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "NDIter" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "To match the " }, { "__type": "InlineRole", "__tag": 4003, "value": "zeros", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " function " }, { "__type": "InlineRole", "__tag": 4003, "value": "zeros_like", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " now returns an array initialized with empty strings instead of an array filled with " }, { "__type": "InlineRole", "__tag": 4003, "value": "'0'", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ], "title": [ { "__type": "InlineCode", "__tag": 4051, "value": "zeros_like" }, { "__type": "Text", "__tag": 4046, "value": " for string dtypes now returns empty strings" } ], "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": "InlineCode", "__tag": 4051, "value": "np.percentile" }, { "__type": "Text", "__tag": 4046, "value": " now has the interpolation keyword argument to specify in which way points should be interpolated if the percentiles fall between two values. See the documentation for the available options." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Percentile supports more interpolation options" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "np.median" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.percentile" }, { "__type": "Text", "__tag": 4046, "value": " now support generalized axis arguments like ufunc reductions do since 1.7. One can now say axis=(index, index) to pick a list of axes for the reduction. The " }, { "__type": "InlineCode", "__tag": 4051, "value": "keepdims" }, { "__type": "Text", "__tag": 4046, "value": " keyword argument was also added to allow convenient broadcasting to arrays of the original shape." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Generalized axis support for median and percentile" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The returned data type from the " }, { "__type": "InlineCode", "__tag": 4051, "value": "linspace" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "logspace" }, { "__type": "Text", "__tag": 4046, "value": " functions can now be specified using the dtype parameter." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Dtype parameter added to " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.linspace" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.logspace" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "For arrays with " }, { "__type": "InlineCode", "__tag": 4051, "value": "ndim" }, { "__type": "Text", "__tag": 4046, "value": " exceeding 2, these functions will now apply to the final two axes instead of raising an exception." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "More general " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.triu" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.tril" }, { "__type": "Text", "__tag": 4046, "value": " broadcasting" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "ndarray.tobytes" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "MaskedArray.tobytes" }, { "__type": "Text", "__tag": 4046, "value": " have been added as aliases for " }, { "__type": "InlineCode", "__tag": 4051, "value": "tostring" }, { "__type": "Text", "__tag": 4046, "value": " which exports arrays as " }, { "__type": "InlineCode", "__tag": 4051, "value": "bytes" }, { "__type": "Text", "__tag": 4046, "value": ". This is more consistent in Python 3 where " }, { "__type": "InlineCode", "__tag": 4051, "value": "str" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "bytes" }, { "__type": "Text", "__tag": 4046, "value": " are not the same." } ] } ], "title": [ { "__type": "InlineCode", "__tag": 4051, "value": "tobytes" }, { "__type": "Text", "__tag": 4046, "value": " alias for " }, { "__type": "InlineCode", "__tag": 4051, "value": "tostring" }, { "__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": "Added experimental support for the ppc64le and OpenRISC architecture." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Build system" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "All numerical numpy types are now registered with the type hierarchy in the python " }, { "__type": "InlineCode", "__tag": 4051, "value": "numbers" }, { "__type": "Text", "__tag": 4046, "value": " module." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Compatibility to python " }, { "__type": "InlineCode", "__tag": 4051, "value": "numbers" }, { "__type": "Text", "__tag": 4046, "value": " module" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The ordering of the columns of the Vandermonde matrix can be specified with this new boolean argument." } ] } ], "title": [ { "__type": "InlineCode", "__tag": 4051, "value": "increasing" }, { "__type": "Text", "__tag": 4046, "value": " parameter added to " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.vander" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The number of times each unique item comes up in the input can now be obtained as an optional return value." } ] } ], "title": [ { "__type": "InlineCode", "__tag": 4051, "value": "unique_counts" }, { "__type": "Text", "__tag": 4046, "value": " parameter added to " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.unique" } ], "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.nanmedian" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.nanpercentile" }, { "__type": "Text", "__tag": 4046, "value": " functions behave like the median and percentile functions except that NaNs are ignored." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Support for median and percentile in nanfunctions" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The class may be imported from numpy.lib and can be used for version comparison when the numpy version goes to 1.10.devel. For example " } ] }, { "__type": "Code", "__tag": 4050, "value": ">>> from numpy.lib import NumpyVersion\n>>> if NumpyVersion(np.__version__) < '1.10.0'):\n... print('Wow, that is an old NumPy version!')", "execution_status": null } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "NumpyVersion class added" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The numpy storage format 1.0 only allowed the array header to have a total size of 65535 bytes. This can be exceeded by structured arrays with a large number of columns. A new format 2.0 has been added which extends the header size to 4 GiB. " }, { "__type": "InlineRole", "__tag": 4003, "value": "np.save", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " will automatically save in 2.0 format if the data requires it, else it will always use the more compatible 1.0 format." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Allow saving arrays with large number of named columns" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "np.cross" }, { "__type": "Text", "__tag": 4046, "value": " now properly broadcasts its two input arrays, even if they have different number of dimensions. In earlier versions this would result in either an error being raised, or wrong results computed." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Full broadcasting support for " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.cross" } ], "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": "Pairwise summation is now used in the sum method, but only along the fast axis and for groups of the values <= 8192 in length. This should also improve the accuracy of var and std in some common cases." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Better numerical stability for sum in some cases" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "InlineCode", "__tag": 4051, "value": "np.percentile" }, { "__type": "Text", "__tag": 4046, "value": " has been implemented in terms of " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.partition" }, { "__type": "Text", "__tag": 4046, "value": " which only partially sorts the data via a selection algorithm. This improves the time complexity from " }, { "__type": "InlineCode", "__tag": 4051, "value": "O(nlog(n))" }, { "__type": "Text", "__tag": 4046, "value": " to " }, { "__type": "InlineCode", "__tag": 4051, "value": "O(n)" }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Percentile implemented in terms of " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.partition" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The performance of converting lists containing arrays to arrays using " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.array" }, { "__type": "Text", "__tag": 4046, "value": " has been improved. It is now equivalent in speed to " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.vstack(list)" }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Performance improvement for " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.array" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "For the built-in numeric types, " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.searchsorted" }, { "__type": "Text", "__tag": 4046, "value": " no longer relies on the data type's " }, { "__type": "InlineCode", "__tag": 4051, "value": "compare" }, { "__type": "Text", "__tag": 4046, "value": " function to perform the search, but is now implemented by type specific functions. Depending on the size of the inputs, this can result in performance improvements over 2x." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Performance improvement for " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.searchsorted" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Set " }, { "__type": "InlineCode", "__tag": 4051, "value": "numpy.distutils.system_info.system_info.verbosity = 0" }, { "__type": "Text", "__tag": 4046, "value": " and then calls to " }, { "__type": "InlineCode", "__tag": 4051, "value": "numpy.distutils.system_info.get_info('blas_opt')" }, { "__type": "Text", "__tag": 4046, "value": " will not print anything on the output. This is mostly for other packages using numpy.distutils." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Optional reduced verbosity for np.distutils" } ], "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": "RuntimeWarning" }, { "__type": "Text", "__tag": 4046, "value": " warning is raised when the covariance matrix is not positive-semidefinite." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Covariance check in " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.random.multivariate_normal" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The polynomial classes have been refactored to use an abstract base class rather than a template in order to implement a common interface. This makes importing the polynomial package faster as the classes do not need to be compiled on import." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Polynomial Classes no longer template based" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Several more functions now release the Global Interpreter Lock allowing more efficient parallelization using the " }, { "__type": "InlineCode", "__tag": 4051, "value": "threading" }, { "__type": "Text", "__tag": 4046, "value": " module. Most notably the GIL is now released for fancy indexing, " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.where" }, { "__type": "Text", "__tag": 4046, "value": " and the " }, { "__type": "InlineCode", "__tag": 4051, "value": "random" }, { "__type": "Text", "__tag": 4046, "value": " module now uses a per-state lock instead of the GIL." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "More GIL releases" } ], "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, " }, { "__type": "InlineCode", "__tag": 4051, "value": "repr" }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineCode", "__tag": 4051, "value": "str" }, { "__type": "Text", "__tag": 4046, "value": " should now work more reliably." } ] } ], "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": "C-API" } ], "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": "Using non-integer numpy scalars to repeat python sequences is deprecated. For example " }, { "__type": "InlineCode", "__tag": 4051, "value": "np.float_(2) * [1]" }, { "__type": "Text", "__tag": 4046, "value": " will be an error in the future." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Non-integer scalars for sequence repetition" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The integer and empty input to " }, { "__type": "InlineCode", "__tag": 4051, "value": "select" }, { "__type": "Text", "__tag": 4046, "value": " is deprecated. In the future only boolean arrays will be valid conditions and an empty " }, { "__type": "InlineCode", "__tag": 4051, "value": "condlist" }, { "__type": "Text", "__tag": 4046, "value": " will be considered an input error instead of returning the default." } ] } ], "title": [ { "__type": "InlineCode", "__tag": 4051, "value": "select" }, { "__type": "Text", "__tag": 4046, "value": " input deprecations" } ], "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": "rank" }, { "__type": "Text", "__tag": 4046, "value": " function has been deprecated to avoid confusion with " }, { "__type": "InlineCode", "__tag": 4051, "value": "numpy.linalg.matrix_rank" }, { "__type": "Text", "__tag": 4046, "value": "." } ] } ], "title": [ { "__type": "InlineCode", "__tag": 4051, "value": "rank" }, { "__type": "Text", "__tag": 4046, "value": " function" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "In the future object array comparisons both " }, { "__type": "InlineRole", "__tag": 4003, "value": "==", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineRole", "__tag": 4003, "value": "np.equal", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " will not make use of identity checks anymore. For example:" } ] }, { "__type": "Code", "__tag": 4050, "value": ">>> a = np.array([np.array([1, 2, 3]), 1])\n>>> b = np.array([np.array([1, 2, 3]), 1])\n>>> a == b", "execution_status": null }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "will consistently return False (and in the future an error) even if the array in " }, { "__type": "InlineRole", "__tag": 4003, "value": "a", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " and " }, { "__type": "InlineRole", "__tag": 4003, "value": "b", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " was the same object." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The equality operator " }, { "__type": "InlineRole", "__tag": 4003, "value": "==", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " will in the future raise errors like " }, { "__type": "InlineRole", "__tag": 4003, "value": "np.equal", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " if broadcasting or element comparisons, etc. fails." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "Comparison with " }, { "__type": "InlineRole", "__tag": 4003, "value": "arr == None", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": " will in the future do an elementwise comparison instead of just returning False. Code should be using " }, { "__type": "InlineRole", "__tag": 4003, "value": "arr is None", "domain": null, "role": null, "inventory": null }, { "__type": "Text", "__tag": 4046, "value": "." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "All of these changes will give Deprecation- or FutureWarnings at this time." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "Object array equality comparisons" } ], "level": 2, "target": null }, { "__type": "Section", "__tag": 4015, "children": [ { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "The utility function npy_PyFile_Dup and npy_PyFile_DupClose are broken by the internal buffering python 3 applies to its file objects. To fix this two new functions npy_PyFile_Dup2 and npy_PyFile_DupClose2 are declared in npy_3kcompat.h and the old functions are deprecated. Due to the fragile nature of these functions it is recommended to instead use the python API when possible." } ] }, { "__type": "Paragraph", "__tag": 4045, "children": [ { "__type": "Text", "__tag": 4046, "value": "This change was already applied to the 1.8.1 release." } ] } ], "title": [ { "__type": "Text", "__tag": 4046, "value": "C-API" } ], "level": 2, "target": null } ], "local_refs": [] }