NumPy manual contents

• NumPy User Guide
  • Setting up
    • What is NumPy?
    • Installing NumPy
  • Quickstart tutorial
    • Prerequisites
    • The Basics
      • An example
      • Array Creation
      • Printing Arrays
      • Basic Operations
      • Universal Functions
      • Indexing, Slicing and Iterating
    • Shape Manipulation
      • Changing the shape of an array
      • Stacking together different arrays
      • Splitting one array into several smaller ones
    • Copies and Views
      • No Copy at All
      • View or Shallow Copy
      • Deep Copy
      • Functions and Methods Overview
    • Less Basic
      • Broadcasting rules
    • Fancy indexing and index tricks
      • Indexing with Arrays of Indices
      • Indexing with Boolean Arrays
      • The ix_() function
      • Indexing with strings
    • Linear Algebra
      • Simple Array Operations
    • Tricks and Tips
      • “Automatic” Reshaping
      • Vector Stacking
      • Histograms
    • Further reading
  • NumPy basics
    • Data types
      • Array types and conversions between types
      • Array Scalars
      • Extended Precision
    • Array creation
      • Introduction
      • Converting Python array_like Objects to NumPy Arrays
      • Intrinsic NumPy Array Creation
      • Reading Arrays From Disk
        • Standard Binary Formats
        • Common ASCII Formats
        • Custom Binary Formats
        • Use of Special Libraries
    • I/O with NumPy
      • Importing data with genfromtxt
        • Defining the input
        • Splitting the lines into columns
          • The delimiter argument
          • The autostrip argument
          • The comments argument
        • Skipping lines and choosing columns
          • The skip_header and skip_footer arguments
          • The usecols argument
        • Choosing the data type
        • Setting the names
          • The names argument
          • The defaultfmt argument
          • Validating names
        • Tweaking the conversion
          • The converters argument
          • Using missing and filling values
          • missing_values
          • filling_values
          • usemask
        • Shortcut functions
    • Indexing
      • Assignment vs referencing
      • Single element indexing
      • Other indexing options
      • Index arrays
      • Indexing Multi-dimensional arrays
      • Boolean or “mask” index arrays
      • Combining index arrays with slices
      • Structural indexing tools
      • Assigning values to indexed arrays
      • Dealing with variable numbers of indices within programs
    • Broadcasting
      • General Broadcasting Rules
    • Byte-swapping
      • Introduction to byte ordering and ndarrays
      • Changing byte ordering
        • Data and dtype endianness don’t match, change dtype to match data
        • Data and type endianness don’t match, change data to match dtype
        • Data and dtype endianness match, swap data and dtype
    • Structured arrays
      • Introduction
      • Defining Structured Arrays
      • Accessing and modifying field names
      • Accessing field titles
      • Accessing multiple fields at once
      • Filling structured arrays
      • Record Arrays
    • Subclassing ndarray
      • Credits
      • Introduction
        • ndarrays and object creation
      • View casting
      • Creating new from template
      • Relationship of view casting and new-from-template
      • Implications for subclassing
        • A brief Python primer on __new__ and __init__
        • The role of __array_finalize__
      • Simple example - adding an extra attribute to ndarray
      • Slightly more realistic example - attribute added to existing array
      • __array_wrap__ for ufuncs
      • Extra gotchas - custom __del__ methods and ndarray.base
      • Subclassing and Downstream Compatibility
  • Miscellaneous
    • IEEE 754 Floating Point Special Values
    • How numpy handles numerical exceptions
    • Examples
    • Interfacing to C
    • Interfacing to Fortran:
    • Interfacing to C++:
  • NumPy for Matlab users
    • Introduction
    • Some Key Differences
    • ‘array’ or ‘matrix’? Which should I use?
      • Short answer
      • Long answer
    • Facilities for Matrix Users
    • Table of Rough MATLAB-NumPy Equivalents
      • General Purpose Equivalents
      • Linear Algebra Equivalents
    • Notes
    • Customizing Your Environment
    • Links
  • Building from source
    • Prerequisites
    • Basic Installation
      • Parallel builds
    • FORTRAN ABI mismatch
      • Choosing the fortran compiler
      • How to check the ABI of blas/lapack/atlas
    • Disabling ATLAS and other accelerated libraries
    • Supplying additional compiler flags
    • Building with ATLAS support
      • Ubuntu
  • Using NumPy C-API
    • How to extend NumPy
      • Writing an extension module
      • Required subroutine
      • Defining functions
        • Functions without keyword arguments
        • Functions with keyword arguments
        • Reference counting
      • Dealing with array objects
        • Converting an arbitrary sequence object
        • Creating a brand-new ndarray
        • Getting at ndarray memory and accessing elements of the ndarray
      • Example
    • Using Python as glue
      • Calling other compiled libraries from Python
      • Hand-generated wrappers
      • f2py
        • Creating source for a basic extension module
        • Creating a compiled extension module
        • Improving the basic interface
        • Inserting directives in Fortran source
        • A filtering example
        • Calling f2py from Python
        • Automatic extension module generation
        • Conclusion
      • Cython
        • Complex addition in Cython
        • Image filter in Cython
        • Conclusion
      • ctypes
        • Having a shared library
        • Loading the shared library
        • Converting arguments
        • Calling the function
        • Complete example
        • Conclusion
      • Additional tools you may find useful
        • SWIG
        • SIP
        • Boost Python
        • PyFort
    • Writing your own ufunc
      • Creating a new universal function
      • Example Non-ufunc extension
      • Example NumPy ufunc for one dtype
      • Example NumPy ufunc with multiple dtypes
      • Example NumPy ufunc with multiple arguments/return values
      • Example NumPy ufunc with structured array dtype arguments
      • PyUFunc_FromFuncAndData Specification
    • Beyond the Basics
      • Iterating over elements in the array
        • Basic Iteration
        • Iterating over all but one axis
        • Iterating over multiple arrays
        • Broadcasting over multiple arrays
      • User-defined data-types
        • Adding the new data-type
        • Registering a casting function
        • Registering coercion rules
        • Registering a ufunc loop
      • Subtyping the ndarray in C
        • Creating sub-types
        • Specific features of ndarray sub-typing
          • The __array_finalize__ method
          • The __array_priority__ attribute
          • The __array_wrap__ method
