doc_content
stringlengths 1
386k
| doc_id
stringlengths 5
188
|
|---|---|
numpy.distutils.ccompiler_opt.CCompilerOpt.feature_get_til method distutils.ccompiler_opt.CCompilerOpt.feature_get_til(names, keyisfalse)[source]
same as feature_implies_c() but stop collecting implied features when feature’s option that provided through parameter ‘keyisfalse’ is False, also sorting the returned features. | numpy.reference.generated.numpy.distutils.ccompiler_opt.ccompileropt.feature_get_til |
numpy.distutils.ccompiler_opt.CCompilerOpt.feature_implies method distutils.ccompiler_opt.CCompilerOpt.feature_implies(names, keep_origins=False)[source]
Return a set of CPU features that implied by ‘names’ Parameters
names: str or sequence of str
CPU feature name(s) in uppercase. keep_origins: bool
if False(default) then the returned set will not contain any features from ‘names’. This case happens only when two features imply each other. Examples >>> self.feature_implies("SSE3")
{'SSE', 'SSE2'}
>>> self.feature_implies("SSE2")
{'SSE'}
>>> self.feature_implies("SSE2", keep_origins=True)
# 'SSE2' found here since 'SSE' and 'SSE2' imply each other
{'SSE', 'SSE2'} | numpy.reference.generated.numpy.distutils.ccompiler_opt.ccompileropt.feature_implies |
numpy.distutils.ccompiler_opt.CCompilerOpt.feature_implies_c method distutils.ccompiler_opt.CCompilerOpt.feature_implies_c(names)[source]
same as feature_implies() but combining ‘names’ | numpy.reference.generated.numpy.distutils.ccompiler_opt.ccompileropt.feature_implies_c |
numpy.distutils.ccompiler_opt.CCompilerOpt.feature_is_exist method distutils.ccompiler_opt.CCompilerOpt.feature_is_exist(name)[source]
Returns True if a certain feature is exist and covered within _Config.conf_features. Parameters
‘name’: str
feature name in uppercase. | numpy.reference.generated.numpy.distutils.ccompiler_opt.ccompileropt.feature_is_exist |
numpy.distutils.ccompiler_opt.CCompilerOpt.feature_names method distutils.ccompiler_opt.CCompilerOpt.feature_names(names=None, force_flags=None, macros=[])[source]
Returns a set of CPU feature names that supported by platform and the C compiler. Parameters
names: sequence or None, optional
Specify certain CPU features to test it against the C compiler. if None(default), it will test all current supported features. Note: feature names must be in upper-case. force_flags: list or None, optional
If None(default), default compiler flags for every CPU feature will be used during the test.
macroslist of tuples, optional
A list of C macro definitions. | numpy.reference.generated.numpy.distutils.ccompiler_opt.ccompileropt.feature_names |
numpy.distutils.ccompiler_opt.CCompilerOpt.feature_sorted method distutils.ccompiler_opt.CCompilerOpt.feature_sorted(names, reverse=False)[source]
Sort a list of CPU features ordered by the lowest interest. Parameters
‘names’: sequence
sequence of supported feature names in uppercase. ‘reverse’: bool, optional
If true, the sorted features is reversed. (highest interest) Returns
list, sorted CPU features | numpy.reference.generated.numpy.distutils.ccompiler_opt.ccompileropt.feature_sorted |
numpy.distutils.ccompiler_opt.CCompilerOpt.feature_untied method distutils.ccompiler_opt.CCompilerOpt.feature_untied(names)[source]
same as ‘feature_ahead()’ but if both features implied each other and keep the highest interest. Parameters
‘names’: sequence
sequence of CPU feature names in uppercase. Returns
list of CPU features sorted as-is ‘names’
Examples >>> self.feature_untied(["SSE2", "SSE3", "SSE41"])
["SSE2", "SSE3", "SSE41"]
# assume AVX2 and FMA3 implies each other
>>> self.feature_untied(["SSE2", "SSE3", "SSE41", "FMA3", "AVX2"])
["SSE2", "SSE3", "SSE41", "AVX2"] | numpy.reference.generated.numpy.distutils.ccompiler_opt.ccompileropt.feature_untied |
numpy.distutils.ccompiler_opt.CCompilerOpt.generate_dispatch_header method distutils.ccompiler_opt.CCompilerOpt.generate_dispatch_header(header_path)[source]
Generate the dispatch header which contains the #definitions and headers for platform-specific instruction-sets for the enabled CPU baseline and dispatch-able features. Its highly recommended to take a look at the generated header also the generated source files via try_dispatch() in order to get the full picture. | numpy.reference.generated.numpy.distutils.ccompiler_opt.ccompileropt.generate_dispatch_header |
numpy.distutils.ccompiler_opt.CCompilerOpt.is_cached method distutils.ccompiler_opt.CCompilerOpt.is_cached()[source]
Returns True if the class loaded from the cache file | numpy.reference.generated.numpy.distutils.ccompiler_opt.ccompileropt.is_cached |
numpy.distutils.ccompiler_opt.CCompilerOpt.parse_targets method distutils.ccompiler_opt.CCompilerOpt.parse_targets(source)[source]
Fetch and parse configuration statements that required for defining the targeted CPU features, statements should be declared in the top of source in between C comment and start with a special mark @targets. Configuration statements are sort of keywords representing CPU features names, group of statements and policies, combined together to determine the required optimization. Parameters
source: str
the path of C source file. Returns
bool, True if group has the ‘baseline’ option
list, list of CPU features
list, list of extra compiler flags | numpy.reference.generated.numpy.distutils.ccompiler_opt.ccompileropt.parse_targets |
numpy.distutils.ccompiler_opt.CCompilerOpt.try_dispatch method distutils.ccompiler_opt.CCompilerOpt.try_dispatch(sources, src_dir=None, ccompiler=None, **kwargs)[source]
Compile one or more dispatch-able sources and generates object files, also generates abstract C config headers and macros that used later for the final runtime dispatching process. The mechanism behind it is to takes each source file that specified in ‘sources’ and branching it into several files depend on special configuration statements that must be declared in the top of each source which contains targeted CPU features, then it compiles every branched source with the proper compiler flags. Parameters
sourceslist
Must be a list of dispatch-able sources file paths, and configuration statements must be declared inside each file.
src_dirstr
Path of parent directory for the generated headers and wrapped sources. If None(default) the files will generated in-place. ccompiler: CCompiler
Distutils CCompiler instance to be used for compilation. If None (default), the provided instance during the initialization will be used instead.
**kwargsany
Arguments to pass on to the CCompiler.compile() Returns
listgenerated object files
Raises
CompileError
Raises by CCompiler.compile() on compiling failure. DistutilsError
Some errors during checking the sanity of configuration statements. See also parse_targets
Parsing the configuration statements of dispatch-able sources. | numpy.reference.generated.numpy.distutils.ccompiler_opt.ccompileropt.try_dispatch |
numpy.distutils.ccompiler_opt.new_ccompiler_opt distutils.ccompiler_opt.new_ccompiler_opt(compiler, dispatch_hpath, **kwargs)[source]
Create a new instance of ‘CCompilerOpt’ and generate the dispatch header which contains the #definitions and headers of platform-specific instruction-sets for the enabled CPU baseline and dispatch-able features. Parameters
compilerCCompiler instance
dispatch_hpathstr
path of the dispatch header **kwargs: passed as-is to `CCompilerOpt(…)`
Returns
——-
new instance of CCompilerOpt | numpy.reference.generated.numpy.distutils.ccompiler_opt.new_ccompiler_opt |
numpy.distutils.cpuinfo.cpu distutils.cpuinfo.cpu = <numpy.distutils.cpuinfo.LinuxCPUInfo object> | numpy.reference.generated.numpy.distutils.cpuinfo.cpu |
numpy.distutils.exec_command.exec_command distutils.exec_command.exec_command(command, execute_in='', use_shell=None, use_tee=None, _with_python=1, **env)[source]
Return (status,output) of executed command. Deprecated since version 1.17: Use subprocess.Popen instead Parameters
commandstr
A concatenated string of executable and arguments.
execute_instr
Before running command cd execute_in and after cd -.
use_shell{bool, None}, optional
If True, execute sh -c command. Default None (True)
use_tee{bool, None}, optional
If True use tee. Default None (True) Returns
resstr
Both stdout and stderr messages. Notes On NT, DOS systems the returned status is correct for external commands. Wild cards will not work for non-posix systems or when use_shell=0. | numpy.reference.generated.numpy.distutils.exec_command.exec_command |
numpy.distutils.exec_command.filepath_from_subprocess_output distutils.exec_command.filepath_from_subprocess_output(output)[source]
Convert bytes in the encoding used by a subprocess into a filesystem-appropriate str. Inherited from exec_command, and possibly incorrect. | numpy.reference.generated.numpy.distutils.exec_command.filepath_from_subprocess_output |
numpy.distutils.exec_command.find_executable distutils.exec_command.find_executable(exe, path=None, _cache={})[source]
Return full path of a executable or None. Symbolic links are not followed. | numpy.reference.generated.numpy.distutils.exec_command.find_executable |
numpy.distutils.exec_command.forward_bytes_to_stdout distutils.exec_command.forward_bytes_to_stdout(val)[source]
Forward bytes from a subprocess call to the console, without attempting to decode them. The assumption is that the subprocess call already returned bytes in a suitable encoding. | numpy.reference.generated.numpy.distutils.exec_command.forward_bytes_to_stdout |
numpy.distutils.exec_command.get_pythonexe distutils.exec_command.get_pythonexe()[source] | numpy.reference.generated.numpy.distutils.exec_command.get_pythonexe |
numpy.distutils.exec_command.temp_file_name distutils.exec_command.temp_file_name()[source] | numpy.reference.generated.numpy.distutils.exec_command.temp_file_name |
numpy.distutils.log.set_verbosity distutils.log.set_verbosity(v, force=False)[source] | numpy.reference.generated.numpy.distutils.log.set_verbosity |
numpy.distutils.system_info.get_info distutils.system_info.get_info(name, notfound_action=0)[source]
notfound_action:
0 - do nothing 1 - display warning message 2 - raise error | numpy.reference.generated.numpy.distutils.system_info.get_info |
numpy.distutils.system_info.get_standard_file distutils.system_info.get_standard_file(fname)[source]
Returns a list of files named ‘fname’ from 1) System-wide directory (directory-location of this module) 2) Users HOME directory (os.environ[‘HOME’]) 3) Local directory | numpy.reference.generated.numpy.distutils.system_info.get_standard_file |
DoxyLimbo(constDoxyLimbo<Tp,N>&l)
Set Default behavior for copy the limbo. | numpy.dev.howto-docs#_CPPv4N9DoxyLimbo9DoxyLimboERK9DoxyLimboI2Tp1NE |
numpy.dtype.__class_getitem__ method dtype.__class_getitem__(item, /)
Return a parametrized wrapper around the dtype type. New in version 1.22. Returns
aliastypes.GenericAlias
A parametrized dtype type. See also PEP 585
Type hinting generics in standard collections. Notes This method is only available for python 3.9 and later. Examples >>> import numpy as np
>>> np.dtype[np.int64]
numpy.dtype[numpy.int64] | numpy.reference.generated.numpy.dtype.__class_getitem__ |
numpy.dtype.__ge__ method dtype.__ge__(value, /)
Return self>=value. | numpy.reference.generated.numpy.dtype.__ge__ |
numpy.dtype.__gt__ method dtype.__gt__(value, /)
Return self>value. | numpy.reference.generated.numpy.dtype.__gt__ |
numpy.dtype.__le__ method dtype.__le__(value, /)
Return self<=value. | numpy.reference.generated.numpy.dtype.__le__ |
numpy.dtype.__lt__ method dtype.__lt__(value, /)
Return self<value. | numpy.reference.generated.numpy.dtype.__lt__ |
numpy.dtype.__reduce__ method dtype.__reduce__()
Helper for pickle. | numpy.reference.generated.numpy.dtype.__reduce__ |
numpy.dtype.__setstate__ method dtype.__setstate__() | numpy.reference.generated.numpy.dtype.__setstate__ |
numpy.dtype.alignment attribute dtype.alignment
The required alignment (bytes) of this data-type according to the compiler. More information is available in the C-API section of the manual. Examples >>> x = np.dtype('i4')
>>> x.alignment
4
>>> x = np.dtype(float)
>>> x.alignment
8 | numpy.reference.generated.numpy.dtype.alignment |
numpy.dtype.base attribute dtype.base
Returns dtype for the base element of the subarrays, regardless of their dimension or shape. See also dtype.subdtype
Examples >>> x = numpy.dtype('8f')
>>> x.base
dtype('float32')
>>> x = numpy.dtype('i2')
>>> x.base
dtype('int16') | numpy.reference.generated.numpy.dtype.base |
numpy.dtype.byteorder attribute dtype.byteorder
A character indicating the byte-order of this data-type object. One of:
‘=’ native
‘<’ little-endian
‘>’ big-endian
‘|’ not applicable All built-in data-type objects have byteorder either ‘=’ or ‘|’. Examples >>> dt = np.dtype('i2')
>>> dt.byteorder
'='
>>> # endian is not relevant for 8 bit numbers
>>> np.dtype('i1').byteorder
'|'
>>> # or ASCII strings
>>> np.dtype('S2').byteorder
'|'
>>> # Even if specific code is given, and it is native
>>> # '=' is the byteorder
>>> import sys
>>> sys_is_le = sys.byteorder == 'little'
>>> native_code = sys_is_le and '<' or '>'
>>> swapped_code = sys_is_le and '>' or '<'
>>> dt = np.dtype(native_code + 'i2')
>>> dt.byteorder
'='
>>> # Swapped code shows up as itself
>>> dt = np.dtype(swapped_code + 'i2')
>>> dt.byteorder == swapped_code
True | numpy.reference.generated.numpy.dtype.byteorder |
numpy.dtype.char attribute dtype.char
A unique character code for each of the 21 different built-in types. Examples >>> x = np.dtype(float)
>>> x.char
'd' | numpy.reference.generated.numpy.dtype.char |
numpy.dtype.descr attribute dtype.descr
__array_interface__ description of the data-type. The format is that required by the ‘descr’ key in the __array_interface__ attribute. Warning: This attribute exists specifically for __array_interface__, and passing it directly to np.dtype will not accurately reconstruct some dtypes (e.g., scalar and subarray dtypes). Examples >>> x = np.dtype(float)
>>> x.descr
[('', '<f8')]
>>> dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))])
>>> dt.descr
[('name', '<U16'), ('grades', '<f8', (2,))] | numpy.reference.generated.numpy.dtype.descr |
numpy.dtype.fields attribute dtype.fields
Dictionary of named fields defined for this data type, or None. The dictionary is indexed by keys that are the names of the fields. Each entry in the dictionary is a tuple fully describing the field: (dtype, offset[, title])
Offset is limited to C int, which is signed and usually 32 bits. If present, the optional title can be any object (if it is a string or unicode then it will also be a key in the fields dictionary, otherwise it’s meta-data). Notice also that the first two elements of the tuple can be passed directly as arguments to the ndarray.getfield and ndarray.setfield methods. See also
ndarray.getfield, ndarray.setfield
Examples >>> dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))])
>>> print(dt.fields)
{'grades': (dtype(('float64',(2,))), 16), 'name': (dtype('|S16'), 0)} | numpy.reference.generated.numpy.dtype.fields |
numpy.dtype.flags attribute dtype.flags
Bit-flags describing how this data type is to be interpreted. Bit-masks are in numpy.core.multiarray as the constants ITEM_HASOBJECT, LIST_PICKLE, ITEM_IS_POINTER, NEEDS_INIT, NEEDS_PYAPI, USE_GETITEM, USE_SETITEM. A full explanation of these flags is in C-API documentation; they are largely useful for user-defined data-types. The following example demonstrates that operations on this particular dtype requires Python C-API. Examples >>> x = np.dtype([('a', np.int32, 8), ('b', np.float64, 6)])
>>> x.flags
16
>>> np.core.multiarray.NEEDS_PYAPI
16 | numpy.reference.generated.numpy.dtype.flags |
numpy.dtype.hasobject attribute dtype.hasobject
Boolean indicating whether this dtype contains any reference-counted objects in any fields or sub-dtypes. Recall that what is actually in the ndarray memory representing the Python object is the memory address of that object (a pointer). Special handling may be required, and this attribute is useful for distinguishing data types that may contain arbitrary Python objects and data-types that won’t. | numpy.reference.generated.numpy.dtype.hasobject |
numpy.dtype.isalignedstruct attribute dtype.isalignedstruct
Boolean indicating whether the dtype is a struct which maintains field alignment. This flag is sticky, so when combining multiple structs together, it is preserved and produces new dtypes which are also aligned. | numpy.reference.generated.numpy.dtype.isalignedstruct |
numpy.dtype.isbuiltin attribute dtype.isbuiltin
Integer indicating how this dtype relates to the built-in dtypes. Read-only.
0 if this is a structured array type, with fields
1 if this is a dtype compiled into numpy (such as ints, floats etc)
2 if the dtype is for a user-defined numpy type A user-defined type uses the numpy C-API machinery to extend numpy to handle a new array type. See User-defined data-types in the NumPy manual. Examples >>> dt = np.dtype('i2')
>>> dt.isbuiltin
1
>>> dt = np.dtype('f8')
>>> dt.isbuiltin
1
>>> dt = np.dtype([('field1', 'f8')])
>>> dt.isbuiltin
0 | numpy.reference.generated.numpy.dtype.isbuiltin |
numpy.dtype.isnative attribute dtype.isnative
Boolean indicating whether the byte order of this dtype is native to the platform. | numpy.reference.generated.numpy.dtype.isnative |
numpy.dtype.itemsize attribute dtype.itemsize
The element size of this data-type object. For 18 of the 21 types this number is fixed by the data-type. For the flexible data-types, this number can be anything. Examples >>> arr = np.array([[1, 2], [3, 4]])
>>> arr.dtype
dtype('int64')
>>> arr.itemsize
8
>>> dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))])
>>> dt.itemsize
80 | numpy.reference.generated.numpy.dtype.itemsize |
numpy.dtype.kind attribute dtype.kind
A character code (one of ‘biufcmMOSUV’) identifying the general kind of data.
b boolean
i signed integer
u unsigned integer
f floating-point
c complex floating-point
m timedelta
M datetime
O object
S (byte-)string
U Unicode
V void Examples >>> dt = np.dtype('i4')
>>> dt.kind
'i'
>>> dt = np.dtype('f8')
>>> dt.kind
'f'
>>> dt = np.dtype([('field1', 'f8')])
>>> dt.kind
'V' | numpy.reference.generated.numpy.dtype.kind |
numpy.dtype.metadata attribute dtype.metadata
Either None or a readonly dictionary of metadata (mappingproxy). The metadata field can be set using any dictionary at data-type creation. NumPy currently has no uniform approach to propagating metadata; although some array operations preserve it, there is no guarantee that others will. Warning Although used in certain projects, this feature was long undocumented and is not well supported. Some aspects of metadata propagation are expected to change in the future. Examples >>> dt = np.dtype(float, metadata={"key": "value"})
>>> dt.metadata["key"]
'value'
>>> arr = np.array([1, 2, 3], dtype=dt)
>>> arr.dtype.metadata
mappingproxy({'key': 'value'})
Adding arrays with identical datatypes currently preserves the metadata: >>> (arr + arr).dtype.metadata
mappingproxy({'key': 'value'})
But if the arrays have different dtype metadata, the metadata may be dropped: >>> dt2 = np.dtype(float, metadata={"key2": "value2"})
>>> arr2 = np.array([3, 2, 1], dtype=dt2)
>>> (arr + arr2).dtype.metadata is None
True # The metadata field is cleared so None is returned | numpy.reference.generated.numpy.dtype.metadata |
numpy.dtype.name attribute dtype.name
A bit-width name for this data-type. Un-sized flexible data-type objects do not have this attribute. Examples >>> x = np.dtype(float)
>>> x.name
'float64'
>>> x = np.dtype([('a', np.int32, 8), ('b', np.float64, 6)])
>>> x.name
'void640' | numpy.reference.generated.numpy.dtype.name |
numpy.dtype.names attribute dtype.names
Ordered list of field names, or None if there are no fields. The names are ordered according to increasing byte offset. This can be used, for example, to walk through all of the named fields in offset order. Examples >>> dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))])
>>> dt.names
('name', 'grades') | numpy.reference.generated.numpy.dtype.names |
numpy.dtype.ndim attribute dtype.ndim
Number of dimensions of the sub-array if this data type describes a sub-array, and 0 otherwise. New in version 1.13.0. Examples >>> x = np.dtype(float)
>>> x.ndim
0
>>> x = np.dtype((float, 8))
>>> x.ndim
1
>>> x = np.dtype(('i4', (3, 4)))
>>> x.ndim
2 | numpy.reference.generated.numpy.dtype.ndim |
numpy.dtype.newbyteorder method dtype.newbyteorder(new_order='S', /)
Return a new dtype with a different byte order. Changes are also made in all fields and sub-arrays of the data type. Parameters
new_orderstring, optional
Byte order to force; a value from the byte order specifications below. The default value (‘S’) results in swapping the current byte order. new_order codes can be any of: ‘S’ - swap dtype from current to opposite endian {‘<’, ‘little’} - little endian {‘>’, ‘big’} - big endian {‘=’, ‘native’} - native order {‘|’, ‘I’} - ignore (no change to byte order) Returns
new_dtypedtype
New dtype object with the given change to the byte order. Notes Changes are also made in all fields and sub-arrays of the data type. Examples >>> import sys
>>> sys_is_le = sys.byteorder == 'little'
>>> native_code = sys_is_le and '<' or '>'
>>> swapped_code = sys_is_le and '>' or '<'
>>> native_dt = np.dtype(native_code+'i2')
>>> swapped_dt = np.dtype(swapped_code+'i2')
>>> native_dt.newbyteorder('S') == swapped_dt
True
>>> native_dt.newbyteorder() == swapped_dt
True
>>> native_dt == swapped_dt.newbyteorder('S')
True
>>> native_dt == swapped_dt.newbyteorder('=')
True
>>> native_dt == swapped_dt.newbyteorder('N')
True
>>> native_dt == native_dt.newbyteorder('|')
True
>>> np.dtype('<i2') == native_dt.newbyteorder('<')
True
>>> np.dtype('<i2') == native_dt.newbyteorder('L')
True
>>> np.dtype('>i2') == native_dt.newbyteorder('>')
True
>>> np.dtype('>i2') == native_dt.newbyteorder('B')
True | numpy.reference.generated.numpy.dtype.newbyteorder |
numpy.dtype.num attribute dtype.num
A unique number for each of the 21 different built-in types. These are roughly ordered from least-to-most precision. Examples >>> dt = np.dtype(str)
>>> dt.num
19
>>> dt = np.dtype(float)
>>> dt.num
12 | numpy.reference.generated.numpy.dtype.num |
numpy.dtype.shape attribute dtype.shape
Shape tuple of the sub-array if this data type describes a sub-array, and () otherwise. Examples >>> dt = np.dtype(('i4', 4))
>>> dt.shape
(4,)
>>> dt = np.dtype(('i4', (2, 3)))
>>> dt.shape
(2, 3) | numpy.reference.generated.numpy.dtype.shape |
numpy.dtype.str attribute dtype.str
The array-protocol typestring of this data-type object. | numpy.reference.generated.numpy.dtype.str |
numpy.dtype.subdtype attribute dtype.subdtype
Tuple (item_dtype, shape) if this dtype describes a sub-array, and None otherwise. The shape is the fixed shape of the sub-array described by this data type, and item_dtype the data type of the array. If a field whose dtype object has this attribute is retrieved, then the extra dimensions implied by shape are tacked on to the end of the retrieved array. See also dtype.base
Examples >>> x = numpy.dtype('8f')
>>> x.subdtype
(dtype('float32'), (8,))
>>> x = numpy.dtype('i2')
>>> x.subdtype
>>> | numpy.reference.generated.numpy.dtype.subdtype |
numpy.dtype.type attribute dtype.type = None | numpy.reference.generated.numpy.dtype.type |
numpy.errstate.__call__ method errstate.__call__(func)
Call self as a function. | numpy.reference.generated.numpy.errstate.__call__ |
numpy.distutils.exec_command exec_command Implements exec_command function that is (almost) equivalent to commands.getstatusoutput function but on NT, DOS systems the returned status is actually correct (though, the returned status values may be different by a factor). In addition, exec_command takes keyword arguments for (re-)defining environment variables. Provides functions: exec_command — execute command in a specified directory and
in the modified environment. find_executable — locate a command using info from environment
variable PATH. Equivalent to posix which command. Author: Pearu Peterson <[email protected]> Created: 11 January 2003 Requires: Python 2.x Successfully tested on:
os.name sys.platform comments
posix linux2 Debian (sid) Linux, Python 2.1.3+, 2.2.3+, 2.3.3 PyCrust 0.9.3, Idle 1.0.2
posix linux2 Red Hat 9 Linux, Python 2.1.3, 2.2.2, 2.3.2
posix sunos5 SunOS 5.9, Python 2.2, 2.3.2
posix darwin Darwin 7.2.0, Python 2.3
nt win32 Windows Me Python 2.3(EE), Idle 1.0, PyCrust 0.7.2 Python 2.1.1 Idle 0.8
nt win32 Windows 98, Python 2.1.1. Idle 0.8
nt win32 Cygwin 98-4.10, Python 2.1.1(MSC) - echo tests fail i.e. redefining environment variables may not work. FIXED: don’t use cygwin echo! Comment: also cmd /c echo will not work but redefining environment variables do work.
posix cygwin Cygwin 98-4.10, Python 2.3.3(cygming special)
nt win32 Windows XP, Python 2.3.3 Known bugs: Tests, that send messages to stderr, fail when executed from MSYS prompt because the messages are lost at some point. Functions
exec_command(command[, execute_in, ...]) Return (status,output) of executed command.
filepath_from_subprocess_output(output) Convert bytes in the encoding used by a subprocess into a filesystem-appropriate str.
find_executable(exe[, path, _cache]) Return full path of a executable or None.
forward_bytes_to_stdout(val) Forward bytes from a subprocess call to the console, without attempting to decode them.
get_pythonexe()
temp_file_name() | numpy.reference.generated.numpy.distutils.exec_command |
Extending The BitGenerators have been designed to be extendable using standard tools for high-performance Python – numba and Cython. The Generator object can also be used with user-provided BitGenerators as long as these export a small set of required functions. Numba Numba can be used with either CTypes or CFFI. The current iteration of the BitGenerators all export a small set of functions through both interfaces. This example shows how numba can be used to produce gaussian samples using a pure Python implementation which is then compiled. The random numbers are provided by ctypes.next_double. import numpy as np
import numba as nb
from numpy.random import PCG64
from timeit import timeit
bit_gen = PCG64()
next_d = bit_gen.cffi.next_double
state_addr = bit_gen.cffi.state_address
def normals(n, state):
out = np.empty(n)
for i in range((n + 1) // 2):
x1 = 2.0 * next_d(state) - 1.0
x2 = 2.0 * next_d(state) - 1.0
r2 = x1 * x1 + x2 * x2
while r2 >= 1.0 or r2 == 0.0:
x1 = 2.0 * next_d(state) - 1.0
x2 = 2.0 * next_d(state) - 1.0
r2 = x1 * x1 + x2 * x2
f = np.sqrt(-2.0 * np.log(r2) / r2)
out[2 * i] = f * x1
if 2 * i + 1 < n:
out[2 * i + 1] = f * x2
return out
# Compile using Numba
normalsj = nb.jit(normals, nopython=True)
# Must use state address not state with numba
n = 10000
def numbacall():
return normalsj(n, state_addr)
rg = np.random.Generator(PCG64())
def numpycall():
return rg.normal(size=n)
# Check that the functions work
r1 = numbacall()
r2 = numpycall()
assert r1.shape == (n,)
assert r1.shape == r2.shape
t1 = timeit(numbacall, number=1000)
print(f'{t1:.2f} secs for {n} PCG64 (Numba/PCG64) gaussian randoms')
t2 = timeit(numpycall, number=1000)
print(f'{t2:.2f} secs for {n} PCG64 (NumPy/PCG64) gaussian randoms')
Both CTypes and CFFI allow the more complicated distributions to be used directly in Numba after compiling the file distributions.c into a DLL or so. An example showing the use of a more complicated distribution is in the examples section below. Cython Cython can be used to unpack the PyCapsule provided by a BitGenerator. This example uses PCG64 and the example from above. The usual caveats for writing high-performance code using Cython – removing bounds checks and wrap around, providing array alignment information – still apply. #!/usr/bin/env python3
#cython: language_level=3
"""
This file shows how the to use a BitGenerator to create a distribution.
"""
import numpy as np
cimport numpy as np
cimport cython
from cpython.pycapsule cimport PyCapsule_IsValid, PyCapsule_GetPointer
from libc.stdint cimport uint16_t, uint64_t
from numpy.random cimport bitgen_t
from numpy.random import PCG64
from numpy.random.c_distributions cimport (
random_standard_uniform_fill, random_standard_uniform_fill_f)
@cython.boundscheck(False)
@cython.wraparound(False)
def uniforms(Py_ssize_t n):
"""
Create an array of `n` uniformly distributed doubles.
A 'real' distribution would want to process the values into
some non-uniform distribution
"""
cdef Py_ssize_t i
cdef bitgen_t *rng
cdef const char *capsule_name = "BitGenerator"
cdef double[::1] random_values
x = PCG64()
capsule = x.capsule
# Optional check that the capsule if from a BitGenerator
if not PyCapsule_IsValid(capsule, capsule_name):
raise ValueError("Invalid pointer to anon_func_state")
# Cast the pointer
rng = <bitgen_t *> PyCapsule_GetPointer(capsule, capsule_name)
random_values = np.empty(n, dtype='float64')
with x.lock, nogil:
for i in range(n):
# Call the function
random_values[i] = rng.next_double(rng.state)
randoms = np.asarray(random_values)
return randoms
The BitGenerator can also be directly accessed using the members of the bitgen_t struct. @cython.boundscheck(False)
@cython.wraparound(False)
def uint10_uniforms(Py_ssize_t n):
"""Uniform 10 bit integers stored as 16-bit unsigned integers"""
cdef Py_ssize_t i
cdef bitgen_t *rng
cdef const char *capsule_name = "BitGenerator"
cdef uint16_t[::1] random_values
cdef int bits_remaining
cdef int width = 10
cdef uint64_t buff, mask = 0x3FF
x = PCG64()
capsule = x.capsule
if not PyCapsule_IsValid(capsule, capsule_name):
raise ValueError("Invalid pointer to anon_func_state")
rng = <bitgen_t *> PyCapsule_GetPointer(capsule, capsule_name)
random_values = np.empty(n, dtype='uint16')
# Best practice is to release GIL and acquire the lock
bits_remaining = 0
with x.lock, nogil:
for i in range(n):
if bits_remaining < width:
buff = rng.next_uint64(rng.state)
random_values[i] = buff & mask
buff >>= width
randoms = np.asarray(random_values)
return randoms
Cython can be used to directly access the functions in numpy/random/c_distributions.pxd. This requires linking with the npyrandom library located in numpy/random/lib. def uniforms_ex(bit_generator, Py_ssize_t n, dtype=np.float64):
"""
Create an array of `n` uniformly distributed doubles via a "fill" function.
A 'real' distribution would want to process the values into
some non-uniform distribution
Parameters
----------
bit_generator: BitGenerator instance
n: int
Output vector length
dtype: {str, dtype}, optional
Desired dtype, either 'd' (or 'float64') or 'f' (or 'float32'). The
default dtype value is 'd'
"""
cdef Py_ssize_t i
cdef bitgen_t *rng
cdef const char *capsule_name = "BitGenerator"
cdef np.ndarray randoms
capsule = bit_generator.capsule
# Optional check that the capsule if from a BitGenerator
if not PyCapsule_IsValid(capsule, capsule_name):
raise ValueError("Invalid pointer to anon_func_state")
# Cast the pointer
rng = <bitgen_t *> PyCapsule_GetPointer(capsule, capsule_name)
_dtype = np.dtype(dtype)
randoms = np.empty(n, dtype=_dtype)
if _dtype == np.float32:
with bit_generator.lock:
random_standard_uniform_fill_f(rng, n, <float*>np.PyArray_DATA(randoms))
elif _dtype == np.float64:
with bit_generator.lock:
random_standard_uniform_fill(rng, n, <double*>np.PyArray_DATA(randoms))
else:
raise TypeError('Unsupported dtype %r for random' % _dtype)
return randoms
See Extending numpy.random via Cython for the complete listings of these examples and a minimal setup.py to build the c-extension modules. CFFI CFFI can be used to directly access the functions in include/numpy/random/distributions.h. Some “massaging” of the header file is required: """
Use cffi to access any of the underlying C functions from distributions.h
"""
import os
import numpy as np
import cffi
from .parse import parse_distributions_h
ffi = cffi.FFI()
inc_dir = os.path.join(np.get_include(), 'numpy')
# Basic numpy types
ffi.cdef('''
typedef intptr_t npy_intp;
typedef unsigned char npy_bool;
''')
parse_distributions_h(ffi, inc_dir)
Once the header is parsed by ffi.cdef, the functions can be accessed directly from the _generator shared object, using the BitGenerator.cffi interface.
# Compare the distributions.h random_standard_normal_fill to
# Generator.standard_random
bit_gen = np.random.PCG64()
rng = np.random.Generator(bit_gen)
state = bit_gen.state
interface = rng.bit_generator.cffi
n = 100
vals_cffi = ffi.new('double[%d]' % n)
lib.random_standard_normal_fill(interface.bit_generator, n, vals_cffi)
# reset the state
bit_gen.state = state
vals = rng.standard_normal(n)
for i in range(n):
assert vals[i] == vals_cffi[i]
New Bit Generators Generator can be used with user-provided BitGenerators. The simplest way to write a new BitGenerator is to examine the pyx file of one of the existing BitGenerators. The key structure that must be provided is the capsule which contains a PyCapsule to a struct pointer of type bitgen_t, typedef struct bitgen {
void *state;
uint64_t (*next_uint64)(void *st);
uint32_t (*next_uint32)(void *st);
double (*next_double)(void *st);
uint64_t (*next_raw)(void *st);
} bitgen_t;
which provides 5 pointers. The first is an opaque pointer to the data structure used by the BitGenerators. The next three are function pointers which return the next 64- and 32-bit unsigned integers, the next random double and the next raw value. This final function is used for testing and so can be set to the next 64-bit unsigned integer function if not needed. Functions inside Generator use this structure as in bitgen_state->next_uint64(bitgen_state->state)
Examples Numba CFFI + Numba
Cython setup.py extending.pyx extending_distributions.pyx CFFI | numpy.reference.random.extending |
extending.pyx #!/usr/bin/env python3
#cython: language_level=3
from libc.stdint cimport uint32_t
from cpython.pycapsule cimport PyCapsule_IsValid, PyCapsule_GetPointer
import numpy as np
cimport numpy as np
cimport cython
from numpy.random cimport bitgen_t
from numpy.random import PCG64
np.import_array()
@cython.boundscheck(False)
@cython.wraparound(False)
def uniform_mean(Py_ssize_t n):
cdef Py_ssize_t i
cdef bitgen_t *rng
cdef const char *capsule_name = "BitGenerator"
cdef double[::1] random_values
cdef np.ndarray randoms
x = PCG64()
capsule = x.capsule
if not PyCapsule_IsValid(capsule, capsule_name):
raise ValueError("Invalid pointer to anon_func_state")
rng = <bitgen_t *> PyCapsule_GetPointer(capsule, capsule_name)
random_values = np.empty(n)
# Best practice is to acquire the lock whenever generating random values.
# This prevents other threads from modifying the state. Acquiring the lock
# is only necessary if if the GIL is also released, as in this example.
with x.lock, nogil:
for i in range(n):
random_values[i] = rng.next_double(rng.state)
randoms = np.asarray(random_values)
return randoms.mean()
# This function is declared nogil so it can be used without the GIL below
cdef uint32_t bounded_uint(uint32_t lb, uint32_t ub, bitgen_t *rng) nogil:
cdef uint32_t mask, delta, val
mask = delta = ub - lb
mask |= mask >> 1
mask |= mask >> 2
mask |= mask >> 4
mask |= mask >> 8
mask |= mask >> 16
val = rng.next_uint32(rng.state) & mask
while val > delta:
val = rng.next_uint32(rng.state) & mask
return lb + val
@cython.boundscheck(False)
@cython.wraparound(False)
def bounded_uints(uint32_t lb, uint32_t ub, Py_ssize_t n):
cdef Py_ssize_t i
cdef bitgen_t *rng
cdef uint32_t[::1] out
cdef const char *capsule_name = "BitGenerator"
x = PCG64()
out = np.empty(n, dtype=np.uint32)
capsule = x.capsule
if not PyCapsule_IsValid(capsule, capsule_name):
raise ValueError("Invalid pointer to anon_func_state")
rng = <bitgen_t *>PyCapsule_GetPointer(capsule, capsule_name)
with x.lock, nogil:
for i in range(n):
out[i] = bounded_uint(lb, ub, rng)
return np.asarray(out) | numpy.reference.random.examples.cython.extending.pyx |
extending_distributions.pyx #!/usr/bin/env python3
#cython: language_level=3
"""
This file shows how the to use a BitGenerator to create a distribution.
"""
import numpy as np
cimport numpy as np
cimport cython
from cpython.pycapsule cimport PyCapsule_IsValid, PyCapsule_GetPointer
from libc.stdint cimport uint16_t, uint64_t
from numpy.random cimport bitgen_t
from numpy.random import PCG64
from numpy.random.c_distributions cimport (
random_standard_uniform_fill, random_standard_uniform_fill_f)
@cython.boundscheck(False)
@cython.wraparound(False)
def uniforms(Py_ssize_t n):
"""
Create an array of `n` uniformly distributed doubles.
A 'real' distribution would want to process the values into
some non-uniform distribution
"""
cdef Py_ssize_t i
cdef bitgen_t *rng
cdef const char *capsule_name = "BitGenerator"
cdef double[::1] random_values
x = PCG64()
capsule = x.capsule
# Optional check that the capsule if from a BitGenerator
if not PyCapsule_IsValid(capsule, capsule_name):
raise ValueError("Invalid pointer to anon_func_state")
# Cast the pointer
rng = <bitgen_t *> PyCapsule_GetPointer(capsule, capsule_name)
random_values = np.empty(n, dtype='float64')
with x.lock, nogil:
for i in range(n):
# Call the function
random_values[i] = rng.next_double(rng.state)
randoms = np.asarray(random_values)
return randoms
# cython example 2
@cython.boundscheck(False)
@cython.wraparound(False)
def uint10_uniforms(Py_ssize_t n):
"""Uniform 10 bit integers stored as 16-bit unsigned integers"""
cdef Py_ssize_t i
cdef bitgen_t *rng
cdef const char *capsule_name = "BitGenerator"
cdef uint16_t[::1] random_values
cdef int bits_remaining
cdef int width = 10
cdef uint64_t buff, mask = 0x3FF
x = PCG64()
capsule = x.capsule
if not PyCapsule_IsValid(capsule, capsule_name):
raise ValueError("Invalid pointer to anon_func_state")
rng = <bitgen_t *> PyCapsule_GetPointer(capsule, capsule_name)
random_values = np.empty(n, dtype='uint16')
# Best practice is to release GIL and acquire the lock
bits_remaining = 0
with x.lock, nogil:
for i in range(n):
if bits_remaining < width:
buff = rng.next_uint64(rng.state)
random_values[i] = buff & mask
buff >>= width
randoms = np.asarray(random_values)
return randoms
# cython example 3
def uniforms_ex(bit_generator, Py_ssize_t n, dtype=np.float64):
"""
Create an array of `n` uniformly distributed doubles via a "fill" function.
A 'real' distribution would want to process the values into
some non-uniform distribution
Parameters
----------
bit_generator: BitGenerator instance
n: int
Output vector length
dtype: {str, dtype}, optional
Desired dtype, either 'd' (or 'float64') or 'f' (or 'float32'). The
default dtype value is 'd'
"""
cdef Py_ssize_t i
cdef bitgen_t *rng
cdef const char *capsule_name = "BitGenerator"
cdef np.ndarray randoms
capsule = bit_generator.capsule
# Optional check that the capsule if from a BitGenerator
if not PyCapsule_IsValid(capsule, capsule_name):
raise ValueError("Invalid pointer to anon_func_state")
# Cast the pointer
rng = <bitgen_t *> PyCapsule_GetPointer(capsule, capsule_name)
_dtype = np.dtype(dtype)
randoms = np.empty(n, dtype=_dtype)
if _dtype == np.float32:
with bit_generator.lock:
random_standard_uniform_fill_f(rng, n, <float*>np.PyArray_DATA(randoms))
elif _dtype == np.float64:
with bit_generator.lock:
random_standard_uniform_fill(rng, n, <double*>np.PyArray_DATA(randoms))
else:
raise TypeError('Unsupported dtype %r for random' % _dtype)
return randoms | numpy.reference.random.examples.cython.extending_distributions.pyx |
numpy.fft.fft fft.fft(a, n=None, axis=- 1, norm=None)[source]
Compute the one-dimensional discrete Fourier Transform. This function computes the one-dimensional n-point discrete Fourier Transform (DFT) with the efficient Fast Fourier Transform (FFT) algorithm [CT]. Parameters
aarray_like
Input array, can be complex.
nint, optional
Length of the transformed axis of the output. If n is smaller than the length of the input, the input is cropped. If it is larger, the input is padded with zeros. If n is not given, the length of the input along the axis specified by axis is used.
axisint, optional
Axis over which to compute the FFT. If not given, the last axis is used.
norm{“backward”, “ortho”, “forward”}, optional
New in version 1.10.0. Normalization mode (see numpy.fft). Default is “backward”. Indicates which direction of the forward/backward pair of transforms is scaled and with what normalization factor. New in version 1.20.0: The “backward”, “forward” values were added. Returns
outcomplex ndarray
The truncated or zero-padded input, transformed along the axis indicated by axis, or the last one if axis is not specified. Raises
IndexError
If axis is not a valid axis of a. See also numpy.fft
for definition of the DFT and conventions used. ifft
The inverse of fft. fft2
The two-dimensional FFT. fftn
The n-dimensional FFT. rfftn
The n-dimensional FFT of real input. fftfreq
Frequency bins for given FFT parameters. Notes FFT (Fast Fourier Transform) refers to a way the discrete Fourier Transform (DFT) can be calculated efficiently, by using symmetries in the calculated terms. The symmetry is highest when n is a power of 2, and the transform is therefore most efficient for these sizes. The DFT is defined, with the conventions used in this implementation, in the documentation for the numpy.fft module. References CT
Cooley, James W., and John W. Tukey, 1965, “An algorithm for the machine calculation of complex Fourier series,” Math. Comput. 19: 297-301. Examples >>> np.fft.fft(np.exp(2j * np.pi * np.arange(8) / 8))
array([-2.33486982e-16+1.14423775e-17j, 8.00000000e+00-1.25557246e-15j,
2.33486982e-16+2.33486982e-16j, 0.00000000e+00+1.22464680e-16j,
-1.14423775e-17+2.33486982e-16j, 0.00000000e+00+5.20784380e-16j,
1.14423775e-17+1.14423775e-17j, 0.00000000e+00+1.22464680e-16j])
In this example, real input has an FFT which is Hermitian, i.e., symmetric in the real part and anti-symmetric in the imaginary part, as described in the numpy.fft documentation: >>> import matplotlib.pyplot as plt
>>> t = np.arange(256)
>>> sp = np.fft.fft(np.sin(t))
>>> freq = np.fft.fftfreq(t.shape[-1])
>>> plt.plot(freq, sp.real, freq, sp.imag)
[<matplotlib.lines.Line2D object at 0x...>, <matplotlib.lines.Line2D object at 0x...>]
>>> plt.show() | numpy.reference.generated.numpy.fft.fft |
numpy.fft.fft2 fft.fft2(a, s=None, axes=(- 2, - 1), norm=None)[source]
Compute the 2-dimensional discrete Fourier Transform. This function computes the n-dimensional discrete Fourier Transform over any axes in an M-dimensional array by means of the Fast Fourier Transform (FFT). By default, the transform is computed over the last two axes of the input array, i.e., a 2-dimensional FFT. Parameters
aarray_like
Input array, can be complex
ssequence of ints, optional
Shape (length of each transformed axis) of the output (s[0] refers to axis 0, s[1] to axis 1, etc.). This corresponds to n for fft(x, n). Along each axis, if the given shape is smaller than that of the input, the input is cropped. If it is larger, the input is padded with zeros. if s is not given, the shape of the input along the axes specified by axes is used.
axessequence of ints, optional
Axes over which to compute the FFT. If not given, the last two axes are used. A repeated index in axes means the transform over that axis is performed multiple times. A one-element sequence means that a one-dimensional FFT is performed.
norm{“backward”, “ortho”, “forward”}, optional
New in version 1.10.0. Normalization mode (see numpy.fft). Default is “backward”. Indicates which direction of the forward/backward pair of transforms is scaled and with what normalization factor. New in version 1.20.0: The “backward”, “forward” values were added. Returns
outcomplex ndarray
The truncated or zero-padded input, transformed along the axes indicated by axes, or the last two axes if axes is not given. Raises
ValueError
If s and axes have different length, or axes not given and len(s) != 2. IndexError
If an element of axes is larger than than the number of axes of a. See also numpy.fft
Overall view of discrete Fourier transforms, with definitions and conventions used. ifft2
The inverse two-dimensional FFT. fft
The one-dimensional FFT. fftn
The n-dimensional FFT. fftshift
Shifts zero-frequency terms to the center of the array. For two-dimensional input, swaps first and third quadrants, and second and fourth quadrants. Notes fft2 is just fftn with a different default for axes. The output, analogously to fft, contains the term for zero frequency in the low-order corner of the transformed axes, the positive frequency terms in the first half of these axes, the term for the Nyquist frequency in the middle of the axes and the negative frequency terms in the second half of the axes, in order of decreasingly negative frequency. See fftn for details and a plotting example, and numpy.fft for definitions and conventions used. Examples >>> a = np.mgrid[:5, :5][0]
>>> np.fft.fft2(a)
array([[ 50. +0.j , 0. +0.j , 0. +0.j , # may vary
0. +0.j , 0. +0.j ],
[-12.5+17.20477401j, 0. +0.j , 0. +0.j ,
0. +0.j , 0. +0.j ],
[-12.5 +4.0614962j , 0. +0.j , 0. +0.j ,
0. +0.j , 0. +0.j ],
[-12.5 -4.0614962j , 0. +0.j , 0. +0.j ,
0. +0.j , 0. +0.j ],
[-12.5-17.20477401j, 0. +0.j , 0. +0.j ,
0. +0.j , 0. +0.j ]]) | numpy.reference.generated.numpy.fft.fft2 |
numpy.fft.fftfreq fft.fftfreq(n, d=1.0)[source]
Return the Discrete Fourier Transform sample frequencies. The returned float array f contains the frequency bin centers in cycles per unit of the sample spacing (with zero at the start). For instance, if the sample spacing is in seconds, then the frequency unit is cycles/second. Given a window length n and a sample spacing d: f = [0, 1, ..., n/2-1, -n/2, ..., -1] / (d*n) if n is even
f = [0, 1, ..., (n-1)/2, -(n-1)/2, ..., -1] / (d*n) if n is odd
Parameters
nint
Window length.
dscalar, optional
Sample spacing (inverse of the sampling rate). Defaults to 1. Returns
fndarray
Array of length n containing the sample frequencies. Examples >>> signal = np.array([-2, 8, 6, 4, 1, 0, 3, 5], dtype=float)
>>> fourier = np.fft.fft(signal)
>>> n = signal.size
>>> timestep = 0.1
>>> freq = np.fft.fftfreq(n, d=timestep)
>>> freq
array([ 0. , 1.25, 2.5 , ..., -3.75, -2.5 , -1.25]) | numpy.reference.generated.numpy.fft.fftfreq |
numpy.fft.fftn fft.fftn(a, s=None, axes=None, norm=None)[source]
Compute the N-dimensional discrete Fourier Transform. This function computes the N-dimensional discrete Fourier Transform over any number of axes in an M-dimensional array by means of the Fast Fourier Transform (FFT). Parameters
aarray_like
Input array, can be complex.
ssequence of ints, optional
Shape (length of each transformed axis) of the output (s[0] refers to axis 0, s[1] to axis 1, etc.). This corresponds to n for fft(x, n). Along any axis, if the given shape is smaller than that of the input, the input is cropped. If it is larger, the input is padded with zeros. if s is not given, the shape of the input along the axes specified by axes is used.
axessequence of ints, optional
Axes over which to compute the FFT. If not given, the last len(s) axes are used, or all axes if s is also not specified. Repeated indices in axes means that the transform over that axis is performed multiple times.
norm{“backward”, “ortho”, “forward”}, optional
New in version 1.10.0. Normalization mode (see numpy.fft). Default is “backward”. Indicates which direction of the forward/backward pair of transforms is scaled and with what normalization factor. New in version 1.20.0: The “backward”, “forward” values were added. Returns
outcomplex ndarray
The truncated or zero-padded input, transformed along the axes indicated by axes, or by a combination of s and a, as explained in the parameters section above. Raises
ValueError
If s and axes have different length. IndexError
If an element of axes is larger than than the number of axes of a. See also numpy.fft
Overall view of discrete Fourier transforms, with definitions and conventions used. ifftn
The inverse of fftn, the inverse n-dimensional FFT. fft
The one-dimensional FFT, with definitions and conventions used. rfftn
The n-dimensional FFT of real input. fft2
The two-dimensional FFT. fftshift
Shifts zero-frequency terms to centre of array Notes The output, analogously to fft, contains the term for zero frequency in the low-order corner of all axes, the positive frequency terms in the first half of all axes, the term for the Nyquist frequency in the middle of all axes and the negative frequency terms in the second half of all axes, in order of decreasingly negative frequency. See numpy.fft for details, definitions and conventions used. Examples >>> a = np.mgrid[:3, :3, :3][0]
>>> np.fft.fftn(a, axes=(1, 2))
array([[[ 0.+0.j, 0.+0.j, 0.+0.j], # may vary
[ 0.+0.j, 0.+0.j, 0.+0.j],
[ 0.+0.j, 0.+0.j, 0.+0.j]],
[[ 9.+0.j, 0.+0.j, 0.+0.j],
[ 0.+0.j, 0.+0.j, 0.+0.j],
[ 0.+0.j, 0.+0.j, 0.+0.j]],
[[18.+0.j, 0.+0.j, 0.+0.j],
[ 0.+0.j, 0.+0.j, 0.+0.j],
[ 0.+0.j, 0.+0.j, 0.+0.j]]])
>>> np.fft.fftn(a, (2, 2), axes=(0, 1))
array([[[ 2.+0.j, 2.+0.j, 2.+0.j], # may vary
[ 0.+0.j, 0.+0.j, 0.+0.j]],
[[-2.+0.j, -2.+0.j, -2.+0.j],
[ 0.+0.j, 0.+0.j, 0.+0.j]]])
>>> import matplotlib.pyplot as plt
>>> [X, Y] = np.meshgrid(2 * np.pi * np.arange(200) / 12,
... 2 * np.pi * np.arange(200) / 34)
>>> S = np.sin(X) + np.cos(Y) + np.random.uniform(0, 1, X.shape)
>>> FS = np.fft.fftn(S)
>>> plt.imshow(np.log(np.abs(np.fft.fftshift(FS))**2))
<matplotlib.image.AxesImage object at 0x...>
>>> plt.show() | numpy.reference.generated.numpy.fft.fftn |
numpy.fft.fftshift fft.fftshift(x, axes=None)[source]
Shift the zero-frequency component to the center of the spectrum. This function swaps half-spaces for all axes listed (defaults to all). Note that y[0] is the Nyquist component only if len(x) is even. Parameters
xarray_like
Input array.
axesint or shape tuple, optional
Axes over which to shift. Default is None, which shifts all axes. Returns
yndarray
The shifted array. See also ifftshift
The inverse of fftshift. Examples >>> freqs = np.fft.fftfreq(10, 0.1)
>>> freqs
array([ 0., 1., 2., ..., -3., -2., -1.])
>>> np.fft.fftshift(freqs)
array([-5., -4., -3., -2., -1., 0., 1., 2., 3., 4.])
Shift the zero-frequency component only along the second axis: >>> freqs = np.fft.fftfreq(9, d=1./9).reshape(3, 3)
>>> freqs
array([[ 0., 1., 2.],
[ 3., 4., -4.],
[-3., -2., -1.]])
>>> np.fft.fftshift(freqs, axes=(1,))
array([[ 2., 0., 1.],
[-4., 3., 4.],
[-1., -3., -2.]]) | numpy.reference.generated.numpy.fft.fftshift |
numpy.fft.hfft fft.hfft(a, n=None, axis=- 1, norm=None)[source]
Compute the FFT of a signal that has Hermitian symmetry, i.e., a real spectrum. Parameters
aarray_like
The input array.
nint, optional
Length of the transformed axis of the output. For n output points, n//2 + 1 input points are necessary. If the input is longer than this, it is cropped. If it is shorter than this, it is padded with zeros. If n is not given, it is taken to be 2*(m-1) where m is the length of the input along the axis specified by axis.
axisint, optional
Axis over which to compute the FFT. If not given, the last axis is used.
norm{“backward”, “ortho”, “forward”}, optional
New in version 1.10.0. Normalization mode (see numpy.fft). Default is “backward”. Indicates which direction of the forward/backward pair of transforms is scaled and with what normalization factor. New in version 1.20.0: The “backward”, “forward” values were added. Returns
outndarray
The truncated or zero-padded input, transformed along the axis indicated by axis, or the last one if axis is not specified. The length of the transformed axis is n, or, if n is not given, 2*m - 2 where m is the length of the transformed axis of the input. To get an odd number of output points, n must be specified, for instance as 2*m - 1 in the typical case, Raises
IndexError
If axis is not a valid axis of a. See also rfft
Compute the one-dimensional FFT for real input. ihfft
The inverse of hfft. Notes hfft/ihfft are a pair analogous to rfft/irfft, but for the opposite case: here the signal has Hermitian symmetry in the time domain and is real in the frequency domain. So here it’s hfft for which you must supply the length of the result if it is to be odd. even: ihfft(hfft(a, 2*len(a) - 2)) == a, within roundoff error, odd: ihfft(hfft(a, 2*len(a) - 1)) == a, within roundoff error. The correct interpretation of the hermitian input depends on the length of the original data, as given by n. This is because each input shape could correspond to either an odd or even length signal. By default, hfft assumes an even output length which puts the last entry at the Nyquist frequency; aliasing with its symmetric counterpart. By Hermitian symmetry, the value is thus treated as purely real. To avoid losing information, the shape of the full signal must be given. Examples >>> signal = np.array([1, 2, 3, 4, 3, 2])
>>> np.fft.fft(signal)
array([15.+0.j, -4.+0.j, 0.+0.j, -1.-0.j, 0.+0.j, -4.+0.j]) # may vary
>>> np.fft.hfft(signal[:4]) # Input first half of signal
array([15., -4., 0., -1., 0., -4.])
>>> np.fft.hfft(signal, 6) # Input entire signal and truncate
array([15., -4., 0., -1., 0., -4.])
>>> signal = np.array([[1, 1.j], [-1.j, 2]])
>>> np.conj(signal.T) - signal # check Hermitian symmetry
array([[ 0.-0.j, -0.+0.j], # may vary
[ 0.+0.j, 0.-0.j]])
>>> freq_spectrum = np.fft.hfft(signal)
>>> freq_spectrum
array([[ 1., 1.],
[ 2., -2.]]) | numpy.reference.generated.numpy.fft.hfft |
numpy.fft.ifft fft.ifft(a, n=None, axis=- 1, norm=None)[source]
Compute the one-dimensional inverse discrete Fourier Transform. This function computes the inverse of the one-dimensional n-point discrete Fourier transform computed by fft. In other words, ifft(fft(a)) == a to within numerical accuracy. For a general description of the algorithm and definitions, see numpy.fft. The input should be ordered in the same way as is returned by fft, i.e.,
a[0] should contain the zero frequency term,
a[1:n//2] should contain the positive-frequency terms,
a[n//2 + 1:] should contain the negative-frequency terms, in increasing order starting from the most negative frequency. For an even number of input points, A[n//2] represents the sum of the values at the positive and negative Nyquist frequencies, as the two are aliased together. See numpy.fft for details. Parameters
aarray_like
Input array, can be complex.
nint, optional
Length of the transformed axis of the output. If n is smaller than the length of the input, the input is cropped. If it is larger, the input is padded with zeros. If n is not given, the length of the input along the axis specified by axis is used. See notes about padding issues.
axisint, optional
Axis over which to compute the inverse DFT. If not given, the last axis is used.
norm{“backward”, “ortho”, “forward”}, optional
New in version 1.10.0. Normalization mode (see numpy.fft). Default is “backward”. Indicates which direction of the forward/backward pair of transforms is scaled and with what normalization factor. New in version 1.20.0: The “backward”, “forward” values were added. Returns
outcomplex ndarray
The truncated or zero-padded input, transformed along the axis indicated by axis, or the last one if axis is not specified. Raises
IndexError
If axis is not a valid axis of a. See also numpy.fft
An introduction, with definitions and general explanations. fft
The one-dimensional (forward) FFT, of which ifft is the inverse ifft2
The two-dimensional inverse FFT. ifftn
The n-dimensional inverse FFT. Notes If the input parameter n is larger than the size of the input, the input is padded by appending zeros at the end. Even though this is the common approach, it might lead to surprising results. If a different padding is desired, it must be performed before calling ifft. Examples >>> np.fft.ifft([0, 4, 0, 0])
array([ 1.+0.j, 0.+1.j, -1.+0.j, 0.-1.j]) # may vary
Create and plot a band-limited signal with random phases: >>> import matplotlib.pyplot as plt
>>> t = np.arange(400)
>>> n = np.zeros((400,), dtype=complex)
>>> n[40:60] = np.exp(1j*np.random.uniform(0, 2*np.pi, (20,)))
>>> s = np.fft.ifft(n)
>>> plt.plot(t, s.real, label='real')
[<matplotlib.lines.Line2D object at ...>]
>>> plt.plot(t, s.imag, '--', label='imaginary')
[<matplotlib.lines.Line2D object at ...>]
>>> plt.legend()
<matplotlib.legend.Legend object at ...>
>>> plt.show() | numpy.reference.generated.numpy.fft.ifft |
numpy.fft.ifft2 fft.ifft2(a, s=None, axes=(- 2, - 1), norm=None)[source]
Compute the 2-dimensional inverse discrete Fourier Transform. This function computes the inverse of the 2-dimensional discrete Fourier Transform over any number of axes in an M-dimensional array by means of the Fast Fourier Transform (FFT). In other words, ifft2(fft2(a)) == a to within numerical accuracy. By default, the inverse transform is computed over the last two axes of the input array. The input, analogously to ifft, should be ordered in the same way as is returned by fft2, i.e. it should have the term for zero frequency in the low-order corner of the two axes, the positive frequency terms in the first half of these axes, the term for the Nyquist frequency in the middle of the axes and the negative frequency terms in the second half of both axes, in order of decreasingly negative frequency. Parameters
aarray_like
Input array, can be complex.
ssequence of ints, optional
Shape (length of each axis) of the output (s[0] refers to axis 0, s[1] to axis 1, etc.). This corresponds to n for ifft(x, n). Along each axis, if the given shape is smaller than that of the input, the input is cropped. If it is larger, the input is padded with zeros. if s is not given, the shape of the input along the axes specified by axes is used. See notes for issue on ifft zero padding.
axessequence of ints, optional
Axes over which to compute the FFT. If not given, the last two axes are used. A repeated index in axes means the transform over that axis is performed multiple times. A one-element sequence means that a one-dimensional FFT is performed.
norm{“backward”, “ortho”, “forward”}, optional
New in version 1.10.0. Normalization mode (see numpy.fft). Default is “backward”. Indicates which direction of the forward/backward pair of transforms is scaled and with what normalization factor. New in version 1.20.0: The “backward”, “forward” values were added. Returns
outcomplex ndarray
The truncated or zero-padded input, transformed along the axes indicated by axes, or the last two axes if axes is not given. Raises
ValueError
If s and axes have different length, or axes not given and len(s) != 2. IndexError
If an element of axes is larger than than the number of axes of a. See also numpy.fft
Overall view of discrete Fourier transforms, with definitions and conventions used. fft2
The forward 2-dimensional FFT, of which ifft2 is the inverse. ifftn
The inverse of the n-dimensional FFT. fft
The one-dimensional FFT. ifft
The one-dimensional inverse FFT. Notes ifft2 is just ifftn with a different default for axes. See ifftn for details and a plotting example, and numpy.fft for definition and conventions used. Zero-padding, analogously with ifft, is performed by appending zeros to the input along the specified dimension. Although this is the common approach, it might lead to surprising results. If another form of zero padding is desired, it must be performed before ifft2 is called. Examples >>> a = 4 * np.eye(4)
>>> np.fft.ifft2(a)
array([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j], # may vary
[0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j],
[0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],
[0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j]]) | numpy.reference.generated.numpy.fft.ifft2 |
numpy.fft.ifftn fft.ifftn(a, s=None, axes=None, norm=None)[source]
Compute the N-dimensional inverse discrete Fourier Transform. This function computes the inverse of the N-dimensional discrete Fourier Transform over any number of axes in an M-dimensional array by means of the Fast Fourier Transform (FFT). In other words, ifftn(fftn(a)) == a to within numerical accuracy. For a description of the definitions and conventions used, see numpy.fft. The input, analogously to ifft, should be ordered in the same way as is returned by fftn, i.e. it should have the term for zero frequency in all axes in the low-order corner, the positive frequency terms in the first half of all axes, the term for the Nyquist frequency in the middle of all axes and the negative frequency terms in the second half of all axes, in order of decreasingly negative frequency. Parameters
aarray_like
Input array, can be complex.
ssequence of ints, optional
Shape (length of each transformed axis) of the output (s[0] refers to axis 0, s[1] to axis 1, etc.). This corresponds to n for ifft(x, n). Along any axis, if the given shape is smaller than that of the input, the input is cropped. If it is larger, the input is padded with zeros. if s is not given, the shape of the input along the axes specified by axes is used. See notes for issue on ifft zero padding.
axessequence of ints, optional
Axes over which to compute the IFFT. If not given, the last len(s) axes are used, or all axes if s is also not specified. Repeated indices in axes means that the inverse transform over that axis is performed multiple times.
norm{“backward”, “ortho”, “forward”}, optional
New in version 1.10.0. Normalization mode (see numpy.fft). Default is “backward”. Indicates which direction of the forward/backward pair of transforms is scaled and with what normalization factor. New in version 1.20.0: The “backward”, “forward” values were added. Returns
outcomplex ndarray
The truncated or zero-padded input, transformed along the axes indicated by axes, or by a combination of s or a, as explained in the parameters section above. Raises
ValueError
If s and axes have different length. IndexError
If an element of axes is larger than than the number of axes of a. See also numpy.fft
Overall view of discrete Fourier transforms, with definitions and conventions used. fftn
The forward n-dimensional FFT, of which ifftn is the inverse. ifft
The one-dimensional inverse FFT. ifft2
The two-dimensional inverse FFT. ifftshift
Undoes fftshift, shifts zero-frequency terms to beginning of array. Notes See numpy.fft for definitions and conventions used. Zero-padding, analogously with ifft, is performed by appending zeros to the input along the specified dimension. Although this is the common approach, it might lead to surprising results. If another form of zero padding is desired, it must be performed before ifftn is called. Examples >>> a = np.eye(4)
>>> np.fft.ifftn(np.fft.fftn(a, axes=(0,)), axes=(1,))
array([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j], # may vary
[0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],
[0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],
[0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]])
Create and plot an image with band-limited frequency content: >>> import matplotlib.pyplot as plt
>>> n = np.zeros((200,200), dtype=complex)
>>> n[60:80, 20:40] = np.exp(1j*np.random.uniform(0, 2*np.pi, (20, 20)))
>>> im = np.fft.ifftn(n).real
>>> plt.imshow(im)
<matplotlib.image.AxesImage object at 0x...>
>>> plt.show() | numpy.reference.generated.numpy.fft.ifftn |
numpy.fft.ifftshift fft.ifftshift(x, axes=None)[source]
The inverse of fftshift. Although identical for even-length x, the functions differ by one sample for odd-length x. Parameters
xarray_like
Input array.
axesint or shape tuple, optional
Axes over which to calculate. Defaults to None, which shifts all axes. Returns
yndarray
The shifted array. See also fftshift
Shift zero-frequency component to the center of the spectrum. Examples >>> freqs = np.fft.fftfreq(9, d=1./9).reshape(3, 3)
>>> freqs
array([[ 0., 1., 2.],
[ 3., 4., -4.],
[-3., -2., -1.]])
>>> np.fft.ifftshift(np.fft.fftshift(freqs))
array([[ 0., 1., 2.],
[ 3., 4., -4.],
[-3., -2., -1.]]) | numpy.reference.generated.numpy.fft.ifftshift |
numpy.fft.ihfft fft.ihfft(a, n=None, axis=- 1, norm=None)[source]
Compute the inverse FFT of a signal that has Hermitian symmetry. Parameters
aarray_like
Input array.
nint, optional
Length of the inverse FFT, the number of points along transformation axis in the input to use. If n is smaller than the length of the input, the input is cropped. If it is larger, the input is padded with zeros. If n is not given, the length of the input along the axis specified by axis is used.
axisint, optional
Axis over which to compute the inverse FFT. If not given, the last axis is used.
norm{“backward”, “ortho”, “forward”}, optional
New in version 1.10.0. Normalization mode (see numpy.fft). Default is “backward”. Indicates which direction of the forward/backward pair of transforms is scaled and with what normalization factor. New in version 1.20.0: The “backward”, “forward” values were added. Returns
outcomplex ndarray
The truncated or zero-padded input, transformed along the axis indicated by axis, or the last one if axis is not specified. The length of the transformed axis is n//2 + 1. See also
hfft, irfft
Notes hfft/ihfft are a pair analogous to rfft/irfft, but for the opposite case: here the signal has Hermitian symmetry in the time domain and is real in the frequency domain. So here it’s hfft for which you must supply the length of the result if it is to be odd: even: ihfft(hfft(a, 2*len(a) - 2)) == a, within roundoff error, odd: ihfft(hfft(a, 2*len(a) - 1)) == a, within roundoff error. Examples >>> spectrum = np.array([ 15, -4, 0, -1, 0, -4])
>>> np.fft.ifft(spectrum)
array([1.+0.j, 2.+0.j, 3.+0.j, 4.+0.j, 3.+0.j, 2.+0.j]) # may vary
>>> np.fft.ihfft(spectrum)
array([ 1.-0.j, 2.-0.j, 3.-0.j, 4.-0.j]) # may vary | numpy.reference.generated.numpy.fft.ihfft |
numpy.fft.irfft fft.irfft(a, n=None, axis=- 1, norm=None)[source]
Computes the inverse of rfft. This function computes the inverse of the one-dimensional n-point discrete Fourier Transform of real input computed by rfft. In other words, irfft(rfft(a), len(a)) == a to within numerical accuracy. (See Notes below for why len(a) is necessary here.) The input is expected to be in the form returned by rfft, i.e. the real zero-frequency term followed by the complex positive frequency terms in order of increasing frequency. Since the discrete Fourier Transform of real input is Hermitian-symmetric, the negative frequency terms are taken to be the complex conjugates of the corresponding positive frequency terms. Parameters
aarray_like
The input array.
nint, optional
Length of the transformed axis of the output. For n output points, n//2+1 input points are necessary. If the input is longer than this, it is cropped. If it is shorter than this, it is padded with zeros. If n is not given, it is taken to be 2*(m-1) where m is the length of the input along the axis specified by axis.
axisint, optional
Axis over which to compute the inverse FFT. If not given, the last axis is used.
norm{“backward”, “ortho”, “forward”}, optional
New in version 1.10.0. Normalization mode (see numpy.fft). Default is “backward”. Indicates which direction of the forward/backward pair of transforms is scaled and with what normalization factor. New in version 1.20.0: The “backward”, “forward” values were added. Returns
outndarray
The truncated or zero-padded input, transformed along the axis indicated by axis, or the last one if axis is not specified. The length of the transformed axis is n, or, if n is not given, 2*(m-1) where m is the length of the transformed axis of the input. To get an odd number of output points, n must be specified. Raises
IndexError
If axis is not a valid axis of a. See also numpy.fft
For definition of the DFT and conventions used. rfft
The one-dimensional FFT of real input, of which irfft is inverse. fft
The one-dimensional FFT. irfft2
The inverse of the two-dimensional FFT of real input. irfftn
The inverse of the n-dimensional FFT of real input. Notes Returns the real valued n-point inverse discrete Fourier transform of a, where a contains the non-negative frequency terms of a Hermitian-symmetric sequence. n is the length of the result, not the input. If you specify an n such that a must be zero-padded or truncated, the extra/removed values will be added/removed at high frequencies. One can thus resample a series to m points via Fourier interpolation by: a_resamp = irfft(rfft(a), m). The correct interpretation of the hermitian input depends on the length of the original data, as given by n. This is because each input shape could correspond to either an odd or even length signal. By default, irfft assumes an even output length which puts the last entry at the Nyquist frequency; aliasing with its symmetric counterpart. By Hermitian symmetry, the value is thus treated as purely real. To avoid losing information, the correct length of the real input must be given. Examples >>> np.fft.ifft([1, -1j, -1, 1j])
array([0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j]) # may vary
>>> np.fft.irfft([1, -1j, -1])
array([0., 1., 0., 0.])
Notice how the last term in the input to the ordinary ifft is the complex conjugate of the second term, and the output has zero imaginary part everywhere. When calling irfft, the negative frequencies are not specified, and the output array is purely real. | numpy.reference.generated.numpy.fft.irfft |
numpy.fft.irfft2 fft.irfft2(a, s=None, axes=(- 2, - 1), norm=None)[source]
Computes the inverse of rfft2. Parameters
aarray_like
The input array
ssequence of ints, optional
Shape of the real output to the inverse FFT.
axessequence of ints, optional
The axes over which to compute the inverse fft. Default is the last two axes.
norm{“backward”, “ortho”, “forward”}, optional
New in version 1.10.0. Normalization mode (see numpy.fft). Default is “backward”. Indicates which direction of the forward/backward pair of transforms is scaled and with what normalization factor. New in version 1.20.0: The “backward”, “forward” values were added. Returns
outndarray
The result of the inverse real 2-D FFT. See also rfft2
The forward two-dimensional FFT of real input, of which irfft2 is the inverse. rfft
The one-dimensional FFT for real input. irfft
The inverse of the one-dimensional FFT of real input. irfftn
Compute the inverse of the N-dimensional FFT of real input. Notes This is really irfftn with different defaults. For more details see irfftn. Examples >>> a = np.mgrid[:5, :5][0]
>>> A = np.fft.rfft2(a)
>>> np.fft.irfft2(A, s=a.shape)
array([[0., 0., 0., 0., 0.],
[1., 1., 1., 1., 1.],
[2., 2., 2., 2., 2.],
[3., 3., 3., 3., 3.],
[4., 4., 4., 4., 4.]]) | numpy.reference.generated.numpy.fft.irfft2 |
numpy.fft.irfftn fft.irfftn(a, s=None, axes=None, norm=None)[source]
Computes the inverse of rfftn. This function computes the inverse of the N-dimensional discrete Fourier Transform for real input over any number of axes in an M-dimensional array by means of the Fast Fourier Transform (FFT). In other words, irfftn(rfftn(a), a.shape) == a to within numerical accuracy. (The a.shape is necessary like len(a) is for irfft, and for the same reason.) The input should be ordered in the same way as is returned by rfftn, i.e. as for irfft for the final transformation axis, and as for ifftn along all the other axes. Parameters
aarray_like
Input array.
ssequence of ints, optional
Shape (length of each transformed axis) of the output (s[0] refers to axis 0, s[1] to axis 1, etc.). s is also the number of input points used along this axis, except for the last axis, where s[-1]//2+1 points of the input are used. Along any axis, if the shape indicated by s is smaller than that of the input, the input is cropped. If it is larger, the input is padded with zeros. If s is not given, the shape of the input along the axes specified by axes is used. Except for the last axis which is taken to be 2*(m-1) where m is the length of the input along that axis.
axessequence of ints, optional
Axes over which to compute the inverse FFT. If not given, the last len(s) axes are used, or all axes if s is also not specified. Repeated indices in axes means that the inverse transform over that axis is performed multiple times.
norm{“backward”, “ortho”, “forward”}, optional
New in version 1.10.0. Normalization mode (see numpy.fft). Default is “backward”. Indicates which direction of the forward/backward pair of transforms is scaled and with what normalization factor. New in version 1.20.0: The “backward”, “forward” values were added. Returns
outndarray
The truncated or zero-padded input, transformed along the axes indicated by axes, or by a combination of s or a, as explained in the parameters section above. The length of each transformed axis is as given by the corresponding element of s, or the length of the input in every axis except for the last one if s is not given. In the final transformed axis the length of the output when s is not given is 2*(m-1) where m is the length of the final transformed axis of the input. To get an odd number of output points in the final axis, s must be specified. Raises
ValueError
If s and axes have different length. IndexError
If an element of axes is larger than than the number of axes of a. See also rfftn
The forward n-dimensional FFT of real input, of which ifftn is the inverse. fft
The one-dimensional FFT, with definitions and conventions used. irfft
The inverse of the one-dimensional FFT of real input. irfft2
The inverse of the two-dimensional FFT of real input. Notes See fft for definitions and conventions used. See rfft for definitions and conventions used for real input. The correct interpretation of the hermitian input depends on the shape of the original data, as given by s. This is because each input shape could correspond to either an odd or even length signal. By default, irfftn assumes an even output length which puts the last entry at the Nyquist frequency; aliasing with its symmetric counterpart. When performing the final complex to real transform, the last value is thus treated as purely real. To avoid losing information, the correct shape of the real input must be given. Examples >>> a = np.zeros((3, 2, 2))
>>> a[0, 0, 0] = 3 * 2 * 2
>>> np.fft.irfftn(a)
array([[[1., 1.],
[1., 1.]],
[[1., 1.],
[1., 1.]],
[[1., 1.],
[1., 1.]]]) | numpy.reference.generated.numpy.fft.irfftn |
numpy.fft.rfft fft.rfft(a, n=None, axis=- 1, norm=None)[source]
Compute the one-dimensional discrete Fourier Transform for real input. This function computes the one-dimensional n-point discrete Fourier Transform (DFT) of a real-valued array by means of an efficient algorithm called the Fast Fourier Transform (FFT). Parameters
aarray_like
Input array
nint, optional
Number of points along transformation axis in the input to use. If n is smaller than the length of the input, the input is cropped. If it is larger, the input is padded with zeros. If n is not given, the length of the input along the axis specified by axis is used.
axisint, optional
Axis over which to compute the FFT. If not given, the last axis is used.
norm{“backward”, “ortho”, “forward”}, optional
New in version 1.10.0. Normalization mode (see numpy.fft). Default is “backward”. Indicates which direction of the forward/backward pair of transforms is scaled and with what normalization factor. New in version 1.20.0: The “backward”, “forward” values were added. Returns
outcomplex ndarray
The truncated or zero-padded input, transformed along the axis indicated by axis, or the last one if axis is not specified. If n is even, the length of the transformed axis is (n/2)+1. If n is odd, the length is (n+1)/2. Raises
IndexError
If axis is not a valid axis of a. See also numpy.fft
For definition of the DFT and conventions used. irfft
The inverse of rfft. fft
The one-dimensional FFT of general (complex) input. fftn
The n-dimensional FFT. rfftn
The n-dimensional FFT of real input. Notes When the DFT is computed for purely real input, the output is Hermitian-symmetric, i.e. the negative frequency terms are just the complex conjugates of the corresponding positive-frequency terms, and the negative-frequency terms are therefore redundant. This function does not compute the negative frequency terms, and the length of the transformed axis of the output is therefore n//2 + 1. When A = rfft(a) and fs is the sampling frequency, A[0] contains the zero-frequency term 0*fs, which is real due to Hermitian symmetry. If n is even, A[-1] contains the term representing both positive and negative Nyquist frequency (+fs/2 and -fs/2), and must also be purely real. If n is odd, there is no term at fs/2; A[-1] contains the largest positive frequency (fs/2*(n-1)/n), and is complex in the general case. If the input a contains an imaginary part, it is silently discarded. Examples >>> np.fft.fft([0, 1, 0, 0])
array([ 1.+0.j, 0.-1.j, -1.+0.j, 0.+1.j]) # may vary
>>> np.fft.rfft([0, 1, 0, 0])
array([ 1.+0.j, 0.-1.j, -1.+0.j]) # may vary
Notice how the final element of the fft output is the complex conjugate of the second element, for real input. For rfft, this symmetry is exploited to compute only the non-negative frequency terms. | numpy.reference.generated.numpy.fft.rfft |
numpy.fft.rfft2 fft.rfft2(a, s=None, axes=(- 2, - 1), norm=None)[source]
Compute the 2-dimensional FFT of a real array. Parameters
aarray
Input array, taken to be real.
ssequence of ints, optional
Shape of the FFT.
axessequence of ints, optional
Axes over which to compute the FFT.
norm{“backward”, “ortho”, “forward”}, optional
New in version 1.10.0. Normalization mode (see numpy.fft). Default is “backward”. Indicates which direction of the forward/backward pair of transforms is scaled and with what normalization factor. New in version 1.20.0: The “backward”, “forward” values were added. Returns
outndarray
The result of the real 2-D FFT. See also rfftn
Compute the N-dimensional discrete Fourier Transform for real input. Notes This is really just rfftn with different default behavior. For more details see rfftn. Examples >>> a = np.mgrid[:5, :5][0]
>>> np.fft.rfft2(a)
array([[ 50. +0.j , 0. +0.j , 0. +0.j ],
[-12.5+17.20477401j, 0. +0.j , 0. +0.j ],
[-12.5 +4.0614962j , 0. +0.j , 0. +0.j ],
[-12.5 -4.0614962j , 0. +0.j , 0. +0.j ],
[-12.5-17.20477401j, 0. +0.j , 0. +0.j ]]) | numpy.reference.generated.numpy.fft.rfft2 |
numpy.fft.rfftfreq fft.rfftfreq(n, d=1.0)[source]
Return the Discrete Fourier Transform sample frequencies (for usage with rfft, irfft). The returned float array f contains the frequency bin centers in cycles per unit of the sample spacing (with zero at the start). For instance, if the sample spacing is in seconds, then the frequency unit is cycles/second. Given a window length n and a sample spacing d: f = [0, 1, ..., n/2-1, n/2] / (d*n) if n is even
f = [0, 1, ..., (n-1)/2-1, (n-1)/2] / (d*n) if n is odd
Unlike fftfreq (but like scipy.fftpack.rfftfreq) the Nyquist frequency component is considered to be positive. Parameters
nint
Window length.
dscalar, optional
Sample spacing (inverse of the sampling rate). Defaults to 1. Returns
fndarray
Array of length n//2 + 1 containing the sample frequencies. Examples >>> signal = np.array([-2, 8, 6, 4, 1, 0, 3, 5, -3, 4], dtype=float)
>>> fourier = np.fft.rfft(signal)
>>> n = signal.size
>>> sample_rate = 100
>>> freq = np.fft.fftfreq(n, d=1./sample_rate)
>>> freq
array([ 0., 10., 20., ..., -30., -20., -10.])
>>> freq = np.fft.rfftfreq(n, d=1./sample_rate)
>>> freq
array([ 0., 10., 20., 30., 40., 50.]) | numpy.reference.generated.numpy.fft.rfftfreq |
numpy.fft.rfftn fft.rfftn(a, s=None, axes=None, norm=None)[source]
Compute the N-dimensional discrete Fourier Transform for real input. This function computes the N-dimensional discrete Fourier Transform over any number of axes in an M-dimensional real array by means of the Fast Fourier Transform (FFT). By default, all axes are transformed, with the real transform performed over the last axis, while the remaining transforms are complex. Parameters
aarray_like
Input array, taken to be real.
ssequence of ints, optional
Shape (length along each transformed axis) to use from the input. (s[0] refers to axis 0, s[1] to axis 1, etc.). The final element of s corresponds to n for rfft(x, n), while for the remaining axes, it corresponds to n for fft(x, n). Along any axis, if the given shape is smaller than that of the input, the input is cropped. If it is larger, the input is padded with zeros. if s is not given, the shape of the input along the axes specified by axes is used.
axessequence of ints, optional
Axes over which to compute the FFT. If not given, the last len(s) axes are used, or all axes if s is also not specified.
norm{“backward”, “ortho”, “forward”}, optional
New in version 1.10.0. Normalization mode (see numpy.fft). Default is “backward”. Indicates which direction of the forward/backward pair of transforms is scaled and with what normalization factor. New in version 1.20.0: The “backward”, “forward” values were added. Returns
outcomplex ndarray
The truncated or zero-padded input, transformed along the axes indicated by axes, or by a combination of s and a, as explained in the parameters section above. The length of the last axis transformed will be s[-1]//2+1, while the remaining transformed axes will have lengths according to s, or unchanged from the input. Raises
ValueError
If s and axes have different length. IndexError
If an element of axes is larger than than the number of axes of a. See also irfftn
The inverse of rfftn, i.e. the inverse of the n-dimensional FFT of real input. fft
The one-dimensional FFT, with definitions and conventions used. rfft
The one-dimensional FFT of real input. fftn
The n-dimensional FFT. rfft2
The two-dimensional FFT of real input. Notes The transform for real input is performed over the last transformation axis, as by rfft, then the transform over the remaining axes is performed as by fftn. The order of the output is as for rfft for the final transformation axis, and as for fftn for the remaining transformation axes. See fft for details, definitions and conventions used. Examples >>> a = np.ones((2, 2, 2))
>>> np.fft.rfftn(a)
array([[[8.+0.j, 0.+0.j], # may vary
[0.+0.j, 0.+0.j]],
[[0.+0.j, 0.+0.j],
[0.+0.j, 0.+0.j]]])
>>> np.fft.rfftn(a, axes=(2, 0))
array([[[4.+0.j, 0.+0.j], # may vary
[4.+0.j, 0.+0.j]],
[[0.+0.j, 0.+0.j],
[0.+0.j, 0.+0.j]]]) | numpy.reference.generated.numpy.fft.rfftn |
numpy.flatiter.base attribute flatiter.base
A reference to the array that is iterated over. Examples >>> x = np.arange(5)
>>> fl = x.flat
>>> fl.base is x
True | numpy.reference.generated.numpy.flatiter.base |
numpy.flatiter.coords attribute flatiter.coords
An N-dimensional tuple of current coordinates. Examples >>> x = np.arange(6).reshape(2, 3)
>>> fl = x.flat
>>> fl.coords
(0, 0)
>>> next(fl)
0
>>> fl.coords
(0, 1) | numpy.reference.generated.numpy.flatiter.coords |
numpy.flatiter.copy method flatiter.copy()
Get a copy of the iterator as a 1-D array. Examples >>> x = np.arange(6).reshape(2, 3)
>>> x
array([[0, 1, 2],
[3, 4, 5]])
>>> fl = x.flat
>>> fl.copy()
array([0, 1, 2, 3, 4, 5]) | numpy.reference.generated.numpy.flatiter.copy |
numpy.flatiter.index attribute flatiter.index
Current flat index into the array. Examples >>> x = np.arange(6).reshape(2, 3)
>>> fl = x.flat
>>> fl.index
0
>>> next(fl)
0
>>> fl.index
1 | numpy.reference.generated.numpy.flatiter.index |
numpy.generic.__array__ method generic.__array__()
sc.__array__(dtype) return 0-dim array from scalar with specified dtype | numpy.reference.generated.numpy.generic.__array__ |
numpy.generic.__array_interface__ attribute generic.__array_interface__
Array protocol: Python side | numpy.reference.generated.numpy.generic.__array_interface__ |
numpy.generic.__array_priority__ attribute generic.__array_priority__
Array priority. | numpy.reference.generated.numpy.generic.__array_priority__ |
numpy.generic.__array_struct__ attribute generic.__array_struct__
Array protocol: struct | numpy.reference.generated.numpy.generic.__array_struct__ |
numpy.generic.__array_wrap__ method generic.__array_wrap__()
sc.__array_wrap__(obj) return scalar from array | numpy.reference.generated.numpy.generic.__array_wrap__ |
numpy.generic.__reduce__ method generic.__reduce__()
Helper for pickle. | numpy.reference.generated.numpy.generic.__reduce__ |
numpy.generic.__setstate__ method generic.__setstate__() | numpy.reference.generated.numpy.generic.__setstate__ |
numpy.generic.base attribute generic.base
Scalar attribute identical to the corresponding array attribute. Please see ndarray.base. | numpy.reference.generated.numpy.generic.base |
numpy.generic.byteswap method generic.byteswap()
Scalar method identical to the corresponding array attribute. Please see ndarray.byteswap. | numpy.reference.generated.numpy.generic.byteswap |
numpy.generic.data attribute generic.data
Pointer to start of data. | numpy.reference.generated.numpy.generic.data |
numpy.generic.dtype attribute generic.dtype
Get array data-descriptor. | numpy.reference.generated.numpy.generic.dtype |
numpy.generic.flags attribute generic.flags
The integer value of flags. | numpy.reference.generated.numpy.generic.flags |
numpy.generic.flat attribute generic.flat
A 1-D view of the scalar. | numpy.reference.generated.numpy.generic.flat |
numpy.generic.imag attribute generic.imag
The imaginary part of the scalar. | numpy.reference.generated.numpy.generic.imag |
numpy.generic.itemsize attribute generic.itemsize
The length of one element in bytes. | numpy.reference.generated.numpy.generic.itemsize |
numpy.generic.ndim attribute generic.ndim
The number of array dimensions. | numpy.reference.generated.numpy.generic.ndim |
numpy.generic.real attribute generic.real
The real part of the scalar. | numpy.reference.generated.numpy.generic.real |
numpy.generic.setflags method generic.setflags()
Scalar method identical to the corresponding array attribute. Please see ndarray.setflags. | numpy.reference.generated.numpy.generic.setflags |
numpy.generic.shape attribute generic.shape
Tuple of array dimensions. | numpy.reference.generated.numpy.generic.shape |
numpy.generic.size attribute generic.size
The number of elements in the gentype. | numpy.reference.generated.numpy.generic.size |
Subsets and Splits