• NumPy Reference
  • Array objects
    • The N-dimensional array (ndarray)
      • Constructing arrays
      • Indexing arrays
      • Internal memory layout of an ndarray
      • Array attributes
        • Memory layout
        • Data type
        • Other attributes
        • Array interface
        • ctypes foreign function interface
      • Array methods
        • Array conversion
        • Shape manipulation
        • Item selection and manipulation
        • Calculation
      • Arithmetic, matrix multiplication, and comparison operations
      • Special methods
    • Scalars
      • Built-in scalar types
      • Attributes
      • Indexing
      • Methods
      • Defining new types
    • Data type objects (dtype)
      • Specifying and constructing data types
      • dtype
        • Attributes
        • Methods
    • Indexing
      • Basic Slicing and Indexing
      • Advanced Indexing
        • Integer array indexing
          • Purely integer array indexing
          • Combining advanced and basic indexing
        • Boolean array indexing
      • Detailed notes
      • Field Access
      • Flat Iterator indexing
    • Iterating Over Arrays
      • Single Array Iteration
        • Controlling Iteration Order
        • Modifying Array Values
        • Using an External Loop
        • Tracking an Index or Multi-Index
        • Buffering the Array Elements
        • Iterating as a Specific Data Type
      • Broadcasting Array Iteration
        • Iterator-Allocated Output Arrays
        • Outer Product Iteration
        • Reduction Iteration
      • Putting the Inner Loop in Cython
    • Standard array subclasses
      • Special attributes and methods
      • Matrix objects
      • Memory-mapped file arrays
      • Character arrays (numpy.char)
      • Record arrays (numpy.rec)
      • Masked arrays (numpy.ma)
      • Standard container class
      • Array Iterators
        • Default iteration
        • Flat iteration
        • N-dimensional enumeration
        • Iterator for broadcasting
    • Masked arrays
      • The numpy.ma module
        • Rationale
        • What is a masked array?
        • The numpy.ma module
      • Using numpy.ma
        • Constructing masked arrays
        • Accessing the data
        • Accessing the mask
        • Accessing only the valid entries
        • Modifying the mask
          • Masking an entry
          • Unmasking an entry
        • Indexing and slicing
        • Operations on masked arrays
      • Examples
        • Data with a given value representing missing data
        • Filling in the missing data
        • Numerical operations
        • Ignoring extreme values
      • Constants of the numpy.ma module
      • The MaskedArray class
        • Attributes and properties of masked arrays
      • MaskedArray methods
        • Conversion
        • Shape manipulation
        • Item selection and manipulation
        • Pickling and copy
        • Calculations
        • Arithmetic and comparison operations
          • Comparison operators:
          • Truth value of an array (bool):
          • Arithmetic:
          • Arithmetic, in-place:
        • Representation
        • Special methods
        • Specific methods
          • Handling the mask
          • Handling the fill_value
          • Counting the missing elements
      • Masked array operations
        • Constants
        • Creation
          • From existing data
          • Ones and zeros
        • Inspecting the array
        • Manipulating a MaskedArray
          • Changing the shape
          • Modifying axes
          • Changing the number of dimensions
          • Joining arrays
        • Operations on masks
          • Creating a mask
          • Accessing a mask
          • Finding masked data
          • Modifying a mask
        • Conversion operations
          • > to a masked array
          • > to a ndarray
          • > to another object
          • Pickling and unpickling
          • Filling a masked array
        • Masked arrays arithmetics
          • Arithmetics
          • Minimum/maximum
          • Sorting
          • Algebra
          • Polynomial fit
          • Clipping and rounding
          • Miscellanea
    • The Array Interface
      • Python side
      • C-struct access
      • Type description examples
      • Differences with Array interface (Version 2)
    • Datetimes and Timedeltas
      • Basic Datetimes
      • Datetime and Timedelta Arithmetic
      • Datetime Units
      • Business Day Functionality
        • np.is_busday():
        • np.busday_count():
          • Custom Weekmasks
      • Changes with NumPy 1.11
      • Differences Between 1.6 and 1.7 Datetimes
        • String Parsing
        • Unit Conversion
        • Datetime Arithmetic
  • Universal functions (ufunc)
    • Broadcasting
    • Output type determination
    • Use of internal buffers
    • Error handling
    • Casting Rules
    • Overriding Ufunc behavior
    • ufunc
      • Optional keyword arguments
      • Attributes
      • Methods
    • Available ufuncs
      • Math operations
      • Trigonometric functions
      • Bit-twiddling functions
      • Comparison functions
      • Floating functions
  • Routines
    • Array creation routines
      • Ones and zeros
      • From existing data
      • Creating record arrays (numpy.rec)
      • Creating character arrays (numpy.char)
      • Numerical ranges
      • Building matrices
      • The Matrix class
    • Array manipulation routines
      • Basic operations
      • Changing array shape
      • Transpose-like operations
      • Changing number of dimensions
      • Changing kind of array
      • Joining arrays
      • Splitting arrays
      • Tiling arrays
      • Adding and removing elements
      • Rearranging elements
    • Binary operations
      • Elementwise bit operations
      • Bit packing
      • Output formatting
    • String operations
      • String operations
      • Comparison
      • String information
      • Convenience class
    • C-Types Foreign Function Interface (numpy.ctypeslib)
    • Datetime Support Functions
      • Business Day Functions
    • Data type routines
      • Creating data types
      • Data type information
      • Data type testing
      • Miscellaneous
    • Optionally Scipy-accelerated routines (numpy.dual)
      • Linear algebra
      • FFT
      • Other
    • Mathematical functions with automatic domain (numpy.emath)
    • Floating point error handling
      • Setting and getting error handling
      • Internal functions
    • Discrete Fourier Transform (numpy.fft)
      • Standard FFTs
      • Real FFTs
      • Hermitian FFTs
      • Helper routines
      • Background information
      • Implementation details
      • Normalization
      • Real and Hermitian transforms
      • Higher dimensions
      • References
      • Examples
    • Financial functions
      • Simple financial functions
    • Functional programming
    • NumPy-specific help functions
      • Finding help
      • Reading help
    • Indexing routines
      • Generating index arrays
      • Indexing-like operations
      • Inserting data into arrays
      • Iterating over arrays
    • Input and output
      • NumPy binary files (NPY, NPZ)
      • Text files
      • Raw binary files
      • String formatting
      • Memory mapping files
      • Text formatting options
      • Base-n representations
      • Data sources
    • Linear algebra (numpy.linalg)
      • Matrix and vector products
      • Decompositions
      • Matrix eigenvalues
      • Norms and other numbers
      • Solving equations and inverting matrices
      • Exceptions
      • Linear algebra on several matrices at once
    • Logic functions
      • Truth value testing
      • Array contents
      • Array type testing
      • Logical operations
      • Comparison
    • Masked array operations
      • Constants
      • Creation
        • From existing data
        • Ones and zeros
      • Inspecting the array
      • Manipulating a MaskedArray
        • Changing the shape
        • Modifying axes
        • Changing the number of dimensions
        • Joining arrays
      • Operations on masks
        • Creating a mask
        • Accessing a mask
        • Finding masked data
        • Modifying a mask
      • Conversion operations
        • > to a masked array
        • > to a ndarray
        • > to another object
        • Pickling and unpickling
        • Filling a masked array
      • Masked arrays arithmetics
        • Arithmetics
        • Minimum/maximum
        • Sorting
        • Algebra
        • Polynomial fit
        • Clipping and rounding
        • Miscellanea
    • Mathematical functions
      • Trigonometric functions
      • Hyperbolic functions
      • Rounding
      • Sums, products, differences
      • Exponents and logarithms
      • Other special functions
      • Floating point routines
      • Arithmetic operations
      • Handling complex numbers
      • Miscellaneous
    • Matrix library (numpy.matlib)
    • Miscellaneous routines
      • Buffer objects
      • Performance tuning
      • Memory ranges
      • NumPy version comparison
    • Padding Arrays
    • Polynomials
      • Transition notice
        • Polynomial Package
          • Using the Convenience Classes
            • Basics
            • Calculus
            • Other Polynomial Constructors
            • Fitting
          • Polynomial Module (numpy.polynomial.polynomial)
            • Polynomial Class
            • Basics
            • Fitting
            • Calculus
            • Algebra
            • Miscellaneous
          • Chebyshev Module (numpy.polynomial.chebyshev)
            • Chebyshev Class
            • Basics
            • Fitting
            • Calculus
            • Algebra
            • Quadrature
            • Miscellaneous
          • Legendre Module (numpy.polynomial.legendre)
            • Legendre Class
            • Basics
            • Fitting
            • Calculus
            • Algebra
            • Quadrature
            • Miscellaneous
          • Laguerre Module (numpy.polynomial.laguerre)
            • Laguerre Class
            • Basics
            • Fitting
            • Calculus
            • Algebra
            • Quadrature
            • Miscellaneous
          • Hermite Module, “Physicists’” (numpy.polynomial.hermite)
            • Hermite Class
            • Basics
            • Fitting
            • Calculus
            • Algebra
            • Quadrature
            • Miscellaneous
          • HermiteE Module, “Probabilists’” (numpy.polynomial.hermite_e)
            • HermiteE Class
            • Basics
            • Fitting
            • Calculus
            • Algebra
            • Quadrature
            • Miscellaneous
        • Poly1d
          • Basics
          • Fitting
          • Calculus
          • Arithmetic
          • Warnings
    • Random sampling (numpy.random)
      • Simple random data
      • Permutations
      • Distributions
      • Random generator
    • Set routines
      • Making proper sets
      • Boolean operations
    • Sorting, searching, and counting
      • Sorting
      • Searching
      • Counting
    • Statistics
      • Order statistics
      • Averages and variances
      • Correlating
      • Histograms
    • Test Support (numpy.testing)
      • Asserts
      • Decorators
      • Test Running
    • Window functions
      • Various windows
  • Packaging (numpy.distutils)
    • Modules in numpy.distutils
      • misc_util
      • Other modules
    • Building Installable C libraries
      • npy-pkg-config files
      • Reusing a C library from another package
    • Conversion of .src files
      • Fortran files
        • Named repeat rule
        • Short repeat rule
        • Pre-defined names
      • Other files
  • NumPy C-API
    • Python Types and C-Structures
      • New Python Types Defined
        • PyArray_Type
        • PyArrayDescr_Type
        • PyUFunc_Type
        • PyArrayIter_Type
        • PyArrayMultiIter_Type
        • PyArrayNeighborhoodIter_Type
        • PyArrayFlags_Type
        • ScalarArrayTypes
      • Other C-Structures
        • PyArray_Dims
        • PyArray_Chunk
        • PyArrayInterface
        • Internally used structures
    • System configuration
      • Data type sizes
      • Platform information
    • Data Type API
      • Enumerated Types
      • Defines
        • Max and min values for integers
        • Number of bits in data types
        • Bit-width references to enumerated typenums
        • Integer that can hold a pointer
      • C-type names
        • Boolean
        • (Un)Signed Integer
        • (Complex) Floating point
        • Bit-width names
      • Printf Formatting
    • Array API
      • Array structure and data access
        • Data access
      • Creating arrays
        • From scratch
        • From other objects
      • Dealing with types
        • General check of Python Type
        • Data-type checking
        • Converting data types
        • New data types
        • Special functions for NPY_OBJECT
      • Array flags
        • Basic Array Flags
        • Combinations of array flags
        • Flag-like constants
        • Flag checking
      • Array method alternative API
        • Conversion
        • Shape Manipulation
        • Item selection and manipulation
        • Calculation
      • Functions
        • Array Functions
        • Other functions
      • Auxiliary Data With Object Semantics
      • Array Iterators
      • Broadcasting (multi-iterators)
      • Neighborhood iterator
      • Array Scalars
      • Data-type descriptors
      • Conversion Utilities
        • For use with PyArg_ParseTuple
        • Other conversions
      • Miscellaneous
        • Importing the API
        • Checking the API Version
        • Internal Flexibility
        • Memory management
        • Threading support
          • Group 1
          • Group 2
        • Priority
        • Default buffers
        • Other constants
        • Miscellaneous Macros
        • Enumerated Types
    • Array Iterator API
      • Array Iterator
      • Simple Iteration Example
      • Simple Multi-Iteration Example
      • Iterator Data Types
      • Construction and Destruction
      • Functions For Iteration
      • Converting from Previous NumPy Iterators
    • UFunc API
      • Constants
      • Macros
      • Functions
      • Generic functions
      • Importing the API
    • Generalized Universal Function API
      • Definitions
      • Details of Signature
      • C-API for implementing Elementary Functions
    • NumPy core libraries
      • NumPy core math library
        • Floating point classification
        • Useful math constants
        • Low-level floating point manipulation
        • Complex functions
        • Linking against the core math library in an extension
        • Half-precision functions
    • C API Deprecations
      • Background
      • Deprecation Mechanism NPY_NO_DEPRECATED_API
  • NumPy internals
    • NumPy C Code Explanations
      • Memory model
      • Data-type encapsulation
      • N-D Iterators
      • Broadcasting
      • Array Scalars
      • Indexing
        • Advanced indexing
      • Universal Functions
        • Setup
        • Function call
          • One Loop
          • Strided Loop
          • Buffered Loop
        • Final output manipulation
        • Methods
          • Setup
          • Reduce
          • Accumulate
          • Reduceat
    • Internal organization of numpy arrays
    • Multidimensional Array Indexing Order Issues
  • NumPy and SWIG
    • numpy.i: a SWIG Interface File for NumPy
      • Introduction
      • Using numpy.i
      • Available Typemaps
        • Input Arrays
        • In-Place Arrays
        • Argout Arrays
        • Argout View Arrays
        • Memory Managed Argout View Arrays
        • Output Arrays
        • Other Common Types: bool
        • Other Common Types: complex
      • NumPy Array Scalars and SWIG
        • Why is There a Second File?
      • Helper Functions
        • Macros
        • Routines
      • Beyond the Provided Typemaps
        • A Common Example
        • Other Situations
        • A Final Note
      • Summary
    • Testing the numpy.i Typemaps
      • Introduction
      • Testing Organization
      • Testing Header Files
      • Testing Source Files
      • Testing SWIG Interface Files
      • Testing Python Scripts
  • Acknowledgements
• F2PY Users Guide and Reference Manual
  • Introduction
    • Three ways to wrap - getting started
      • The quick way
      • The smart way
      • The quick and smart way
    • Signature file
      • Python module block
      • Fortran/C routine signatures
        • Type declarations
        • Statements
        • Attributes
      • Extensions
        • F2PY directives
        • C expressions
        • Multiline blocks
    • Using F2PY bindings in Python
      • Scalar arguments
      • String arguments
      • Array arguments
      • Call-back arguments
        • Resolving arguments to call-back functions
      • Common blocks
      • Fortran 90 module data
        • Allocatable arrays
    • Using F2PY
      • Command f2py
      • Python module f2py2e
    • Using via numpy.distutils
    • Advanced F2PY usages
      • Adding self-written functions to F2PY generated modules
      • Modifying the dictionary of a F2PY generated module
• Contributing to NumPy
  • Working with NumPy source code
    • Introduction
      • Install git
        • Overview
        • In detail
    • Following the latest source
      • Get the local copy of the code
      • Updating the code
    • Git for development
      • Getting started with Git development
        • Basic Git setup
        • Making your own copy (fork) of NumPy
          • Set up and configure a github account
          • Create your own forked copy of NumPy
        • Set up your fork
          • Overview
          • In detail
            • Clone your fork
            • Linking your repository to the upstream repo
      • Git configuration
        • Overview
        • In detail
          • user.name and user.email
          • Aliases
          • Editor
          • Merging
      • Development workflow
        • Basic workflow
          • Making a new feature branch
          • The editing workflow
            • Overview
            • In more detail
            • Writing the commit message
          • Asking for your changes to be merged with the main repo
          • Rebasing on master
          • Recovering from mess-ups
        • Additional things you might want to do
          • Rewriting commit history
          • Deleting a branch on github
          • Several people sharing a single repository
          • Exploring your repository
          • Backporting
          • Pushing changes to the main repo
    • git resources
      • Tutorials and summaries
      • Advanced git workflow
      • Manual pages online
  • Setting up and using your development environment
    • Recommended development setup
    • Building in-place
    • Other build options
    • Using virtualenvs
    • Running tests
    • Rebuilding & cleaning the workspace
    • Debugging
    • Understanding the code & getting started
  • NumPy governance
    • NumPy project governance and decision-making
      • Summary
      • The Project
      • Governance
        • Consensus-based decision making by the community
        • Steering Council
          • Council decision making
          • Council membership
          • Conflict of interest
          • Private communications of the Council
          • Subcommittees
          • NumFOCUS Subcommittee
      • Institutional Partners and Funding
      • Document history
      • Acknowledgements
      • License
    • Current steering council and institutional partners
      • Steering council
      • Emeritus members
      • NumFOCUS Subcommittee
      • Institutional Partners
      • Document history
• NumPy Enhancement Proposals
  • Implemented NEPs
  • Other NEPs
• Release Notes
  • NumPy 1.12.0 Release Notes
    • Highlights
    • Dropped Support
    • Added Support
    • Build System Changes
    • Deprecations
      • Assignment of ndarray object’s data attribute
      • Unsafe int casting of the num attribute in linspace
      • Insufficient bit width parameter to binary_repr
    • Future Changes
      • Multiple-field manipulation of structured arrays
    • Compatibility notes
      • DeprecationWarning to error
      • FutureWarning to changed behavior
      • power and ** raise errors for integer to negative integer powers
      • Relaxed stride checking is the default
      • The np.percentile ‘midpoint’ interpolation method fixed for exact indices
      • keepdims kwarg is passed through to user-class methods
      • bitwise_and identity changed
      • ma.median warns and returns nan when unmasked invalid values are encountered
      • Greater consistancy in assert_almost_equal
      • NoseTester behaviour of warnings during testing
      • assert_warns and deprecated decorator more specific
      • C API
    • New Features
      • Writeable keyword argument for as_strided
      • axes keyword argument for rot90
      • Generalized flip
      • BLIS support in numpy.distutils
      • Hook in numpy/__init__.py to run distribution-specific checks
      • New nanfunctions nancumsum and nancumprod added
      • np.interp can now interpolate complex values
      • New polynomial evaluation function polyvalfromroots added
      • New array creation function geomspace added
      • New context manager for testing warnings
      • New masked array functions ma.convolve and ma.correlate added
      • New float_power ufunc
      • np.loadtxt now supports a single integer as usecol argument
      • Improved automated bin estimators for histogram
      • np.roll can now roll multiple axes at the same time
      • The __complex__ method has been implemented for the ndarrays
      • pathlib.Path objects now supported
      • New bits attribute for np.finfo
      • New signature argument to np.vectorize
      • Emit py3kwarnings for division of integer arrays
      • numpy.sctypes now includes bytes on Python3 too
    • Improvements
      • bitwise_and identity changed
      • Generalized Ufuncs will now unlock the GIL
      • Caches in np.fft are now bounded in total size and item count
      • Improved handling of zero-width string/unicode dtypes
      • Integer ufuncs vectorized with AVX2
      • Order of operations optimization in np.einsum
      • quicksort has been changed to an introsort
      • ediff1d improved performance and subclass handling
      • Improved precision of ndarray.mean for float16 arrays
    • Changes
      • All array-like methods are now called with keyword arguments in fromnumeric.py
      • Operations on np.memmap objects return numpy arrays in most cases
      • stacklevel of warnings increased
    • Contributors
    • Pull requests merged
  • NumPy 1.11.3 Release Notes
    • Contributors to maintenance/1.11.3
    • Pull Requests Merged
    • Pull Requests Merged
    • Fixes Merged
    • Highlights
    • Build System Changes
    • Future Changes
    • Compatibility notes
    • New Features
    • Improvements
    • Changes
    • Deprecations
    • FutureWarnings
    • Compatibility notes
    • Issues Fixed
    • Merged PRs
    • Compatibility notes
    • Issues Fixed
    • Merged PRs
    • Notes
    • Highlights
    • Dropped Support
    • Future Changes
    • Compatibility notes
    • New Features
    • Improvements
    • Changes
    • Deprecations
    • Issues fixed
    • Issues fixed
    • Highlights
    • Dropped Support
    • Future Changes
    • Compatibility notes
    • New Features
    • Improvements
    • Deprecations
    • Issues fixed
    • Issues fixed
    • Changes
    • Deprecations
    • Highlights
    • Dropped Support
    • Future Changes
    • Compatibility notes
    • New Features
    • Improvements
    • Changes
    • Deprecations
    • Authors
    • Issues fixed
    • Issues fixed
    • Highlights
    • Compatibility notes
    • New features
    • Changes
    • Deprecations
    • Issues fixed
    • Changes
    • Issues Fixed
    • Highlights
    • New features
    • Changes
    • Deprecated features
    • Removed features
    • Highlights
    • New features
    • Changes
    • Highlights
    • New features
    • Improvements
    • Deprecations
    • Internal changes
    • Highlights
    • New features
    • Deprecated features
    • Documentation changes
    • New C API
    • Internal changes
• About NumPy
  • NumPy community
• About this documentation
  • Conventions
• Reporting bugs
• NumPy License
• Glossary
  • Jargon